Annotation of parser3/src/include/pa_memory.h, revision 1.33
1.2 paf 1: /** @file
2: Parser: memory reference counting classes decls.
3:
1.30 moko 4: Copyright (c) 2001-2017 Art. Lebedev Studio (http://www.artlebedev.com)
1.2 paf 5:
6: Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)
7: */
8:
9: #ifndef PA_MEMORY_H
10: #define PA_MEMORY_H
11:
1.33 ! moko 12: #define IDENT_PA_MEMORY_H "$Id: pa_memory.h,v 1.32 2017/11/15 22:48:57 moko Exp $"
1.2 paf 13:
14: // include
15:
16: #include "pa_config_includes.h"
17: #include "gc.h"
1.24 moko 18: #include <new>
1.2 paf 19:
1.19 moko 20: // define destructors use for Array, Hash and VMethodFrame
1.17 misha 21: #define USE_DESTRUCTORS
1.33 ! moko 22: // std::basic_stringstream used in ^table.csv-string[] is compatible with delete usage check only under Debian 9
! 23: // #define CHECK_DELETE_USAGE
1.17 misha 24:
1.2 paf 25: inline void* pa_gc_malloc(size_t size) { return GC_MALLOC(size); }
26: inline void* pa_gc_malloc_atomic(size_t size) { return GC_MALLOC_ATOMIC(size); }
27: inline void* pa_gc_realloc(void* ptr, size_t size) { return GC_REALLOC(ptr, size); }
28: inline void pa_gc_free(void* ptr) { GC_FREE(ptr); }
29:
30: // forwards
31:
32: void *pa_fail_alloc(const char* what, size_t size);
33:
34: // inlines
35:
36: inline void *pa_malloc(size_t size) {
1.4 paf 37: if(void *result=pa_gc_malloc(size))
1.2 paf 38: return result;
39:
40: return pa_fail_alloc("allocate", size);
41: }
42:
43: inline void *pa_malloc_atomic(size_t size) {
1.4 paf 44: if(void *result=pa_gc_malloc_atomic(size))
1.2 paf 45: return result;
46:
47: return pa_fail_alloc("allocate clean", size);
48: }
1.20 moko 49:
1.2 paf 50: /// @a length may be null, which mean "autocalc it"
51: inline char *pa_strdup(const char* auto_variable_never_null, size_t helper_length=0) {
1.20 moko 52: size_t known_length= helper_length ? helper_length : strlen(auto_variable_never_null);
1.2 paf 53:
1.10 paf 54: size_t size=known_length+1;
55: if(char *result=static_cast<char*>(pa_gc_malloc_atomic(size))) {
1.9 paf 56: memcpy(result, auto_variable_never_null, known_length);
1.2 paf 57: result[known_length]=0;
58: return result;
59: }
60:
61: return static_cast<char*>(pa_fail_alloc("allocate clean", size));
62: }
63:
64: inline void pa_free(void *ptr) {
1.4 paf 65: pa_gc_free(ptr);
1.2 paf 66: }
67:
68: inline void *pa_realloc(void *ptr, size_t size) {
1.4 paf 69: if(void *result=pa_gc_realloc(ptr, size))
1.2 paf 70: return result;
71:
72: return pa_fail_alloc("reallocate to", size);
73: }
74:
1.32 moko 75: /// memory allocation/dallocation goes via pa_malloc/pa_free.
76: class PA_Allocated {
77: public:
78: /// the sole: instances allocated using our functions
79: static void *operator new(size_t size) {
80: return pa_malloc(size);
81: }
82: static void operator delete(void *ptr) {
83: pa_free(ptr);
84: }
85: static void *operator new[](size_t size) {
86: return pa_malloc(size);
87: }
88: static void operator delete[](void *ptr) {
89: pa_free(ptr);
90: }
91: };
92:
93: // new(PointerFreeGC)/new(PointerGC) should be used to allocate types not inherited from PA_Allocated
94:
95: #define PointerFreeGC (true)
96: #define PointerGC (false)
97:
98: inline void *operator new[] (size_t size, bool pointer_free) {
99: return pointer_free ? pa_malloc_atomic(size) : pa_malloc(size);
100: }
101:
102: inline void *operator new (size_t size, bool pointer_free) {
103: return pointer_free ? pa_malloc_atomic(size) : pa_malloc(size);
104: }
105:
106: /// Base for all Parser classes
107: typedef PA_Allocated PA_Object;
108:
109: // defines
110:
111: #define override
112: #define rethrow throw
113:
1.31 moko 114: #if defined(_MSC_VER) || (__cplusplus>=201103L)
1.26 moko 115: #define PA_THROW(what)
116: #else
117: #define PA_THROW(what) throw(what)
118: #endif
119:
1.32 moko 120: #ifndef _MSC_VER
121:
122: // regular new/delete are disabled from accidental use
123:
124: void *new_disabled();
125: void delete_disabled();
126:
127: inline void *operator new[] (std::size_t size) PA_THROW(std::bad_alloc){ return new_disabled(); }
128: inline void operator delete[](void *ptr) throw(){ delete_disabled(); }
1.2 paf 129:
1.32 moko 130: inline void *operator new(std::size_t size) PA_THROW(std::bad_alloc){ return new_disabled(); }
1.33 ! moko 131: #ifdef CHECK_DELETE_USAGE
1.32 moko 132: inline void operator delete(void *ptr) throw(){ delete_disabled(); }
1.33 ! moko 133: #endif
1.2 paf 134:
1.32 moko 135: // other regular allocators as disabled from accidental use as well
1.21 moko 136:
137: void *calloc_disabled();
138: void *malloc_disabled();
139: void *realloc_disabled();
140: void free_disabled();
141: char *strdup_disabled();
142:
1.24 moko 143: inline void *calloc(size_t) { return calloc_disabled(); }
1.25 moko 144: inline void *malloc(size_t) { return malloc_disabled(); }
145: inline void *realloc(void *, size_t) { return realloc_disabled(); }
146: inline void free(void *) { free_disabled(); }
1.21 moko 147: inline char *strdup(const char*, size_t){ return strdup_disabled(); }
1.32 moko 148:
1.22 moko 149: #endif
1.21 moko 150:
1.2 paf 151: #endif
E-mail:
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pa_memory.h CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [parser3project] / parser3 / src / include