Debian Codegraph @

WWW/Library/Implementation/HTChunk.c

raw
1 /*
2 * $LynxId: HTChunk.c,v 1.31 2026/04/20 08:20:08 tom Exp $
3 *
4 * Chunk handling: Flexible arrays
5 * ===============================
6 *
7 */
8
9 #include <HTUtils.h>
10 #include <HTChunk.h>
11
12 #include <LYLeaks.h>
13
14 /*
15 * Initialize a chunk with a certain allocation unit
16 */
17 void HTChunkInit(HTChunk *ch, int grow)
18 {
19 ch->data = NULL;
20 ch->growby = grow;
21 ch->size = 0;
22 ch->allocated = 0;
23 }
24
25 /* Create a chunk with a certain allocation unit
26 * --------------
27 */
28 HTChunk *HTChunkCreate(int grow)
29 {
30 HTChunk *ch = typecalloc(HTChunk);
31
32 if (ch == NULL)
33 outofmem(__FILE__, "creation of chunk");
34
35 HTChunkInit(ch, grow);
36 return ch;
37 }
38
39 HTChunk *HTChunkCreateMayFail(int grow, int failok)
40 {
41 HTChunk *ch = typecalloc(HTChunk);
42
43 if (ch == NULL) {
44 if (!failok) {
45 outofmem(__FILE__, "creation of chunk");
46 }
47 } else {
48 HTChunkInit(ch, grow);
49 ch->failok = failok;
50 }
51 return ch;
52 }
53
54 /* Create a chunk with a certain allocation unit and ensured size
55 * --------------
56 */
57 HTChunk *HTChunkCreate2(int grow, size_t needed)
58 {
59 HTChunk *ch = typecalloc(HTChunk);
60
61 if (ch == NULL)
62 outofmem(__FILE__, "HTChunkCreate2");
63
64 HTChunkInit(ch, grow);
65 if (needed-- > 0) {
66 /* Round up */
67 ch->allocated = (int) (needed - (needed % (size_t) ch->growby)
68 + (unsigned) ch->growby);
69 CTRACE((tfp, "HTChunkCreate2: requested %d, allocate %u\n",
70 (int) needed, (unsigned) ch->allocated));
71 ch->data = typecallocn(char, (unsigned) ch->allocated);
72
73 if (!ch->data)
74 outofmem(__FILE__, "HTChunkCreate2 data");
75 }
76 return ch;
77 }
78
79 /* Clear a chunk of all data
80 * --------------------------
81 */
82 void HTChunkClear(HTChunk *ch)
83 {
84 FREE(ch->data);
85 ch->size = 0;
86 ch->allocated = 0;
87 }
88
89 /* Free a chunk (and it's chain, if any)
90 * -------------------------------------
91 */
92 void HTChunkFree(HTChunk *ch)
93 {
94 HTChunk *next;
95
96 do {
97 next = ch->next;
98 FREE(ch->data);
99 FREE(ch);
100 ch = next;
101 } while (ch != NULL);
102 }
103
104 /* Realloc the chunk
105 * -----------------
106 */
107 BOOL HTChunkRealloc(HTChunk *ch, int growby)
108 {
109 char *data;
110
111 ch->allocated = ch->allocated + growby;
112
113 data = (ch->data
114 ? typeRealloc(char, ch->data, ch->allocated)
115 : typecallocn(char, ch->allocated));
116
117 if (data) {
118 ch->data = data;
119 } else if (ch->failok) {
120 HTChunkClear(ch); /* allocation failed, clear all data - kw */
121 return FALSE; /* caller should check ch->allocated - kw */
122 } else {
123 outofmem(__FILE__, "HTChunkRealloc");
124 }
125 return TRUE;
126 }
127
128 /* Append a character
129 * ------------------
130 */
131 void HTChunkPutc(HTChunk *ch, unsigned c)
132 {
133 if (ch->size >= ch->allocated) {
134 if (!HTChunkRealloc(ch, ch->growby))
135 return;
136 }
137 ch->data[ch->size++] = (char) c;
138 }
139
140 /* like above but no realloc: extend to another chunk if necessary */
141 HTChunk *HTChunkPutc2(HTChunk *ch, int c)
142 {
143 if (ch->size >= ch->allocated) {
144 HTChunk *chunk = HTChunkCreateMayFail(ch->growby, ch->failok);
145
146 if (chunk != NULL) {
147 ch->next = chunk;
148 ch = chunk;
149 HTChunkPutc(ch, UCH(c));
150 }
151 } else {
152 ch->data[ch->size++] = (char) c;
153 }
154 return ch;
155 }
156
157 /* Ensure a certain size
158 * ---------------------
159 */
160 void HTChunkEnsure(HTChunk *ch, int needed)
161 {
162 if (needed <= ch->allocated)
163 return;
164 ch->allocated = needed - 1 - ((needed - 1) % ch->growby)
165 + ch->growby; /* Round up */
166 ch->data = (ch->data
167 ? typeRealloc(char, ch->data, ch->allocated)
168 : typecallocn(char, ch->allocated));
169
170 if (ch->data == NULL)
171 outofmem(__FILE__, "HTChunkEnsure");
172 }
173
174 /*
175 * Append a block of characters.
176 */
177 void HTChunkPutb(HTChunk *ch, const char *b, int l)
178 {
179 if (l > 0 && ch != NULL) {
180 if (ch->size + l > ch->allocated) {
181 int growby = l - (l % ch->growby) + ch->growby; /* Round up */
182
183 if (!HTChunkRealloc(ch, growby))
184 return;
185 }
186 MemCpy(ch->data + ch->size, b, l);
187 ch->size += l;
188 }
189 }
190
191 /* like above but no realloc: extend to another chunk if necessary */
192 HTChunk *HTChunkPutb2(HTChunk *ch, const char *b, int l)
193 {
194 if (l <= 0)
195 return ch;
196 if (ch->size + l > ch->allocated) {
197 HTChunk *chunk;
198 int m = ch->allocated - ch->size;
199
200 if (m != 0 && b != NULL) {
201 MemCpy(ch->data + ch->size, b, (unsigned) m);
202 ch->size += m;
203 }
204
205 chunk = HTChunkCreateMayFail(ch->growby, ch->failok);
206 ch->next = chunk;
207 ch = chunk;
208 if (b != NULL)
209 HTChunkPutb(ch, b + m, l - m);
210 } else {
211 MemCpy(ch->data + ch->size, b, (unsigned) l);
212 ch->size += l;
213 }
214 return ch;
215 }
216
217 #define PUTC(code) ch->data[ch->size++] = (char)(code)
218 #define PUTC2(code) ch->data[ch->size++] = (char)(0x80|(0x3f &(code)))
219
220 /*
221 * Append a character encoded as UTF-8.
222 */
223 void HTChunkPutUtf8Char(HTChunk *ch, UCode_t code)
224 {
225 int utflen;
226
227 if (TOASCII(code) < 128)
228 utflen = 1;
229 else if (code < 0x800L) {
230 utflen = 2;
231 } else if (code < 0x10000L) {
232 utflen = 3;
233 } else if (code < 0x200000L) {
234 utflen = 4;
235 } else if (code < 0x4000000L) {
236 utflen = 5;
237 } else if (code <= 0x7fffffffL) {
238 utflen = 6;
239 } else
240 utflen = 0;
241
242 if (ch->size + utflen > ch->allocated) {
243 int growby = (ch->growby >= utflen) ? ch->growby : utflen;
244
245 if (!HTChunkRealloc(ch, growby))
246 return;
247 }
248
249 switch (utflen) {
250 case 0:
251 return;
252 case 1:
253 ch->data[ch->size++] = (char) code;
254 return;
255 case 2:
256 PUTC(0xc0 | (code >> 6));
257 break;
258 case 3:
259 PUTC(0xe0 | (code >> 12));
260 break;
261 case 4:
262 PUTC(0xf0 | (code >> 18));
263 break;
264 case 5:
265 PUTC(0xf8 | (code >> 24));
266 break;
267 case 6:
268 PUTC(0xfc | (code >> 30));
269 break;
270 }
271 switch (utflen) {
272 case 6:
273 PUTC2(code >> 24);
274 /* FALLTHRU */
275 case 5:
276 PUTC2(code >> 18);
277 /* FALLTHRU */
278 case 4:
279 PUTC2(code >> 12);
280 /* FALLTHRU */
281 case 3:
282 PUTC2(code >> 6);
283 /* FALLTHRU */
284 case 2:
285 PUTC2(code);
286 break;
287 }
288 }
289
290 /* Terminate a chunk
291 * -----------------
292 */
293 void HTChunkTerminate(HTChunk *ch)
294 {
295 HTChunkPutc(ch, (char) 0);
296 }
297
298 /* Append a string
299 * ---------------
300 */
301 void HTChunkPuts(HTChunk *ch, const char *s)
302 {
303 const char *p;
304
305 if (s != NULL && ch != NULL) {
306 for (p = s; *p; p++) {
307 if (ch->size >= ch->allocated) {
308 if (!HTChunkRealloc(ch, ch->growby))
309 break;
310 }
311 ch->data[ch->size++] = *p;
312 }
313 }
314 }
315
316 /* like above but no realloc: extend to another chunk if necessary */
317 HTChunk *HTChunkPuts2(HTChunk *ch, const char *s)
318 {
319 const char *p;
320
321 if (s != NULL) {
322 for (p = s; *p; p++) {
323 if (ch->size >= ch->allocated) {
324 HTChunk *chunk = HTChunkCreateMayFail(ch->growby, ch->failok);
325
326 ch->next = chunk;
327 ch = chunk;
328 HTChunkPuts(ch, p);
329 break;
330 }
331 ch->data[ch->size++] = *p;
332 }
333 }
334 return ch;
335 }