Annotation of parser3/src/lib/gc/include/gc_allocator.h, revision 1.2
1.1 misha 1: /*
2: * Copyright (c) 1996-1997
3: * Silicon Graphics Computer Systems, Inc.
4: *
5: * Permission to use, copy, modify, distribute and sell this software
6: * and its documentation for any purpose is hereby granted without fee,
7: * provided that the above copyright notice appear in all copies and
8: * that both that copyright notice and this permission notice appear
9: * in supporting documentation. Silicon Graphics makes no
10: * representations about the suitability of this software for any
11: * purpose. It is provided "as is" without express or implied warranty.
12: *
13: * Copyright (c) 2002
14: * Hewlett-Packard Company
15: *
16: * Permission to use, copy, modify, distribute and sell this software
17: * and its documentation for any purpose is hereby granted without fee,
18: * provided that the above copyright notice appear in all copies and
19: * that both that copyright notice and this permission notice appear
20: * in supporting documentation. Hewlett-Packard Company makes no
21: * representations about the suitability of this software for any
22: * purpose. It is provided "as is" without express or implied warranty.
23: */
24:
25: /*
26: * This implements standard-conforming allocators that interact with
27: * the garbage collector. Gc_alloctor<T> allocates garbage-collectable
28: * objects of type T. Traceable_allocator<T> allocates objects that
29: * are not temselves garbage collected, but are scanned by the
30: * collector for pointers to collectable objects. Traceable_alloc
31: * should be used for explicitly managed STL containers that may
32: * point to collectable objects.
33: *
34: * This code was derived from an earlier version of the GNU C++ standard
35: * library, which itself was derived from the SGI STL implementation.
36: */
37:
38: #ifndef GC_ALLOCATOR_H
39:
40: #define GC_ALLOCATOR_H
41:
42: #include "gc.h"
43: #include <new> // for placement new
44:
45: #if defined(__GNUC__)
46: # define GC_ATTR_UNUSED __attribute__((unused))
47: #else
48: # define GC_ATTR_UNUSED
49: #endif
50:
51: /* First some helpers to allow us to dispatch on whether or not a type
52: * is known to be pointerfree.
53: * These are private, except that the client may invoke the
54: * GC_DECLARE_PTRFREE macro.
55: */
56:
57: struct GC_true_type {};
58: struct GC_false_type {};
59:
60: template <class GC_tp>
61: struct GC_type_traits {
62: GC_false_type GC_is_ptr_free;
63: };
64:
65: # define GC_DECLARE_PTRFREE(T) \
66: template<> struct GC_type_traits<T> { GC_true_type GC_is_ptr_free; }
67:
68: GC_DECLARE_PTRFREE(char);
69: GC_DECLARE_PTRFREE(signed char);
70: GC_DECLARE_PTRFREE(unsigned char);
71: GC_DECLARE_PTRFREE(signed short);
72: GC_DECLARE_PTRFREE(unsigned short);
73: GC_DECLARE_PTRFREE(signed int);
74: GC_DECLARE_PTRFREE(unsigned int);
75: GC_DECLARE_PTRFREE(signed long);
76: GC_DECLARE_PTRFREE(unsigned long);
77: GC_DECLARE_PTRFREE(float);
78: GC_DECLARE_PTRFREE(double);
79: GC_DECLARE_PTRFREE(long double);
80: /* The client may want to add others. */
81:
82: // In the following GC_Tp is GC_true_type iff we are allocating a
83: // pointerfree object.
84: template <class GC_Tp>
85: inline void * GC_selective_alloc(size_t n, GC_Tp) {
86: return GC_MALLOC(n);
87: }
88:
89: template <>
90: inline void * GC_selective_alloc<GC_true_type>(size_t n, GC_true_type) {
91: return GC_MALLOC_ATOMIC(n);
92: }
93:
94: /* Now the public gc_allocator<T> class:
95: */
96: template <class GC_Tp>
97: class gc_allocator {
98: public:
99: typedef size_t size_type;
100: typedef ptrdiff_t difference_type;
101: typedef GC_Tp* pointer;
102: typedef const GC_Tp* const_pointer;
103: typedef GC_Tp& reference;
104: typedef const GC_Tp& const_reference;
105: typedef GC_Tp value_type;
106:
107: template <class GC_Tp1> struct rebind {
108: typedef gc_allocator<GC_Tp1> other;
109: };
110:
111: gc_allocator() {}
112: gc_allocator(const gc_allocator&) throw() {}
113: # if !(GC_NO_MEMBER_TEMPLATES || 0 < _MSC_VER && _MSC_VER <= 1200)
114: // MSVC++ 6.0 do not support member templates
115: template <class GC_Tp1> gc_allocator(const gc_allocator<GC_Tp1>&) throw() {}
116: # endif
117: ~gc_allocator() throw() {}
118:
119: pointer address(reference GC_x) const { return &GC_x; }
120: const_pointer address(const_reference GC_x) const { return &GC_x; }
121:
122: // GC_n is permitted to be 0. The C++ standard says nothing about what
123: // the return value is when GC_n == 0.
124: GC_Tp* allocate(size_type GC_n, const void* = 0) {
125: GC_type_traits<GC_Tp> traits;
126: return static_cast<GC_Tp *>
127: (GC_selective_alloc(GC_n * sizeof(GC_Tp),
128: traits.GC_is_ptr_free));
129: }
130:
131: // __p is not permitted to be a null pointer.
1.2 ! moko 132: void deallocate(pointer __p, size_type GC_ATTR_UNUSED)
1.1 misha 133: { GC_FREE(__p); }
134:
135: size_type max_size() const throw()
136: { return size_t(-1) / sizeof(GC_Tp); }
137:
138: void construct(pointer __p, const GC_Tp& __val) { new(__p) GC_Tp(__val); }
139: void destroy(pointer __p) { __p->~GC_Tp(); }
140: };
141:
142: template<>
143: class gc_allocator<void> {
144: typedef size_t size_type;
145: typedef ptrdiff_t difference_type;
146: typedef void* pointer;
147: typedef const void* const_pointer;
148: typedef void value_type;
149:
150: template <class GC_Tp1> struct rebind {
151: typedef gc_allocator<GC_Tp1> other;
152: };
153: };
154:
155:
156: template <class GC_T1, class GC_T2>
157: inline bool operator==(const gc_allocator<GC_T1>&, const gc_allocator<GC_T2>&)
158: {
159: return true;
160: }
161:
162: template <class GC_T1, class GC_T2>
163: inline bool operator!=(const gc_allocator<GC_T1>&, const gc_allocator<GC_T2>&)
164: {
165: return false;
166: }
167:
168: /*
169: * And the public traceable_allocator class.
170: */
171:
172: // Note that we currently don't specialize the pointer-free case, since a
173: // pointer-free traceable container doesn't make that much sense,
174: // though it could become an issue due to abstraction boundaries.
175: template <class GC_Tp>
176: class traceable_allocator {
177: public:
178: typedef size_t size_type;
179: typedef ptrdiff_t difference_type;
180: typedef GC_Tp* pointer;
181: typedef const GC_Tp* const_pointer;
182: typedef GC_Tp& reference;
183: typedef const GC_Tp& const_reference;
184: typedef GC_Tp value_type;
185:
186: template <class GC_Tp1> struct rebind {
187: typedef traceable_allocator<GC_Tp1> other;
188: };
189:
190: traceable_allocator() throw() {}
191: traceable_allocator(const traceable_allocator&) throw() {}
192: # if !(GC_NO_MEMBER_TEMPLATES || 0 < _MSC_VER && _MSC_VER <= 1200)
193: // MSVC++ 6.0 do not support member templates
194: template <class GC_Tp1> traceable_allocator
195: (const traceable_allocator<GC_Tp1>&) throw() {}
196: # endif
197: ~traceable_allocator() throw() {}
198:
199: pointer address(reference GC_x) const { return &GC_x; }
200: const_pointer address(const_reference GC_x) const { return &GC_x; }
201:
202: // GC_n is permitted to be 0. The C++ standard says nothing about what
203: // the return value is when GC_n == 0.
204: GC_Tp* allocate(size_type GC_n, const void* = 0) {
205: return static_cast<GC_Tp*>(GC_MALLOC_UNCOLLECTABLE(GC_n * sizeof(GC_Tp)));
206: }
207:
208: // __p is not permitted to be a null pointer.
209: void deallocate(pointer __p, size_type GC_ATTR_UNUSED GC_n)
210: { GC_FREE(__p); }
211:
212: size_type max_size() const throw()
213: { return size_t(-1) / sizeof(GC_Tp); }
214:
215: void construct(pointer __p, const GC_Tp& __val) { new(__p) GC_Tp(__val); }
216: void destroy(pointer __p) { __p->~GC_Tp(); }
217: };
218:
219: template<>
220: class traceable_allocator<void> {
221: typedef size_t size_type;
222: typedef ptrdiff_t difference_type;
223: typedef void* pointer;
224: typedef const void* const_pointer;
225: typedef void value_type;
226:
227: template <class GC_Tp1> struct rebind {
228: typedef traceable_allocator<GC_Tp1> other;
229: };
230: };
231:
232:
233: template <class GC_T1, class GC_T2>
234: inline bool operator==(const traceable_allocator<GC_T1>&, const traceable_allocator<GC_T2>&)
235: {
236: return true;
237: }
238:
239: template <class GC_T1, class GC_T2>
240: inline bool operator!=(const traceable_allocator<GC_T1>&, const traceable_allocator<GC_T2>&)
241: {
242: return false;
243: }
244:
245: #endif /* GC_ALLOCATOR_H */
E-mail:
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to gc_allocator.h CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [parser3project] / parser3 / src / lib / gc / include