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