| // -*- c-basic-offset: 2 -*- |
| /* |
| * Copyright (C) 1999-2001 Harri Porten (porten@kde.org) |
| * Copyright (C) 2004, 2005, 2006, 2007, 2008 Apple Inc. All rights reserved. |
| * |
| * This library is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU Lesser General Public |
| * License as published by the Free Software Foundation; either |
| * version 2 of the License, or (at your option) any later version. |
| * |
| * This library is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| * Lesser General Public License for more details. |
| * |
| * You should have received a copy of the GNU Lesser General Public |
| * License along with this library; if not, write to the Free Software |
| * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
| * |
| */ |
| |
| #include "config.h" |
| #include "string_object.h" |
| |
| #include "JSArray.h" |
| #include "JSWrapperObject.h" |
| #include "ObjectPrototype.h" |
| #include "PropertyNameArray.h" |
| #include "RegExpObject.h" |
| #include "error_object.h" |
| #include "operations.h" |
| #include <wtf/MathExtras.h> |
| #include <wtf/unicode/Collator.h> |
| |
| using namespace WTF; |
| |
| namespace KJS { |
| |
| static JSValue* stringProtoFuncToString(ExecState*, JSObject*, JSValue*, const ArgList&); |
| static JSValue* stringProtoFuncCharAt(ExecState*, JSObject*, JSValue*, const ArgList&); |
| static JSValue* stringProtoFuncCharCodeAt(ExecState*, JSObject*, JSValue*, const ArgList&); |
| static JSValue* stringProtoFuncConcat(ExecState*, JSObject*, JSValue*, const ArgList&); |
| static JSValue* stringProtoFuncIndexOf(ExecState*, JSObject*, JSValue*, const ArgList&); |
| static JSValue* stringProtoFuncLastIndexOf(ExecState*, JSObject*, JSValue*, const ArgList&); |
| static JSValue* stringProtoFuncMatch(ExecState*, JSObject*, JSValue*, const ArgList&); |
| static JSValue* stringProtoFuncReplace(ExecState*, JSObject*, JSValue*, const ArgList&); |
| static JSValue* stringProtoFuncSearch(ExecState*, JSObject*, JSValue*, const ArgList&); |
| static JSValue* stringProtoFuncSlice(ExecState*, JSObject*, JSValue*, const ArgList&); |
| static JSValue* stringProtoFuncSplit(ExecState*, JSObject*, JSValue*, const ArgList&); |
| static JSValue* stringProtoFuncSubstr(ExecState*, JSObject*, JSValue*, const ArgList&); |
| static JSValue* stringProtoFuncSubstring(ExecState*, JSObject*, JSValue*, const ArgList&); |
| static JSValue* stringProtoFuncToLowerCase(ExecState*, JSObject*, JSValue*, const ArgList&); |
| static JSValue* stringProtoFuncToUpperCase(ExecState*, JSObject*, JSValue*, const ArgList&); |
| static JSValue* stringProtoFuncToLocaleLowerCase(ExecState*, JSObject*, JSValue*, const ArgList&); |
| static JSValue* stringProtoFuncToLocaleUpperCase(ExecState*, JSObject*, JSValue*, const ArgList&); |
| static JSValue* stringProtoFuncLocaleCompare(ExecState*, JSObject*, JSValue*, const ArgList&); |
| |
| static JSValue* stringProtoFuncBig(ExecState*, JSObject*, JSValue*, const ArgList&); |
| static JSValue* stringProtoFuncSmall(ExecState*, JSObject*, JSValue*, const ArgList&); |
| static JSValue* stringProtoFuncBlink(ExecState*, JSObject*, JSValue*, const ArgList&); |
| static JSValue* stringProtoFuncBold(ExecState*, JSObject*, JSValue*, const ArgList&); |
| static JSValue* stringProtoFuncFixed(ExecState*, JSObject*, JSValue*, const ArgList&); |
| static JSValue* stringProtoFuncItalics(ExecState*, JSObject*, JSValue*, const ArgList&); |
| static JSValue* stringProtoFuncStrike(ExecState*, JSObject*, JSValue*, const ArgList&); |
| static JSValue* stringProtoFuncSub(ExecState*, JSObject*, JSValue*, const ArgList&); |
| static JSValue* stringProtoFuncSup(ExecState*, JSObject*, JSValue*, const ArgList&); |
| static JSValue* stringProtoFuncFontcolor(ExecState*, JSObject*, JSValue*, const ArgList&); |
| static JSValue* stringProtoFuncFontsize(ExecState*, JSObject*, JSValue*, const ArgList&); |
| static JSValue* stringProtoFuncAnchor(ExecState*, JSObject*, JSValue*, const ArgList&); |
| static JSValue* stringProtoFuncLink(ExecState*, JSObject*, JSValue*, const ArgList&); |
| |
| } |
| |
| #include "string_object.lut.h" |
| |
| namespace KJS { |
| |
| // ------------------------------ StringObject ---------------------------- |
| |
| const ClassInfo StringObject::info = { "String", 0, 0, 0 }; |
| |
| StringObject::StringObject(ExecState* exec, JSObject* proto) |
| : JSWrapperObject(proto) |
| { |
| setInternalValue(jsString(exec, "")); |
| } |
| |
| StringObject::StringObject(JSObject* proto, JSString* string) |
| : JSWrapperObject(proto) |
| { |
| setInternalValue(string); |
| } |
| |
| StringObject::StringObject(ExecState* exec, JSObject* proto, const UString& string) |
| : JSWrapperObject(proto) |
| { |
| setInternalValue(jsString(exec, string)); |
| } |
| |
| bool StringObject::getOwnPropertySlot(ExecState* exec, const Identifier& propertyName, PropertySlot& slot) |
| { |
| if (internalValue()->getStringPropertySlot(exec, propertyName, slot)) |
| return true; |
| return JSObject::getOwnPropertySlot(exec, propertyName, slot); |
| } |
| |
| bool StringObject::getOwnPropertySlot(ExecState* exec, unsigned propertyName, PropertySlot& slot) |
| { |
| if (internalValue()->getStringPropertySlot(propertyName, slot)) |
| return true; |
| return JSObject::getOwnPropertySlot(exec, Identifier::from(exec, propertyName), slot); |
| } |
| |
| void StringObject::put(ExecState* exec, const Identifier& propertyName, JSValue* value) |
| { |
| if (propertyName == exec->propertyNames().length) |
| return; |
| JSObject::put(exec, propertyName, value); |
| } |
| |
| bool StringObject::deleteProperty(ExecState *exec, const Identifier &propertyName) |
| { |
| if (propertyName == exec->propertyNames().length) |
| return false; |
| return JSObject::deleteProperty(exec, propertyName); |
| } |
| |
| void StringObject::getPropertyNames(ExecState* exec, PropertyNameArray& propertyNames) |
| { |
| int size = internalValue()->value().size(); |
| for (int i = 0; i < size; i++) |
| propertyNames.add(Identifier(exec, UString::from(i))); |
| return JSObject::getPropertyNames(exec, propertyNames); |
| } |
| |
| UString StringObject::toString(ExecState*) const |
| { |
| return internalValue()->value(); |
| } |
| |
| UString StringObject::toThisString(ExecState*) const |
| { |
| return internalValue()->value(); |
| } |
| |
| JSString* StringObject::toThisJSString(ExecState*) |
| { |
| return internalValue(); |
| } |
| |
| // ------------------------------ StringPrototype --------------------------- |
| const ClassInfo StringPrototype::info = { "String", &StringObject::info, 0, ExecState::stringTable }; |
| /* Source for string_object.lut.h |
| @begin stringTable 26 |
| toString stringProtoFuncToString DontEnum|Function 0 |
| valueOf stringProtoFuncToString DontEnum|Function 0 |
| charAt stringProtoFuncCharAt DontEnum|Function 1 |
| charCodeAt stringProtoFuncCharCodeAt DontEnum|Function 1 |
| concat stringProtoFuncConcat DontEnum|Function 1 |
| indexOf stringProtoFuncIndexOf DontEnum|Function 1 |
| lastIndexOf stringProtoFuncLastIndexOf DontEnum|Function 1 |
| match stringProtoFuncMatch DontEnum|Function 1 |
| replace stringProtoFuncReplace DontEnum|Function 2 |
| search stringProtoFuncSearch DontEnum|Function 1 |
| slice stringProtoFuncSlice DontEnum|Function 2 |
| split stringProtoFuncSplit DontEnum|Function 2 |
| substr stringProtoFuncSubstr DontEnum|Function 2 |
| substring stringProtoFuncSubstring DontEnum|Function 2 |
| toLowerCase stringProtoFuncToLowerCase DontEnum|Function 0 |
| toUpperCase stringProtoFuncToUpperCase DontEnum|Function 0 |
| toLocaleLowerCase stringProtoFuncToLocaleLowerCase DontEnum|Function 0 |
| toLocaleUpperCase stringProtoFuncToLocaleUpperCase DontEnum|Function 0 |
| localeCompare stringProtoFuncLocaleCompare DontEnum|Function 1 |
| |
| big stringProtoFuncBig DontEnum|Function 0 |
| small stringProtoFuncSmall DontEnum|Function 0 |
| blink stringProtoFuncBlink DontEnum|Function 0 |
| bold stringProtoFuncBold DontEnum|Function 0 |
| fixed stringProtoFuncFixed DontEnum|Function 0 |
| italics stringProtoFuncItalics DontEnum|Function 0 |
| strike stringProtoFuncStrike DontEnum|Function 0 |
| sub stringProtoFuncSub DontEnum|Function 0 |
| sup stringProtoFuncSup DontEnum|Function 0 |
| fontcolor stringProtoFuncFontcolor DontEnum|Function 1 |
| fontsize stringProtoFuncFontsize DontEnum|Function 1 |
| anchor stringProtoFuncAnchor DontEnum|Function 1 |
| link stringProtoFuncLink DontEnum|Function 1 |
| @end |
| */ |
| // ECMA 15.5.4 |
| StringPrototype::StringPrototype(ExecState* exec, ObjectPrototype* objProto) |
| : StringObject(exec, objProto) |
| { |
| // The constructor will be added later, after StringConstructor has been built |
| putDirect(exec->propertyNames().length, jsNumber(exec, 0), DontDelete | ReadOnly | DontEnum); |
| } |
| |
| bool StringPrototype::getOwnPropertySlot(ExecState *exec, const Identifier& propertyName, PropertySlot &slot) |
| { |
| return getStaticFunctionSlot<StringObject>(exec, ExecState::stringTable(exec), this, propertyName, slot); |
| } |
| |
| // ------------------------------ Functions -------------------------- |
| |
| static inline UString substituteBackreferences(const UString& replacement, const UString& source, const int* ovector, RegExp* reg) |
| { |
| UString substitutedReplacement; |
| int offset = 0; |
| int i = -1; |
| while ((i = replacement.find('$', i + 1)) != -1) { |
| if (i + 1 == replacement.size()) |
| break; |
| |
| unsigned short ref = replacement[i + 1]; |
| if (ref == '$') { |
| // "$$" -> "$" |
| ++i; |
| substitutedReplacement.append(replacement.data() + offset, i - offset); |
| offset = i + 1; |
| substitutedReplacement.append('$'); |
| continue; |
| } |
| |
| int backrefStart; |
| int backrefLength; |
| int advance = 0; |
| if (ref == '&') { |
| backrefStart = ovector[0]; |
| backrefLength = ovector[1] - backrefStart; |
| } else if (ref == '`') { |
| backrefStart = 0; |
| backrefLength = ovector[0]; |
| } else if (ref == '\'') { |
| backrefStart = ovector[1]; |
| backrefLength = source.size() - backrefStart; |
| } else if (ref >= '0' && ref <= '9') { |
| // 1- and 2-digit back references are allowed |
| unsigned backrefIndex = ref - '0'; |
| if (backrefIndex > reg->numSubpatterns()) |
| continue; |
| if (replacement.size() > i + 2) { |
| ref = replacement[i + 2]; |
| if (ref >= '0' && ref <= '9') { |
| backrefIndex = 10 * backrefIndex + ref - '0'; |
| if (backrefIndex > reg->numSubpatterns()) |
| backrefIndex = backrefIndex / 10; // Fall back to the 1-digit reference |
| else |
| advance = 1; |
| } |
| } |
| backrefStart = ovector[2 * backrefIndex]; |
| backrefLength = ovector[2 * backrefIndex + 1] - backrefStart; |
| } else |
| continue; |
| |
| if (i - offset) |
| substitutedReplacement.append(replacement.data() + offset, i - offset); |
| i += 1 + advance; |
| offset = i + 1; |
| substitutedReplacement.append(source.data() + backrefStart, backrefLength); |
| } |
| |
| if (!offset) |
| return replacement; |
| |
| if (replacement.size() - offset) |
| substitutedReplacement.append(replacement.data() + offset, replacement.size() - offset); |
| |
| return substitutedReplacement; |
| } |
| |
| static inline int localeCompare(const UString& a, const UString& b) |
| { |
| return Collator::userDefault()->collate(reinterpret_cast<const ::UChar*>(a.data()), a.size(), reinterpret_cast<const ::UChar*>(b.data()), b.size()); |
| } |
| |
| JSValue* stringProtoFuncReplace(ExecState* exec, JSObject*, JSValue* thisValue, const ArgList& args) |
| { |
| JSString* sourceVal = thisValue->toThisJSString(exec); |
| const UString& source = sourceVal->value(); |
| |
| JSValue* pattern = args[0]; |
| |
| JSValue* replacement = args[1]; |
| UString replacementString; |
| CallData callData; |
| CallType callType = replacement->getCallData(callData); |
| if (callType == CallTypeNone) |
| replacementString = replacement->toString(exec); |
| |
| if (pattern->isObject(&RegExpObject::info)) { |
| RegExp* reg = static_cast<RegExpObject*>(pattern)->regExp(); |
| bool global = reg->global(); |
| |
| RegExpConstructor* regExpObj = exec->lexicalGlobalObject()->regExpConstructor(); |
| |
| int lastIndex = 0; |
| int startPosition = 0; |
| |
| Vector<UString::Range, 16> sourceRanges; |
| Vector<UString, 16> replacements; |
| |
| // This is either a loop (if global is set) or a one-way (if not). |
| do { |
| int matchIndex; |
| int matchLen; |
| int* ovector; |
| regExpObj->performMatch(reg, source, startPosition, matchIndex, matchLen, &ovector); |
| if (matchIndex < 0) |
| break; |
| |
| sourceRanges.append(UString::Range(lastIndex, matchIndex - lastIndex)); |
| |
| if (callType != CallTypeNone) { |
| int completeMatchStart = ovector[0]; |
| ArgList args; |
| |
| for (unsigned i = 0; i < reg->numSubpatterns() + 1; i++) { |
| int matchStart = ovector[i * 2]; |
| int matchLen = ovector[i * 2 + 1] - matchStart; |
| |
| if (matchStart < 0) |
| args.append(jsUndefined()); |
| else |
| args.append(jsString(exec, source.substr(matchStart, matchLen))); |
| } |
| |
| args.append(jsNumber(exec, completeMatchStart)); |
| args.append(sourceVal); |
| |
| replacements.append(call(exec, replacement, callType, callData, exec->globalThisValue(), args)->toString(exec)); |
| } else |
| replacements.append(substituteBackreferences(replacementString, source, ovector, reg)); |
| |
| lastIndex = matchIndex + matchLen; |
| startPosition = lastIndex; |
| |
| // special case of empty match |
| if (matchLen == 0) { |
| startPosition++; |
| if (startPosition > source.size()) |
| break; |
| } |
| } while (global); |
| |
| if (lastIndex < source.size()) |
| sourceRanges.append(UString::Range(lastIndex, source.size() - lastIndex)); |
| |
| UString result = source.spliceSubstringsWithSeparators(sourceRanges.data(), sourceRanges.size(), replacements.data(), replacements.size()); |
| |
| if (result == source) |
| return sourceVal; |
| |
| return jsString(exec, result); |
| } |
| |
| // First arg is a string |
| UString patternString = pattern->toString(exec); |
| int matchPos = source.find(patternString); |
| int matchLen = patternString.size(); |
| // Do the replacement |
| if (matchPos == -1) |
| return sourceVal; |
| |
| if (callType != CallTypeNone) { |
| ArgList args; |
| |
| args.append(jsString(exec, source.substr(matchPos, matchLen))); |
| args.append(jsNumber(exec, matchPos)); |
| args.append(sourceVal); |
| |
| replacementString = call(exec, replacement, callType, callData, exec->globalThisValue(), args)->toString(exec); |
| } |
| |
| return jsString(exec, source.substr(0, matchPos) + replacementString + source.substr(matchPos + matchLen)); |
| } |
| |
| JSValue* stringProtoFuncToString(ExecState* exec, JSObject*, JSValue* thisValue, const ArgList&) |
| { |
| // Also used for valueOf. |
| |
| if (thisValue->isString()) |
| return thisValue; |
| |
| if (thisValue->isObject(&StringObject::info)) |
| return static_cast<StringObject*>(thisValue)->internalValue(); |
| |
| return throwError(exec, TypeError); |
| } |
| |
| JSValue* stringProtoFuncCharAt(ExecState* exec, JSObject*, JSValue* thisValue, const ArgList& args) |
| { |
| UString s = thisValue->toThisString(exec); |
| int len = s.size(); |
| |
| UString u; |
| JSValue* a0 = args[0]; |
| double dpos = a0->toInteger(exec); |
| if (dpos >= 0 && dpos < len) |
| u = s.substr(static_cast<int>(dpos), 1); |
| else |
| u = ""; |
| return jsString(exec, u); |
| } |
| |
| JSValue* stringProtoFuncCharCodeAt(ExecState* exec, JSObject*, JSValue* thisValue, const ArgList& args) |
| { |
| UString s = thisValue->toThisString(exec); |
| int len = s.size(); |
| |
| JSValue* result = 0; |
| |
| JSValue* a0 = args[0]; |
| double dpos = a0->toInteger(exec); |
| if (dpos >= 0 && dpos < len) |
| result = jsNumber(exec, s[static_cast<int>(dpos)]); |
| else |
| result = jsNaN(exec); |
| return result; |
| } |
| |
| JSValue* stringProtoFuncConcat(ExecState* exec, JSObject*, JSValue* thisValue, const ArgList& args) |
| { |
| UString s = thisValue->toThisString(exec); |
| |
| ArgList::const_iterator end = args.end(); |
| for (ArgList::const_iterator it = args.begin(); it != end; ++it) { |
| s += (*it)->toString(exec); |
| } |
| return jsString(exec, s); |
| } |
| |
| JSValue* stringProtoFuncIndexOf(ExecState* exec, JSObject*, JSValue* thisValue, const ArgList& args) |
| { |
| UString s = thisValue->toThisString(exec); |
| int len = s.size(); |
| |
| JSValue* a0 = args[0]; |
| JSValue* a1 = args[1]; |
| UString u2 = a0->toString(exec); |
| double dpos = a1->toInteger(exec); |
| if (dpos < 0) |
| dpos = 0; |
| else if (dpos > len) |
| dpos = len; |
| return jsNumber(exec, s.find(u2, static_cast<int>(dpos))); |
| } |
| |
| JSValue* stringProtoFuncLastIndexOf(ExecState* exec, JSObject*, JSValue* thisValue, const ArgList& args) |
| { |
| UString s = thisValue->toThisString(exec); |
| int len = s.size(); |
| |
| JSValue* a0 = args[0]; |
| JSValue* a1 = args[1]; |
| |
| UString u2 = a0->toString(exec); |
| double dpos = a1->toIntegerPreserveNaN(exec); |
| if (dpos < 0) |
| dpos = 0; |
| else if (!(dpos <= len)) // true for NaN |
| dpos = len; |
| return jsNumber(exec, s.rfind(u2, static_cast<int>(dpos))); |
| } |
| |
| JSValue* stringProtoFuncMatch(ExecState* exec, JSObject*, JSValue* thisValue, const ArgList& args) |
| { |
| UString s = thisValue->toThisString(exec); |
| |
| JSValue* a0 = args[0]; |
| |
| UString u = s; |
| RefPtr<RegExp> reg; |
| RegExpObject* imp = 0; |
| if (a0->isObject() && static_cast<JSObject *>(a0)->inherits(&RegExpObject::info)) { |
| reg = static_cast<RegExpObject *>(a0)->regExp(); |
| } else { |
| /* |
| * ECMA 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). |
| */ |
| reg = RegExp::create(a0->toString(exec)); |
| } |
| RegExpConstructor* regExpObj = exec->lexicalGlobalObject()->regExpConstructor(); |
| int pos; |
| int matchLength; |
| regExpObj->performMatch(reg.get(), u, 0, pos, matchLength); |
| JSValue* result; |
| if (!(reg->global())) { |
| // case without 'g' flag is handled like RegExp.prototype.exec |
| if (pos < 0) |
| result = jsNull(); |
| else |
| result = regExpObj->arrayOfMatches(exec); |
| } else { |
| // return array of matches |
| ArgList list; |
| int lastIndex = 0; |
| while (pos >= 0) { |
| list.append(jsString(exec, u.substr(pos, matchLength))); |
| lastIndex = pos; |
| pos += matchLength == 0 ? 1 : matchLength; |
| regExpObj->performMatch(reg.get(), u, pos, pos, matchLength); |
| } |
| if (imp) |
| imp->setLastIndex(lastIndex); |
| if (list.isEmpty()) { |
| // if there are no matches at all, it's important to return |
| // Null instead of an empty array, because this matches |
| // other browsers and because Null is a false value. |
| result = jsNull(); |
| } else { |
| result = constructArray(exec, list); |
| } |
| } |
| return result; |
| } |
| |
| JSValue* stringProtoFuncSearch(ExecState* exec, JSObject*, JSValue* thisValue, const ArgList& args) |
| { |
| UString s = thisValue->toThisString(exec); |
| |
| JSValue* a0 = args[0]; |
| |
| UString u = s; |
| RefPtr<RegExp> reg; |
| if (a0->isObject() && static_cast<JSObject*>(a0)->inherits(&RegExpObject::info)) { |
| reg = static_cast<RegExpObject*>(a0)->regExp(); |
| } else { |
| /* |
| * ECMA 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). |
| */ |
| reg = RegExp::create(a0->toString(exec)); |
| } |
| RegExpConstructor* regExpObj = exec->lexicalGlobalObject()->regExpConstructor(); |
| int pos; |
| int matchLength; |
| regExpObj->performMatch(reg.get(), u, 0, pos, matchLength); |
| return jsNumber(exec, pos); |
| } |
| |
| JSValue* stringProtoFuncSlice(ExecState* exec, JSObject*, JSValue* thisValue, const ArgList& args) |
| { |
| UString s = thisValue->toThisString(exec); |
| int len = s.size(); |
| |
| JSValue* a0 = args[0]; |
| JSValue* a1 = args[1]; |
| |
| // The arg processing is very much like ArrayProtoFunc::Slice |
| double start = a0->toInteger(exec); |
| double end = a1->isUndefined() ? len : a1->toInteger(exec); |
| double from = start < 0 ? len + start : start; |
| double to = end < 0 ? len + end : end; |
| if (to > from && to > 0 && from < len) { |
| if (from < 0) |
| from = 0; |
| if (to > len) |
| to = len; |
| return jsString(exec, s.substr(static_cast<int>(from), static_cast<int>(to - from))); |
| } |
| |
| return jsString(exec, ""); |
| } |
| |
| JSValue* stringProtoFuncSplit(ExecState* exec, JSObject*, JSValue* thisValue, const ArgList& args) |
| { |
| UString s = thisValue->toThisString(exec); |
| |
| JSValue* a0 = args[0]; |
| JSValue* a1 = args[1]; |
| |
| JSObject* res = constructEmptyArray(exec); |
| JSValue* result = res; |
| UString u = s; |
| int pos; |
| int i = 0; |
| int p0 = 0; |
| uint32_t limit = a1->isUndefined() ? 0xFFFFFFFFU : a1->toUInt32(exec); |
| if (a0->isObject() && static_cast<JSObject *>(a0)->inherits(&RegExpObject::info)) { |
| RegExp *reg = static_cast<RegExpObject *>(a0)->regExp(); |
| if (u.isEmpty() && reg->match(u, 0) >= 0) { |
| // empty string matched by regexp -> empty array |
| res->put(exec, exec->propertyNames().length, jsNumber(exec, 0)); |
| return result; |
| } |
| pos = 0; |
| while (static_cast<uint32_t>(i) != limit && pos < u.size()) { |
| OwnArrayPtr<int> ovector; |
| int mpos = reg->match(u, pos, &ovector); |
| if (mpos < 0) |
| break; |
| int mlen = ovector[1] - ovector[0]; |
| pos = mpos + (mlen == 0 ? 1 : mlen); |
| if (mpos != p0 || mlen) { |
| res->put(exec,i, jsString(exec, u.substr(p0, mpos-p0))); |
| p0 = mpos + mlen; |
| i++; |
| } |
| for (unsigned si = 1; si <= reg->numSubpatterns(); ++si) { |
| int spos = ovector[si * 2]; |
| if (spos < 0) |
| res->put(exec, i++, jsUndefined()); |
| else |
| res->put(exec, i++, jsString(exec, u.substr(spos, ovector[si * 2 + 1] - spos))); |
| } |
| } |
| } else { |
| UString u2 = a0->toString(exec); |
| if (u2.isEmpty()) { |
| if (u.isEmpty()) { |
| // empty separator matches empty string -> empty array |
| res->put(exec, exec->propertyNames().length, jsNumber(exec, 0)); |
| return result; |
| } else { |
| while (static_cast<uint32_t>(i) != limit && i < u.size()-1) |
| res->put(exec, i++, jsString(exec, u.substr(p0++, 1))); |
| } |
| } else { |
| while (static_cast<uint32_t>(i) != limit && (pos = u.find(u2, p0)) >= 0) { |
| res->put(exec, i, jsString(exec, u.substr(p0, pos - p0))); |
| p0 = pos + u2.size(); |
| i++; |
| } |
| } |
| } |
| // add remaining string, if any |
| if (static_cast<uint32_t>(i) != limit) |
| res->put(exec, i++, jsString(exec, u.substr(p0))); |
| res->put(exec, exec->propertyNames().length, jsNumber(exec, i)); |
| return result; |
| } |
| |
| JSValue* stringProtoFuncSubstr(ExecState* exec, JSObject*, JSValue* thisValue, const ArgList& args) |
| { |
| UString s = thisValue->toThisString(exec); |
| int len = s.size(); |
| |
| JSValue* a0 = args[0]; |
| JSValue* a1 = args[1]; |
| |
| double start = a0->toInteger(exec); |
| double length = a1->isUndefined() ? len : a1->toInteger(exec); |
| if (start >= len) |
| return jsString(exec, ""); |
| if (length < 0) |
| return jsString(exec, ""); |
| if (start < 0) { |
| start += len; |
| if (start < 0) |
| start = 0; |
| } |
| if (length > len) |
| length = len; |
| return jsString(exec, s.substr(static_cast<int>(start), static_cast<int>(length))); |
| } |
| |
| JSValue* stringProtoFuncSubstring(ExecState* exec, JSObject*, JSValue* thisValue, const ArgList& args) |
| { |
| UString s = thisValue->toThisString(exec); |
| int len = s.size(); |
| |
| JSValue* a0 = args[0]; |
| JSValue* a1 = args[1]; |
| |
| double start = a0->toNumber(exec); |
| double end = a1->toNumber(exec); |
| if (isnan(start)) |
| start = 0; |
| if (isnan(end)) |
| end = 0; |
| if (start < 0) |
| start = 0; |
| if (end < 0) |
| end = 0; |
| if (start > len) |
| start = len; |
| if (end > len) |
| end = len; |
| if (a1->isUndefined()) |
| end = len; |
| if (start > end) { |
| double temp = end; |
| end = start; |
| start = temp; |
| } |
| return jsString(exec, s.substr((int)start, (int)end-(int)start)); |
| } |
| |
| JSValue* stringProtoFuncToLowerCase(ExecState* exec, JSObject*, JSValue* thisValue, const ArgList&) |
| { |
| JSString* sVal = thisValue->toThisJSString(exec); |
| const UString& s = sVal->value(); |
| |
| int ssize = s.size(); |
| if (!ssize) |
| return sVal; |
| Vector<UChar> buffer(ssize); |
| bool error; |
| int length = Unicode::toLower(buffer.data(), ssize, reinterpret_cast<const UChar*>(s.data()), ssize, &error); |
| if (error) { |
| buffer.resize(length); |
| length = Unicode::toLower(buffer.data(), length, reinterpret_cast<const UChar*>(s.data()), ssize, &error); |
| if (error) |
| return sVal; |
| } |
| if (length == ssize && memcmp(buffer.data(), s.data(), length * sizeof(UChar)) == 0) |
| return sVal; |
| return jsString(exec, UString(buffer.releaseBuffer(), length, false)); |
| } |
| |
| JSValue* stringProtoFuncToUpperCase(ExecState* exec, JSObject*, JSValue* thisValue, const ArgList&) |
| { |
| JSString* sVal = thisValue->toThisJSString(exec); |
| const UString& s = sVal->value(); |
| |
| int ssize = s.size(); |
| if (!ssize) |
| return sVal; |
| Vector<UChar> buffer(ssize); |
| bool error; |
| int length = Unicode::toUpper(buffer.data(), ssize, reinterpret_cast<const UChar*>(s.data()), ssize, &error); |
| if (error) { |
| buffer.resize(length); |
| length = Unicode::toUpper(buffer.data(), length, reinterpret_cast<const UChar*>(s.data()), ssize, &error); |
| if (error) |
| return sVal; |
| } |
| if (length == ssize && memcmp(buffer.data(), s.data(), length * sizeof(UChar)) == 0) |
| return sVal; |
| return jsString(exec, UString(buffer.releaseBuffer(), length, false)); |
| } |
| |
| JSValue* stringProtoFuncToLocaleLowerCase(ExecState* exec, JSObject*, JSValue* thisValue, const ArgList&) |
| { |
| // FIXME: See http://www.unicode.org/Public/UNIDATA/SpecialCasing.txt for locale-sensitive mappings that aren't implemented. |
| |
| JSString* sVal = thisValue->toThisJSString(exec); |
| const UString& s = sVal->value(); |
| |
| int ssize = s.size(); |
| if (!ssize) |
| return sVal; |
| Vector<UChar> buffer(ssize); |
| bool error; |
| int length = Unicode::toLower(buffer.data(), ssize, reinterpret_cast<const UChar*>(s.data()), ssize, &error); |
| if (error) { |
| buffer.resize(length); |
| length = Unicode::toLower(buffer.data(), length, reinterpret_cast<const UChar*>(s.data()), ssize, &error); |
| if (error) |
| return sVal; |
| } |
| if (length == ssize && memcmp(buffer.data(), s.data(), length * sizeof(UChar)) == 0) |
| return sVal; |
| return jsString(exec, UString(buffer.releaseBuffer(), length, false)); |
| } |
| |
| JSValue* stringProtoFuncToLocaleUpperCase(ExecState* exec, JSObject*, JSValue* thisValue, const ArgList&) |
| { |
| JSString* sVal = thisValue->toThisJSString(exec); |
| const UString& s = sVal->value(); |
| |
| int ssize = s.size(); |
| if (!ssize) |
| return sVal; |
| Vector<UChar> buffer(ssize); |
| bool error; |
| int length = Unicode::toUpper(buffer.data(), ssize, reinterpret_cast<const UChar*>(s.data()), ssize, &error); |
| if (error) { |
| buffer.resize(length); |
| length = Unicode::toUpper(buffer.data(), length, reinterpret_cast<const UChar*>(s.data()), ssize, &error); |
| if (error) |
| return sVal; |
| } |
| if (length == ssize && memcmp(buffer.data(), s.data(), length * sizeof(UChar)) == 0) |
| return sVal; |
| return jsString(exec, UString(buffer.releaseBuffer(), length, false)); |
| } |
| |
| JSValue* stringProtoFuncLocaleCompare(ExecState* exec, JSObject*, JSValue* thisValue, const ArgList& args) |
| { |
| if (args.size() < 1) |
| return jsNumber(exec, 0); |
| |
| UString s = thisValue->toThisString(exec); |
| JSValue* a0 = args[0]; |
| return jsNumber(exec, localeCompare(s, a0->toString(exec))); |
| } |
| |
| JSValue* stringProtoFuncBig(ExecState* exec, JSObject*, JSValue* thisValue, const ArgList&) |
| { |
| UString s = thisValue->toThisString(exec); |
| return jsString(exec, "<big>" + s + "</big>"); |
| } |
| |
| JSValue* stringProtoFuncSmall(ExecState* exec, JSObject*, JSValue* thisValue, const ArgList&) |
| { |
| UString s = thisValue->toThisString(exec); |
| return jsString(exec, "<small>" + s + "</small>"); |
| } |
| |
| JSValue* stringProtoFuncBlink(ExecState* exec, JSObject*, JSValue* thisValue, const ArgList&) |
| { |
| UString s = thisValue->toThisString(exec); |
| return jsString(exec, "<blink>" + s + "</blink>"); |
| } |
| |
| JSValue* stringProtoFuncBold(ExecState* exec, JSObject*, JSValue* thisValue, const ArgList&) |
| { |
| UString s = thisValue->toThisString(exec); |
| return jsString(exec, "<b>" + s + "</b>"); |
| } |
| |
| JSValue* stringProtoFuncFixed(ExecState* exec, JSObject*, JSValue* thisValue, const ArgList&) |
| { |
| UString s = thisValue->toThisString(exec); |
| return jsString(exec, "<tt>" + s + "</tt>"); |
| } |
| |
| JSValue* stringProtoFuncItalics(ExecState* exec, JSObject*, JSValue* thisValue, const ArgList&) |
| { |
| UString s = thisValue->toThisString(exec); |
| return jsString(exec, "<i>" + s + "</i>"); |
| } |
| |
| JSValue* stringProtoFuncStrike(ExecState* exec, JSObject*, JSValue* thisValue, const ArgList&) |
| { |
| UString s = thisValue->toThisString(exec); |
| return jsString(exec, "<strike>" + s + "</strike>"); |
| } |
| |
| JSValue* stringProtoFuncSub(ExecState* exec, JSObject*, JSValue* thisValue, const ArgList&) |
| { |
| UString s = thisValue->toThisString(exec); |
| return jsString(exec, "<sub>" + s + "</sub>"); |
| } |
| |
| JSValue* stringProtoFuncSup(ExecState* exec, JSObject*, JSValue* thisValue, const ArgList&) |
| { |
| UString s = thisValue->toThisString(exec); |
| return jsString(exec, "<sup>" + s + "</sup>"); |
| } |
| |
| JSValue* stringProtoFuncFontcolor(ExecState* exec, JSObject*, JSValue* thisValue, const ArgList& args) |
| { |
| UString s = thisValue->toThisString(exec); |
| JSValue* a0 = args[0]; |
| return jsString(exec, "<font color=\"" + a0->toString(exec) + "\">" + s + "</font>"); |
| } |
| |
| JSValue* stringProtoFuncFontsize(ExecState* exec, JSObject*, JSValue* thisValue, const ArgList& args) |
| { |
| UString s = thisValue->toThisString(exec); |
| JSValue* a0 = args[0]; |
| return jsString(exec, "<font size=\"" + a0->toString(exec) + "\">" + s + "</font>"); |
| } |
| |
| JSValue* stringProtoFuncAnchor(ExecState* exec, JSObject*, JSValue* thisValue, const ArgList& args) |
| { |
| UString s = thisValue->toThisString(exec); |
| JSValue* a0 = args[0]; |
| return jsString(exec, "<a name=\"" + a0->toString(exec) + "\">" + s + "</a>"); |
| } |
| |
| JSValue* stringProtoFuncLink(ExecState* exec, JSObject*, JSValue* thisValue, const ArgList& args) |
| { |
| UString s = thisValue->toThisString(exec); |
| JSValue* a0 = args[0]; |
| return jsString(exec, "<a href=\"" + a0->toString(exec) + "\">" + s + "</a>"); |
| } |
| |
| // ------------------------------ StringConstructor ------------------------------ |
| |
| static JSValue* stringFromCharCode(ExecState* exec, JSObject*, JSValue*, const ArgList& args) |
| { |
| UString s; |
| if (args.size()) { |
| UChar* buf = static_cast<UChar*>(fastMalloc(args.size() * sizeof(UChar))); |
| UChar* p = buf; |
| ArgList::const_iterator end = args.end(); |
| for (ArgList::const_iterator it = args.begin(); it != end; ++it) |
| *p++ = static_cast<UChar>((*it)->toUInt32(exec)); |
| s = UString(buf, args.size(), false); |
| } else |
| s = ""; |
| |
| return jsString(exec, s); |
| } |
| |
| StringConstructor::StringConstructor(ExecState* exec, FunctionPrototype* funcProto, StringPrototype* stringProto) |
| : InternalFunction(funcProto, Identifier(exec, stringProto->classInfo()->className)) |
| { |
| // ECMA 15.5.3.1 String.prototype |
| putDirect(exec->propertyNames().prototype, stringProto, ReadOnly | DontEnum | DontDelete); |
| |
| // ECMA 15.5.3.2 fromCharCode() |
| putDirectFunction(new (exec) PrototypeFunction(exec, funcProto, 1, exec->propertyNames().fromCharCode, stringFromCharCode), DontEnum); |
| |
| // no. of arguments for constructor |
| putDirect(exec->propertyNames().length, jsNumber(exec, 1), ReadOnly | DontEnum | DontDelete); |
| } |
| |
| // ECMA 15.5.2 |
| static JSObject* constructWithStringConstructor(ExecState* exec, JSObject*, const ArgList& args) |
| { |
| JSObject* prototype = exec->lexicalGlobalObject()->stringPrototype(); |
| if (args.isEmpty()) |
| return new (exec) StringObject(exec, prototype); |
| return new (exec) StringObject(exec, prototype, args[0]->toString(exec)); |
| } |
| |
| ConstructType StringConstructor::getConstructData(ConstructData& constructData) |
| { |
| constructData.native.function = constructWithStringConstructor; |
| return ConstructTypeNative; |
| } |
| |
| // ECMA 15.5.1 |
| static JSValue* callStringConstructor(ExecState* exec, JSObject*, JSValue*, const ArgList& args) |
| { |
| if (args.isEmpty()) |
| return jsString(exec, ""); |
| return jsString(exec, args[0]->toString(exec)); |
| } |
| |
| CallType StringConstructor::getCallData(CallData& callData) |
| { |
| callData.native.function = callStringConstructor; |
| return CallTypeNative; |
| } |
| |
| } // namespace KJS |
