// -*- c-basic-offset: 2 -*-

/*

 *  This file is part of the KDE libraries

 *  Copyright (C) 1999-2002 Harri Porten (porten@kde.org)

 *  Copyright (C) 2001 Peter Kelly (pmk@post.com)

 *  Copyright (C) 2003 Apple Computer, Inc.

 *  Copyright (C) 2007 Cameron Zwarich (cwzwarich@uwaterloo.ca)

 *

 *  This library is free software; you can redistribute it and/or

 *  modify it under the terms of the GNU Library General Public

 *  License as published by the Free Software Foundation; either

 *  version 2 of the License, or (at your option) any later version.

 *

 *  This library is distributed in the hope that it will be useful,

 *  but WITHOUT ANY WARRANTY; without even the implied warranty of

 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 *  Library General Public License for more details.

 *

 *  You should have received a copy of the GNU Library General Public License

 *  along with this library; see the file COPYING.LIB.  If not, write to

 *  the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,

 *  Boston, MA 02110-1301, USA.

 *

 */

#include "config.h"

#include "function.h"

#include "dtoa.h"

#include "internal.h"

#include "function_object.h"

#include "lexer.h"

#include "nodes.h"

#include "operations.h"

#include "debugger.h"

#include "context.h"

#include <stdio.h>

#include <errno.h>

#include <stdlib.h>

#include <assert.h>

#include <string.h>

#include <ctype.h>

#include <wtf/unicode/Unicode.h>

using namespace WTF;

using namespace Unicode;

namespace KJS {

// ----------------------------- FunctionImp ----------------------------------

const ClassInfo FunctionImp::info = {"Function", &InternalFunctionImp::info, 0, 0};

FunctionImp::FunctionImp(ExecState* exec, const Identifier& n, FunctionBodyNode* b)

  : InternalFunctionImp(static_cast<FunctionPrototype*>

                        (exec->lexicalInterpreter()->builtinFunctionPrototype()), n)

  , body(b)

{

}

void FunctionImp::mark()

{

    InternalFunctionImp::mark();

    _scope.mark();

}

FunctionImp::~FunctionImp()

{

}

JSValue* FunctionImp::callAsFunction(ExecState* exec, JSObject* thisObj, const List& args)

{

  JSObject* globalObj = exec->dynamicInterpreter()->globalObject();

  // enter a new execution context

  Context ctx(globalObj, exec->dynamicInterpreter(), thisObj, body.get(),

                 codeType(), exec->context(), this, &args);

  ExecState newExec(exec->dynamicInterpreter(), &ctx);

  if (exec->hadException())

    newExec.setException(exec->exception());

  ctx.setExecState(&newExec);

  // assign user supplied arguments to parameters

  passInParameters(&newExec, args);

  // add variable declarations (initialized to undefined)

  processVarDecls(&newExec);

  Debugger* dbg = exec->dynamicInterpreter()->debugger();

  int sid = -1;

  int lineno = -1;

  if (dbg) {

    if (inherits(&DeclaredFunctionImp::info)) {

      sid = static_cast<DeclaredFunctionImp*>(this)->body->sourceId();

      lineno = static_cast<DeclaredFunctionImp*>(this)->body->firstLine();

    }

    bool cont = dbg->callEvent(&newExec,sid,lineno,this,args);

    if (!cont) {

      dbg->imp()->abort();

      return jsUndefined();

    }

  }

  Completion comp = execute(&newExec);

  // if an exception occured, propogate it back to the previous execution object

  if (newExec.hadException())

    comp = Completion(Throw, newExec.exception());

#ifdef KJS_VERBOSE

  if (comp.complType() == Throw)

    printInfo(exec,"throwing", comp.value());

  else if (comp.complType() == ReturnValue)

    printInfo(exec,"returning", comp.value());

  else

    fprintf(stderr, "returning: undefined\n");

#endif

  // The debugger may have been deallocated by now if the WebFrame

  // we were running in has been destroyed, so refetch it.

  // See http://bugs.webkit.org/show_bug.cgi?id=9477

  dbg = exec->dynamicInterpreter()->debugger();

  if (dbg) {

    if (inherits(&DeclaredFunctionImp::info))

      lineno = static_cast<DeclaredFunctionImp*>(this)->body->lastLine();

    if (comp.complType() == Throw)

        newExec.setException(comp.value());

    int cont = dbg->returnEvent(&newExec,sid,lineno,this);

    if (!cont) {

      dbg->imp()->abort();

      return jsUndefined();

    }

  }

  if (comp.complType() == Throw) {

    exec->setException(comp.value());

    return comp.value();

  }

  else if (comp.complType() == ReturnValue)

    return comp.value();

  else

    return jsUndefined();

}

// ECMA 10.1.3q

inline void FunctionImp::passInParameters(ExecState* exec, const List& args)

{

    Vector<Parameter>& parameters = body->parameters();

    JSObject* variable = exec->context()->variableObject();

#ifdef KJS_VERBOSE

    fprintf(stderr, "---------------------------------------------------\n"

          "processing parameters for %s call\n",

          functionName().isEmpty() ? "(internal)" : functionName().ascii());

#endif

    size_t size = parameters.size();

    for (size_t i = 0; i < size; ++i) {

#ifdef KJS_VERBOSE

      fprintf(stderr, "setting parameter %s ", parameters.at(i).name.ascii());

      printInfo(exec, "to", args[i]);

#endif

      variable->put(exec, parameters[i].name, args[i]);

    }

}

void FunctionImp::processVarDecls(ExecState*)

{

}

JSValue* FunctionImp::argumentsGetter(ExecState* exec, JSObject*, const Identifier& propertyName, const PropertySlot& slot)

{

  FunctionImp* thisObj = static_cast<FunctionImp*>(slot.slotBase());

  Context* context = exec->m_context;

  while (context) {

    if (context->function() == thisObj)

      return static_cast<ActivationImp*>(context->activationObject())->get(exec, propertyName);

    context = context->callingContext();

  }

  return jsNull();

}

JSValue* FunctionImp::callerGetter(ExecState* exec, JSObject*, const Identifier&, const PropertySlot& slot)

{

    FunctionImp* thisObj = static_cast<FunctionImp*>(slot.slotBase());

    Context* context = exec->m_context;

    while (context) {

        if (context->function() == thisObj)

            break;

        context = context->callingContext();

    }

    if (!context)

        return jsNull();

    Context* callingContext = context->callingContext();

    if (!callingContext)

        return jsNull();

    FunctionImp* callingFunction = callingContext->function();

    if (!callingFunction)

        return jsNull();

    return callingFunction;

}

JSValue* FunctionImp::lengthGetter(ExecState*, JSObject*, const Identifier&, const PropertySlot& slot)

{

    FunctionImp* thisObj = static_cast<FunctionImp*>(slot.slotBase());

    return jsNumber(thisObj->body->numParams());

}

bool FunctionImp::getOwnPropertySlot(ExecState* exec, const Identifier& propertyName, PropertySlot& slot)

{

    // Find the arguments from the closest context.

    if (propertyName == exec->propertyNames().arguments) {

        slot.setCustom(this, argumentsGetter);

        return true;

    }

    // Compute length of parameters.

    if (propertyName == exec->propertyNames().length) {

        slot.setCustom(this, lengthGetter);

        return true;

    }

    if (propertyName == exec->propertyNames().caller) {

        slot.setCustom(this, callerGetter);

        return true;

    }

    return InternalFunctionImp::getOwnPropertySlot(exec, propertyName, slot);

}

void FunctionImp::put(ExecState* exec, const Identifier& propertyName, JSValue* value, int attr)

{

    if (propertyName == exec->propertyNames().arguments || propertyName == exec->propertyNames().length)

        return;

    InternalFunctionImp::put(exec, propertyName, value, attr);

}

bool FunctionImp::deleteProperty(ExecState* exec, const Identifier& propertyName)

{

    if (propertyName == exec->propertyNames().arguments || propertyName == exec->propertyNames().length)

        return false;

    return InternalFunctionImp::deleteProperty(exec, propertyName);

}

/* Returns the parameter name corresponding to the given index. eg:

 * function f1(x, y, z): getParameterName(0) --> x

 *

 * If a name appears more than once, only the last index at which

 * it appears associates with it. eg:

 * function f2(x, x): getParameterName(0) --> null

 */

Identifier FunctionImp::getParameterName(int index)

{

    Vector<Parameter>& parameters = body->parameters();

    if (static_cast<size_t>(index) >= body->numParams())

        return CommonIdentifiers::shared()->nullIdentifier;

    Identifier name = parameters[index].name;

    // Are there any subsequent parameters with the same name?

    size_t size = parameters.size();

    for (size_t i = index + 1; i < size; ++i)

        if (parameters[i].name == name)

            return CommonIdentifiers::shared()->nullIdentifier;

    return name;

}

// ------------------------------ DeclaredFunctionImp --------------------------

// ### is "Function" correct here?

const ClassInfo DeclaredFunctionImp::info = {"Function", &FunctionImp::info, 0, 0};

DeclaredFunctionImp::DeclaredFunctionImp(ExecState* exec, const Identifier& n,

                                         FunctionBodyNode* b, const ScopeChain& sc)

  : FunctionImp(exec, n, b)

{

  setScope(sc);

}

bool DeclaredFunctionImp::implementsConstruct() const

{

  return true;

}

// ECMA 13.2.2 [[Construct]]

JSObject* DeclaredFunctionImp::construct(ExecState* exec, const List& args)

{

  JSObject* proto;

  JSValue* p = get(exec, exec->propertyNames().prototype);

  if (p->isObject())

    proto = static_cast<JSObject*>(p);

  else

    proto = exec->lexicalInterpreter()->builtinObjectPrototype();

  JSObject* obj(new JSObject(proto));

  JSValue* res = call(exec,obj,args);

  if (res->isObject())

    return static_cast<JSObject*>(res);

  else

    return obj;

}

Completion DeclaredFunctionImp::execute(ExecState* exec)

{

  Completion result = body->execute(exec);

  if (result.complType() == Throw || result.complType() == ReturnValue)

      return result;

  return Completion(Normal, jsUndefined()); // TODO: or ReturnValue ?

}

void DeclaredFunctionImp::processVarDecls(ExecState* exec)

{

  body->processVarDecls(exec);

}

// ------------------------------ IndexToNameMap ---------------------------------

// We map indexes in the arguments array to their corresponding argument names. 

// Example: function f(x, y, z): arguments[0] = x, so we map 0 to Identifier("x"). 

// Once we have an argument name, we can get and set the argument's value in the 

// activation object.

// We use Identifier::null to indicate that a given argument's value

// isn't stored in the activation object.

IndexToNameMap::IndexToNameMap(FunctionImp* func, const List& args)

{

  _map = new Identifier[args.size()];

  this->size = args.size();

  int i = 0;

  ListIterator iterator = args.begin(); 

  for (; iterator != args.end(); i++, iterator++)

    _map[i] = func->getParameterName(i); // null if there is no corresponding parameter

}

IndexToNameMap::~IndexToNameMap() {

  delete [] _map;

}

bool IndexToNameMap::isMapped(const Identifier& index) const

{

  bool indexIsNumber;

  int indexAsNumber = index.toUInt32(&indexIsNumber);

  if (!indexIsNumber)

    return false;

  if (indexAsNumber >= size)

    return false;

  if (_map[indexAsNumber].isNull())

    return false;

  return true;

}

void IndexToNameMap::unMap(const Identifier& index)

{

  bool indexIsNumber;

  int indexAsNumber = index.toUInt32(&indexIsNumber);

  assert(indexIsNumber && indexAsNumber < size);

  _map[indexAsNumber] = CommonIdentifiers::shared()->nullIdentifier;

}

Identifier& IndexToNameMap::operator[](int index)

{

  return _map[index];

}

Identifier& IndexToNameMap::operator[](const Identifier& index)

{

  bool indexIsNumber;

  int indexAsNumber = index.toUInt32(&indexIsNumber);

  assert(indexIsNumber && indexAsNumber < size);

  return (*this)[indexAsNumber];

}

// ------------------------------ Arguments ---------------------------------

const ClassInfo Arguments::info = {"Arguments", 0, 0, 0};

// ECMA 10.1.8

Arguments::Arguments(ExecState* exec, FunctionImp* func, const List& args, ActivationImp* act)

: JSObject(exec->lexicalInterpreter()->builtinObjectPrototype()), 

_activationObject(act),

indexToNameMap(func, args)

{

  putDirect(exec->propertyNames().callee, func, DontEnum);

  putDirect(exec->propertyNames().length, args.size(), DontEnum);

  int i = 0;

  ListIterator iterator = args.begin(); 

  for (; iterator != args.end(); i++, iterator++) {

    if (!indexToNameMap.isMapped(Identifier::from(i))) {

      JSObject::put(exec, Identifier::from(i), *iterator, DontEnum);

    }

  }

}

void Arguments::mark() 

{

  JSObject::mark();

  if (_activationObject && !_activationObject->marked())

    _activationObject->mark();

}

JSValue* Arguments::mappedIndexGetter(ExecState* exec, JSObject*, const Identifier& propertyName, const PropertySlot& slot)

{

  Arguments* thisObj = static_cast<Arguments*>(slot.slotBase());

  return thisObj->_activationObject->get(exec, thisObj->indexToNameMap[propertyName]);

}

bool Arguments::getOwnPropertySlot(ExecState* exec, const Identifier& propertyName, PropertySlot& slot)

{

  if (indexToNameMap.isMapped(propertyName)) {

    slot.setCustom(this, mappedIndexGetter);

    return true;

  }

  return JSObject::getOwnPropertySlot(exec, propertyName, slot);

}

void Arguments::put(ExecState* exec, const Identifier& propertyName, JSValue* value, int attr)

{

  if (indexToNameMap.isMapped(propertyName)) {

    _activationObject->put(exec, indexToNameMap[propertyName], value, attr);

  } else {

    JSObject::put(exec, propertyName, value, attr);

  }

}

bool Arguments::deleteProperty(ExecState* exec, const Identifier& propertyName) 

{

  if (indexToNameMap.isMapped(propertyName)) {

    indexToNameMap.unMap(propertyName);

    return true;

  } else {

    return JSObject::deleteProperty(exec, propertyName);

  }

}

// ------------------------------ ActivationImp --------------------------------

const ClassInfo ActivationImp::info = {"Activation", 0, 0, 0};

// ECMA 10.1.6

ActivationImp::ActivationImp(FunctionImp* function, const List& arguments)

    : _function(function), _arguments(arguments), _argumentsObject(0)

{

  // FIXME: Do we need to support enumerating the arguments property?

}

JSValue* ActivationImp::argumentsGetter(ExecState* exec, JSObject*, const Identifier&, const PropertySlot& slot)

{

  ActivationImp* thisObj = static_cast<ActivationImp*>(slot.slotBase());

  // default: return builtin arguments array

  if (!thisObj->_argumentsObject)

    thisObj->createArgumentsObject(exec);

  return thisObj->_argumentsObject;

}

PropertySlot::GetValueFunc ActivationImp::getArgumentsGetter()

{

  return ActivationImp::argumentsGetter;

}

bool ActivationImp::getOwnPropertySlot(ExecState* exec, const Identifier& propertyName, PropertySlot& slot)

{

    // do this first so property map arguments property wins over the below

    // we don't call JSObject because we won't have getter/setter properties

    // and we don't want to support __proto__

    if (JSValue** location = getDirectLocation(propertyName)) {

        slot.setValueSlot(this, location);

        return true;

    }

    if (propertyName == exec->propertyNames().arguments) {

        slot.setCustom(this, getArgumentsGetter());

        return true;

    }

    return false;

}

bool ActivationImp::deleteProperty(ExecState* exec, const Identifier& propertyName)

{

    if (propertyName == exec->propertyNames().arguments)

        return false;

    return JSObject::deleteProperty(exec, propertyName);

}

void ActivationImp::put(ExecState*, const Identifier& propertyName, JSValue* value, int attr)

{

  // There's no way that an activation object can have a prototype or getter/setter properties

  assert(!_prop.hasGetterSetterProperties());

  assert(prototype() == jsNull());

  _prop.put(propertyName, value, attr, (attr == None || attr == DontDelete));

}

void ActivationImp::mark()