Reviewed by Oliver Hunt.
[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 "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