twe-rebanlance/array.c at master · gcliupeng/twe-rebanlance · GitHub

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
142
143

#include <stdlib.h>
#include "array.h"

struct array *
array_create(uint32_t n, size_t size)
{
    struct array *a;

    a = malloc(sizeof(*a));
    if (a == NULL) {
        return NULL;
    }

    a->elem = malloc(n * size);
    if (a->elem == NULL) {
        free(a);
        return NULL;
    }

    a->nelem = 0;
    a->size = size;
    a->nalloc = n;

    return a;
}

void
array_destroy(struct array *a)
{
    array_deinit(a);
    free(a);
}

int
array_init(struct array *a, uint32_t n, size_t size)
{

    a->elem = malloc(n * size);
    if (a->elem == NULL) {
        return 0;
    }

    a->nelem = 0;
    a->size = size;
    a->nalloc = n;

    return 1;
}

void
array_deinit(struct array *a)
{

    if (a->elem != NULL) {
        free(a->elem);
    }
}

uint32_t
array_idx(struct array *a, void *elem)
{
    uint8_t *p, *q;
    uint32_t off, idx;

    p = a->elem;
    q = elem;
    off = (uint32_t)(q - p);

    idx = off / (uint32_t)a->size;

    return idx;
}

void *
array_push(struct array *a)
{
    void *elem, *new;
    size_t size;

    if (a->nelem == a->nalloc) {

        /* the array is full; allocate new array */
        size = a->size * a->nalloc;
        new =  realloc(a->elem, 2 * size);
        if (new == NULL) {
            return NULL;
        }

        a->elem = new;
        a->nalloc *= 2;
    }

    elem = (uint8_t *)a->elem + a->size * a->nelem;
    a->nelem++;

    return elem;
}

void *
array_pop(struct array *a)
{
    void *elem;

    a->nelem--;
    elem = (uint8_t *)a->elem + a->size * a->nelem;

    return elem;
}

void *
array_get(struct array *a, uint32_t idx)
{
    void *elem;

    elem = (uint8_t *)a->elem + (a->size * idx);

    return elem;
}

void *
array_top(struct array *a)
{

    return array_get(a, a->nelem - 1);
}

int array_each(struct array *a, array_each_t func, void *data)
{
    uint32_t i, nelem;

    for (i = 0, nelem = array_n(a); i < nelem; i++) {
        void *elem = array_get(a, i);
        int status;

        status = func(elem, data);
        if (status != 1) {
            return status;
        }
    }

    return 1;
}