Ruby 4.1.0dev (2026-11-16 revision 9c7bc705b8bd4542beac71542a8ea79f9bb7622b)
buffer.c
1#include "prism/internal/buffer.h"
2
4
5#include "prism/internal/allocator.h"
6#include "prism/internal/assert.h"
7#include "prism/internal/char.h"
8#include "prism/internal/oom.h"
9
10#include <stdarg.h>
11#include <stdlib.h>
12#include <string.h>
13
17void
18pm_buffer_init(pm_buffer_t *buffer, size_t capacity) {
19 buffer->length = 0;
20 buffer->capacity = capacity;
21
22 buffer->value = (char *) xmalloc(capacity);
23 if (buffer->value == NULL) PRISM_OOM();
24}
25
30pm_buffer_new(void) {
31 pm_buffer_t *buffer = (pm_buffer_t *) xmalloc(sizeof(pm_buffer_t));
32 if (buffer == NULL) PRISM_OOM();
33
34 pm_buffer_init(buffer, 1024);
35 return buffer;
36}
37
41char *
42pm_buffer_value(const pm_buffer_t *buffer) {
43 return buffer->value;
44}
45
49size_t
50pm_buffer_length(const pm_buffer_t *buffer) {
51 return buffer->length;
52}
53
64static PRISM_INLINE bool
65pm_buffer_append_length(pm_buffer_t *buffer, size_t length) {
66 if (length == 0) return false;
67
68 size_t next_length = buffer->length + length;
69 if (next_length < buffer->length) PRISM_OOM();
70
71 if (next_length > buffer->capacity) {
72 size_t next_capacity = buffer->capacity == 0 ? 1 : buffer->capacity;
73
74 while (next_length > next_capacity) {
75 if (next_capacity > SIZE_MAX / 2) PRISM_OOM();
76 next_capacity *= 2;
77 }
78
79 char *next_value = xrealloc_sized(buffer->value, next_capacity, buffer->capacity);
80 if (next_value == NULL) PRISM_OOM();
81
82 buffer->value = next_value;
83 buffer->capacity = next_capacity;
84 }
85
86 buffer->length = next_length;
87 return true;
88}
89
93static PRISM_INLINE void
94pm_buffer_append(pm_buffer_t *buffer, const void *source, size_t length) {
95 size_t cursor = buffer->length;
96 if (pm_buffer_append_length(buffer, length)) {
97 memcpy(buffer->value + cursor, source, length);
98 }
99}
100
104void
105pm_buffer_append_zeroes(pm_buffer_t *buffer, size_t length) {
106 size_t cursor = buffer->length;
107 if (pm_buffer_append_length(buffer, length)) {
108 memset(buffer->value + cursor, 0, length);
109 }
110}
111
115void
116pm_buffer_append_repeated(pm_buffer_t *buffer, uint8_t value, size_t length) {
117 size_t cursor = buffer->length;
118 if (pm_buffer_append_length(buffer, length)) {
119 memset(buffer->value + cursor, value, length);
120 }
121}
122
126void
127pm_buffer_append_format(pm_buffer_t *buffer, const char *format, ...) {
128 va_list arguments;
129 va_start(arguments, format);
130 int result = vsnprintf(NULL, 0, format, arguments);
131 va_end(arguments);
132
133 if (result < 0) return;
134 size_t length = (size_t) (result + 1);
135
136 size_t cursor = buffer->length;
137 if (pm_buffer_append_length(buffer, length)) {
138 va_start(arguments, format);
139 vsnprintf(buffer->value + cursor, length, format, arguments);
140 va_end(arguments);
141 buffer->length--;
142 }
143}
144
148void
149pm_buffer_append_string(pm_buffer_t *buffer, const char *value, size_t length) {
150 pm_buffer_append(buffer, value, length);
151}
152
156void
157pm_buffer_append_bytes(pm_buffer_t *buffer, const uint8_t *value, size_t length) {
158 pm_buffer_append(buffer, (const char *) value, length);
159}
160
164void
165pm_buffer_append_byte(pm_buffer_t *buffer, uint8_t value) {
166 const void *source = &value;
167 pm_buffer_append(buffer, source, sizeof(uint8_t));
168}
169
173void
174pm_buffer_append_varuint(pm_buffer_t *buffer, uint32_t value) {
175 if (value < 128) {
176 pm_buffer_append_byte(buffer, (uint8_t) value);
177 } else {
178 uint32_t n = value;
179 while (n >= 128) {
180 pm_buffer_append_byte(buffer, (uint8_t) (n | 128));
181 n >>= 7;
182 }
183 pm_buffer_append_byte(buffer, (uint8_t) n);
184 }
185}
186
190void
191pm_buffer_append_varsint(pm_buffer_t *buffer, int32_t value) {
192 uint32_t unsigned_int = ((uint32_t)(value) << 1) ^ ((uint32_t)(value >> 31));
193 pm_buffer_append_varuint(buffer, unsigned_int);
194}
195
199void
200pm_buffer_append_double(pm_buffer_t *buffer, double value) {
201 const void *source = &value;
202 pm_buffer_append(buffer, source, sizeof(double));
203}
204
208void
209pm_buffer_append_uint64(pm_buffer_t *buffer, uint64_t value) {
210 const void *source = &value;
211 pm_buffer_append(buffer, source, sizeof(uint64_t));
212}
213
217bool
218pm_buffer_append_unicode_codepoint(pm_buffer_t *buffer, uint32_t value) {
219 if (value <= 0x7F) {
220 pm_buffer_append_byte(buffer, (uint8_t) value); // 0xxxxxxx
221 return true;
222 } else if (value <= 0x7FF) {
223 uint8_t bytes[] = {
224 (uint8_t) (0xC0 | ((value >> 6) & 0x3F)), // 110xxxxx
225 (uint8_t) (0x80 | (value & 0x3F)) // 10xxxxxx
226 };
227
228 pm_buffer_append_bytes(buffer, bytes, 2);
229 return true;
230 } else if (value <= 0xFFFF) {
231 uint8_t bytes[] = {
232 (uint8_t) (0xE0 | ((value >> 12) & 0x3F)), // 1110xxxx
233 (uint8_t) (0x80 | ((value >> 6) & 0x3F)), // 10xxxxxx
234 (uint8_t) (0x80 | (value & 0x3F)) // 10xxxxxx
235 };
236
237 pm_buffer_append_bytes(buffer, bytes, 3);
238 return true;
239 } else if (value <= 0x10FFFF) {
240 uint8_t bytes[] = {
241 (uint8_t) (0xF0 | ((value >> 18) & 0x3F)), // 11110xxx
242 (uint8_t) (0x80 | ((value >> 12) & 0x3F)), // 10xxxxxx
243 (uint8_t) (0x80 | ((value >> 6) & 0x3F)), // 10xxxxxx
244 (uint8_t) (0x80 | (value & 0x3F)) // 10xxxxxx
245 };
246
247 pm_buffer_append_bytes(buffer, bytes, 4);
248 return true;
249 } else {
250 return false;
251 }
252}
253
257void
258pm_buffer_append_source(pm_buffer_t *buffer, const uint8_t *source, size_t length, pm_buffer_escaping_t escaping) {
259 for (size_t index = 0; index < length; index++) {
260 const uint8_t byte = source[index];
261
262 if ((byte <= 0x06) || (byte >= 0x0E && byte <= 0x1F) || (byte >= 0x7F)) {
263 if (escaping == PM_BUFFER_ESCAPING_RUBY) {
264 pm_buffer_append_format(buffer, "\\x%02X", byte);
265 } else {
266 pm_buffer_append_format(buffer, "\\u%04X", byte);
267 }
268 } else {
269 switch (byte) {
270 case '\a':
271 if (escaping == PM_BUFFER_ESCAPING_RUBY) {
272 pm_buffer_append_string(buffer, "\\a", 2);
273 } else {
274 pm_buffer_append_format(buffer, "\\u%04X", byte);
275 }
276 break;
277 case '\b':
278 pm_buffer_append_string(buffer, "\\b", 2);
279 break;
280 case '\t':
281 pm_buffer_append_string(buffer, "\\t", 2);
282 break;
283 case '\n':
284 pm_buffer_append_string(buffer, "\\n", 2);
285 break;
286 case '\v':
287 if (escaping == PM_BUFFER_ESCAPING_RUBY) {
288 pm_buffer_append_string(buffer, "\\v", 2);
289 } else {
290 pm_buffer_append_format(buffer, "\\u%04X", byte);
291 }
292 break;
293 case '\f':
294 pm_buffer_append_string(buffer, "\\f", 2);
295 break;
296 case '\r':
297 pm_buffer_append_string(buffer, "\\r", 2);
298 break;
299 case '"':
300 pm_buffer_append_string(buffer, "\\\"", 2);
301 break;
302 case '#': {
303 if (escaping == PM_BUFFER_ESCAPING_RUBY && index + 1 < length) {
304 const uint8_t next_byte = source[index + 1];
305 if (next_byte == '{' || next_byte == '@' || next_byte == '$') {
306 pm_buffer_append_byte(buffer, '\\');
307 }
308 }
309
310 pm_buffer_append_byte(buffer, '#');
311 break;
312 }
313 case '\\':
314 pm_buffer_append_string(buffer, "\\\\", 2);
315 break;
316 default:
317 pm_buffer_append_byte(buffer, byte);
318 break;
319 }
320 }
321 }
322}
323
327void
328pm_buffer_prepend_string(pm_buffer_t *buffer, const char *value, size_t length) {
329 size_t cursor = buffer->length;
330 if (pm_buffer_append_length(buffer, length)) {
331 memmove(buffer->value + length, buffer->value, cursor);
332 memcpy(buffer->value, value, length);
333 }
334}
335
339void
340pm_buffer_concat(pm_buffer_t *destination, const pm_buffer_t *source) {
341 if (source->length > 0) {
342 pm_buffer_append(destination, source->value, source->length);
343 }
344}
345
350void
351pm_buffer_clear(pm_buffer_t *buffer) {
352 buffer->length = 0;
353}
354
358void
359pm_buffer_rstrip(pm_buffer_t *buffer) {
360 while (buffer->length > 0 && pm_char_is_whitespace((uint8_t) buffer->value[buffer->length - 1])) {
361 buffer->length--;
362 }
363}
364
368size_t
369pm_buffer_index(const pm_buffer_t *buffer, char value) {
370 const char *first = memchr(buffer->value, value, buffer->length);
371 return (first == NULL) ? SIZE_MAX : (size_t) (first - buffer->value);
372}
373
377void
378pm_buffer_insert(pm_buffer_t *buffer, size_t index, const char *value, size_t length) {
379 PRISM_ASSERT(index <= buffer->length);
380
381 if (index == buffer->length) {
382 pm_buffer_append_string(buffer, value, length);
383 } else {
384 pm_buffer_append_zeroes(buffer, length);
385 memmove(buffer->value + index + length, buffer->value + index, buffer->length - length - index);
386 memcpy(buffer->value + index, value, length);
387 }
388}
389
393void
394pm_buffer_cleanup(pm_buffer_t *buffer) {
395 xfree_sized(buffer->value, buffer->capacity);
396}
397
401void
402pm_buffer_free(pm_buffer_t *buffer) {
403 pm_buffer_cleanup(buffer);
404 xfree_sized(buffer, sizeof(pm_buffer_t));
405}
#define xmalloc
Old name of ruby_xmalloc.
Definition xmalloc.h:53
#define PRISM_INLINE
Old Visual Studio versions do not support the inline keyword, so we need to define it to be __inline.
Definition inline.h:12
Defines old _.