1/*
2 * Copyright (C) 2010 Apple Inc. All rights reserved.
3 *
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions
6 * are met:
7 * 1. Redistributions of source code must retain the above copyright
8 *    notice, this list of conditions and the following disclaimer.
9 * 2. Redistributions in binary form must reproduce the above copyright
10 *    notice, this list of conditions and the following disclaimer in the
11 *    documentation and/or other materials provided with the distribution.
12 *
13 * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
14 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
15 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
17 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
18 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
19 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
20 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
21 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
22 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
23 * THE POSSIBILITY OF SUCH DAMAGE.
24 */
25
26#ifndef Local_h
27#define Local_h
28
29#include "Handle.h"
30#include "JSGlobalData.h"
31
32/*
33    A strongly referenced handle whose lifetime is temporary, limited to a given
34    LocalScope. Use Locals for local values on the stack. It is an error to
35    create a Local outside of any LocalScope.
36*/
37
38namespace JSC {
39
40template <typename T> class Local : public Handle<T> {
41    friend class LocalScope;
42    using Handle<T>::slot;
43
44public:
45    typedef typename Handle<T>::ExternalType ExternalType;
46
47    Local(JSGlobalData&, ExternalType = ExternalType());
48    Local(JSGlobalData&, Handle<T>);
49    Local(const Local<T>&); // Adopting constructor. Used to return a Local to a calling function.
50
51    Local& operator=(ExternalType);
52    Local& operator=(Handle<T>);
53
54private:
55    Local(HandleSlot, ExternalType); // Used by LocalScope::release() to move a Local to a containing scope.
56    void set(ExternalType);
57};
58
59template <typename T> inline Local<T>::Local(JSGlobalData& globalData, ExternalType value)
60    : Handle<T>(globalData.allocateLocalHandle())
61{
62    set(value);
63}
64
65template <typename T> inline Local<T>::Local(JSGlobalData& globalData, Handle<T> other)
66    : Handle<T>(globalData.allocateLocalHandle())
67{
68    set(other.get());
69}
70
71template <typename T> inline Local<T>::Local(const Local<T>& other)
72    : Handle<T>(other.slot())
73{
74    const_cast<Local<T>&>(other).setSlot(0); // Prevent accidental sharing.
75}
76
77template <typename T> inline Local<T>::Local(HandleSlot slot, ExternalType value)
78    : Handle<T>(slot, value)
79{
80}
81
82template <typename T> inline Local<T>& Local<T>::operator=(ExternalType value)
83{
84    set(value);
85    return *this;
86}
87
88template <typename T> inline Local<T>& Local<T>::operator=(Handle<T> other)
89{
90    set(other.get());
91    return *this;
92}
93
94template <typename T> inline void Local<T>::set(ExternalType externalType)
95{
96    ASSERT(slot());
97    ASSERT(!HandleTypes<T>::toJSValue(externalType) || !HandleTypes<T>::toJSValue(externalType).isCell() || Heap::isMarked(HandleTypes<T>::toJSValue(externalType).asCell()));
98    *slot() = externalType;
99}
100
101
102template <typename T, unsigned inlineCapacity = 0> class LocalStack {
103    typedef typename Handle<T>::ExternalType ExternalType;
104public:
105    LocalStack(JSGlobalData& globalData)
106        : m_globalData(&globalData)
107        , m_count(0)
108    {
109    }
110
111    ExternalType peek() const
112    {
113        ASSERT(m_count > 0);
114        return m_stack[m_count - 1].get();
115    }
116
117    ExternalType pop()
118    {
119        ASSERT(m_count > 0);
120        return m_stack[--m_count].get();
121    }
122
123    void push(ExternalType value)
124    {
125        if (m_count == m_stack.size())
126            m_stack.append(Local<T>(*m_globalData, value));
127        else
128            m_stack[m_count] = value;
129        m_count++;
130    }
131
132    bool isEmpty() const { return !m_count; }
133    unsigned size() const { return m_count; }
134
135private:
136    RefPtr<JSGlobalData> m_globalData;
137    Vector<Local<T>, inlineCapacity> m_stack;
138    unsigned m_count;
139};
140
141}
142
143namespace WTF {
144
145template<typename T> struct VectorTraits<JSC::Local<T> > : SimpleClassVectorTraits {
146    static const bool needsDestruction = false;
147    static const bool canInitializeWithMemset = false;
148    static const bool canCompareWithMemcmp = false;
149};
150
151}
152
153#endif
154