2006-04-18 Eric Seidel <eseidel@apple.com>
[WebKit-https.git] / JavaScriptCore / kjs / function_object.cpp
1 // -*- c-basic-offset: 2 -*-
2 /*
3  *  This file is part of the KDE libraries
4  *  Copyright (C) 1999-2001 Harri Porten (porten@kde.org)
5  *  Copyright (C) 2003, 2004, 2005, 2006 Apple Computer, Inc.
6  *
7  *  This library is free software; you can redistribute it and/or
8  *  modify it under the terms of the GNU Lesser General Public
9  *  License as published by the Free Software Foundation; either
10  *  version 2 of the License, or (at your option) any later version.
11  *
12  *  This library is distributed in the hope that it will be useful,
13  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
14  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  *  Lesser General Public License for more details.
16  *
17  *  You should have received a copy of the GNU Lesser General Public
18  *  License along with this library; if not, write to the Free Software
19  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
20  *
21  */
22
23 #include "config.h"
24 #include "function_object.h"
25 #include "internal.h"
26 #include "function.h"
27 #include "array_object.h"
28 #include "nodes.h"
29 #include "lexer.h"
30 #include "debugger.h"
31 #include "object.h"
32
33 #include <assert.h>
34 #include <stdio.h>
35 #include <string.h>
36
37 using namespace KJS;
38
39 // ------------------------------ FunctionPrototype -------------------------
40
41 FunctionPrototype::FunctionPrototype(ExecState *exec)
42 {
43   putDirect(lengthPropertyName, jsNumber(0), DontDelete|ReadOnly|DontEnum);
44   putDirectFunction(new FunctionProtoFunc(exec, this, FunctionProtoFunc::ToString, 0, toStringPropertyName), DontEnum);
45   static const Identifier applyPropertyName("apply");
46   putDirectFunction(new FunctionProtoFunc(exec, this, FunctionProtoFunc::Apply, 2, applyPropertyName), DontEnum);
47   static const Identifier callPropertyName("call");
48   putDirectFunction(new FunctionProtoFunc(exec, this, FunctionProtoFunc::Call, 1, callPropertyName), DontEnum);
49 }
50
51 FunctionPrototype::~FunctionPrototype()
52 {
53 }
54
55 // ECMA 15.3.4
56 JSValue *FunctionPrototype::callAsFunction(ExecState */*exec*/, JSObject */*thisObj*/, const List &/*args*/)
57 {
58   return jsUndefined();
59 }
60
61 // ------------------------------ FunctionProtoFunc -------------------------
62
63 FunctionProtoFunc::FunctionProtoFunc(ExecState*, FunctionPrototype* funcProto, int i, int len, const Identifier& name)
64   : InternalFunctionImp(funcProto, name)
65   , id(i)
66 {
67   putDirect(lengthPropertyName, len, DontDelete|ReadOnly|DontEnum);
68 }
69
70 JSValue *FunctionProtoFunc::callAsFunction(ExecState *exec, JSObject *thisObj, const List &args)
71 {
72   JSValue *result = NULL;
73
74   switch (id) {
75   case ToString:
76     if (!thisObj || !thisObj->inherits(&InternalFunctionImp::info)) {
77 #ifndef NDEBUG
78       fprintf(stderr,"attempted toString() call on null or non-function object\n");
79 #endif
80       return throwError(exec, TypeError);
81     }
82     if (thisObj->inherits(&DeclaredFunctionImp::info)) {
83         DeclaredFunctionImp *fi = static_cast<DeclaredFunctionImp*>(thisObj);
84         return jsString("function " + fi->functionName().ustring() + "(" +
85                         fi->parameterString() + ") " + fi->body->toString());
86      } else if (thisObj->inherits(&InternalFunctionImp::info) &&
87                 !static_cast<InternalFunctionImp*>(thisObj)->functionName().isNull()) {
88        result = jsString("\nfunction " + static_cast<InternalFunctionImp*>(thisObj)->functionName().ustring() + "() {\n"
89                        "    [native code]\n}\n");
90     } else {
91       result = jsString("[function]");
92     }
93     break;
94   case Apply: {
95     JSValue *thisArg = args[0];
96     JSValue *argArray = args[1];
97     JSObject *func = thisObj;
98
99     if (!func->implementsCall())
100       return throwError(exec, TypeError);
101
102     JSObject *applyThis;
103     if (thisArg->isUndefinedOrNull())
104       applyThis = exec->dynamicInterpreter()->globalObject();
105     else
106       applyThis = thisArg->toObject(exec);
107
108     List applyArgs;
109     if (!argArray->isUndefinedOrNull()) {
110       if (argArray->isObject() &&
111            (static_cast<JSObject *>(argArray)->inherits(&ArrayInstance::info) ||
112             static_cast<JSObject *>(argArray)->inherits(&Arguments::info))) {
113
114         JSObject *argArrayObj = static_cast<JSObject *>(argArray);
115         unsigned int length = argArrayObj->get(exec,lengthPropertyName)->toUInt32(exec);
116         for (unsigned int i = 0; i < length; i++)
117           applyArgs.append(argArrayObj->get(exec,i));
118       }
119       else
120         return throwError(exec, TypeError);
121     }
122     result = func->call(exec,applyThis,applyArgs);
123     }
124     break;
125   case Call: {
126     JSValue *thisArg = args[0];
127     JSObject *func = thisObj;
128
129     if (!func->implementsCall())
130       return throwError(exec, TypeError);
131
132     JSObject *callThis;
133     if (thisArg->isUndefinedOrNull())
134       callThis = exec->dynamicInterpreter()->globalObject();
135     else
136       callThis = thisArg->toObject(exec);
137
138     result = func->call(exec,callThis,args.copyTail());
139     }
140     break;
141   }
142
143   return result;
144 }
145
146 // ------------------------------ FunctionObjectImp ----------------------------
147
148 FunctionObjectImp::FunctionObjectImp(ExecState*, FunctionPrototype* funcProto)
149   : InternalFunctionImp(funcProto)
150 {
151   putDirect(prototypePropertyName, funcProto, DontEnum|DontDelete|ReadOnly);
152
153   // no. of arguments for constructor
154   putDirect(lengthPropertyName, jsNumber(1), ReadOnly|DontDelete|DontEnum);
155 }
156
157 FunctionObjectImp::~FunctionObjectImp()
158 {
159 }
160
161 bool FunctionObjectImp::implementsConstruct() const
162 {
163   return true;
164 }
165
166 // ECMA 15.3.2 The Function Constructor
167 JSObject* FunctionObjectImp::construct(ExecState* exec, const List& args, const Identifier& functionName, const UString& sourceURL, int lineNumber)
168 {
169   UString p("");
170   UString body;
171   int argsSize = args.size();
172   if (argsSize == 0) {
173     body = "";
174   } else if (argsSize == 1) {
175     body = args[0]->toString(exec);
176   } else {
177     p = args[0]->toString(exec);
178     for (int k = 1; k < argsSize - 1; k++)
179       p += "," + args[k]->toString(exec);
180     body = args[argsSize-1]->toString(exec);
181   }
182
183   // parse the source code
184   int sid;
185   int errLine;
186   UString errMsg;
187   RefPtr<ProgramNode> progNode = Parser::parse(sourceURL, lineNumber, body.data(),body.size(),&sid,&errLine,&errMsg);
188
189   // notify debugger that source has been parsed
190   Debugger *dbg = exec->dynamicInterpreter()->imp()->debugger();
191   if (dbg) {
192     // send empty sourceURL to indicate constructed code
193     bool cont = dbg->sourceParsed(exec,sid,UString(),body,errLine);
194     if (!cont) {
195       dbg->imp()->abort();
196       return new JSObject();
197     }
198   }
199
200   // no program node == syntax error - throw a syntax error
201   if (!progNode)
202     // we can't return a Completion(Throw) here, so just set the exception
203     // and return it
204     return throwError(exec, SyntaxError, errMsg, errLine, sid, &sourceURL);
205
206   ScopeChain scopeChain;
207   scopeChain.push(exec->lexicalInterpreter()->globalObject());
208   FunctionBodyNode *bodyNode = progNode.get();
209
210   FunctionImp* fimp = new DeclaredFunctionImp(exec, functionName, bodyNode, scopeChain);
211   
212   // parse parameter list. throw syntax error on illegal identifiers
213   int len = p.size();
214   const UChar *c = p.data();
215   int i = 0, params = 0;
216   UString param;
217   while (i < len) {
218       while (*c == ' ' && i < len)
219           c++, i++;
220       if (Lexer::isIdentStart(c->uc)) {  // else error
221           param = UString(c, 1);
222           c++, i++;
223           while (i < len && (Lexer::isIdentPart(c->uc))) {
224               param += UString(c, 1);
225               c++, i++;
226           }
227           while (i < len && *c == ' ')
228               c++, i++;
229           if (i == len) {
230               fimp->addParameter(Identifier(param));
231               params++;
232               break;
233           } else if (*c == ',') {
234               fimp->addParameter(Identifier(param));
235               params++;
236               c++, i++;
237               continue;
238           } // else error
239       }
240       return throwError(exec, SyntaxError, "Syntax error in parameter list");
241   }
242   
243   List consArgs;
244
245   JSObject *objCons = exec->lexicalInterpreter()->builtinObject();
246   JSObject *prototype = objCons->construct(exec,List::empty());
247   prototype->put(exec, constructorPropertyName, fimp, DontEnum|DontDelete|ReadOnly);
248   fimp->put(exec, prototypePropertyName, prototype, DontEnum|DontDelete|ReadOnly);
249   return fimp;
250 }
251
252 // ECMA 15.3.2 The Function Constructor
253 JSObject* FunctionObjectImp::construct(ExecState* exec, const List& args)
254 {
255   return construct(exec, args, "anonymous", UString(), 0);
256 }
257
258 // ECMA 15.3.1 The Function Constructor Called as a Function
259 JSValue* FunctionObjectImp::callAsFunction(ExecState* exec, JSObject* /*thisObj*/, const List &args)
260 {
261   return construct(exec, args);
262 }