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