1#include "prism/internal/buffer.h"
5#include "prism/internal/allocator.h"
6#include "prism/internal/assert.h"
7#include "prism/internal/char.h"
8#include "prism/internal/oom.h"
18pm_buffer_init(
pm_buffer_t *buffer,
size_t capacity) {
20 buffer->capacity = capacity;
22 buffer->value = (
char *)
xmalloc(capacity);
23 if (buffer->value == NULL) PRISM_OOM();
32 if (buffer == NULL) PRISM_OOM();
34 pm_buffer_init(buffer, 1024);
51 return buffer->length;
65pm_buffer_append_length(
pm_buffer_t *buffer,
size_t length) {
66 if (length == 0)
return false;
68 size_t next_length = buffer->length + length;
69 if (next_length < buffer->length) PRISM_OOM();
71 if (next_length > buffer->capacity) {
72 size_t next_capacity = buffer->capacity == 0 ? 1 : buffer->capacity;
74 while (next_length > next_capacity) {
75 if (next_capacity > SIZE_MAX / 2) PRISM_OOM();
79 char *next_value = xrealloc_sized(buffer->value, next_capacity, buffer->capacity);
80 if (next_value == NULL) PRISM_OOM();
82 buffer->value = next_value;
83 buffer->capacity = next_capacity;
86 buffer->length = next_length;
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);
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);
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);
127pm_buffer_append_format(
pm_buffer_t *buffer,
const char *format, ...) {
129 va_start(arguments, format);
130 int result = vsnprintf(NULL, 0, format, arguments);
133 if (result < 0)
return;
134 size_t length = (size_t) (result + 1);
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);
149pm_buffer_append_string(
pm_buffer_t *buffer,
const char *value,
size_t length) {
150 pm_buffer_append(buffer, value, length);
157pm_buffer_append_bytes(
pm_buffer_t *buffer,
const uint8_t *value,
size_t length) {
158 pm_buffer_append(buffer, (
const char *) value, length);
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));
174pm_buffer_append_varuint(
pm_buffer_t *buffer, uint32_t value) {
176 pm_buffer_append_byte(buffer, (uint8_t) value);
180 pm_buffer_append_byte(buffer, (uint8_t) (n | 128));
183 pm_buffer_append_byte(buffer, (uint8_t) n);
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);
200pm_buffer_append_double(
pm_buffer_t *buffer,
double value) {
201 const void *source = &value;
202 pm_buffer_append(buffer, source,
sizeof(
double));
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));
218pm_buffer_append_unicode_codepoint(
pm_buffer_t *buffer, uint32_t value) {
220 pm_buffer_append_byte(buffer, (uint8_t) value);
222 }
else if (value <= 0x7FF) {
224 (uint8_t) (0xC0 | ((value >> 6) & 0x3F)),
225 (uint8_t) (0x80 | (value & 0x3F))
228 pm_buffer_append_bytes(buffer, bytes, 2);
230 }
else if (value <= 0xFFFF) {
232 (uint8_t) (0xE0 | ((value >> 12) & 0x3F)),
233 (uint8_t) (0x80 | ((value >> 6) & 0x3F)),
234 (uint8_t) (0x80 | (value & 0x3F))
237 pm_buffer_append_bytes(buffer, bytes, 3);
239 }
else if (value <= 0x10FFFF) {
241 (uint8_t) (0xF0 | ((value >> 18) & 0x3F)),
242 (uint8_t) (0x80 | ((value >> 12) & 0x3F)),
243 (uint8_t) (0x80 | ((value >> 6) & 0x3F)),
244 (uint8_t) (0x80 | (value & 0x3F))
247 pm_buffer_append_bytes(buffer, bytes, 4);
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];
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);
266 pm_buffer_append_format(buffer,
"\\u%04X",
byte);
271 if (escaping == PM_BUFFER_ESCAPING_RUBY) {
272 pm_buffer_append_string(buffer,
"\\a", 2);
274 pm_buffer_append_format(buffer,
"\\u%04X",
byte);
278 pm_buffer_append_string(buffer,
"\\b", 2);
281 pm_buffer_append_string(buffer,
"\\t", 2);
284 pm_buffer_append_string(buffer,
"\\n", 2);
287 if (escaping == PM_BUFFER_ESCAPING_RUBY) {
288 pm_buffer_append_string(buffer,
"\\v", 2);
290 pm_buffer_append_format(buffer,
"\\u%04X",
byte);
294 pm_buffer_append_string(buffer,
"\\f", 2);
297 pm_buffer_append_string(buffer,
"\\r", 2);
300 pm_buffer_append_string(buffer,
"\\\"", 2);
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,
'\\');
310 pm_buffer_append_byte(buffer,
'#');
314 pm_buffer_append_string(buffer,
"\\\\", 2);
317 pm_buffer_append_byte(buffer,
byte);
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);
341 if (source->length > 0) {
342 pm_buffer_append(destination, source->value, source->length);
360 while (buffer->length > 0 && pm_char_is_whitespace((uint8_t) buffer->value[buffer->length - 1])) {
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);
378pm_buffer_insert(
pm_buffer_t *buffer,
size_t index,
const char *value,
size_t length) {
379 PRISM_ASSERT(index <= buffer->length);
381 if (index == buffer->length) {
382 pm_buffer_append_string(buffer, value, length);
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);
395 xfree_sized(buffer->value, buffer->capacity);
403 pm_buffer_cleanup(buffer);
#define xmalloc
Old name of ruby_xmalloc.
#define PRISM_INLINE
Old Visual Studio versions do not support the inline keyword, so we need to define it to be __inline.