JavaScriptCore/kjs/function.cpp

   1 // -*- c-basic-offset: 2 -*-
   2 /*
   3  *  Copyright (C) 1999-2002 Harri Porten (porten@kde.org)
   4  *  Copyright (C) 2001 Peter Kelly (pmk@post.com)
   5  *  Copyright (C) 2003, 2004, 2005, 2006, 2007 Apple Inc. All rights reserved.
   6  *  Copyright (C) 2007 Cameron Zwarich (cwzwarich@uwaterloo.ca)
   7  *
   8  *  This library is free software; you can redistribute it and/or
   9  *  modify it under the terms of the GNU Library General Public
  10  *  License as published by the Free Software Foundation; either
  11  *  version 2 of the License, or (at your option) any later version.
  12  *
  13  *  This library is distributed in the hope that it will be useful,
  14  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  *  Library General Public License for more details.
  17  *
  18  *  You should have received a copy of the GNU Library General Public License
  19  *  along with this library; see the file COPYING.LIB.  If not, write to
  20  *  the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  21  *  Boston, MA 02110-1301, USA.
  22  *
  23  */
  24
  25 #include "config.h"
  26 #include "function.h"
  27
  28 #include "context.h"
  29 #include "debugger.h"
  30 #include "dtoa.h"
  31 #include "function_object.h"
  32 #include "internal.h"
  33 #include "JSGlobalObject.h"
  34 #include "lexer.h"
  35 #include "nodes.h"
  36 #include "operations.h"
  37 #include <errno.h>
  38 #include <stdio.h>
  39 #include <stdlib.h>
  40 #include <string.h>
  41 #include <wtf/ASCIICType.h>
  42 #include <wtf/Assertions.h>
  43 #include <wtf/unicode/Unicode.h>
  44
  45 using namespace WTF;
  46 using namespace Unicode;
  47
  48 namespace KJS {
  49
  50 // ----------------------------- FunctionImp ----------------------------------
  51
  52 const ClassInfo FunctionImp::info = { "Function", &InternalFunctionImp::info, 0, 0 };
  53
  54 FunctionImp::FunctionImp(ExecState* exec, const Identifier& name, FunctionBodyNode* b, const ScopeChain& sc)
  55   : InternalFunctionImp(static_cast<FunctionPrototype*>(exec->lexicalInterpreter()->builtinFunctionPrototype()), name)
  56   , body(b)
  57   , _scope(sc)
  58 {
  59 }
  60
  61 void FunctionImp::mark()
  62 {
  63     InternalFunctionImp::mark();
  64     _scope.mark();
  65 }
  66
  67 JSValue* FunctionImp::callAsFunction(ExecState* exec, JSObject* thisObj, const List& args)
  68 {
  69   JSGlobalObject* globalObj = exec->dynamicInterpreter()->globalObject();
  70
  71   // enter a new execution context
  72   Context ctx(globalObj, exec->dynamicInterpreter(), thisObj, body.get(),
  73                  FunctionCode, exec->context(), this, &args);
  74   ExecState newExec(exec->dynamicInterpreter(), &ctx);
  75   if (exec->hadException())
  76     newExec.setException(exec->exception());
  77   ctx.setExecState(&newExec);
  78
  79   Debugger* dbg = exec->dynamicInterpreter()->debugger();
  80   int sid = -1;
  81   int lineno = -1;
  82   if (dbg) {
  83     sid = body->sourceId();
  84     lineno = body->firstLine();
  85
  86     bool cont = dbg->callEvent(&newExec,sid,lineno,this,args);
  87     if (!cont) {
  88       dbg->imp()->abort();
  89       return jsUndefined();
  90     }
  91   }
  92
  93   Completion comp = execute(&newExec);
  94
  95   // if an exception occured, propogate it back to the previous execution object
  96   if (newExec.hadException())
  97     comp = Completion(Throw, newExec.exception());
  98
  99   // The debugger may have been deallocated by now if the WebFrame
 100   // we were running in has been destroyed, so refetch it.
 101   // See http://bugs.webkit.org/show_bug.cgi?id=9477
 102   dbg = exec->dynamicInterpreter()->debugger();
 103
 104   if (dbg) {
 105     lineno = body->lastLine();
 106
 107     if (comp.complType() == Throw)
 108         newExec.setException(comp.value());
 109
 110     int cont = dbg->returnEvent(&newExec,sid,lineno,this);
 111     if (!cont) {
 112       dbg->imp()->abort();
 113       return jsUndefined();
 114     }
 115   }
 116
 117   if (comp.complType() == Throw) {
 118     exec->setException(comp.value());
 119     return comp.value();
 120   }
 121   else if (comp.complType() == ReturnValue)
 122     return comp.value();
 123   else
 124     return jsUndefined();
 125 }
 126
 127 JSValue* FunctionImp::argumentsGetter(ExecState* exec, JSObject*, const Identifier& propertyName, const PropertySlot& slot)
 128 {
 129   FunctionImp* thisObj = static_cast<FunctionImp*>(slot.slotBase());
 130   Context* context = exec->m_context;
 131   while (context) {
 132     if (context->function() == thisObj)
 133       return static_cast<ActivationImp*>(context->activationObject())->get(exec, propertyName);
 134     context = context->callingContext();
 135   }
 136   return jsNull();
 137 }
 138
 139 JSValue* FunctionImp::callerGetter(ExecState* exec, JSObject*, const Identifier&, const PropertySlot& slot)
 140 {
 141     FunctionImp* thisObj = static_cast<FunctionImp*>(slot.slotBase());
 142     Context* context = exec->m_context;
 143     while (context) {
 144         if (context->function() == thisObj)
 145             break;
 146         context = context->callingContext();
 147     }
 148
 149     if (!context)
 150         return jsNull();
 151
 152     Context* callingContext = context->callingContext();
 153     if (!callingContext)
 154         return jsNull();
 155
 156     FunctionImp* callingFunction = callingContext->function();
 157     if (!callingFunction)
 158         return jsNull();
 159
 160     return callingFunction;
 161 }
 162
 163 JSValue* FunctionImp::lengthGetter(ExecState*, JSObject*, const Identifier&, const PropertySlot& slot)
 164 {
 165     FunctionImp* thisObj = static_cast<FunctionImp*>(slot.slotBase());
 166     return jsNumber(thisObj->body->numParams());
 167 }
 168
 169 bool FunctionImp::getOwnPropertySlot(ExecState* exec, const Identifier& propertyName, PropertySlot& slot)
 170 {
 171     // Find the arguments from the closest context.
 172     if (propertyName == exec->propertyNames().arguments) {
 173         slot.setCustom(this, argumentsGetter);
 174         return true;
 175     }
 176
 177     // Compute length of parameters.
 178     if (propertyName == exec->propertyNames().length) {
 179         slot.setCustom(this, lengthGetter);
 180         return true;
 181     }
 182
 183     if (propertyName == exec->propertyNames().caller) {
 184         slot.setCustom(this, callerGetter);
 185         return true;
 186     }
 187
 188     return InternalFunctionImp::getOwnPropertySlot(exec, propertyName, slot);
 189 }
 190
 191 void FunctionImp::put(ExecState* exec, const Identifier& propertyName, JSValue* value, int attr)
 192 {
 193     if (propertyName == exec->propertyNames().arguments || propertyName == exec->propertyNames().length)
 194         return;
 195     InternalFunctionImp::put(exec, propertyName, value, attr);
 196 }
 197
 198 bool FunctionImp::deleteProperty(ExecState* exec, const Identifier& propertyName)
 199 {
 200     if (propertyName == exec->propertyNames().arguments || propertyName == exec->propertyNames().length)
 201         return false;
 202     return InternalFunctionImp::deleteProperty(exec, propertyName);
 203 }
 204
 205 /* Returns the parameter name corresponding to the given index. eg:
 206  * function f1(x, y, z): getParameterName(0) --> x
 207  *
 208  * If a name appears more than once, only the last index at which
 209  * it appears associates with it. eg:
 210  * function f2(x, x): getParameterName(0) --> null
 211  */
 212 Identifier FunctionImp::getParameterName(int index)
 213 {
 214     Vector<Identifier>& parameters = body->parameters();
 215
 216     if (static_cast<size_t>(index) >= body->numParams())
 217         return CommonIdentifiers::shared()->nullIdentifier;
 218
 219     Identifier name = parameters[index];
 220
 221     // Are there any subsequent parameters with the same name?
 222     size_t size = parameters.size();
 223     for (size_t i = index + 1; i < size; ++i)
 224         if (parameters[i] == name)
 225             return CommonIdentifiers::shared()->nullIdentifier;
 226
 227     return name;
 228 }
 229
 230 // ECMA 13.2.2 [[Construct]]
 231 JSObject* FunctionImp::construct(ExecState* exec, const List& args)
 232 {
 233   JSObject* proto;
 234   JSValue* p = get(exec, exec->propertyNames().prototype);
 235   if (p->isObject())
 236     proto = static_cast<JSObject*>(p);
 237   else
 238     proto = exec->lexicalInterpreter()->builtinObjectPrototype();
 239
 240   JSObject* obj(new JSObject(proto));
 241
 242   JSValue* res = call(exec,obj,args);
 243
 244   if (res->isObject())
 245     return static_cast<JSObject*>(res);
 246   else
 247     return obj;
 248 }
 249
 250 Completion FunctionImp::execute(ExecState* exec)
 251 {
 252   Completion result = body->execute(exec);
 253
 254   if (result.complType() == Throw || result.complType() == ReturnValue)
 255       return result;
 256   return Completion(Normal, jsUndefined()); // TODO: or ReturnValue ?
 257 }
 258
 259 // ------------------------------ IndexToNameMap ---------------------------------
 260
 261 // We map indexes in the arguments array to their corresponding argument names.
 262 // Example: function f(x, y, z): arguments[0] = x, so we map 0 to Identifier("x").
 263
 264 // Once we have an argument name, we can get and set the argument's value in the
 265 // activation object.
 266
 267 // We use Identifier::null to indicate that a given argument's value
 268 // isn't stored in the activation object.
 269
 270 IndexToNameMap::IndexToNameMap(FunctionImp* func, const List& args)
 271 {
 272   _map = new Identifier[args.size()];
 273   this->size = args.size();
 274
 275   int i = 0;
 276   ListIterator iterator = args.begin();
 277   for (; iterator != args.end(); i++, iterator++)
 278     _map[i] = func->getParameterName(i); // null if there is no corresponding parameter
 279 }
 280
 281 IndexToNameMap::~IndexToNameMap() {
 282   delete [] _map;
 283 }
 284
 285 bool IndexToNameMap::isMapped(const Identifier& index) const
 286 {
 287   bool indexIsNumber;
 288   int indexAsNumber = index.toUInt32(&indexIsNumber);
 289
 290   if (!indexIsNumber)
 291     return false;
 292
 293   if (indexAsNumber >= size)
 294     return false;
 295
 296   if (_map[indexAsNumber].isNull())
 297     return false;
 298
 299   return true;
 300 }
 301
 302 void IndexToNameMap::unMap(const Identifier& index)
 303 {
 304   bool indexIsNumber;
 305   int indexAsNumber = index.toUInt32(&indexIsNumber);
 306
 307   ASSERT(indexIsNumber && indexAsNumber < size);
 308
 309   _map[indexAsNumber] = CommonIdentifiers::shared()->nullIdentifier;
 310 }
 311
 312 Identifier& IndexToNameMap::operator[](int index)
 313 {
 314   return _map[index];
 315 }
 316
 317 Identifier& IndexToNameMap::operator[](const Identifier& index)
 318 {
 319   bool indexIsNumber;
 320   int indexAsNumber = index.toUInt32(&indexIsNumber);
 321
 322   ASSERT(indexIsNumber && indexAsNumber < size);
 323
 324   return (*this)[indexAsNumber];
 325 }
 326
 327 // ------------------------------ Arguments ---------------------------------
 328
 329 const ClassInfo Arguments::info = {"Arguments", 0, 0, 0};
 330
 331 // ECMA 10.1.8
 332 Arguments::Arguments(ExecState* exec, FunctionImp* func, const List& args, ActivationImp* act)
 333 : JSObject(exec->lexicalInterpreter()->builtinObjectPrototype()),
 334 _activationObject(act),
 335 indexToNameMap(func, args)
 336 {
 337   putDirect(exec->propertyNames().callee, func, DontEnum);
 338   putDirect(exec->propertyNames().length, args.size(), DontEnum);
 339
 340   int i = 0;
 341   ListIterator iterator = args.begin();
 342   for (; iterator != args.end(); i++, iterator++) {
 343     if (!indexToNameMap.isMapped(Identifier::from(i))) {
 344       JSObject::put(exec, Identifier::from(i), *iterator, DontEnum);
 345     }
 346   }
 347 }
 348
 349 void Arguments::mark()
 350 {
 351   JSObject::mark();
 352   if (_activationObject && !_activationObject->marked())
 353     _activationObject->mark();
 354 }
 355
 356 JSValue* Arguments::mappedIndexGetter(ExecState* exec, JSObject*, const Identifier& propertyName, const PropertySlot& slot)
 357 {
 358   Arguments* thisObj = static_cast<Arguments*>(slot.slotBase());
 359   return thisObj->_activationObject->get(exec, thisObj->indexToNameMap[propertyName]);
 360 }
 361
 362 bool Arguments::getOwnPropertySlot(ExecState* exec, const Identifier& propertyName, PropertySlot& slot)
 363 {
 364   if (indexToNameMap.isMapped(propertyName)) {
 365     slot.setCustom(this, mappedIndexGetter);
 366     return true;
 367   }
 368
 369   return JSObject::getOwnPropertySlot(exec, propertyName, slot);
 370 }
 371
 372 void Arguments::put(ExecState* exec, const Identifier& propertyName, JSValue* value, int attr)
 373 {
 374   if (indexToNameMap.isMapped(propertyName)) {
 375     _activationObject->put(exec, indexToNameMap[propertyName], value, attr);
 376   } else {
 377     JSObject::put(exec, propertyName, value, attr);
 378   }
 379 }
 380
 381 bool Arguments::deleteProperty(ExecState* exec, const Identifier& propertyName)
 382 {
 383   if (indexToNameMap.isMapped(propertyName)) {
 384     indexToNameMap.unMap(propertyName);
 385     return true;
 386   } else {
 387     return JSObject::deleteProperty(exec, propertyName);
 388   }
 389 }
 390
 391 // ------------------------------ ActivationImp --------------------------------
 392
 393 const ClassInfo ActivationImp::info = {"Activation", 0, 0, 0};
 394
 395 // ECMA 10.1.6
 396 ActivationImp::ActivationImp(FunctionImp* function, const List& arguments)
 397     : _function(function), _arguments(arguments), _argumentsObject(0)
 398 {
 399   // FIXME: Do we need to support enumerating the arguments property?
 400 }
 401
 402 JSValue* ActivationImp::argumentsGetter(ExecState* exec, JSObject*, const Identifier&, const PropertySlot& slot)
 403 {
 404   ActivationImp* thisObj = static_cast<ActivationImp*>(slot.slotBase());
 405
 406   // default: return builtin arguments array
 407   if (!thisObj->_argumentsObject)
 408     thisObj->createArgumentsObject(exec);
 409
 410   return thisObj->_argumentsObject;
 411 }
 412
 413 PropertySlot::GetValueFunc ActivationImp::getArgumentsGetter()
 414 {
 415   return ActivationImp::argumentsGetter;
 416 }
 417
 418 bool ActivationImp::getOwnPropertySlot(ExecState* exec, const Identifier& propertyName, PropertySlot& slot)
 419 {
 420     // do this first so property map arguments property wins over the below
 421     // we don't call JSObject because we won't have getter/setter properties
 422     // and we don't want to support __proto__
 423
 424     if (JSValue** location = getDirectLocation(propertyName)) {
 425         slot.setValueSlot(this, location);
 426         return true;
 427     }
 428
 429     if (propertyName == exec->propertyNames().arguments) {
 430         slot.setCustom(this, getArgumentsGetter());
 431         return true;
 432     }
 433
 434     return false;
 435 }
 436
 437 bool ActivationImp::deleteProperty(ExecState* exec, const Identifier& propertyName)
 438 {
 439     if (propertyName == exec->propertyNames().arguments)
 440         return false;
 441     return JSObject::deleteProperty(exec, propertyName);
 442 }
 443
 444 void ActivationImp::put(ExecState*, const Identifier& propertyName, JSValue* value, int attr)
 445 {
 446   // There's no way that an activation object can have a prototype or getter/setter properties
 447   ASSERT(!_prop.hasGetterSetterProperties());
 448   ASSERT(prototype() == jsNull());
 449
 450   _prop.put(propertyName, value, attr, (attr == None || attr == DontDelete));
 451 }
 452
 453 void ActivationImp::mark()
 454 {
 455     if (_function && !_function->marked())
 456         _function->mark();
 457     if (_argumentsObject && !_argumentsObject->marked())
 458         _argumentsObject->mark();
 459     JSObject::mark();
 460 }
 461
 462 void ActivationImp::createArgumentsObject(ExecState* exec)
 463 {
 464   _argumentsObject = new Arguments(exec, _function, _arguments, const_cast<ActivationImp*>(this));
 465   // The arguments list is only needed to create the arguments object, so discard it now
 466   _arguments.reset();
 467 }
 468
 469 // ------------------------------ GlobalFunc -----------------------------------
 470
 471
 472 GlobalFuncImp::GlobalFuncImp(ExecState* exec, FunctionPrototype* funcProto, int i, int len, const Identifier& name)
 473   : InternalFunctionImp(funcProto, name)
 474   , id(i)
 475 {
 476   putDirect(exec->propertyNames().length, len, DontDelete|ReadOnly|DontEnum);
 477 }
 478
 479 static JSValue* encode(ExecState* exec, const List& args, const char* do_not_escape)
 480 {
 481   UString r = "", s, str = args[0]->toString(exec);
 482   CString cstr = str.UTF8String();
 483   const char* p = cstr.c_str();
 484   for (size_t k = 0; k < cstr.size(); k++, p++) {
 485     char c = *p;
 486     if (c && strchr(do_not_escape, c)) {
 487       r.append(c);
 488     } else {
 489       char tmp[4];
 490       sprintf(tmp, "%%%02X", (unsigned char)c);
 491       r += tmp;
 492     }
 493   }
 494   return jsString(r);
 495 }
 496
 497 static JSValue* decode(ExecState* exec, const List& args, const char* do_not_unescape, bool strict)
 498 {
 499   UString s = "", str = args[0]->toString(exec);
 500   int k = 0, len = str.size();
 501   const UChar* d = str.data();
 502   UChar u;
 503   while (k < len) {
 504     const UChar* p = d + k;
 505     UChar c = *p;
 506     if (c == '%') {
 507       int charLen = 0;
 508       if (k <= len - 3 && isASCIIHexDigit(p[1].uc) && isASCIIHexDigit(p[2].uc)) {
 509         const char b0 = Lexer::convertHex(p[1].uc, p[2].uc);
 510         const int sequenceLen = UTF8SequenceLength(b0);
 511         if (sequenceLen != 0 && k <= len - sequenceLen * 3) {
 512           charLen = sequenceLen * 3;
 513           char sequence[5];
 514           sequence[0] = b0;
 515           for (int i = 1; i < sequenceLen; ++i) {
 516             const UChar* q = p + i * 3;
 517             if (q[0] == '%' && isASCIIHexDigit(q[1].uc) && isASCIIHexDigit(q[2].uc))
 518               sequence[i] = Lexer::convertHex(q[1].uc, q[2].uc);
 519             else {
 520               charLen = 0;
 521               break;
 522             }
 523           }
 524           if (charLen != 0) {
 525             sequence[sequenceLen] = 0;
 526             const int character = decodeUTF8Sequence(sequence);
 527             if (character < 0 || character >= 0x110000) {
 528               charLen = 0;
 529             } else if (character >= 0x10000) {
 530               // Convert to surrogate pair.
 531               s.append(static_cast<unsigned short>(0xD800 | ((character - 0x10000) >> 10)));
 532               u = static_cast<unsigned short>(0xDC00 | ((character - 0x10000) & 0x3FF));
 533             } else {
 534               u = static_cast<unsigned short>(character);
 535             }
 536           }
 537         }
 538       }
 539       if (charLen == 0) {
 540         if (strict)
 541           return throwError(exec, URIError);
 542         // The only case where we don't use "strict" mode is the "unescape" function.
 543         // For that, it's good to support the wonky "%u" syntax for compatibility with WinIE.
 544         if (k <= len - 6 && p[1] == 'u'
 545             && isASCIIHexDigit(p[2].uc) && isASCIIHexDigit(p[3].uc)
 546             && isASCIIHexDigit(p[4].uc) && isASCIIHexDigit(p[5].uc)) {
 547           charLen = 6;
 548           u = Lexer::convertUnicode(p[2].uc, p[3].uc, p[4].uc, p[5].uc);
 549         }
 550       }
 551       if (charLen && (u.uc == 0 || u.uc >= 128 || !strchr(do_not_unescape, u.low()))) {
 552         c = u;
 553         k += charLen - 1;
 554       }
 555     }
 556     k++;
 557     s.append(c);
 558   }
 559   return jsString(s);
 560 }
 561
 562 static bool isStrWhiteSpace(unsigned short c)
 563 {
 564     switch (c) {
 565         case 0x0009:
 566         case 0x000A:
 567         case 0x000B:
 568         case 0x000C:
 569         case 0x000D:
 570         case 0x0020:
 571         case 0x00A0:
 572         case 0x2028:
 573         case 0x2029:
 574             return true;
 575         default:
 576             return isSeparatorSpace(c);
 577     }
 578 }
 579
 580 static int parseDigit(unsigned short c, int radix)
 581 {
 582     int digit = -1;
 583
 584     if (c >= '0' && c <= '9') {
 585         digit = c - '0';
 586     } else if (c >= 'A' && c <= 'Z') {
 587         digit = c - 'A' + 10;
 588     } else if (c >= 'a' && c <= 'z') {
 589         digit = c - 'a' + 10;
 590     }
 591
 592     if (digit >= radix)
 593         return -1;
 594     return digit;
 595 }
 596
 597 double parseIntOverflow(const char* s, int length, int radix)
 598 {
 599     double number = 0.0;
 600     double radixMultiplier = 1.0;
 601
 602     for (const char* p = s + length - 1; p >= s; p--) {
 603         if (radixMultiplier == Inf) {
 604             if (*p != '0') {
 605                 number = Inf;
 606                 break;
 607             }
 608         } else {
 609             int digit = parseDigit(*p, radix);
 610             number += digit * radixMultiplier;
 611         }
 612
 613         radixMultiplier *= radix;
 614     }
 615
 616     return number;
 617 }
 618
 619 static double parseInt(const UString& s, int radix)
 620 {
 621     int length = s.size();
 622     int p = 0;
 623
 624     while (p < length && isStrWhiteSpace(s[p].uc)) {
 625         ++p;
 626     }
 627
 628     double sign = 1;
 629     if (p < length) {
 630         if (s[p] == '+') {
 631             ++p;
 632         } else if (s[p] == '-') {
 633             sign = -1;
 634             ++p;
 635         }
 636     }
 637
 638     if ((radix == 0 || radix == 16) && length - p >= 2 && s[p] == '0' && (s[p + 1] == 'x' || s[p + 1] == 'X')) {
 639         radix = 16;
 640         p += 2;
 641     } else if (radix == 0) {
 642         if (p < length && s[p] == '0')
 643             radix = 8;
 644         else
 645             radix = 10;
 646     }
 647
 648     if (radix < 2 || radix > 36)
 649         return NaN;
 650
 651     int firstDigitPosition = p;
 652     bool sawDigit = false;
 653     double number = 0;
 654     while (p < length) {
 655         int digit = parseDigit(s[p].uc, radix);
 656         if (digit == -1)
 657             break;
 658         sawDigit = true;
 659         number *= radix;
 660         number += digit;
 661         ++p;
 662     }
 663
 664     if (number >= mantissaOverflowLowerBound) {
 665         if (radix == 10)
 666             number = kjs_strtod(s.substr(firstDigitPosition, p - firstDigitPosition).ascii(), 0);
 667         else if (radix == 2 || radix == 4 || radix == 8 || radix == 16 || radix == 32)
 668             number = parseIntOverflow(s.substr(firstDigitPosition, p - firstDigitPosition).ascii(), p - firstDigitPosition, radix);
 669     }
 670
 671     if (!sawDigit)
 672         return NaN;
 673
 674     return sign * number;
 675 }
 676
 677 static double parseFloat(const UString& s)
 678 {
 679     // Check for 0x prefix here, because toDouble allows it, but we must treat it as 0.
 680     // Need to skip any whitespace and then one + or - sign.
 681     int length = s.size();
 682     int p = 0;
 683     while (p < length && isStrWhiteSpace(s[p].uc)) {
 684         ++p;
 685     }
 686     if (p < length && (s[p] == '+' || s[p] == '-')) {
 687         ++p;
 688     }
 689     if (length - p >= 2 && s[p] == '0' && (s[p + 1] == 'x' || s[p + 1] == 'X')) {
 690         return 0;
 691     }
 692
 693     return s.toDouble( true /*tolerant*/, false /* NaN for empty string */ );
 694 }
 695
 696 JSValue* GlobalFuncImp::callAsFunction(ExecState* exec, JSObject* thisObj, const List& args)
 697 {
 698   JSValue* res = jsUndefined();
 699
 700   static const char do_not_escape[] =
 701     "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
 702     "abcdefghijklmnopqrstuvwxyz"
 703     "0123456789"
 704     "*+-./@_";
 705
 706   static const char do_not_escape_when_encoding_URI_component[] =
 707     "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
 708     "abcdefghijklmnopqrstuvwxyz"
 709     "0123456789"
 710     "!'()*-._~";
 711   static const char do_not_escape_when_encoding_URI[] =
 712     "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
 713     "abcdefghijklmnopqrstuvwxyz"
 714     "0123456789"
 715     "!#$&'()*+,-./:;=?@_~";
 716   static const char do_not_unescape_when_decoding_URI[] =
 717     "#$&+,/:;=?@";
 718
 719   switch (id) {
 720     case Eval: { // eval()
 721       JSValue* x = args[0];
 722       if (!x->isString())
 723         return x;
 724       else {
 725         UString s = x->toString(exec);
 726
 727         int sid;
 728         int errLine;
 729         UString errMsg;
 730         RefPtr<ProgramNode> progNode(Parser::parse(UString(), 0, s.data(),s.size(),&sid,&errLine,&errMsg));
 731
 732         Debugger* dbg = exec->dynamicInterpreter()->debugger();
 733         if (dbg) {
 734           bool cont = dbg->sourceParsed(exec, sid, UString(), s, 0, errLine, errMsg);
 735           if (!cont)
 736             return jsUndefined();
 737         }
 738
 739         // no program node means a syntax occurred
 740         if (!progNode)
 741           return throwError(exec, SyntaxError, errMsg, errLine, sid, NULL);
 742
 743         bool switchGlobal = thisObj && thisObj != exec->dynamicInterpreter()->globalObject();
 744
 745         // enter a new execution context
 746         Interpreter* interpreter = switchGlobal ? static_cast<JSGlobalObject*>(thisObj)->interpreter() : exec->dynamicInterpreter();
 747         JSObject* thisVal = static_cast<JSObject*>(exec->context()->thisValue());
 748         Context ctx(interpreter->globalObject(),
 749                        interpreter,
 750                        thisVal,
 751                        progNode.get(),
 752                        EvalCode,
 753                        exec->context());
 754         ExecState newExec(interpreter, &ctx);
 755         if (exec->hadException())
 756             newExec.setException(exec->exception());
 757         ctx.setExecState(&newExec);
 758
 759         if (switchGlobal) {
 760             ctx.pushScope(thisObj);
 761             ctx.setVariableObject(thisObj);
 762         }
 763
 764         Completion c = progNode->execute(&newExec);
 765
 766         if (switchGlobal)
 767             ctx.popScope();
 768
 769         // if an exception occured, propogate it back to the previous execution object
 770         if (newExec.hadException())
 771           exec->setException(newExec.exception());
 772
 773         res = jsUndefined();
 774         if (c.complType() == Throw)
 775           exec->setException(c.value());
 776         else if (c.isValueCompletion())
 777             res = c.value();
 778       }
 779       break;
 780     }
 781   case ParseInt:
 782     res = jsNumber(parseInt(args[0]->toString(exec), args[1]->toInt32(exec)));
 783     break;
 784   case ParseFloat:
 785     res = jsNumber(parseFloat(args[0]->toString(exec)));
 786     break;
 787   case IsNaN:
 788     res = jsBoolean(isNaN(args[0]->toNumber(exec)));
 789     break;
 790   case IsFinite: {
 791     double n = args[0]->toNumber(exec);
 792     res = jsBoolean(!isNaN(n) && !isInf(n));
 793     break;
 794   }
 795   case DecodeURI:
 796     res = decode(exec, args, do_not_unescape_when_decoding_URI, true);
 797     break;
 798   case DecodeURIComponent:
 799     res = decode(exec, args, "", true);
 800     break;
 801   case EncodeURI:
 802     res = encode(exec, args, do_not_escape_when_encoding_URI);
 803     break;
 804   case EncodeURIComponent:
 805     res = encode(exec, args, do_not_escape_when_encoding_URI_component);
 806     break;
 807   case Escape:
 808     {
 809       UString r = "", s, str = args[0]->toString(exec);
 810       const UChar* c = str.data();
 811       for (int k = 0; k < str.size(); k++, c++) {
 812         int u = c->uc;
 813         if (u > 255) {
 814           char tmp[7];
 815           sprintf(tmp, "%%u%04X", u);
 816           s = UString(tmp);
 817         } else if (u != 0 && strchr(do_not_escape, (char)u)) {
 818           s = UString(c, 1);
 819         } else {
 820           char tmp[4];
 821           sprintf(tmp, "%%%02X", u);
 822           s = UString(tmp);
 823         }
 824         r += s;
 825       }
 826       res = jsString(r);
 827       break;
 828     }
 829   case UnEscape:
 830     {
 831       UString s = "", str = args[0]->toString(exec);
 832       int k = 0, len = str.size();
 833       while (k < len) {
 834         const UChar* c = str.data() + k;
 835         UChar u;
 836         if (*c == UChar('%') && k <= len - 6 && *(c+1) == UChar('u')) {
 837           if (Lexer::isHexDigit((c+2)->uc) && Lexer::isHexDigit((c+3)->uc) &&
 838               Lexer::isHexDigit((c+4)->uc) && Lexer::isHexDigit((c+5)->uc)) {
 839           u = Lexer::convertUnicode((c+2)->uc, (c+3)->uc,
 840                                     (c+4)->uc, (c+5)->uc);
 841           c = &u;
 842           k += 5;
 843           }
 844         } else if (*c == UChar('%') && k <= len - 3 &&
 845                    Lexer::isHexDigit((c+1)->uc) && Lexer::isHexDigit((c+2)->uc)) {
 846           u = UChar(Lexer::convertHex((c+1)->uc, (c+2)->uc));
 847           c = &u;
 848           k += 2;
 849         }
 850         k++;
 851         s += UString(c, 1);
 852       }
 853       res = jsString(s);
 854       break;
 855     }
 856 #ifndef NDEBUG
 857   case KJSPrint:
 858     puts(args[0]->toString(exec).ascii());
 859     break;
 860 #endif
 861   }
 862
 863   return res;
 864 }
 865
 866 UString escapeStringForPrettyPrinting(const UString& s)
 867 {
 868     UString escapedString;
 869
 870     for (int i = 0; i < s.size(); i++) {
 871         unsigned short c = s.data()[i].unicode();
 872
 873         switch (c) {
 874         case '\"':
 875             escapedString += "\\\"";
 876             break;
 877         case '\n':
 878             escapedString += "\\n";
 879             break;
 880         case '\r':
 881             escapedString += "\\r";
 882             break;
 883         case '\t':
 884             escapedString += "\\t";
 885             break;
 886         case '\\':
 887             escapedString += "\\\\";
 888             break;
 889         default:
 890             if (c < 128 && isPrintableChar(c))
 891                 escapedString.append(c);
 892             else {
 893                 char hexValue[7];
 894
 895 #if PLATFORM(WIN_OS)
 896                 _snprintf(hexValue, 7, "\\u%04x", c);
 897 #else
 898                 snprintf(hexValue, 7, "\\u%04x", c);
 899 #endif
 900                 escapedString += hexValue;
 901             }
 902         }
 903     }
 904
 905     return escapedString;
 906 }
 907
 908 } // namespace