|
0
|
1
|
|
|
2 /*
|
|
|
3 * Copyright (C) Igor Sysoev
|
|
|
4 */
|
|
|
5
|
|
|
6
|
|
|
7 #include <ngx_config.h>
|
|
|
8 #include <ngx_core.h>
|
|
|
9
|
|
|
10
|
|
34
|
11 ngx_array_t *ngx_array_create(ngx_pool_t *p, ngx_uint_t n, size_t size)
|
|
0
|
12 {
|
|
|
13 ngx_array_t *a;
|
|
|
14
|
|
34
|
15 if (!(a = ngx_palloc(p, sizeof(ngx_array_t)))) {
|
|
|
16 return NULL;
|
|
|
17 }
|
|
0
|
18
|
|
34
|
19 if (!(a->elts = ngx_palloc(p, n * size))) {
|
|
|
20 return NULL;
|
|
|
21 }
|
|
|
22
|
|
0
|
23 a->nelts = 0;
|
|
34
|
24 a->size = size;
|
|
0
|
25 a->nalloc = n;
|
|
34
|
26 a->pool = p;
|
|
0
|
27
|
|
|
28 return a;
|
|
|
29 }
|
|
|
30
|
|
|
31
|
|
34
|
32 void ngx_array_destroy(ngx_array_t *a)
|
|
0
|
33 {
|
|
|
34 ngx_pool_t *p;
|
|
|
35
|
|
|
36 p = a->pool;
|
|
|
37
|
|
34
|
38 if ((u_char *) a->elts + a->size * a->nalloc == p->last) {
|
|
0
|
39 p->last -= a->size * a->nalloc;
|
|
|
40 }
|
|
|
41
|
|
34
|
42 if ((u_char *) a + sizeof(ngx_array_t) == p->last) {
|
|
|
43 p->last = (u_char *) a;
|
|
0
|
44 }
|
|
|
45 }
|
|
|
46
|
|
|
47
|
|
34
|
48 void *ngx_array_push(ngx_array_t *a)
|
|
0
|
49 {
|
|
|
50 void *elt, *new;
|
|
34
|
51 size_t size;
|
|
0
|
52 ngx_pool_t *p;
|
|
|
53
|
|
|
54 if (a->nelts == a->nalloc) {
|
|
34
|
55
|
|
|
56 /* the array is full */
|
|
|
57
|
|
|
58 size = a->size * a->nalloc;
|
|
|
59
|
|
0
|
60 p = a->pool;
|
|
|
61
|
|
34
|
62 if ((u_char *) a->elts + size == p->last && p->last + a->size <= p->end)
|
|
0
|
63 {
|
|
34
|
64 /*
|
|
|
65 * the array allocation is the last in the pool
|
|
|
66 * and there is space for new allocation
|
|
|
67 */
|
|
|
68
|
|
0
|
69 p->last += a->size;
|
|
|
70 a->nalloc++;
|
|
|
71
|
|
|
72 } else {
|
|
34
|
73 /* allocate a new array */
|
|
0
|
74
|
|
34
|
75 if (!(new = ngx_palloc(p, 2 * size))) {
|
|
|
76 return NULL;
|
|
|
77 }
|
|
|
78
|
|
|
79 ngx_memcpy(new, a->elts, size);
|
|
0
|
80 a->elts = new;
|
|
|
81 a->nalloc *= 2;
|
|
|
82 }
|
|
|
83 }
|
|
|
84
|
|
34
|
85 elt = (u_char *) a->elts + a->size * a->nelts;
|
|
0
|
86 a->nelts++;
|
|
|
87
|
|
|
88 return elt;
|
|
|
89 }
|
|
34
|
90
|
|
|
91
|
|
|
92 void *ngx_array_push_n(ngx_array_t *a, ngx_uint_t n)
|
|
|
93 {
|
|
|
94 void *elt, *new;
|
|
|
95 size_t size;
|
|
|
96 ngx_uint_t nalloc;
|
|
|
97 ngx_pool_t *p;
|
|
|
98
|
|
|
99 size = n * a->size;
|
|
|
100
|
|
|
101 if (a->nelts + n > a->nalloc) {
|
|
|
102
|
|
|
103 /* the array is full */
|
|
|
104
|
|
|
105 p = a->pool;
|
|
|
106
|
|
|
107 if ((u_char *) a->elts + a->size * a->nalloc == p->last
|
|
|
108 && p->last + size <= p->end)
|
|
|
109 {
|
|
|
110 /*
|
|
|
111 * the array allocation is the last in the pool
|
|
|
112 * and there is space for new allocation
|
|
|
113 */
|
|
|
114
|
|
|
115 p->last += size;
|
|
|
116 a->nalloc += n;
|
|
|
117
|
|
|
118 } else {
|
|
|
119 /* allocate a new array */
|
|
|
120
|
|
|
121 nalloc = 2 * ((n >= a->nalloc) ? n : a->nalloc);
|
|
|
122
|
|
|
123 if (!(new = ngx_palloc(p, nalloc * a->size))) {
|
|
|
124 return NULL;
|
|
|
125 }
|
|
|
126
|
|
|
127 ngx_memcpy(new, a->elts, a->nelts * a->size);
|
|
|
128 a->elts = new;
|
|
|
129 a->nalloc = nalloc;
|
|
|
130 }
|
|
|
131 }
|
|
|
132
|
|
|
133 elt = (u_char *) a->elts + a->size * a->nelts;
|
|
|
134 a->nelts += n;
|
|
|
135
|
|
|
136 return elt;
|
|
|
137 }
|
