nappgui-sys 0.2.0

Rust raw bindings to NAppGUI
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141

/*
 * NAppGUI Cross-platform C SDK
 * 2015-2025 Francisco Garcia Collado
 * MIT Licence
 * https://nappgui.com/en/legal/license.html
 *
 * File: bmem_unix.c
 *
 */

/* Operating System memory support */

#include "../bmem.h"
#include "../bmem.inl"

#if !defined(__UNIX__)
#error This file is for Unix/Unix-like system
#endif

#include "../cassert.h"
#include <stdlib.h>
#include <string.h>

/* Posix memalign is available from Snow Leopard */
#if defined(__MACOS__)
#include <AvailabilityMacros.h>
#if defined(MAC_OS_X_VERSION_10_6) && MAC_OS_X_VERSION_MIN_REQUIRED >= MAC_OS_X_VERSION_10_6
#define HAVE_POSIX_MEMALIGN

#endif
#else
#define HAVE_POSIX_MEMALIGN

int posix_memalign(void **memptr, size_t alignment, size_t size);
#endif

/*---------------------------------------------------------------------------*/

void _bmem_start(void)
{
}

/*---------------------------------------------------------------------------*/

void _bmem_finish(void)
{
}

/*---------------------------------------------------------------------------*/

void _bmem_atexit(void)
{
}

/*---------------------------------------------------------------------------*/

byte_t *bmem_aligned_malloc(const uint32_t size, const uint32_t align)
{
    byte_t *mem = NULL;
    /* Align must be power of 2 */
    cassert((align != 0) && (align & (align - 1)) == 0);
#if defined(HAVE_POSIX_MEMALIGN)
    {
        void *mem1 = NULL;
        int ret = 0;
        ret = posix_memalign(&mem1, (size_t)align, (size_t)size);
        mem = cast(mem1, byte_t);
        cassert_unref(ret == 0, ret);
    }
#else
    {
        /* Allocates a bigger buffer for alignment purpose, and stores the original allocated
           address just before the aligned buffer for a later call to free */
        void *alloc_mem = malloc((size_t)(size + (align - 1) + sizeofptr));
        mem = cast(alloc_mem, byte_t) + sizeofptr;
        mem += (align - ((size_t)mem & (align - 1)) & (align - 1));
        dcast(mem[-1], void) = alloc_mem;
    }
#endif

    return mem;
}

/*---------------------------------------------------------------------------*/

byte_t *bmem_aligned_realloc(byte_t *mem, const uint32_t size, const uint32_t new_size, const uint32_t align)
{
    /* Align must be power of 2 */
    cassert_no_null(mem);
    cassert((align != 0) && (align & (align - 1)) == 0);

/* We try 'in place' realloc. */
/* For typical alignments, we can avoid copying. */
#if defined(HAVE_POSIX_MEMALIGN)
    mem = cast(realloc(cast(mem, void), (size_t)new_size), byte_t);
    if (((intptr_t)mem % (intptr_t)align) == 0)
        return mem;
#endif

    /* realloc has not been successful. */
    {
        byte_t *new_mem = bmem_aligned_malloc(new_size, align);
        size_t min_size = size;
        if (new_size < min_size)
            min_size = new_size;
        memcpy(cast(new_mem, void), cast_const(mem, void), min_size);
        bmem_free(mem);
        return new_mem;
    }
}

/*---------------------------------------------------------------------------*/

void bmem_free(byte_t *mem)
{
    cassert_no_null(mem);
#if defined(HAVE_POSIX_MEMALIGN)
    free(cast(mem, void));
#else
    {
        void *memp = dcast(mem[-1], void);
        free(memp);
    }
#endif
}

/*---------------------------------------------------------------------------*/

void bmem_set1(byte_t *dest, const uint32_t size, const byte_t mask)
{
    cassert_no_null(dest);
    cassert(size > 0);
    memset(cast(dest, void), (int)mask, (size_t)size);
}

/*---------------------------------------------------------------------------*/

void bmem_set_zero(byte_t *dest, const uint32_t size)
{
    cassert_no_null(dest);
    cassert(size > 0);
    memset(cast(dest, void), 0, (size_t)size);
}