DefaultAllocator

Documentation

API Reference

DefaultAllocator

Description

Obtain the library default allocator. This currently expands to the heap allocator descriptor.

Usage example (from documentation)

  Allocator alloc = DefaultAllocator();

Usage example (Cross-references)

Usage examples (Cross-references)

In Sys.c:40:

        char  *env_var;
        size_t requiredSize;
        Allocator allocator = DefaultAllocator();
    
        getenv_s(&requiredSize, NULL, 0, name);

In Memory.c:171:

    
    char *ZstrDupN(const char *src, size n) {
        return ZstrDupNAlloc(src, n, DefaultAllocator());
    }

In Memory.c:195:

        }
    
        *dst = ZstrDupNAlloc(*src, ZstrLen(*src), alloc ? *alloc : DefaultAllocator());
        return *dst != NULL;
    }

In Memory.c:205:

    
        if (*zs) {
            Allocator alloc = DefaultAllocator();
            AllocatorFree(&alloc, (void *)*zs, ZstrLen(*zs) + 1, 1);
            *zs = NULL;

In Memory.c:219:

    
        if (*zs) {
            Allocator allocator = alloc ? *alloc : DefaultAllocator();
            AllocatorFree(&allocator, (void *)*zs, ZstrLen(*zs) + 1, 1);
            *zs = NULL;

In Io.c:2777:

        char      *result            = NULL;
        const char *next             = NULL;
        Allocator  allocator         = DefaultAllocator();
    
        if (!i || !out)

In Io.c:2841:

    
        if (!allocator_ptr) {
            default_allocator = DefaultAllocator();
            allocator_ptr     = &default_allocator;
        }

In File.c:43:

    
        if (!active_allocator) {
            default_allocator = DefaultAllocator();
            active_allocator  = &default_allocator;
        }

In Graph.c:462:

        graph->alignment            = 0;
        AllocatorUnbind(&graph->allocator);
        graph->allocator   = AllocatorBind(DefaultAllocator());
        graph->type_anchor = NULL;
        graph->__magic     = 0;

In Vec.c:93:

        vec->capacity = 0;
        AllocatorUnbind(&vec->allocator);
        vec->allocator = AllocatorBind(DefaultAllocator());
    }

In Float.c:324:

        Float result;
    
        result = FloatInit(DefaultAllocator());
        (void)float_try_from_u64_value(&result, value, DefaultAllocator());
        float_normalize(&result);

In Float.c:325:

    
        result = FloatInit(DefaultAllocator());
        (void)float_try_from_u64_value(&result, value, DefaultAllocator());
        float_normalize(&result);
        return result;

In Float.c:331:

    
    Float float_from_i64(i64 value) {
        Float result = FloatInit(DefaultAllocator());
    
        (void)float_try_from_i64_value(&result, value, DefaultAllocator());

In Float.c:333:

        Float result = FloatInit(DefaultAllocator());
    
        (void)float_try_from_i64_value(&result, value, DefaultAllocator());
        float_normalize(&result);
        return result;

In Float.c:349:

    
    Float float_from_f32(float value) {
        Float result = FloatInit(DefaultAllocator());
    
        (void)float_try_from_f32_value(&result, value, DefaultAllocator());

In Float.c:351:

        Float result = FloatInit(DefaultAllocator());
    
        (void)float_try_from_f32_value(&result, value, DefaultAllocator());
        return result;
    }

In Float.c:356:

    
    Float float_from_f64(double value) {
        Float result = FloatInit(DefaultAllocator());
    
        (void)float_try_from_f64_value(&result, value, DefaultAllocator());

In Float.c:358:

        Float result = FloatInit(DefaultAllocator());
    
        (void)float_try_from_f64_value(&result, value, DefaultAllocator());
        return result;
    }

In List.c:42:

        list->length      = 0;
        AllocatorUnbind(&list->allocator);
        list->allocator = AllocatorBind(DefaultAllocator());
    }

In Int.c:476:

        Int result = IntInit();
    
        (void)int_try_from_u64_with_allocator(&result, value, DefaultAllocator());
        return result;
    }

In BitVec.c:65:

        bitvec->byte_size = 0;
        AllocatorUnbind(&bitvec->allocator);
        bitvec->allocator = AllocatorBind(DefaultAllocator());
    }

In Map.c:462:

        map->policy.next_index      = NULL;
        map->policy.max_probe_count = 0;
        map->allocator              = AllocatorBind(DefaultAllocator());
        map->__magic                = 0;
    }

In Proc.c:144:

        close(stderr_pipe[WRITE_END]);
    
        Allocator allocator = DefaultAllocator();
        SysProc  *proc      = (SysProc *)AllocatorAlloc(&allocator, sizeof(SysProc), _Alignof(SysProc), true);

In Proc.c:227:

        CloseHandle(hStderrWrite); // parent won't write to child's stderr, will read from it
    
        Allocator allocator = DefaultAllocator();
        SysProc  *proc      = (SysProc *)AllocatorAlloc(&allocator, sizeof(SysProc), _Alignof(SysProc), true);

In Proc.c:416:

    
    void SysProcDestroy(SysProc *proc) {
        Allocator allocator = DefaultAllocator();
    
        if (!proc) {

In Mutex.c:31:

    
    SysMutex *SysMutexCreate(void) {
        Allocator allocator = DefaultAllocator();
        SysMutex *m         = (SysMutex *)AllocatorAlloc(&allocator, sizeof(SysMutex), _Alignof(SysMutex), true);

In Mutex.c:47:

    
    void SysMutexDestroy(SysMutex *m) {
        Allocator allocator = DefaultAllocator();
    
    #ifdef _WIN32

In Int.Convert.c:148:

        Int       value = IntFrom(0xBEEF);
        Str       text;
        Allocator alloc = DefaultAllocator();
        bool      ok;

In Io.Read.c:361:

        {
            char      *zs    = NULL;
            Allocator  alloc = DefaultAllocator();
    
            z = "Allocator-backed";

In Vec.Init.c:145:

    
        typedef Vec(TestItem) TestVec;
        Allocator alloc = DefaultAllocator();
        alloc.retry_limit = 17;

In Graph.Init.c:107:

    
        typedef Graph(Str) StrGraph;
        Allocator alloc = DefaultAllocator();
        alloc.retry_limit = 31;

In List.Init.c:57:

    
        typedef List(int) IntList;
        Allocator alloc = DefaultAllocator();
        alloc.retry_limit = 23;

In BitVec.Convert.c:245:

        WriteFmt("Testing BitVec try conversion allocator behavior\n");
    
        Allocator alloc = DefaultAllocator();
        alloc.effort    = ALLOCATOR_EFFORT_RETRY;
        alloc.retry_limit = 3;

In File.c:59:

    
        {
            Allocator allocator = DefaultAllocator();
            AllocatorFree(&allocator, buffer, capacity, 1);
        }

In File.c:72:

        u64   capacity     = 0;
        bool  result       = false;
        Allocator allocator = DefaultAllocator();
    
        WriteFmt("Testing ReadCompleteFile with existing buffer allocator\n");

In Float.Convert.c:128:

        Float     value = FloatFromStr("-123.45");
        Str       text;
        Allocator alloc = DefaultAllocator();
        bool      ok;

In Init.h:208:

         .states            = NULL,                                                                                        \
         .policy            = validate_map_policy_copy((policy_value)),                                                    \
         .allocator         = AllocatorBind(DefaultAllocator()),                                                           \
         .__magic           = MISRA_MAP_MAGIC}

In Init.h:27:

    #define VEC_INIT_HAS_ARGS(...) VEC_INIT_HAS_ARGS_IMPL(__VA_OPT__(,) __VA_ARGS__, 1, 0, 0)
    #define VecInit(...) CONCAT(VecInit_, VEC_INIT_HAS_ARGS(__VA_ARGS__))(__VA_ARGS__)
    #define VecInit_0() VEC_INIT_ALIGNED_WITH_DEEP_COPY_VALUE(NULL, NULL, 1, DefaultAllocator())
    #define VecInit_1(alloc) VEC_INIT_ALIGNED_WITH_DEEP_COPY_VALUE(NULL, NULL, 1, (alloc))

In Init.h:69:

    #define VecInitWithDeepCopy(...)                                                                                       \
        CONCAT(VecInitWithDeepCopy_, VEC_INIT_WITH_DEEP_COPY_HAS_ARGS(__VA_ARGS__))(__VA_ARGS__)
    #define VecInitWithDeepCopy_2(ci, cd) VEC_INIT_ALIGNED_WITH_DEEP_COPY_VALUE((ci), (cd), 1, DefaultAllocator())
    #define VecInitWithDeepCopy_3(ci, cd, alloc) VEC_INIT_ALIGNED_WITH_DEEP_COPY_VALUE((ci), (cd), 1, (alloc))

In Init.h:120:

    #define VEC_INIT_ALIGNED_HAS_ARGS(...) VEC_INIT_ALIGNED_HAS_ARGS_IMPL(__VA_ARGS__, 2, 1, 0)
    #define VecInitAligned(...) CONCAT(VecInitAligned_, VEC_INIT_ALIGNED_HAS_ARGS(__VA_ARGS__))(__VA_ARGS__)
    #define VecInitAligned_1(aln) VEC_INIT_ALIGNED_WITH_DEEP_COPY_VALUE(NULL, NULL, (aln), DefaultAllocator())
    #define VecInitAligned_2(aln, alloc) VEC_INIT_ALIGNED_WITH_DEEP_COPY_VALUE(NULL, NULL, (aln), (alloc))

In Init.h:180:

        CONCAT(VecInitAlignedWithDeepCopy_, VEC_INIT_ALIGNED_WITH_DEEP_COPY_HAS_ARGS(__VA_ARGS__))(__VA_ARGS__)
    #define VecInitAlignedWithDeepCopy_3(ci, cd, aln)                                                                      \
        VEC_INIT_ALIGNED_WITH_DEEP_COPY_VALUE((ci), (cd), (aln), DefaultAllocator())
    #define VecInitAlignedWithDeepCopy_4(ci, cd, aln, alloc)                                                               \
        VEC_INIT_ALIGNED_WITH_DEEP_COPY_VALUE((ci), (cd), (aln), (alloc))

In Init.h:85:

    #define STR_TRY_INIT_FROM_CSTR_HAS_ARGS(...)                             STR_TRY_INIT_FROM_CSTR_HAS_ARGS_IMPL(__VA_ARGS__, 4, 3, 2, 1, 0)
    #define StrTryInitFromCstr(...)                                          CONCAT(StrTryInitFromCstr_, STR_TRY_INIT_FROM_CSTR_HAS_ARGS(__VA_ARGS__))(__VA_ARGS__)
    #define StrTryInitFromCstr_3(out, cstr, len)                             StrTryInitFromCstrAlloc((out), (cstr), (len), DefaultAllocator())
    #define StrTryInitFromCstr_4(out, cstr, len, alloc)                      StrTryInitFromCstrAlloc((out), (cstr), (len), (alloc))

In Init.h:114:

    #define STR_INIT_FROM_CSTR_HAS_ARGS(...)                         STR_INIT_FROM_CSTR_HAS_ARGS_IMPL(__VA_ARGS__, 3, 2, 1, 0)
    #define StrInitFromCstr(...)                                     CONCAT(StrInitFromCstr_, STR_INIT_FROM_CSTR_HAS_ARGS(__VA_ARGS__))(__VA_ARGS__)
    #define StrInitFromCstr_2(cstr, len)                             StrInitFromCstrAlloc((cstr), (len), DefaultAllocator())
    #define StrInitFromCstr_3(cstr, len, alloc)                      StrInitFromCstrAlloc((cstr), (len), (alloc))

In Init.h:18:

    #define LIST_INIT_HAS_ARGS(...)                     LIST_INIT_HAS_ARGS_IMPL(__VA_OPT__(, ) __VA_ARGS__, 1, 0, 0)
    #define ListInit(...)                               CONCAT(ListInit_, LIST_INIT_HAS_ARGS(__VA_ARGS__))(__VA_ARGS__)
    #define ListInit_0()                                LIST_INIT_WITH_DEEP_COPY_VALUE(NULL, NULL, DefaultAllocator())
    #define ListInit_1(alloc)                           LIST_INIT_WITH_DEEP_COPY_VALUE(NULL, NULL, (alloc))

In Init.h:49:

    #define ListInitWithDeepCopy(...)                                                                                      \
        CONCAT(ListInitWithDeepCopy_, LIST_INIT_WITH_DEEP_COPY_HAS_ARGS(__VA_ARGS__))(__VA_ARGS__)
    #define ListInitWithDeepCopy_2(ci, cd)        LIST_INIT_WITH_DEEP_COPY_VALUE((ci), (cd), DefaultAllocator())
    #define ListInitWithDeepCopy_3(ci, cd, alloc) LIST_INIT_WITH_DEEP_COPY_VALUE((ci), (cd), (alloc))

In Convert.h:241:

    #define BITVEC_TRY_FROM_STR_HAS_ARGS(...)                         BITVEC_TRY_FROM_STR_HAS_ARGS_IMPL(__VA_ARGS__, 3, 2, 1, 0)
    #define BitVecTryFromStr(...)                                     CONCAT(BitVecTryFromStr_, BITVEC_TRY_FROM_STR_HAS_ARGS(__VA_ARGS__))(__VA_ARGS__)
    #define BitVecTryFromStr_2(out, str)                              BitVecTryFromStrAlloc((out), (str), DefaultAllocator())
    #define BitVecTryFromStr_3(out, str, alloc)                       BitVecTryFromStrAlloc((out), (str), (alloc))

In Convert.h:262:

    #define BITVEC_FROM_STR_HAS_ARGS(...)                     BITVEC_FROM_STR_HAS_ARGS_IMPL(__VA_ARGS__, 2, 1, 0)
    #define BitVecFromStr(...)                                CONCAT(BitVecFromStr_, BITVEC_FROM_STR_HAS_ARGS(__VA_ARGS__))(__VA_ARGS__)
    #define BitVecFromStr_1(str)                              BitVecFromStrAlloc((str), DefaultAllocator())
    #define BitVecFromStr_2(str, alloc)                       BitVecFromStrAlloc((str), (alloc))

In Convert.h:283:

    #define BITVEC_TRY_FROM_BYTES_HAS_ARGS(...)                             BITVEC_TRY_FROM_BYTES_HAS_ARGS_IMPL(__VA_ARGS__, 4, 3, 2, 1, 0)
    #define BitVecTryFromBytes(...)                                         CONCAT(BitVecTryFromBytes_, BITVEC_TRY_FROM_BYTES_HAS_ARGS(__VA_ARGS__))(__VA_ARGS__)
    #define BitVecTryFromBytes_3(out, bytes, bit_len)                       BitVecTryFromBytesAlloc((out), (bytes), (bit_len), DefaultAllocator())
    #define BitVecTryFromBytes_4(out, bytes, bit_len, alloc)                BitVecTryFromBytesAlloc((out), (bytes), (bit_len), (alloc))

In Convert.h:304:

    #define BITVEC_FROM_BYTES_HAS_ARGS(...)                         BITVEC_FROM_BYTES_HAS_ARGS_IMPL(__VA_ARGS__, 3, 2, 1, 0)
    #define BitVecFromBytes(...)                                    CONCAT(BitVecFromBytes_, BITVEC_FROM_BYTES_HAS_ARGS(__VA_ARGS__))(__VA_ARGS__)
    #define BitVecFromBytes_2(bytes, bit_len)                       BitVecFromBytesAlloc((bytes), (bit_len), DefaultAllocator())
    #define BitVecFromBytes_3(bytes, bit_len, alloc)                BitVecFromBytesAlloc((bytes), (bit_len), (alloc))

In Convert.h:326:

    #define BitVecTryFromInteger(...)                                                                                      \
        CONCAT(BitVecTryFromInteger_, BITVEC_TRY_FROM_INTEGER_HAS_ARGS(__VA_ARGS__))(__VA_ARGS__)
    #define BitVecTryFromInteger_3(out, value, bits)        BitVecTryFromIntegerAlloc((out), (value), (bits), DefaultAllocator())
    #define BitVecTryFromInteger_4(out, value, bits, alloc) BitVecTryFromIntegerAlloc((out), (value), (bits), (alloc))

In Convert.h:347:

    #define BITVEC_FROM_INTEGER_HAS_ARGS(...)                         BITVEC_FROM_INTEGER_HAS_ARGS_IMPL(__VA_ARGS__, 3, 2, 1, 0)
    #define BitVecFromInteger(...)                                    CONCAT(BitVecFromInteger_, BITVEC_FROM_INTEGER_HAS_ARGS(__VA_ARGS__))(__VA_ARGS__)
    #define BitVecFromInteger_2(value, bits)                          BitVecFromIntegerAlloc((value), (bits), DefaultAllocator())
    #define BitVecFromInteger_3(value, bits, alloc)                   BitVecFromIntegerAlloc((value), (bits), (alloc))

In Init.h:90:

                .data      = NULL,                                                                                         \
                .byte_size = 0,                                                                                            \
                .allocator = AllocatorBind(DefaultAllocator()),                                                            \
                .__magic   = MISRA_BITVEC_MAGIC                                                                            \
            })

In Init.h:109:

                       .data      = NULL,                                                                                  \
                       .byte_size = 0,                                                                                     \
                       .allocator = AllocatorBind(DefaultAllocator()),                                                     \
                       .__magic   = MISRA_BITVEC_MAGIC})
    #    define BitVecInit_1(alloc)                                                                                        \

In Init.h:165:

    #define BitVecInitWithCapacity(...)                                                                                    \
        CONCAT(BitVecInitWithCapacity_, BITVEC_INIT_WITH_CAPACITY_HAS_ARGS(__VA_ARGS__))(__VA_ARGS__)
    #define BitVecInitWithCapacity_1(cap)        BitVecInitWithCapacityAlloc((cap), DefaultAllocator())
    #define BitVecInitWithCapacity_2(cap, alloc) BitVecInitWithCapacityAlloc((cap), (alloc))

In Init.h:26:

    #define GRAPH_INIT_HAS_ARGS(...) GRAPH_INIT_HAS_ARGS_IMPL(__VA_OPT__(,) __VA_ARGS__, 1, 0, 0)
    #define GraphInit(...) CONCAT(GraphInit_, GRAPH_INIT_HAS_ARGS(__VA_ARGS__))(__VA_ARGS__)
    #define GraphInit_0() GRAPH_INIT_ALIGNED_WITH_DEEP_COPY_VALUE(NULL, NULL, 1, DefaultAllocator())
    #define GraphInit_1(alloc) GRAPH_INIT_ALIGNED_WITH_DEEP_COPY_VALUE(NULL, NULL, 1, (alloc))

In Init.h:56:

    #define GraphInitWithDeepCopy(...)                                                                                    \
        CONCAT(GraphInitWithDeepCopy_, GRAPH_INIT_WITH_DEEP_COPY_HAS_ARGS(__VA_ARGS__))(__VA_ARGS__)
    #define GraphInitWithDeepCopy_2(ci, cd) GRAPH_INIT_ALIGNED_WITH_DEEP_COPY_VALUE((ci), (cd), 1, DefaultAllocator())
    #define GraphInitWithDeepCopy_3(ci, cd, alloc) GRAPH_INIT_ALIGNED_WITH_DEEP_COPY_VALUE((ci), (cd), 1, (alloc))

In Init.h:87:

    #define GRAPH_INIT_ALIGNED_HAS_ARGS(...) GRAPH_INIT_ALIGNED_HAS_ARGS_IMPL(__VA_ARGS__, 2, 1, 0)
    #define GraphInitAligned(...) CONCAT(GraphInitAligned_, GRAPH_INIT_ALIGNED_HAS_ARGS(__VA_ARGS__))(__VA_ARGS__)
    #define GraphInitAligned_1(aln) GRAPH_INIT_ALIGNED_WITH_DEEP_COPY_VALUE(NULL, NULL, (aln), DefaultAllocator())
    #define GraphInitAligned_2(aln, alloc) GRAPH_INIT_ALIGNED_WITH_DEEP_COPY_VALUE(NULL, NULL, (aln), (alloc))

In Init.h:121:

        CONCAT(GraphInitAlignedWithDeepCopy_, GRAPH_INIT_ALIGNED_WITH_DEEP_COPY_HAS_ARGS(__VA_ARGS__))(__VA_ARGS__)
    #define GraphInitAlignedWithDeepCopy_3(ci, cd, aln)                                                                   \
        GRAPH_INIT_ALIGNED_WITH_DEEP_COPY_VALUE((ci), (cd), (aln), DefaultAllocator())
    #define GraphInitAlignedWithDeepCopy_4(ci, cd, aln, alloc)                                                            \
        GRAPH_INIT_ALIGNED_WITH_DEEP_COPY_VALUE((ci), (cd), (aln), (alloc))

In Init.h:52:

    ///
    #define IntInit(...)     CONCAT(IntInit_, INT_INIT_HAS_ARGS(__VA_ARGS__))(__VA_ARGS__)
    #define IntInit_0()      IntInitAlloc(DefaultAllocator())
    #define IntInit_1(alloc) IntInitAlloc((alloc))

In Init.h:55:

    ///
    #define FloatInit(...)     CONCAT(FloatInit_, FLOAT_INIT_HAS_ARGS(__VA_ARGS__))(__VA_ARGS__)
    #define FloatInit_0()      FloatInitAlloc(DefaultAllocator())
    #define FloatInit_1(alloc) FloatInitAlloc((alloc))

Last updated on May 14, 2026

CONCAT_FmtInfo