Reviewed by Darin.
[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   static const Identifier* applyPropertyName = new Identifier("apply");
44   static const Identifier* callPropertyName = new Identifier("call");
45
46   putDirect(exec->propertyNames().length, jsNumber(0), DontDelete | ReadOnly | DontEnum);
47   putDirectFunction(new FunctionProtoFunc(exec, this, FunctionProtoFunc::ToString, 0, exec->propertyNames().toString), DontEnum);
48   putDirectFunction(new FunctionProtoFunc(exec, this, FunctionProtoFunc::Apply, 2, *applyPropertyName), DontEnum);
49   putDirectFunction(new FunctionProtoFunc(exec, this, FunctionProtoFunc::Call, 1, *callPropertyName), DontEnum);
50 }
51
52 FunctionPrototype::~FunctionPrototype()
53 {
54 }
55
56 // ECMA 15.3.4
57 JSValue *FunctionPrototype::callAsFunction(ExecState*, JSObject* /*thisObj*/, const List &/*args*/)
58 {
59   return jsUndefined();
60 }
61
62 // ------------------------------ FunctionProtoFunc -------------------------
63
64 FunctionProtoFunc::FunctionProtoFunc(ExecState* exec, FunctionPrototype* funcProto, int i, int len, const Identifier& name)
65   : InternalFunctionImp(funcProto, name)
66   , id(i)
67 {
68   putDirect(exec->propertyNames().length, len, DontDelete | ReadOnly | DontEnum);
69 }
70
71 JSValue* FunctionProtoFunc::callAsFunction(ExecState* exec, JSObject* thisObj, const List &args)
72 {
73   JSValue* result = NULL;
74
75   switch (id) {
76   case ToString:
77     if (!thisObj || !thisObj->inherits(&InternalFunctionImp::info)) {
78 #ifndef NDEBUG
79       fprintf(stderr,"attempted toString() call on null or non-function object\n");
80 #endif
81       return throwError(exec, TypeError);
82     }
83     if (thisObj->inherits(&DeclaredFunctionImp::info)) {
84         DeclaredFunctionImp *fi = static_cast<DeclaredFunctionImp*>(thisObj);
85         return jsString("function " + fi->functionName().ustring() + "(" +
86                         fi->body->paramString() + ") " + fi->body->toString());
87      } else if (thisObj->inherits(&InternalFunctionImp::info) &&
88                 !static_cast<InternalFunctionImp*>(thisObj)->functionName().isNull()) {
89        result = jsString("\nfunction " + static_cast<InternalFunctionImp*>(thisObj)->functionName().ustring() + "() {\n"
90                        "    [native code]\n}\n");
91     } else {
92       result = jsString("[function]");
93     }
94     break;
95   case Apply: {
96     JSValue *thisArg = args[0];
97     JSValue *argArray = args[1];
98     JSObject *func = thisObj;
99
100     if (!func->implementsCall())
101       return throwError(exec, TypeError);
102
103     JSObject *applyThis;
104     if (thisArg->isUndefinedOrNull())
105       applyThis = exec->dynamicInterpreter()->globalObject();
106     else
107       applyThis = thisArg->toObject(exec);
108
109     List applyArgs;
110     if (!argArray->isUndefinedOrNull()) {
111       if (argArray->isObject() &&
112            (static_cast<JSObject *>(argArray)->inherits(&ArrayInstance::info) ||
113             static_cast<JSObject *>(argArray)->inherits(&Arguments::info))) {
114
115         JSObject *argArrayObj = static_cast<JSObject *>(argArray);
116         unsigned int length = argArrayObj->get(exec, exec->propertyNames().length)->toUInt32(exec);
117         for (unsigned int i = 0; i < length; i++)
118           applyArgs.append(argArrayObj->get(exec,i));
119       }
120       else
121         return throwError(exec, TypeError);
122     }
123     result = func->call(exec,applyThis,applyArgs);
124     }
125     break;
126   case Call: {
127     JSValue *thisArg = args[0];
128     JSObject *func = thisObj;
129
130     if (!func->implementsCall())
131       return throwError(exec, TypeError);
132
133     JSObject *callThis;
134     if (thisArg->isUndefinedOrNull())
135       callThis = exec->dynamicInterpreter()->globalObject();
136     else
137       callThis = thisArg->toObject(exec);
138
139     result = func->call(exec,callThis,args.copyTail());
140     }
141     break;
142   }
143
144   return result;
145 }
146
147 // ------------------------------ FunctionObjectImp ----------------------------
148
149 FunctionObjectImp::FunctionObjectImp(ExecState* exec, FunctionPrototype* funcProto)
150   : InternalFunctionImp(funcProto)
151 {
152   putDirect(exec->propertyNames().prototype, funcProto, DontEnum|DontDelete|ReadOnly);
153
154   // no. of arguments for constructor
155   putDirect(exec->propertyNames().length, jsNumber(1), ReadOnly|DontDelete|DontEnum);
156 }
157
158 FunctionObjectImp::~FunctionObjectImp()
159 {
160 }
161
162 bool FunctionObjectImp::implementsConstruct() const
163 {
164   return true;
165 }
166
167 // ECMA 15.3.2 The Function Constructor
168 JSObject* FunctionObjectImp::construct(ExecState* exec, const List& args, const Identifier& functionName, const UString& sourceURL, int lineNumber)
169 {
170   UString p("");
171   UString body;
172   int argsSize = args.size();
173   if (argsSize == 0) {
174     body = "";
175   } else if (argsSize == 1) {
176     body = args[0]->toString(exec);
177   } else {
178     p = args[0]->toString(exec);
179     for (int k = 1; k < argsSize - 1; k++)
180       p += "," + args[k]->toString(exec);
181     body = args[argsSize-1]->toString(exec);
182   }
183
184   // parse the source code
185   int sid;
186   int errLine;
187   UString errMsg;
188   RefPtr<ProgramNode> progNode = Parser::parse(sourceURL, lineNumber, body.data(),body.size(),&sid,&errLine,&errMsg);
189
190   // notify debugger that source has been parsed
191   Debugger *dbg = exec->dynamicInterpreter()->debugger();
192   if (dbg) {
193     // send empty sourceURL to indicate constructed code
194     bool cont = dbg->sourceParsed(exec, sid, UString(), body, lineNumber, errLine, errMsg);
195     if (!cont) {
196       dbg->imp()->abort();
197       return new JSObject();
198     }
199   }
200
201   // no program node == syntax error - throw a syntax error
202   if (!progNode)
203     // we can't return a Completion(Throw) here, so just set the exception
204     // and return it
205     return throwError(exec, SyntaxError, errMsg, errLine, sid, sourceURL);
206
207   ScopeChain scopeChain;
208   scopeChain.push(exec->lexicalInterpreter()->globalObject());
209   FunctionBodyNode *bodyNode = progNode.get();
210
211   FunctionImp* fimp = new DeclaredFunctionImp(exec, functionName, bodyNode, scopeChain);
212   
213   // parse parameter list. throw syntax error on illegal identifiers
214   int len = p.size();
215   const UChar *c = p.data();
216   int i = 0, params = 0;
217   UString param;
218   while (i < len) {
219       while (*c == ' ' && i < len)
220           c++, i++;
221       if (Lexer::isIdentStart(c->uc)) {  // else error
222           param = UString(c, 1);
223           c++, i++;
224           while (i < len && (Lexer::isIdentPart(c->uc))) {
225               param += UString(c, 1);
226               c++, i++;
227           }
228           while (i < len && *c == ' ')
229               c++, i++;
230           if (i == len) {
231               bodyNode->addParam(Identifier(param));
232               params++;
233               break;
234           } else if (*c == ',') {
235               bodyNode->addParam(Identifier(param));
236               params++;
237               c++, i++;
238               continue;
239           } // else error
240       }
241       return throwError(exec, SyntaxError, "Syntax error in parameter list");
242   }
243   
244   List consArgs;
245
246   JSObject* objCons = exec->lexicalInterpreter()->builtinObject();
247   JSObject* prototype = objCons->construct(exec,List::empty());
248   prototype->put(exec, exec->propertyNames().constructor, fimp, DontEnum|DontDelete|ReadOnly);
249   fimp->put(exec, exec->propertyNames().prototype, prototype, Internal|DontDelete);
250   return fimp;
251 }
252
253 // ECMA 15.3.2 The Function Constructor
254 JSObject* FunctionObjectImp::construct(ExecState* exec, const List& args)
255 {
256   return construct(exec, args, "anonymous", UString(), 0);
257 }
258
259 // ECMA 15.3.1 The Function Constructor Called as a Function
260 JSValue* FunctionObjectImp::callAsFunction(ExecState* exec, JSObject* /*thisObj*/, const List &args)
261 {
262   return construct(exec, args);
263 }