[WTF] Use m_suspendCount instead of m_suspended flag in Thread
[WebKit-https.git] / Source / JavaScriptCore / heap / 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 #pragma once
27
28 #include "Handle.h"
29 #include "VM.h"
30
31 /*
32     A strongly referenced handle whose lifetime is temporary, limited to a given
33     LocalScope. Use Locals for local values on the stack. It is an error to
34     create a Local outside of any LocalScope.
35 */
36
37 namespace JSC {
38
39 template <typename T> class Local : public Handle<T> {
40     friend class LocalScope;
41     using Handle<T>::slot;
42
43 public:
44     typedef typename Handle<T>::ExternalType ExternalType;
45
46     Local(VM&, ExternalType = ExternalType());
47     Local(VM&, Handle<T>);
48     Local(const Local<T>&); // Adopting constructor. Used to return a Local to a calling function.
49
50     Local& operator=(ExternalType);
51     Local& operator=(Handle<T>);
52
53 private:
54     Local(HandleSlot, ExternalType); // Used by LocalScope::release() to move a Local to a containing scope.
55     void set(ExternalType);
56 };
57
58 template <typename T> inline Local<T>::Local(VM& vm, ExternalType value)
59     : Handle<T>(vm.heap.handleStack()->push())
60 {
61     set(value);
62 }
63
64 template <typename T> inline Local<T>::Local(VM& vm, Handle<T> other)
65     : Handle<T>(vm.heap.handleStack()->push())
66 {
67     set(other.get());
68 }
69
70 template <typename T> inline Local<T>::Local(const Local<T>& other)
71     : Handle<T>(other.slot())
72 {
73     const_cast<Local<T>&>(other).setSlot(0); // Prevent accidental sharing.
74 }
75
76 template <typename T> inline Local<T>::Local(HandleSlot slot, ExternalType value)
77     : Handle<T>(slot, value)
78 {
79 }
80
81 template <typename T> inline Local<T>& Local<T>::operator=(ExternalType value)
82 {
83     set(value);
84     return *this;
85 }
86
87 template <typename T> inline Local<T>& Local<T>::operator=(Handle<T> other)
88 {
89     set(other.get());
90     return *this;
91 }
92
93 template <typename T> inline void Local<T>::set(ExternalType externalType)
94 {
95     ASSERT(slot());
96     *slot() = externalType;
97 }
98
99
100 template <typename T, unsigned inlineCapacity = 0> class LocalStack {
101     typedef typename Handle<T>::ExternalType ExternalType;
102 public:
103     LocalStack(VM& vm)
104         : m_vm(vm)
105         , m_count(0)
106     {
107     }
108
109     ExternalType peek() const
110     {
111         ASSERT(m_count > 0);
112         return m_stack[m_count - 1].get();
113     }
114
115     ExternalType pop()
116     {
117         ASSERT(m_count > 0);
118         return m_stack[--m_count].get();
119     }
120
121     void push(ExternalType value)
122     {
123         if (m_count == m_stack.size())
124             m_stack.append(Local<T>(m_vm, value));
125         else
126             m_stack[m_count] = value;
127         m_count++;
128     }
129
130     bool isEmpty() const { return !m_count; }
131     unsigned size() const { return m_count; }
132
133 private:
134     VM& m_vm;
135     Vector<Local<T>, inlineCapacity> m_stack;
136     unsigned m_count;
137 };
138
139 } // namespace JSC
140
141 namespace WTF {
142
143 template<typename T> struct VectorTraits<JSC::Local<T>> : SimpleClassVectorTraits {
144     static const bool needsDestruction = false;
145     static const bool canInitializeWithMemset = false;
146     static const bool canCompareWithMemcmp = false;
147 };
148
149 } // namespace WTF