/*

 *  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, 2004, 2005, 2006, 2007 Apple Inc. All rights reserved.

 *  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 "nodes.h"

#include <math.h>

#ifdef KJS_DEBUG_MEM

#include <stdio.h>

#include <typeinfo>

#endif

#include "context.h"

#include "debugger.h"

#include "function_object.h"

#include "lexer.h"

#include "operations.h"

#include "PropertyNameArray.h"

#include <wtf/HashSet.h>

#include <wtf/HashCountedSet.h>

#include <wtf/MathExtras.h>

#if PLATFORM(SYMBIAN)

const int MAXIMUMSTMTEXEC = 200000;

#endif

using namespace KJS;

#if PLATFORM(SYMBIAN)

	#define KJS_BREAKPOINT \

	exec->context()->setLineno(m_line);\

	if (Debugger::debuggersPresent > 0 && !hitStatement(exec)) \

	    return Completion(Normal);

#else

	#define KJS_BREAKPOINT \

	if (Debugger::debuggersPresent > 0 && !hitStatement(exec)) \

	    return Completion(Normal);

#endif

#define KJS_ABORTPOINT \

  if (Debugger::debuggersPresent > 0 && \

      exec->dynamicInterpreter()->imp()->debugger() && \

      exec->dynamicInterpreter()->imp()->debugger()->imp()->aborted()) \

    return Completion(Normal);

#define KJS_CHECKEXCEPTION \

  if (exec->hadException()) { \

    JSValue *ex = exec->exception(); \

    exec->clearException(); \

    handleException(exec, ex); \

    return Completion(Throw, ex); \

  } \

  if (Collector::isOutOfMemory()) \

    return Completion(Throw, Error::create(exec, GeneralError, "Out of memory"));

#define KJS_CHECKEXCEPTIONVALUE \

  if (exec->hadException()) { \

    handleException(exec); \

    return jsUndefined(); \

  } \

  if (Collector::isOutOfMemory()) \

    return jsUndefined(); // will be picked up by KJS_CHECKEXCEPTION

#define KJS_CHECKEXCEPTIONLIST \

  if (exec->hadException()) { \

    handleException(exec); \

    return List(); \

  } \

  if (Collector::isOutOfMemory()) \

    return List(); // will be picked up by KJS_CHECKEXCEPTION

// ------------------------------ Node -----------------------------------------

#ifndef NDEBUG

#ifndef LOG_CHANNEL_PREFIX

#define LOG_CHANNEL_PREFIX Log

#endif

static WTFLogChannel LogKJSNodeLeaks = { 0x00000000, "", WTFLogChannelOn };

struct NodeCounter {

    static unsigned count;

    ~NodeCounter()

    {

        if (count)

            LOG(KJSNodeLeaks, "LEAK: %u KJS::Node\n", count);

    }

};

unsigned NodeCounter::count = 0;

static NodeCounter nodeCounter;

#endif

static HashSet<Node*>* newNodes;

static HashCountedSet<Node*>* nodeExtraRefCounts;

Node::Node()

{

#ifndef NDEBUG

    ++NodeCounter::count;

#endif

  m_line = Lexer::curr()->lineNo();

  if (!newNodes)

      newNodes = new HashSet<Node*>;

  newNodes->add(this);

}

Node::~Node()

{

#ifndef NDEBUG

    --NodeCounter::count;

#endif

}

void Node::ref()

{

    // bumping from 0 to 1 is just removing from the new nodes set

    if (newNodes) {

        HashSet<Node*>::iterator it = newNodes->find(this);

        if (it != newNodes->end()) {

            newNodes->remove(it);

            ASSERT(!nodeExtraRefCounts || !nodeExtraRefCounts->contains(this));

            return;

        }

    }

    ASSERT(!newNodes || !newNodes->contains(this));

    if (!nodeExtraRefCounts)

        nodeExtraRefCounts = new HashCountedSet<Node*>;

    nodeExtraRefCounts->add(this);

}

void Node::deref()

{

    ASSERT(!newNodes || !newNodes->contains(this));

    if (!nodeExtraRefCounts) {

        delete this;

        return;

    }

    HashCountedSet<Node*>::iterator it = nodeExtraRefCounts->find(this);

    if (it == nodeExtraRefCounts->end())

        delete this;

    else

        nodeExtraRefCounts->remove(it);

}

unsigned Node::refcount()

{

    if (newNodes && newNodes->contains(this)) {

        ASSERT(!nodeExtraRefCounts || !nodeExtraRefCounts->contains(this));

        return 0;

    }

    ASSERT(!newNodes || !newNodes->contains(this));

    if (!nodeExtraRefCounts)

        return 1;

    return 1 + nodeExtraRefCounts->count(this);

}

void Node::clearNewNodes()

{

    if (!newNodes)

        return;

#ifndef NDEBUG

    HashSet<Node*>::iterator end = newNodes->end();

    for (HashSet<Node*>::iterator it = newNodes->begin(); it != end; ++it)

        ASSERT(!nodeExtraRefCounts || !nodeExtraRefCounts->contains(*it));

#endif

    deleteAllValues(*newNodes);

    delete newNodes;

    newNodes = 0;

}

static void substitute(UString &string, const UString &substring) KJS_FAST_CALL;

static void substitute(UString &string, const UString &substring)

{

    int position = string.find("%s");

    assert(position != -1);

    string = string.substr(0, position) + substring + string.substr(position + 2);

}

static inline int currentSourceId(ExecState* exec) KJS_FAST_CALL;

static inline int currentSourceId(ExecState* exec)

{

    return exec->context()->currentBody()->sourceId();

}

static inline const UString& currentSourceURL(ExecState* exec) KJS_FAST_CALL;

static inline const UString& currentSourceURL(ExecState* exec)

{

    return exec->context()->currentBody()->sourceURL();

}

Completion Node::createErrorCompletion(ExecState* exec, ErrorType e, const char *msg)

{

    return Completion(Throw, Error::create(exec, e, msg, lineNo(), currentSourceId(exec), currentSourceURL(exec)));

}

Completion Node::createErrorCompletion(ExecState *exec, ErrorType e, const char *msg, const Identifier &ident)

{

    UString message = msg;

    substitute(message, ident.ustring());

    return Completion(Throw, Error::create(exec, e, message, lineNo(), currentSourceId(exec), currentSourceURL(exec)));

}

JSValue *Node::throwError(ExecState* exec, ErrorType e, const char *msg)

{

    return KJS::throwError(exec, e, msg, lineNo(), currentSourceId(exec), currentSourceURL(exec));

}

JSValue *Node::throwError(ExecState* exec, ErrorType e, const char* msg, const char* string)

{

    UString message = msg;

    substitute(message, string);

    return KJS::throwError(exec, e, message, lineNo(), currentSourceId(exec), currentSourceURL(exec));

}

JSValue *Node::throwError(ExecState *exec, ErrorType e, const char *msg, JSValue *v, Node *expr)

{

    UString message = msg;

    substitute(message, v->toString(exec));

    substitute(message, expr->toString());

    return KJS::throwError(exec, e, message, lineNo(), currentSourceId(exec), currentSourceURL(exec));

}

JSValue *Node::throwError(ExecState *exec, ErrorType e, const char *msg, const Identifier &label)

{

    UString message = msg;

    substitute(message, label.ustring());

    return KJS::throwError(exec, e, message, lineNo(), currentSourceId(exec), currentSourceURL(exec));

}

JSValue *Node::throwError(ExecState *exec, ErrorType e, const char *msg, JSValue *v, Node *e1, Node *e2)

{

    UString message = msg;

    substitute(message, v->toString(exec));

    substitute(message, e1->toString());

    substitute(message, e2->toString());

    return KJS::throwError(exec, e, message, lineNo(), currentSourceId(exec), currentSourceURL(exec));

}

JSValue *Node::throwError(ExecState *exec, ErrorType e, const char *msg, JSValue *v, Node *expr, const Identifier &label)

{

    UString message = msg;

    substitute(message, v->toString(exec));

    substitute(message, expr->toString());

    substitute(message, label.ustring());

    return KJS::throwError(exec, e, message, lineNo(), currentSourceId(exec), currentSourceURL(exec));

}

JSValue *Node::throwError(ExecState *exec, ErrorType e, const char *msg, JSValue *v, const Identifier &label)

{

    UString message = msg;

    substitute(message, v->toString(exec));

    substitute(message, label.ustring());

    return KJS::throwError(exec, e, message, lineNo(), currentSourceId(exec), currentSourceURL(exec));

}

JSValue *Node::throwUndefinedVariableError(ExecState *exec, const Identifier &ident)

{

    return throwError(exec, ReferenceError, "Can't find variable: %s", ident);

}

void Node::handleException(ExecState* exec)

{

    handleException(exec, exec->exception());

}

void Node::handleException(ExecState* exec, JSValue* exceptionValue)

{

    if (exceptionValue->isObject()) {

        JSObject* exception = static_cast<JSObject*>(exceptionValue);

        if (!exception->hasProperty(exec, "line") && !exception->hasProperty(exec, "sourceURL")) {

            exception->put(exec, "line", jsNumber(m_line));

            exception->put(exec, "sourceURL", jsString(currentSourceURL(exec)));

        }

    }

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

    if (dbg && !dbg->hasHandledException(exec, exceptionValue)) {

        bool cont = dbg->exception(exec, currentSourceId(exec), m_line, exceptionValue);

        if (!cont)

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

    }

}

Node *Node::nodeInsideAllParens()

{

    return this;

}

// ------------------------------ StatementNode --------------------------------

StatementNode::StatementNode()

    : m_lastLine(-1)

{

    m_line = -1;

}

void StatementNode::setLoc(int firstLine, int lastLine)

{

    m_line = firstLine;

    m_lastLine = lastLine;

}

// return true if the debugger wants us to stop at this point

bool StatementNode::hitStatement(ExecState* exec)

{

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

  if (dbg)

    return dbg->atStatement(exec, currentSourceId(exec), firstLine(), lastLine());

  else

    return true; // continue

}

void StatementNode::processFuncDecl(ExecState*)

{

}

// ------------------------------ NullNode -------------------------------------

JSValue *NullNode::evaluate(ExecState *)

{

  return jsNull();

}

// ------------------------------ BooleanNode ----------------------------------

JSValue *BooleanNode::evaluate(ExecState *)

{

  return jsBoolean(value);

}

// ------------------------------ NumberNode -----------------------------------

JSValue *NumberNode::evaluate(ExecState *)

{

  return jsNumber(value);

}

// ------------------------------ StringNode -----------------------------------

JSValue *StringNode::evaluate(ExecState *)

{

  return jsOwnedString(value);

}

// ------------------------------ RegExpNode -----------------------------------

JSValue *RegExpNode::evaluate(ExecState *exec)

{

  List list;

  list.append(jsOwnedString(pattern));

  list.append(jsOwnedString(flags));

  JSObject *reg = exec->lexicalInterpreter()->builtinRegExp();

  return reg->construct(exec,list);

}

// ------------------------------ ThisNode -------------------------------------

// ECMA 11.1.1

JSValue *ThisNode::evaluate(ExecState *exec)

{

  return exec->context()->thisValue();

}

// ------------------------------ ResolveNode ----------------------------------

// ECMA 11.1.2 & 10.1.4

JSValue *ResolveNode::evaluate(ExecState *exec)

{

  const ScopeChain& chain = exec->context()->scopeChain();

  ScopeChainIterator iter = chain.begin();

  ScopeChainIterator end = chain.end();

  // we must always have something in the scope chain

  assert(iter != end);

  PropertySlot slot;

  do {

    JSObject *o = *iter;

    if (o->getPropertySlot(exec, ident, slot))

      return slot.getValue(exec, o, ident);

    ++iter;

  } while (iter != end);

  return throwUndefinedVariableError(exec, ident);

}

// ------------------------------ GroupNode ------------------------------------

// ECMA 11.1.6

JSValue *GroupNode::evaluate(ExecState *exec)

{

  return group->evaluate(exec);

}

Node *GroupNode::nodeInsideAllParens()

{

    Node *n = this;

    do

        n = static_cast<GroupNode *>(n)->group.get();

    while (n->isGroupNode());

    return n;

}

// ------------------------------ ElementNode ----------------------------------

// ECMA 11.1.4

JSValue *ElementNode::evaluate(ExecState *exec)

{

  JSObject *array = exec->lexicalInterpreter()->builtinArray()->construct(exec, List::empty());

  int length = 0;

  for (ElementNode *n = this; n; n = n->next.get()) {

    JSValue *val = n->node->evaluate(exec);

    KJS_CHECKEXCEPTIONVALUE

    length += n->elision;

    array->put(exec, length++, val);

  }

  return array;

}

void ElementNode::breakCycle()

{

    next = 0;

}

// ------------------------------ ArrayNode ------------------------------------

// ECMA 11.1.4

JSValue *ArrayNode::evaluate(ExecState *exec)

{

  JSObject *array;

  int length;

  if (element) {

    array = static_cast<JSObject*>(element->evaluate(exec));

    KJS_CHECKEXCEPTIONVALUE

    length = opt ? array->get(exec, exec->propertyNames().length)->toInt32(exec) : 0;

  } else {

    JSValue *newArr = exec->lexicalInterpreter()->builtinArray()->construct(exec,List::empty());

    array = static_cast<JSObject*>(newArr);

    length = 0;

  }

  if (opt)

    array->put(exec, exec->propertyNames().length, jsNumber(elision + length), DontEnum | DontDelete);

  return array;

}

// ------------------------------ ObjectLiteralNode ----------------------------

// ECMA 11.1.5

JSValue *ObjectLiteralNode::evaluate(ExecState *exec)

{

  if (list)

    return list->evaluate(exec);

  return exec->lexicalInterpreter()->builtinObject()->construct(exec,List::empty());

}

// ------------------------------ PropertyListNode -----------------------------

// ECMA 11.1.5

JSValue *PropertyListNode::evaluate(ExecState *exec)

{

  JSObject *obj = exec->lexicalInterpreter()->builtinObject()->construct(exec, List::empty());

  for (PropertyListNode *p = this; p; p = p->next.get()) {

    JSValue *n = p->node->name->evaluate(exec);

    KJS_CHECKEXCEPTIONVALUE

    JSValue *v = p->node->assign->evaluate(exec);

    KJS_CHECKEXCEPTIONVALUE

    Identifier propertyName = Identifier(n->toString(exec));

    switch (p->node->type) {

      case PropertyNode::Getter:

        assert(v->isObject());

        obj->defineGetter(exec, propertyName, static_cast<JSObject *>(v));

        break;

      case PropertyNode::Setter:

        assert(v->isObject());