/*

 *  Copyright (C) 2003, 2008, 2009 Apple Inc. All rights reserved.

 *

 *  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.

 *

 */

#ifndef ScopeChain_h

#define ScopeChain_h

#include "FastAllocBase.h"

namespace JSC {

    class JSGlobalData;

    class JSGlobalObject;

    class JSObject;

    class MarkStack;

    class ScopeChainIterator;

    class ScopeChainNode : public FastAllocBase {

    public:

        ScopeChainNode(ScopeChainNode* next, JSObject* object, JSGlobalData* globalData, JSGlobalObject* globalObject, JSObject* globalThis)

            : next(next)

            , object(object)

            , globalData(globalData)

            , globalObject(globalObject)

            , globalThis(globalThis)

            , refCount(1)

        {

            ASSERT(globalData);

            ASSERT(globalObject);

        }

#ifndef NDEBUG

        // Due to the number of subtle and timing dependent bugs that have occurred due

        // to deleted but still "valid" ScopeChainNodes we now deliberately clobber the

        // contents in debug builds.

        ~ScopeChainNode()

        {

            next = 0;

            object = 0;

            globalData = 0;

            globalObject = 0;

            globalThis = 0;

        }

#endif

        ScopeChainNode* next;

        JSObject* object;

        JSGlobalData* globalData;

        JSGlobalObject* globalObject;

        JSObject* globalThis;

        int refCount;

        void deref() { ASSERT(refCount); if (--refCount == 0) { release();} }

        void ref() { ASSERT(refCount); ++refCount; }

        void release();

        // Before calling "push" on a bare ScopeChainNode, a client should

        // logically "copy" the node. Later, the client can "deref" the head

        // of its chain of ScopeChainNodes to reclaim all the nodes it added

        // after the logical copy, leaving nodes added before the logical copy

        // (nodes shared with other clients) untouched.

        ScopeChainNode* copy()

        {

            ref();

            return this;

        }

        ScopeChainNode* push(JSObject*);

        ScopeChainNode* pop();

        ScopeChainIterator begin() const;

        ScopeChainIterator end() const;

#ifndef NDEBUG        

        void print() const;

#endif

    };

    inline ScopeChainNode* ScopeChainNode::push(JSObject* o)

    {

        ASSERT(o);

        return new ScopeChainNode(this, o, globalData, globalObject, globalThis);

    }

    inline ScopeChainNode* ScopeChainNode::pop()

    {

        ASSERT(next);

        ScopeChainNode* result = next;

        if (--refCount != 0)

            ++result->refCount;

        else

            delete this;

        return result;

    }

    inline void ScopeChainNode::release()

    {

        // This function is only called by deref(),

        // Deref ensures these conditions are true.

        ASSERT(refCount == 0);

        ScopeChainNode* n = this;

        do {

            ScopeChainNode* next = n->next;

            delete n;

            n = next;

        } while (n && --n->refCount == 0);

    }

    class ScopeChainIterator {

    public:

        ScopeChainIterator(const ScopeChainNode* node)

            : m_node(node)

        {

        }

        JSObject* const & operator*() const { return m_node->object; }

        JSObject* const * operator->() const { return &(operator*()); }

        ScopeChainIterator& operator++() { m_node = m_node->next; return *this; }

        // postfix ++ intentionally omitted

        bool operator==(const ScopeChainIterator& other) const { return m_node == other.m_node; }

        bool operator!=(const ScopeChainIterator& other) const { return m_node != other.m_node; }

    private:

        const ScopeChainNode* m_node;

    };

    inline ScopeChainIterator ScopeChainNode::begin() const

    {

        return ScopeChainIterator(this); 

    }

    inline ScopeChainIterator ScopeChainNode::end() const

    { 

        return ScopeChainIterator(0); 

    }

    class NoScopeChain {};

    class ScopeChain {

        friend class JIT;

    public:

        ScopeChain(NoScopeChain)

            : m_node(0)

        {

        }

        ScopeChain(JSObject* o, JSGlobalData* globalData, JSGlobalObject* globalObject, JSObject* globalThis)

            : m_node(new ScopeChainNode(0, o, globalData, globalObject, globalThis))

        {

        }

        ScopeChain(const ScopeChain& c)

            : m_node(c.m_node->copy())

        {

        }

        ScopeChain& operator=(const ScopeChain& c);

        explicit ScopeChain(ScopeChainNode* node)

            : m_node(node->copy())

        {

        }

        ~ScopeChain()

        {

            if (m_node)

                m_node->deref();

#ifndef NDEBUG

            m_node = 0;

#endif

        }

        void swap(ScopeChain&);

        ScopeChainNode* node() const { return m_node; }

        JSObject* top() const { return m_node->object; }

        ScopeChainIterator begin() const { return m_node->begin(); }

        ScopeChainIterator end() const { return m_node->end(); }

        void push(JSObject* o) { m_node = m_node->push(o); }

        void pop() { m_node = m_node->pop(); }

        void clear() { m_node->deref(); m_node = 0; }

        JSGlobalObject* globalObject() const { return m_node->globalObject; }

        void markAggregate(MarkStack&) const;

        // Caution: this should only be used if the codeblock this is being used

        // with needs a full scope chain, otherwise this returns the depth of

        // the preceeding call frame

        //

        // Returns the depth of the current call frame's scope chain

        int localDepth() const;

#ifndef NDEBUG        

        void print() const { m_node->print(); }

#endif

    private:

        ScopeChainNode* m_node;

    };

    inline void ScopeChain::swap(ScopeChain& o)

    {

        ScopeChainNode* tmp = m_node;

        m_node = o.m_node;

        o.m_node = tmp;

    }

    inline ScopeChain& ScopeChain::operator=(const ScopeChain& c)

    {

        ScopeChain tmp(c);

        swap(tmp);

        return *this;

    }

} // namespace JSC

#endif // ScopeChain_h