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