035e9e90ecf7a259394851848e5fc4cd9aa2183d
[WebKit-https.git] / Source / JavaScriptCore / collector / handles / Local.h
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 Local is a temporary handle whose lifetime is tied to a given LocalScope.
34     Use Locals for local values on the stack. It is an error to create a Local
35     outside of any LocalScope.
36 */
37
38 namespace JSC {
39 template <typename T> class Local;
40 }
41
42 namespace WTF {
43
44 template<typename T> struct VectorTraits<JSC::Local<T> > {
45     static const bool needsDestruction = false;
46     static const bool needsInitialization = true;
47     static const bool canInitializeWithMemset = false;
48     static const bool canMoveWithMemcpy = true;
49     static const bool canCopyWithMemcpy = false;
50     static const bool canFillWithMemset = false;
51     static const bool canCompareWithMemcmp = true;
52 };
53
54 }
55
56 namespace JSC {
57
58 template <typename T> class Local : public Handle<T> {
59     friend class LocalScope;
60 public:
61     typedef typename Handle<T>::ExternalType ExternalType;
62     Local(JSGlobalData&, ExternalType = ExternalType());
63     Local(JSGlobalData&, Handle<T>);
64     Local(const Local<T>&); // Adopting constructor. Used to return a Local to a calling function.
65
66     Local& operator=(ExternalType);
67     Local& operator=(Handle<T>);
68     
69     using Handle<T>::slot;
70
71 private:
72     Local(HandleSlot, ExternalType); // Used by LocalScope::release() to move a Local to a containing scope.
73     void internalSet(ExternalType value)
74     {
75         JSValue newValue(HandleTypes<T>::toJSValue(value));
76         HandleSlot slot = this->slot();
77         *slot = newValue;
78     }
79 };
80
81 template <typename T> inline Local<T>::Local(JSGlobalData& globalData, ExternalType value)
82     : Handle<T>(globalData.allocateLocalHandle())
83 {
84     internalSet(value);
85 }
86
87 template <typename T> inline Local<T>::Local(JSGlobalData& globalData, Handle<T> handle)
88     : Handle<T>(globalData.allocateLocalHandle())
89 {
90     internalSet(handle.get());
91 }
92
93 template <typename T> inline Local<T>::Local(const Local<T>& o)
94     : Handle<T>(o.slot())
95 {
96     const_cast<Local<T>&>(o).invalidate(); // Prevent accidental sharing.
97 }
98
99 template <typename T> inline Local<T>::Local(HandleSlot slot, ExternalType value)
100     : Handle<T>(slot, value)
101 {
102 }
103
104 template <typename T> inline Local<T>& Local<T>::operator=(ExternalType value)
105 {
106     internalSet(value);
107     return *this;
108 }
109
110 template <typename T> inline Local<T>& Local<T>::operator=(Handle<T> handle)
111 {
112     internalSet(handle.get());
113     return *this;
114 }
115
116 template <typename T, unsigned inlineCapacity = 0> class LocalStack {
117     typedef typename Handle<T>::ExternalType ExternalType;
118 public:
119     LocalStack(JSGlobalData& globalData)
120         : m_globalData(&globalData)
121         , m_count(0)
122     {
123     }
124
125     ExternalType peek() const
126     {
127         ASSERT(m_count > 0);
128         return m_stack[m_count - 1].get();
129     }
130
131     ExternalType pop()
132     {
133         ASSERT(m_count > 0);
134         return m_stack[--m_count].get();
135     }
136
137     void push(ExternalType value)
138     {
139         if (m_count == m_stack.size())
140             m_stack.append(Local<T>(*m_globalData, value));
141         else
142             m_stack[m_count] = value;
143         m_count++;
144     }
145
146     bool isEmpty() const { return !m_count; }
147     unsigned size() const { return m_count; }
148
149 private:
150     RefPtr<JSGlobalData> m_globalData;
151     Vector<Local<T>, inlineCapacity> m_stack;
152     unsigned m_count;
153 };
154
155 }
156
157 #endif