← Back to branch summary

~oif-team/ubuntu/natty/qt4-x11/xi2.1

« back to all changes in this revision

Viewing changes to src/3rdparty/javascriptcore/JavaScriptCore/runtime/Protect.h

  • Committer: Bazaar Package Importer
  • Author(s): Alessandro Ghersi
  • Date: 2009-11-02 18:30:08 UTC
  • mfrom: (1.2.2 upstream)
  • mto: (15.2.5 experimental)
  • mto: This revision was merged to the branch mainline in revision 88.
  • Revision ID: james.westby@ubuntu.com-20091102183008-b6a4gcs128mvfb3m
Tags: upstream-4.6.0~beta1
Import upstream version 4.6.0~beta1

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/3rdparty/javascriptcore/JavaScriptCore/runtime/Protect.h
 
1
/*
 
2
 *  Copyright (C) 2004, 2008, 2009 Apple Inc. All rights reserved.
 
3
 *
 
4
 *  This library is free software; you can redistribute it and/or
 
5
 *  modify it under the terms of the GNU Library General Public
 
6
 *  License as published by the Free Software Foundation; either
 
7
 *  version 2 of the License, or (at your option) any later version.
 
8
 *
 
9
 *  This library is distributed in the hope that it will be useful,
 
10
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 
11
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 
12
 *  Library General Public License for more details.
 
13
 *
 
14
 *  You should have received a copy of the GNU Library General Public License
 
15
 *  along with this library; see the file COPYING.LIB.  If not, write to
 
16
 *  the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 
17
 *  Boston, MA 02110-1301, USA.
 
18
 *
 
19
 */
 
20
 
 
21
 
 
22
#ifndef Protect_h
 
23
#define Protect_h
 
24
 
 
25
#include "JSCell.h"
 
26
#include "Collector.h"
 
27
 
 
28
namespace JSC {
 
29
 
 
30
    inline void gcProtect(JSCell* val) 
 
31
    {
 
32
        Heap::heap(val)->protect(val);
 
33
    }
 
34
 
 
35
    inline void gcUnprotect(JSCell* val)
 
36
    {
 
37
        Heap::heap(val)->unprotect(val);
 
38
    }
 
39
 
 
40
    inline void gcProtectNullTolerant(JSCell* val) 
 
41
    {
 
42
        if (val) 
 
43
            gcProtect(val);
 
44
    }
 
45
 
 
46
    inline void gcUnprotectNullTolerant(JSCell* val) 
 
47
    {
 
48
        if (val) 
 
49
            gcUnprotect(val);
 
50
    }
 
51
    
 
52
    inline void gcProtect(JSValue value)
 
53
    {
 
54
        if (value && value.isCell())
 
55
            gcProtect(asCell(value));
 
56
    }
 
57
 
 
58
    inline void gcUnprotect(JSValue value)
 
59
    {
 
60
        if (value && value.isCell())
 
61
            gcUnprotect(asCell(value));
 
62
    }
 
63
 
 
64
    // FIXME: Share more code with RefPtr template? The only differences are the ref/deref operation
 
65
    // and the implicit conversion to raw pointer
 
66
    template <class T> class ProtectedPtr {
 
67
    public:
 
68
        ProtectedPtr() : m_ptr(0) {}
 
69
        ProtectedPtr(T* ptr);
 
70
        ProtectedPtr(const ProtectedPtr&);
 
71
        ~ProtectedPtr();
 
72
 
 
73
        template <class U> ProtectedPtr(const ProtectedPtr<U>&);
 
74
        
 
75
        T* get() const { return m_ptr; }
 
76
        operator T*() const { return m_ptr; }
 
77
        operator JSValue() const { return JSValue(m_ptr); }
 
78
        T* operator->() const { return m_ptr; }
 
79
        
 
80
        operator bool() const { return m_ptr; }
 
81
        bool operator!() const { return !m_ptr; }
 
82
 
 
83
        ProtectedPtr& operator=(const ProtectedPtr&);
 
84
        ProtectedPtr& operator=(T*);
 
85
        
 
86
    private:
 
87
        T* m_ptr;
 
88
    };
 
89
 
 
90
    class ProtectedJSValue {
 
91
    public:
 
92
        ProtectedJSValue() {}
 
93
        ProtectedJSValue(JSValue value);
 
94
        ProtectedJSValue(const ProtectedJSValue&);
 
95
        ~ProtectedJSValue();
 
96
 
 
97
        template <class U> ProtectedJSValue(const ProtectedPtr<U>&);
 
98
        
 
99
        JSValue get() const { return m_value; }
 
100
        operator JSValue() const { return m_value; }
 
101
        //JSValue operator->() const { return m_value; }
 
102
        
 
103
        operator bool() const { return m_value; }
 
104
        bool operator!() const { return !m_value; }
 
105
 
 
106
        ProtectedJSValue& operator=(const ProtectedJSValue&);
 
107
        ProtectedJSValue& operator=(JSValue);
 
108
        
 
109
    private:
 
110
        JSValue m_value;
 
111
    };
 
112
 
 
113
    template <class T> inline ProtectedPtr<T>::ProtectedPtr(T* ptr)
 
114
        : m_ptr(ptr)
 
115
    {
 
116
        gcProtectNullTolerant(m_ptr);
 
117
    }
 
118
 
 
119
    template <class T> inline ProtectedPtr<T>::ProtectedPtr(const ProtectedPtr& o)
 
120
        : m_ptr(o.get())
 
121
    {
 
122
        gcProtectNullTolerant(m_ptr);
 
123
    }
 
124
 
 
125
    template <class T> inline ProtectedPtr<T>::~ProtectedPtr()
 
126
    {
 
127
        gcUnprotectNullTolerant(m_ptr);
 
128
    }
 
129
 
 
130
    template <class T> template <class U> inline ProtectedPtr<T>::ProtectedPtr(const ProtectedPtr<U>& o)
 
131
        : m_ptr(o.get())
 
132
    {
 
133
        gcProtectNullTolerant(m_ptr);
 
134
    }
 
135
 
 
136
    template <class T> inline ProtectedPtr<T>& ProtectedPtr<T>::operator=(const ProtectedPtr<T>& o) 
 
137
    {
 
138
        T* optr = o.m_ptr;
 
139
        gcProtectNullTolerant(optr);
 
140
        gcUnprotectNullTolerant(m_ptr);
 
141
        m_ptr = optr;
 
142
        return *this;
 
143
    }
 
144
 
 
145
    template <class T> inline ProtectedPtr<T>& ProtectedPtr<T>::operator=(T* optr)
 
146
    {
 
147
        gcProtectNullTolerant(optr);
 
148
        gcUnprotectNullTolerant(m_ptr);
 
149
        m_ptr = optr;
 
150
        return *this;
 
151
    }
 
152
 
 
153
    inline ProtectedJSValue::ProtectedJSValue(JSValue value)
 
154
        : m_value(value)
 
155
    {
 
156
        gcProtect(m_value);
 
157
    }
 
158
 
 
159
    inline ProtectedJSValue::ProtectedJSValue(const ProtectedJSValue& o)
 
160
        : m_value(o.get())
 
161
    {
 
162
        gcProtect(m_value);
 
163
    }
 
164
 
 
165
    inline ProtectedJSValue::~ProtectedJSValue()
 
166
    {
 
167
        gcUnprotect(m_value);
 
168
    }
 
169
 
 
170
    template <class U> ProtectedJSValue::ProtectedJSValue(const ProtectedPtr<U>& o)
 
171
        : m_value(o.get())
 
172
    {
 
173
        gcProtect(m_value);
 
174
    }
 
175
 
 
176
    inline ProtectedJSValue& ProtectedJSValue::operator=(const ProtectedJSValue& o) 
 
177
    {
 
178
        JSValue ovalue = o.m_value;
 
179
        gcProtect(ovalue);
 
180
        gcUnprotect(m_value);
 
181
        m_value = ovalue;
 
182
        return *this;
 
183
    }
 
184
 
 
185
    inline ProtectedJSValue& ProtectedJSValue::operator=(JSValue ovalue)
 
186
    {
 
187
        gcProtect(ovalue);
 
188
        gcUnprotect(m_value);
 
189
        m_value = ovalue;
 
190
        return *this;
 
191
    }
 
192
 
 
193
    template <class T> inline bool operator==(const ProtectedPtr<T>& a, const ProtectedPtr<T>& b) { return a.get() == b.get(); }
 
194
    template <class T> inline bool operator==(const ProtectedPtr<T>& a, const T* b) { return a.get() == b; }
 
195
    template <class T> inline bool operator==(const T* a, const ProtectedPtr<T>& b) { return a == b.get(); }
 
196
 
 
197
    template <class T> inline bool operator!=(const ProtectedPtr<T>& a, const ProtectedPtr<T>& b) { return a.get() != b.get(); }
 
198
    template <class T> inline bool operator!=(const ProtectedPtr<T>& a, const T* b) { return a.get() != b; }
 
199
    template <class T> inline bool operator!=(const T* a, const ProtectedPtr<T>& b) { return a != b.get(); }
 
200
 
 
201
    inline bool operator==(const ProtectedJSValue& a, const ProtectedJSValue& b) { return a.get() == b.get(); }
 
202
    inline bool operator==(const ProtectedJSValue& a, const JSValue b) { return a.get() == b; }
 
203
    template <class T> inline bool operator==(const ProtectedJSValue& a, const ProtectedPtr<T>& b) { return a.get() == JSValue(b.get()); }
 
204
    inline bool operator==(const JSValue a, const ProtectedJSValue& b) { return a == b.get(); }
 
205
    template <class T> inline bool operator==(const ProtectedPtr<T>& a, const ProtectedJSValue& b) { return JSValue(a.get()) == b.get(); }
 
206
 
 
207
    inline bool operator!=(const ProtectedJSValue& a, const ProtectedJSValue& b) { return a.get() != b.get(); }
 
208
    inline bool operator!=(const ProtectedJSValue& a, const JSValue b) { return a.get() != b; }
 
209
    template <class T> inline bool operator!=(const ProtectedJSValue& a, const ProtectedPtr<T>& b) { return a.get() != JSValue(b.get()); }
 
210
    inline bool operator!=(const JSValue a, const ProtectedJSValue& b) { return a != b.get(); }
 
211
    template <class T> inline bool operator!=(const ProtectedPtr<T>& a, const ProtectedJSValue& b) { return JSValue(a.get()) != b.get(); }
 
212
 
 
213
} // namespace JSC
 
214
 
 
215
#endif // Protect_h