Return to pa_memory.h CVS log

Up to [parser3project] / parser3 / src / include

Annotation of parser3/src/include/pa_memory.h, revision 1.21

1.2       paf         1: /** @file
                      2:        Parser: memory reference counting classes decls.
                      3: 
1.18      moko        4:        Copyright (c) 2001-2012 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.21    ! moko       12: #define IDENT_PA_MEMORY_H "$Id: pa_memory.h,v 1.20 2013/07/23 15:47:07 moko Exp $"
1.2       paf        13: 
                     14: // include
                     15: 
                     16: #include "pa_config_includes.h"
                     17: #include "gc.h"
                     18: 
1.19      moko       19: // define destructors use for Array, Hash and VMethodFrame
1.17      misha      20: #define USE_DESTRUCTORS
                     21: 
1.2       paf        22: inline void* pa_gc_malloc(size_t size) { return GC_MALLOC(size); }
                     23: inline void* pa_gc_malloc_atomic(size_t size) { return GC_MALLOC_ATOMIC(size); }
                     24: inline void* pa_gc_realloc(void* ptr, size_t size) { return GC_REALLOC(ptr, size); }
                     25: inline void pa_gc_free(void* ptr) { GC_FREE(ptr); }
                     26: 
                     27: // forwards
                     28: 
                     29: void *pa_fail_alloc(const char* what, size_t size);
                     30: 
                     31: // inlines
                     32: 
                     33: inline void *pa_malloc(size_t size) {
1.4       paf        34:        if(void *result=pa_gc_malloc(size))
1.2       paf        35:                return result;
                     36: 
                     37:        return pa_fail_alloc("allocate", size);
                     38: }
                     39: 
                     40: inline void *pa_malloc_atomic(size_t size) {
1.4       paf        41:        if(void *result=pa_gc_malloc_atomic(size))
1.2       paf        42:                return result;
                     43: 
                     44:        return pa_fail_alloc("allocate clean", size);
                     45: }
1.20      moko       46: 
1.2       paf        47: /// @a length may be null, which mean "autocalc it"
                     48: inline char *pa_strdup(const char* auto_variable_never_null, size_t helper_length=0) {
1.20      moko       49:        size_t known_length= helper_length ? helper_length : strlen(auto_variable_never_null);
1.2       paf        50: 
1.10      paf        51:        size_t size=known_length+1;
                     52:        if(char *result=static_cast<char*>(pa_gc_malloc_atomic(size))) {
1.9       paf        53:                memcpy(result, auto_variable_never_null, known_length);
1.2       paf        54:                result[known_length]=0;
                     55:                return result;
                     56:        }
                     57: 
                     58:        return static_cast<char*>(pa_fail_alloc("allocate clean", size));
                     59: }
                     60: 
                     61: inline void pa_free(void *ptr) {
1.4       paf        62:        pa_gc_free(ptr);
1.2       paf        63: }
                     64: 
                     65: inline void *pa_realloc(void *ptr, size_t size) {
1.4       paf        66:        if(void *result=pa_gc_realloc(ptr, size))
1.2       paf        67:                return result;
                     68: 
                     69:        return pa_fail_alloc("reallocate to", size);
                     70: }
                     71: 
                     72: #define PointerFreeGC (true)
                     73: 
                     74: //{@ Array-oriented
1.21    ! moko       75: inline void *operator new[] (size_t size) {
1.2       paf        76:        return pa_malloc(size);
                     77: }
                     78: inline void *operator new[] (size_t size, bool) { // PointerFreeGC
                     79:        return pa_malloc_atomic(size);
                     80: }
                     81: inline void operator delete[] (void *ptr) {
                     82:        pa_free(ptr);
                     83: }
                     84: //}@
                     85: 
                     86: //{@ Structure-oriented
1.21    ! moko       87: inline void *operator new(size_t size) {
1.2       paf        88:        return pa_malloc(size);
                     89: }
                     90: inline void *operator new (size_t size, bool) { // PointerFreeGC
                     91:        return pa_malloc_atomic(size);
                     92: }
                     93: inline void operator delete(void *ptr) {
                     94:        pa_free(ptr);
                     95: }
                     96: //}@
                     97: 
1.21    ! moko       98: // disabled from accidental use
        !            99: 
        !           100: void *calloc_disabled();
        !           101: void *malloc_disabled();
        !           102: void *realloc_disabled();
        !           103: void free_disabled();
        !           104: char *strdup_disabled();
        !           105: 
        !           106: inline void *calloc(size_t){ return calloc_disabled(); }
        !           107: inline void *malloc(size_t){ return malloc_disabled(); }
        !           108: inline void *realloc(void *, size_t){ return realloc_disabled(); }
        !           109: inline void free(void *){ free_disabled(); }
        !           110: inline char *strdup(const char*, size_t){ return strdup_disabled(); }
        !           111: 
1.2       paf       112: /// memory allocation/dallocation goes via pa_malloc/pa_free.
                    113: class PA_Allocated {
                    114: public:
                    115:        /// the sole: instances allocated using our functions
                    116:        static void *operator new(size_t size) { 
                    117:                return pa_malloc(size);
                    118:        }
                    119:        static void operator delete(void *ptr) {
                    120:                pa_free(ptr);
                    121:        }
                    122: };
                    123: 
                    124: /// Base for all Parser classes
                    125: typedef PA_Allocated PA_Object;
                    126: 
                    127: // defines
                    128: 
                    129: #define override
                    130: #define rethrow throw
                    131: 
                    132: #endif