diff --git a/include/prism/compiler/noreturn.h b/include/prism/compiler/noreturn.h new file mode 100644 index 0000000000..02cf7517a3 --- /dev/null +++ b/include/prism/compiler/noreturn.h @@ -0,0 +1,24 @@ +/** + * @file compiler/noreturn.h + */ +#ifndef PRISM_COMPILER_NORETURN_H +#define PRISM_COMPILER_NORETURN_H + +/** + * Mark a function as never returning to its caller, so that the compiler can + * treat the code after a call to it as unreachable. Every form of this goes + * before the declaration. + */ +#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 202311L +# define PRISM_NORETURN [[noreturn]] +#elif defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L +# define PRISM_NORETURN _Noreturn +#elif defined(__GNUC__) || defined(__clang__) +# define PRISM_NORETURN __attribute__((__noreturn__)) +#elif defined(_MSC_VER) +# define PRISM_NORETURN __declspec(noreturn) +#else +# define PRISM_NORETURN +#endif + +#endif diff --git a/include/prism/internal/arena.h b/include/prism/internal/arena.h index 22f4ee542a..d4bdeec611 100644 --- a/include/prism/internal/arena.h +++ b/include/prism/internal/arena.h @@ -1,14 +1,17 @@ #ifndef PRISM_INTERNAL_ARENA_H #define PRISM_INTERNAL_ARENA_H -#include "prism/compiler/exported.h" +#include "prism/compiler/align.h" +#include "prism/compiler/branch.h" #include "prism/compiler/flex_array.h" #include "prism/compiler/force_inline.h" #include "prism/compiler/inline.h" +#include "prism/compiler/noreturn.h" #include "prism/arena.h" #include +#include #include /* @@ -70,6 +73,13 @@ void pm_arena_reserve(pm_arena_t *arena, size_t capacity); */ void * pm_arena_alloc_slow(pm_arena_t *arena, size_t size); +/* + * Report an array allocation whose total size does not fit in a size_t. This + * goes through PRISM_OOM like any other allocation failure, and lives out of + * line so this header does not need the headers PRISM_OOM depends on. + */ +PRISM_NORETURN void pm_arena_alloc_overflow(void); + /* * Allocate memory from the arena. The returned memory is NOT zeroed. This * function is infallible — it aborts on allocation failure. @@ -99,6 +109,28 @@ pm_arena_alloc(pm_arena_t *arena, size_t size, size_t alignment) { */ void * pm_arena_alloc_aligned(pm_arena_t *arena, size_t size, size_t alignment); +/* + * Allocate memory for a single element of type T_ from the arena. + */ +#define PM_ARENA_ALLOC(arena_, T_) \ + ((T_ *) pm_arena_alloc(arena_, sizeof(T_), PRISM_ALIGNOF(T_))) + +/* + * Allocate an array of elements from the arena. The returned memory is NOT + * zeroed. This function is infallible — it aborts on allocation failure. + */ +static PRISM_INLINE void * +pm_arena_alloc_array(pm_arena_t *arena, size_t count, size_t size, size_t alignment) { + if (PRISM_UNLIKELY(count > SIZE_MAX / size)) pm_arena_alloc_overflow(); + return pm_arena_alloc(arena, count * size, alignment); +} + +/* + * Allocate an array of elements of type T_ from the arena. + */ +#define PM_ARENA_ALLOC_ARRAY(arena_, T_, count_) \ + ((T_ *) pm_arena_alloc_array(arena_, count_, sizeof(T_), PRISM_ALIGNOF(T_))) + /* * Allocate zero-initialized memory from the arena. This function is infallible * — it aborts on allocation failure. @@ -110,6 +142,29 @@ pm_arena_zalloc(pm_arena_t *arena, size_t size, size_t alignment) { return ptr; } +/* + * Allocate a zero-initialized element of type T_ from the arena. + */ +#define PM_ARENA_ZALLOC(arena_, T_) \ + ((T_ *) pm_arena_zalloc(arena_, sizeof(T_), PRISM_ALIGNOF(T_))) + +/* + * Allocate a zero-initialized array of elements from the arena. This function + * is infallible — it aborts on allocation failure. + */ +static PRISM_INLINE void * +pm_arena_zalloc_array(pm_arena_t *arena, size_t count, size_t size, size_t alignment) { + void *ptr = pm_arena_alloc_array(arena, count, size, alignment); + memset(ptr, 0, count * size); + return ptr; +} + +/* + * Allocate a zero-initialized array of elements of type T_ from the arena. + */ +#define PM_ARENA_ZALLOC_ARRAY(arena_, T_, count_) \ + ((T_ *) pm_arena_zalloc_array(arena_, count_, sizeof(T_), PRISM_ALIGNOF(T_))) + /* * Allocate memory from the arena and copy the given data into it. This is a * convenience wrapper around pm_arena_alloc + memcpy. @@ -149,4 +204,10 @@ pm_arena_realloc(pm_arena_t *arena, void *ptr, size_t new_size, size_t old_size, return result; } +/* + * Reallocate an element of type T_ from the arena. + */ +#define PM_ARENA_REALLOC(arena_, ptr_, new_size_, old_size_, T_) \ + ((T_ *) pm_arena_realloc(arena_, ptr_, new_size_, old_size_, PRISM_ALIGNOF(T_))) + #endif diff --git a/prism.gemspec b/prism.gemspec index 7429225ae7..b27063d392 100644 --- a/prism.gemspec +++ b/prism.gemspec @@ -65,6 +65,7 @@ Gem::Specification.new do |spec| "include/prism/compiler/lifetimebound.hpp", "include/prism/compiler/nodiscard.h", "include/prism/compiler/nonnull.h", + "include/prism/compiler/noreturn.h", "include/prism/compiler/stack.h", "include/prism/compiler/unused.h", "include/prism/internal/allocator.h", diff --git a/src/arena.c b/src/arena.c index 11ff357106..cff7423eda 100644 --- a/src/arena.c +++ b/src/arena.c @@ -153,6 +153,17 @@ pm_arena_alloc_aligned(pm_arena_t *arena, size_t size, size_t alignment) { return (void *) aligned; } +/** + * Report an array allocation whose total size does not fit in a size_t. A + * consumer's PRISM_OOM is not required to stop execution, so this aborts after + * it to keep the promise that it never returns. + */ +void +pm_arena_alloc_overflow(void) { + PRISM_OOM(); + abort(); +} + /** * Returns a newly allocated and initialized arena. */ diff --git a/src/buffer.c b/src/buffer.c index c9f891ecd1..b062e157c2 100644 --- a/src/buffer.c +++ b/src/buffer.c @@ -264,35 +264,35 @@ pm_buffer_append_source(pm_buffer_t *buffer, const uint8_t *source, size_t lengt switch (byte) { case '\a': if (escaping == PM_BUFFER_ESCAPING_RUBY) { - pm_buffer_append_string(buffer, "\\a", 2); + PM_BUFFER_APPEND_LITERAL(buffer, "\\a"); } else { pm_buffer_append_format(buffer, "\\u%04X", byte); } break; case '\b': - pm_buffer_append_string(buffer, "\\b", 2); + PM_BUFFER_APPEND_LITERAL(buffer, "\\b"); break; case '\t': - pm_buffer_append_string(buffer, "\\t", 2); + PM_BUFFER_APPEND_LITERAL(buffer, "\\t"); break; case '\n': - pm_buffer_append_string(buffer, "\\n", 2); + PM_BUFFER_APPEND_LITERAL(buffer, "\\n"); break; case '\v': if (escaping == PM_BUFFER_ESCAPING_RUBY) { - pm_buffer_append_string(buffer, "\\v", 2); + PM_BUFFER_APPEND_LITERAL(buffer, "\\v"); } else { pm_buffer_append_format(buffer, "\\u%04X", byte); } break; case '\f': - pm_buffer_append_string(buffer, "\\f", 2); + PM_BUFFER_APPEND_LITERAL(buffer, "\\f"); break; case '\r': - pm_buffer_append_string(buffer, "\\r", 2); + PM_BUFFER_APPEND_LITERAL(buffer, "\\r"); break; case '"': - pm_buffer_append_string(buffer, "\\\"", 2); + PM_BUFFER_APPEND_LITERAL(buffer, "\\\""); break; case '#': { if (escaping == PM_BUFFER_ESCAPING_RUBY && index + 1 < length) { @@ -306,7 +306,7 @@ pm_buffer_append_source(pm_buffer_t *buffer, const uint8_t *source, size_t lengt break; } case '\\': - pm_buffer_append_string(buffer, "\\\\", 2); + PM_BUFFER_APPEND_LITERAL(buffer, "\\\\"); break; default: pm_buffer_append_byte(buffer, byte); diff --git a/src/comments.c b/src/comments.c index ebd99be497..c038cd2444 100644 --- a/src/comments.c +++ b/src/comments.c @@ -75,7 +75,7 @@ pm_comments_compare(const void *left, const void *right) { */ static const pm_comment_t ** pm_comments_sort(pm_parser_t *parser, uint32_t size) { - pm_comment_t **comments = (pm_comment_t **) pm_arena_alloc(&parser->metadata_arena, sizeof(pm_comment_t *) * size, PRISM_ALIGNOF(pm_comment_t *)); + pm_comment_t **comments = PM_ARENA_ALLOC_ARRAY(&parser->metadata_arena, pm_comment_t *, size); uint32_t index = 0; for (pm_list_node_t *node = parser->comment_list.head; node != NULL; node = node->next) { @@ -232,7 +232,7 @@ pm_comments_push(const pm_node_t *node, void *data) { if (walk->stack.size == walk->stack.capacity) { size_t capacity = walk->stack.capacity == 0 ? 64 : walk->stack.capacity * 2; - const pm_node_t **nodes = (const pm_node_t **) pm_arena_alloc(walk->arena, sizeof(pm_node_t *) * capacity, PRISM_ALIGNOF(pm_node_t *)); + const pm_node_t **nodes = PM_ARENA_ALLOC_ARRAY(walk->arena, const pm_node_t *, capacity); if (walk->stack.size > 0) memcpy((void *) nodes, (const void *) walk->stack.nodes, sizeof(pm_node_t *) * walk->stack.size); walk->stack.nodes = nodes; @@ -398,9 +398,9 @@ pm_comments_attach(pm_parser_t *parser, const pm_node_t *root) { .source = parser->start, .comments = pm_comments_sort(parser, size), .size = size, - .starts = (uint32_t *) pm_arena_alloc(arena, sizeof(uint32_t) * size, PRISM_ALIGNOF(uint32_t)), - .attached = (const pm_node_t **) pm_arena_zalloc(arena, sizeof(pm_node_t *) * size, PRISM_ALIGNOF(pm_node_t *)), - .unclaimed = (uint32_t *) pm_arena_alloc(arena, sizeof(uint32_t) * (size + 1), PRISM_ALIGNOF(uint32_t)) + .starts = PM_ARENA_ALLOC_ARRAY(arena, uint32_t, size), + .attached = PM_ARENA_ZALLOC_ARRAY(arena, const pm_node_t *, size), + .unclaimed = PM_ARENA_ALLOC_ARRAY(arena, uint32_t, size + 1) }; for (uint32_t index = 0; index < size; index++) walk.starts[index] = walk.comments[index]->location.start; @@ -427,8 +427,8 @@ pm_comments_attach(pm_parser_t *parser, const pm_node_t *root) { /* The ranges only extend to the largest node id that owns a comment, since * none of the nodes after it own any. */ - pm_comment_range_t *ranges = (pm_comment_range_t *) pm_arena_zalloc(&parser->metadata_arena, sizeof(pm_comment_range_t) * ranges_size, PRISM_ALIGNOF(pm_comment_range_t)); - uint32_t *attachments = (uint32_t *) pm_arena_alloc(&parser->metadata_arena, sizeof(uint32_t) * size, PRISM_ALIGNOF(uint32_t)); + pm_comment_range_t *ranges = PM_ARENA_ZALLOC_ARRAY(&parser->metadata_arena, pm_comment_range_t, ranges_size); + uint32_t *attachments = PM_ARENA_ALLOC_ARRAY(&parser->metadata_arena, uint32_t, size); for (uint32_t index = 0; index < size; index++) { ranges[walk.attached[index]->node_id].length++; diff --git a/src/constant_pool.c b/src/constant_pool.c index 2b56792f7b..299225adbb 100644 --- a/src/constant_pool.c +++ b/src/constant_pool.c @@ -13,7 +13,7 @@ void pm_constant_id_list_init(pm_arena_t *arena, pm_constant_id_list_t *list, uint32_t size) { if (size) { - list->ids = (pm_constant_id_t *) pm_arena_zalloc(arena, size * sizeof(pm_constant_id_t), PRISM_ALIGNOF(pm_constant_id_t)); + list->ids = PM_ARENA_ZALLOC_ARRAY(arena, pm_constant_id_t, size); } else { list->ids = NULL; } @@ -29,10 +29,10 @@ pm_constant_id_list_init(pm_arena_t *arena, pm_constant_id_list_t *list, uint32_ void pm_constant_id_list_append(pm_arena_t *arena, pm_constant_id_list_t *list, pm_constant_id_t id) { if (list->size == 0) { - list->ids = (pm_constant_id_t *) pm_arena_alloc(arena, sizeof(pm_constant_id_t), PRISM_ALIGNOF(pm_constant_id_t)); + list->ids = PM_ARENA_ALLOC(arena, pm_constant_id_t); list->ids[list->size++] = id; } else { - list->ids =(pm_constant_id_t *) pm_arena_realloc(arena, list->ids, sizeof(pm_constant_id_t) * (list->size + 1), sizeof(pm_constant_id_t) * list->size, PRISM_ALIGNOF(pm_constant_id_t)); + list->ids = PM_ARENA_REALLOC(arena, list->ids, sizeof(pm_constant_id_t) * (list->size + 1), sizeof(pm_constant_id_t) * list->size, pm_constant_id_t); list->ids[list->size++] = id; } } @@ -83,7 +83,7 @@ pm_constant_id_set_insert(pm_arena_t *arena, pm_constant_id_set_t *set, pm_const pm_constant_id_set_t grown = { .size = set->size, .capacity = capacity, - .ids = (pm_constant_id_t *) pm_arena_zalloc(arena, capacity * sizeof(pm_constant_id_t), PRISM_ALIGNOF(pm_constant_id_t)) + .ids = PM_ARENA_ZALLOC_ARRAY(arena, pm_constant_id_t, capacity) }; for (size_t index = 0; index < set->capacity; index++) { @@ -231,9 +231,9 @@ pm_constant_pool_resize(pm_arena_t *arena, pm_constant_pool_t *pool) { * in the arena. */ size_t constants_size = pm_constant_pool_constants_capacity(pool->capacity) * sizeof(pm_constant_t); size_t next_constants_size = pm_constant_pool_constants_capacity(next_capacity) * sizeof(pm_constant_t); - pool->constants = (pm_constant_t *) pm_arena_realloc(arena, pool->constants, next_constants_size, constants_size, PRISM_ALIGNOF(pm_constant_t)); + pool->constants = PM_ARENA_REALLOC(arena, pool->constants, next_constants_size, constants_size, pm_constant_t); - pm_constant_pool_bucket_t *next_buckets = (pm_constant_pool_bucket_t *) pm_arena_zalloc(arena, next_capacity * sizeof(pm_constant_pool_bucket_t), PRISM_ALIGNOF(pm_constant_pool_bucket_t)); + pm_constant_pool_bucket_t *next_buckets = PM_ARENA_ZALLOC_ARRAY(arena, pm_constant_pool_bucket_t, next_capacity); // For each bucket in the current constant pool, find the index in the // next constant pool, and insert it. @@ -268,8 +268,9 @@ pm_constant_pool_resize(pm_arena_t *arena, pm_constant_pool_t *pool) { void pm_constant_pool_init(pm_arena_t *arena, pm_constant_pool_t *pool, uint32_t capacity) { capacity = next_power_of_two(capacity); - pool->buckets = (pm_constant_pool_bucket_t *) pm_arena_zalloc(arena, capacity * sizeof(pm_constant_pool_bucket_t), PRISM_ALIGNOF(pm_constant_pool_bucket_t)); - pool->constants = (pm_constant_t *) pm_arena_alloc(arena, pm_constant_pool_constants_capacity(capacity) * sizeof(pm_constant_t), PRISM_ALIGNOF(pm_constant_t)); + + pool->buckets = PM_ARENA_ZALLOC_ARRAY(arena, pm_constant_pool_bucket_t, capacity); + pool->constants = PM_ARENA_ALLOC_ARRAY(arena, pm_constant_t, pm_constant_pool_constants_capacity(capacity)); pool->size = 0; pool->capacity = capacity; } diff --git a/src/integer.c b/src/integer.c index 7e4c209397..156e5b3f7c 100644 --- a/src/integer.c +++ b/src/integer.c @@ -124,7 +124,7 @@ pm_integer_parse_powof2(pm_arena_t *arena, pm_integer_t *integer, uint32_t base, uint32_t length = (uint32_t) (((uint64_t) (digits - 1) * bit + leading_bits + 31) / 32); assert(length > 2); - uint32_t *words = pm_arena_zalloc(arena, sizeof(uint32_t) * length, PRISM_ALIGNOF(uint32_t)); + uint32_t *words = PM_ARENA_ZALLOC_ARRAY(arena, uint32_t, length); uint64_t bit_position = 0; for (const uint8_t *cursor = end; cursor > start;) { @@ -217,7 +217,7 @@ pm_integer_parse_decimal_divide(pm_arena_t *arena, pm_integer_t *integer, uint32 pm_bignum_t result = { .length = 0, - .words = (uint32_t *) pm_arena_alloc(arena, sizeof(uint32_t) * capacity, PRISM_ALIGNOF(uint32_t)) + .words = PM_ARENA_ALLOC_ARRAY(arena, uint32_t, capacity) }; /* The scratch space is about 12 times the number of chunks, which can @@ -288,7 +288,7 @@ pm_integer_parse_decimal_schoolbook(pm_arena_t *arena, pm_integer_t *integer, ui uint32_t capacity = pm_integer_decimal_words(digits); pm_bignum_t bignum = { .length = 0, - .words = (uint32_t *) pm_arena_alloc(arena, sizeof(uint32_t) * capacity, PRISM_ALIGNOF(uint32_t)) + .words = PM_ARENA_ALLOC_ARRAY(arena, uint32_t, capacity) }; uint32_t chunk_size = digits % 9 == 0 ? 9 : digits % 9; @@ -457,7 +457,7 @@ pm_integer_parse_rational(pm_arena_t *arena, pm_integer_t *numerator, pm_integer pm_bignum_t bignum = { .length = 1, - .words = (uint32_t *) pm_arena_alloc(arena, sizeof(uint32_t) * capacity, PRISM_ALIGNOF(uint32_t)) + .words = PM_ARENA_ALLOC_ARRAY(arena, uint32_t, capacity) }; bignum.words[0] = 1; diff --git a/src/line_offset_list.c b/src/line_offset_list.c index ce217ebd3f..9d39feba10 100644 --- a/src/line_offset_list.c +++ b/src/line_offset_list.c @@ -10,7 +10,7 @@ */ void pm_line_offset_list_init(pm_arena_t *arena, pm_line_offset_list_t *list, size_t capacity) { - list->offsets = (uint32_t *) pm_arena_alloc(arena, capacity * sizeof(uint32_t), PRISM_ALIGNOF(uint32_t)); + list->offsets = PM_ARENA_ALLOC_ARRAY(arena, uint32_t, capacity); // The first line always has offset 0. list->offsets[0] = 0; @@ -32,7 +32,7 @@ pm_line_offset_list_clear(pm_line_offset_list_t *list) { void pm_line_offset_list_append_slow(pm_arena_t *arena, pm_line_offset_list_t *list, uint32_t cursor) { size_t new_capacity = (list->capacity * 3) / 2; - uint32_t *new_offsets = (uint32_t *) pm_arena_alloc(arena, new_capacity * sizeof(uint32_t), PRISM_ALIGNOF(uint32_t)); + uint32_t *new_offsets = PM_ARENA_ALLOC_ARRAY(arena, uint32_t, new_capacity); memcpy(new_offsets, list->offsets, list->size * sizeof(uint32_t)); diff --git a/src/prism.c b/src/prism.c index 0898430f70..7c11143062 100644 --- a/src/prism.c +++ b/src/prism.c @@ -193,7 +193,7 @@ lex_mode_push(pm_parser_t *parser, pm_lex_mode_t lex_mode) { if (next != NULL) { parser->lex_modes.free = next->prev; } else { - next = (pm_lex_mode_t *) pm_arena_alloc(&parser->scratch_arena, sizeof(pm_lex_mode_t), PRISM_ALIGNOF(pm_lex_mode_t)); + next = PM_ARENA_ALLOC(&parser->scratch_arena, pm_lex_mode_t); } lex_mode.prev = parser->lex_modes.current; @@ -711,7 +711,7 @@ pm_parser_scope_push(pm_parser_t *parser, bool closed) { memset(locals.locals, 0, locals.capacity * sizeof(pm_local_t)); } } else { - scope = (pm_scope_t *) pm_arena_alloc(&parser->scratch_arena, sizeof(pm_scope_t), PRISM_ALIGNOF(pm_scope_t)); + scope = PM_ARENA_ALLOC(&parser->scratch_arena, pm_scope_t); } *scope = (pm_scope_t) { @@ -890,7 +890,7 @@ pm_locals_resize(pm_arena_t *arena, pm_locals_t *locals) { uint32_t next_capacity = locals->capacity == 0 ? 4 : (locals->capacity * 2); assert(next_capacity > locals->capacity); - pm_local_t *next_locals = (pm_local_t *) pm_arena_zalloc(arena, next_capacity * sizeof(pm_local_t), PRISM_ALIGNOF(pm_local_t)); + pm_local_t *next_locals = PM_ARENA_ZALLOC_ARRAY(arena, pm_local_t, next_capacity); if (next_capacity < PM_LOCALS_HASH_THRESHOLD) { if (locals->size > 0) { @@ -3216,7 +3216,7 @@ pm_call_write_read_name_init(pm_parser_t *parser, pm_constant_id_t *read_name, p if (write_constant->length > 0) { size_t length = write_constant->length - 1; - uint8_t *memory = (uint8_t *) pm_arena_alloc(parser->arena, length, 1); + uint8_t *memory = PM_ARENA_ALLOC_ARRAY(parser->arena, uint8_t, length); memcpy(memory, write_constant->start, length); *read_name = pm_constant_pool_insert_owned(&parser->metadata_arena, &parser->constant_pool, memory, length); @@ -7740,7 +7740,7 @@ parser_lex_magic_comment(pm_parser_t *parser, bool semantic_token_seen) { } // Allocate a new magic comment node to append to the parser's list. - pm_magic_comment_t *magic_comment = (pm_magic_comment_t *) pm_arena_alloc(&parser->metadata_arena, sizeof(pm_magic_comment_t), PRISM_ALIGNOF(pm_magic_comment_t)); + pm_magic_comment_t *magic_comment = PM_ARENA_ALLOC(&parser->metadata_arena, pm_magic_comment_t); magic_comment->node.next = NULL; magic_comment->key = (pm_location_t) { .start = U32(key_start - parser->start), .length = U32(key_length) }; magic_comment->value = (pm_location_t) { .start = U32(value_start - parser->start), .length = value_length }; @@ -7841,7 +7841,7 @@ context_push(pm_parser_t *parser, pm_context_t context) { if (context_node != NULL) { parser->free_contexts = context_node->prev; } else { - context_node = (pm_context_node_t *) pm_arena_alloc(&parser->scratch_arena, sizeof(pm_context_node_t), PRISM_ALIGNOF(pm_context_node_t)); + context_node = PM_ARENA_ALLOC(&parser->scratch_arena, pm_context_node_t); } pm_context_node_t *previous = parser->current_context; @@ -9570,7 +9570,7 @@ parser_lex_callback(pm_parser_t *parser) { */ static PRISM_INLINE pm_comment_t * parser_comment(pm_parser_t *parser, pm_comment_type_t type) { - pm_comment_t *comment = (pm_comment_t *) pm_arena_alloc(&parser->metadata_arena, sizeof(pm_comment_t), PRISM_ALIGNOF(pm_comment_t)); + pm_comment_t *comment = PM_ARENA_ALLOC(&parser->metadata_arena, pm_comment_t); *comment = (pm_comment_t) { .type = type, @@ -13042,7 +13042,7 @@ parse_write_name(pm_parser_t *parser, pm_constant_id_t *name_field) { // append an =. pm_constant_t *constant = pm_constant_pool_id_to_constant(&parser->constant_pool, *name_field); size_t length = constant->length; - uint8_t *name = (uint8_t *) pm_arena_alloc(parser->arena, length + 1, 1); + uint8_t *name = PM_ARENA_ALLOC_ARRAY(parser->arena, uint8_t, length + 1); memcpy(name, constant->start, length); name[length] = '='; @@ -21268,7 +21268,7 @@ pm_named_capture_escape_hex(pm_buffer_t *unescaped, const uint8_t *cursor, const pm_buffer_append_byte(unescaped, value); } else { - pm_buffer_append_string(unescaped, "\\x", 2); + PM_BUFFER_APPEND_LITERAL(unescaped, "\\x"); } return cursor; @@ -21299,7 +21299,7 @@ pm_named_capture_escape_unicode(pm_parser_t *parser, pm_buffer_t *unescaped, con cursor++; if (cursor >= end) { - pm_buffer_append_string(unescaped, "\\u", 2); + PM_BUFFER_APPEND_LITERAL(unescaped, "\\u"); return cursor; } @@ -21455,7 +21455,7 @@ parse_regular_expression_named_capture(pm_parser_t *parser, const pm_string_t *c start = parser->start + PM_NODE_START(call->receiver); end = parser->start + PM_NODE_END(call->receiver); - uint8_t *memory = (uint8_t *) pm_arena_alloc(parser->arena, length, 1); + uint8_t *memory = PM_ARENA_ALLOC_ARRAY(parser->arena, uint8_t, length); memcpy(memory, source, length); name = pm_parser_constant_id_owned(parser, memory, length); } @@ -21654,7 +21654,7 @@ parse_match(pm_parser_t *parser, pm_node_t *node, pm_binding_power_t binding_pow } if (!interpolated && total_length > 0) { - uint8_t *memory = (uint8_t *) pm_arena_alloc(&parser->scratch_arena, total_length, PRISM_ALIGNOF(uint8_t)); + uint8_t *memory = PM_ARENA_ALLOC_ARRAY(&parser->scratch_arena, uint8_t, total_length); uint8_t *cursor = memory; PM_NODE_LIST_FOREACH(parts, index, part) { pm_string_t *unescaped = &((pm_string_node_t *) part)->unescaped; @@ -23112,7 +23112,7 @@ pm_parser_init(pm_arena_t *arena, pm_parser_t *parser, const uint8_t *source, si const uint8_t *source = pm_string_source(local); size_t length = pm_string_length(local); - uint8_t *allocated = (uint8_t *) pm_arena_alloc(&parser->metadata_arena, length, 1); + uint8_t *allocated = PM_ARENA_ALLOC_ARRAY(&parser->metadata_arena, uint8_t, length); memcpy(allocated, source, length); pm_parser_local_add_owned(parser, allocated, length); } @@ -23487,7 +23487,7 @@ pm_parse_stream(pm_parser_t **parser, pm_arena_t *arena, pm_source_t *source, co static PRISM_INLINE void pm_serialize_header(pm_buffer_t *buffer) { - pm_buffer_append_string(buffer, "PRISM", 5); + PM_BUFFER_APPEND_LITERAL(buffer, "PRISM"); pm_buffer_append_byte(buffer, PRISM_VERSION_MAJOR); pm_buffer_append_byte(buffer, PRISM_VERSION_MINOR); pm_buffer_append_byte(buffer, PRISM_VERSION_PATCH); diff --git a/src/regexp.c b/src/regexp.c index ed8b0af5d3..5a454ebefa 100644 --- a/src/regexp.c +++ b/src/regexp.c @@ -1424,7 +1424,7 @@ pm_regexp_format_for_error(pm_buffer_t *buffer, const pm_encoding_t *encoding, c size_t width = encoding->char_width(source + index, (ptrdiff_t) (length - index)); if (width > 1) { - pm_buffer_append_string(buffer, "\\x{", 3); + PM_BUFFER_APPEND_LITERAL(buffer, "\\x{"); for (size_t i = 0; i < width; i++) { pm_buffer_append_format(buffer, "%02X", source[index + i]); } diff --git a/src/static_literals.c b/src/static_literals.c index 5579c3eea0..2555b4576f 100644 --- a/src/static_literals.c +++ b/src/static_literals.c @@ -457,7 +457,7 @@ void pm_static_literal_inspect(pm_buffer_t *buffer, const pm_parser_t *parser, const pm_node_t *node) { switch (PM_NODE_TYPE(node)) { case PM_FALSE_NODE: - pm_buffer_append_string(buffer, "false", 5); + PM_BUFFER_APPEND_LITERAL(buffer, "false"); break; case PM_FLOAT_NODE: { const double value = ((const pm_float_node_t *) node)->value; @@ -466,12 +466,12 @@ pm_static_literal_inspect(pm_buffer_t *buffer, const pm_parser_t *parser, const if (parser->start[node->location.start] == '-') { pm_buffer_append_byte(buffer, '-'); } - pm_buffer_append_string(buffer, "Infinity", 8); + PM_BUFFER_APPEND_LITERAL(buffer, "Infinity"); } else if (value == 0.0) { if (parser->start[node->location.start] == '-') { pm_buffer_append_byte(buffer, '-'); } - pm_buffer_append_string(buffer, "0.0", 3); + PM_BUFFER_APPEND_LITERAL(buffer, "0.0"); } else { pm_buffer_append_format(buffer, "%g", value); @@ -489,20 +489,20 @@ pm_static_literal_inspect(pm_buffer_t *buffer, const pm_parser_t *parser, const } case PM_IMAGINARY_NODE: { const pm_node_t *numeric = ((const pm_imaginary_node_t *) node)->numeric; - pm_buffer_append_string(buffer, "(0", 2); + PM_BUFFER_APPEND_LITERAL(buffer, "(0"); if (pm_static_literal_positive_p(numeric)) pm_buffer_append_byte(buffer, '+'); pm_static_literal_inspect(buffer, parser, numeric); if (PM_NODE_TYPE_P(numeric, PM_RATIONAL_NODE)) { pm_buffer_append_byte(buffer, '*'); } - pm_buffer_append_string(buffer, "i)", 2); + PM_BUFFER_APPEND_LITERAL(buffer, "i)"); break; } case PM_INTEGER_NODE: pm_integer_string(buffer, &((const pm_integer_node_t *) node)->value); break; case PM_NIL_NODE: - pm_buffer_append_string(buffer, "nil", 3); + PM_BUFFER_APPEND_LITERAL(buffer, "nil"); break; case PM_RATIONAL_NODE: { const pm_rational_node_t *rational = (const pm_rational_node_t *) node; @@ -519,10 +519,10 @@ pm_static_literal_inspect(pm_buffer_t *buffer, const pm_parser_t *parser, const pm_buffer_append_source(buffer, pm_string_source(unescaped), pm_string_length(unescaped), PM_BUFFER_ESCAPING_RUBY); pm_buffer_append_byte(buffer, '/'); - if (PM_NODE_FLAG_P(node, PM_REGULAR_EXPRESSION_FLAGS_MULTI_LINE)) pm_buffer_append_string(buffer, "m", 1); - if (PM_NODE_FLAG_P(node, PM_REGULAR_EXPRESSION_FLAGS_IGNORE_CASE)) pm_buffer_append_string(buffer, "i", 1); - if (PM_NODE_FLAG_P(node, PM_REGULAR_EXPRESSION_FLAGS_EXTENDED)) pm_buffer_append_string(buffer, "x", 1); - if (PM_NODE_FLAG_P(node, PM_REGULAR_EXPRESSION_FLAGS_ASCII_8BIT)) pm_buffer_append_string(buffer, "n", 1); + if (PM_NODE_FLAG_P(node, PM_REGULAR_EXPRESSION_FLAGS_MULTI_LINE)) pm_buffer_append_byte(buffer, 'm'); + if (PM_NODE_FLAG_P(node, PM_REGULAR_EXPRESSION_FLAGS_IGNORE_CASE)) pm_buffer_append_byte(buffer, 'i'); + if (PM_NODE_FLAG_P(node, PM_REGULAR_EXPRESSION_FLAGS_EXTENDED)) pm_buffer_append_byte(buffer, 'x'); + if (PM_NODE_FLAG_P(node, PM_REGULAR_EXPRESSION_FLAGS_ASCII_8BIT)) pm_buffer_append_byte(buffer, 'n'); break; } @@ -553,7 +553,7 @@ pm_static_literal_inspect(pm_buffer_t *buffer, const pm_parser_t *parser, const break; } case PM_TRUE_NODE: - pm_buffer_append_string(buffer, "true", 4); + PM_BUFFER_APPEND_LITERAL(buffer, "true"); break; default: assert(false && "unreachable"); diff --git a/templates/ext/prism/api_node.c.erb b/templates/ext/prism/api_node.c.erb index a9d24d882d..0ef8ab5179 100644 --- a/templates/ext/prism/api_node.c.erb +++ b/templates/ext/prism/api_node.c.erb @@ -98,7 +98,7 @@ typedef struct pm_node_stack_node { static void pm_node_stack_push(pm_arena_t *arena, pm_node_stack_node_t **stack, const pm_node_t *visit) { - pm_node_stack_node_t *node = (pm_node_stack_node_t *) pm_arena_alloc(arena, sizeof(pm_node_stack_node_t), PRISM_ALIGNOF(pm_node_stack_node_t)); + pm_node_stack_node_t *node = PM_ARENA_ALLOC(arena, pm_node_stack_node_t); node->prev = *stack; node->visit = visit; node->visited = false; diff --git a/templates/src/diagnostic.c.erb b/templates/src/diagnostic.c.erb index dee2b39995..41a8901a9d 100644 --- a/templates/src/diagnostic.c.erb +++ b/templates/src/diagnostic.c.erb @@ -520,7 +520,7 @@ pm_diagnostic_next(const pm_diagnostic_t *diagnostic) { */ void pm_diagnostic_list_append(pm_arena_t *arena, pm_list_t *list, uint32_t start, uint32_t length, pm_diagnostic_id_t diag_id) { - pm_diagnostic_t *diagnostic = (pm_diagnostic_t *) pm_arena_zalloc(arena, sizeof(pm_diagnostic_t), PRISM_ALIGNOF(pm_diagnostic_t)); + pm_diagnostic_t *diagnostic = PM_ARENA_ZALLOC(arena, pm_diagnostic_t); *diagnostic = (pm_diagnostic_t) { .location = { .start = start, .length = length }, @@ -554,10 +554,10 @@ pm_diagnostic_list_append_format(pm_arena_t *arena, pm_list_t *list, uint32_t st return; } - pm_diagnostic_t *diagnostic = (pm_diagnostic_t *) pm_arena_zalloc(arena, sizeof(pm_diagnostic_t), PRISM_ALIGNOF(pm_diagnostic_t)); + pm_diagnostic_t *diagnostic = PM_ARENA_ZALLOC(arena, pm_diagnostic_t); size_t message_length = (size_t) (result + 1); - char *message = (char *) pm_arena_alloc(arena, message_length, 1); + char *message = PM_ARENA_ALLOC_ARRAY(arena, char, message_length); if (message_length <= sizeof(stack)) { memcpy(message, stack, message_length); diff --git a/templates/src/json.c.erb b/templates/src/json.c.erb index 5c4ab8d92a..6965d0b162 100644 --- a/templates/src/json.c.erb +++ b/templates/src/json.c.erb @@ -33,18 +33,18 @@ pm_dump_json(pm_buffer_t *buffer, const pm_parser_t *parser, const pm_node_t *no switch (PM_NODE_TYPE(node)) { <%- nodes.each do |node| -%> case <%= node.type %>: { - pm_buffer_append_string(buffer, "{\"type\":\"<%= node.name %>\",\"location\":", <%= node.name.bytesize + 22 %>); + PM_BUFFER_APPEND_LITERAL(buffer, "{\"type\":\"<%= node.name %>\",\"location\":"); const pm_<%= node.human %>_t *cast = (const pm_<%= node.human %>_t *) node; pm_dump_json_location(buffer, &cast->base.location); <%- [*node.flags, *node.fields].each_with_index do |field, index| -%> // Dump the <%= field.name %> field - pm_buffer_append_byte(buffer, ','); + PM_BUFFER_APPEND_LITERAL(buffer, ","); <%- if field.is_a?(Prism::Template::Flags) -%> - pm_buffer_append_string(buffer, "\"flags\":", 8); + PM_BUFFER_APPEND_LITERAL(buffer, "\"flags\":"); <%- else -%> - pm_buffer_append_string(buffer, "\"<%= field.name %>\":", <%= field.name.bytesize + 3 %>); + PM_BUFFER_APPEND_LITERAL(buffer, "\"<%= field.name %>\":"); <%- end -%> <%- case field -%> <%- when Prism::Template::NodeField -%> @@ -53,7 +53,7 @@ pm_dump_json(pm_buffer_t *buffer, const pm_parser_t *parser, const pm_node_t *no if (cast-><%= field.name %> != NULL) { pm_dump_json(buffer, parser, (const pm_node_t *) cast-><%= field.name %>); } else { - pm_buffer_append_string(buffer, "null", 4); + PM_BUFFER_APPEND_LITERAL(buffer, "null"); } <%- when Prism::Template::NodeListField -%> const pm_node_list_t *<%= field.name %> = &cast-><%= field.name %>; @@ -75,7 +75,7 @@ pm_dump_json(pm_buffer_t *buffer, const pm_parser_t *parser, const pm_node_t *no if (cast-><%= field.name %> != PM_CONSTANT_ID_UNSET) { pm_dump_json_constant(buffer, parser, cast-><%= field.name %>); } else { - pm_buffer_append_string(buffer, "null", 4); + PM_BUFFER_APPEND_LITERAL(buffer, "null"); } <%- when Prism::Template::ConstantListField -%> const pm_constant_id_list_t *<%= field.name %> = &cast-><%= field.name %>; @@ -92,7 +92,7 @@ pm_dump_json(pm_buffer_t *buffer, const pm_parser_t *parser, const pm_node_t *no if (cast-><%= field.name %>.length != 0) { pm_dump_json_location(buffer, &cast-><%= field.name %>); } else { - pm_buffer_append_string(buffer, "null", 4); + PM_BUFFER_APPEND_LITERAL(buffer, "null"); } <%- when Prism::Template::UInt8Field -%> pm_buffer_append_format(buffer, "%" PRIu8, cast-><%= field.name %>); @@ -104,7 +104,7 @@ pm_dump_json(pm_buffer_t *buffer, const pm_parser_t *parser, const pm_node_t *no <%- node.flags.values.each_with_index do |value, index| -%> if (PM_NODE_FLAG_P(cast, PM_<%= node.flags.human.upcase %>_<%= value.name %>)) { if (flags != 0) pm_buffer_append_byte(buffer, ','); - pm_buffer_append_string(buffer, "\"<%= value.name %>\"", <%= value.name.bytesize + 2 %>); + PM_BUFFER_APPEND_LITERAL(buffer, "\"<%= value.name %>\""); flags++; } <%- end -%> diff --git a/templates/src/node.c.erb b/templates/src/node.c.erb index 779be9f236..0f7524b4a4 100644 --- a/templates/src/node.c.erb +++ b/templates/src/node.c.erb @@ -31,7 +31,7 @@ pm_scratch_node_list_grow(pm_arena_t *arena, pm_scratch_node_list_t *list, uint3 } // Allocate a new array from the arena (old array is abandoned). - pm_node_t **nodes = (pm_node_t **) pm_arena_alloc(arena, sizeof(pm_node_t *) * next_capacity, PRISM_ALIGNOF(pm_node_t *)); + pm_node_t **nodes = PM_ARENA_ALLOC_ARRAY(arena, pm_node_t *, next_capacity); // Copy old data into the new array. if (list->size > 0) { @@ -135,7 +135,7 @@ void pm_node_list_finalize(pm_node_chunks_t *chunks, pm_arena_t *arena, pm_node_list_t *list) { if (list->size == 0) return; - pm_node_t **nodes = (pm_node_t **) pm_arena_alloc(arena, sizeof(pm_node_t *) * list->size, PRISM_ALIGNOF(pm_node_t *)); + pm_node_t **nodes = PM_ARENA_ALLOC_ARRAY(arena, pm_node_t *, list->size); pm_node_chunk_t *last = PM_NODE_CHUNK_OF(list->nodes - 1); pm_node_chunk_t *chunk = last; @@ -162,7 +162,7 @@ pm_node_list_finalize(pm_node_chunks_t *chunks, pm_arena_t *arena, pm_node_list_ */ pm_node_list_t pm_node_list_single(pm_arena_t *arena, pm_node_t *node) { - pm_node_t **nodes = (pm_node_t **) pm_arena_alloc(arena, sizeof(pm_node_t *), PRISM_ALIGNOF(pm_node_t *)); + pm_node_t **nodes = PM_ARENA_ALLOC_ARRAY(arena, pm_node_t *, 1); nodes[0] = node; return (pm_node_list_t) { .size = 1, .nodes = nodes }; } @@ -173,7 +173,7 @@ pm_node_list_single(pm_arena_t *arena, pm_node_t *node) { */ void pm_node_list_prepend_finalized(pm_arena_t *arena, pm_node_list_t *list, pm_node_t *node) { - pm_node_t **nodes = (pm_node_t **) pm_arena_alloc(arena, sizeof(pm_node_t *) * (list->size + 1), PRISM_ALIGNOF(pm_node_t *)); + pm_node_t **nodes = PM_ARENA_ALLOC_ARRAY(arena, pm_node_t *, list->size + 1); nodes[0] = node; if (list->size > 0) { @@ -263,7 +263,7 @@ pm_visit_child_nodes(const pm_node_t *node, pm_visit_callback_t visitor, void *d */ pm_<%= node.human %>_t * pm_<%= node.human %>_new(pm_arena_t *arena, uint32_t node_id, pm_node_flags_t flags, pm_location_t location<%= params.empty? ? "" : ", #{params.join(", ")}" %>) { - pm_<%= node.human %>_t *node = (pm_<%= node.human %>_t *) pm_arena_alloc(arena, sizeof(pm_<%= node.human %>_t), PRISM_ALIGNOF(pm_<%= node.human %>_t)); + pm_<%= node.human %>_t *node = PM_ARENA_ALLOC(arena, pm_<%= node.human %>_t); *node = (pm_<%= node.human %>_t) { .base = { .type = <%= node.type %>, .flags = flags, .node_id = node_id, .location = location }<%= node.fields.empty? ? "" : "," %> diff --git a/templates/src/prettyprint.c.erb b/templates/src/prettyprint.c.erb index f12531d934..bc9780e4dd 100644 --- a/templates/src/prettyprint.c.erb +++ b/templates/src/prettyprint.c.erb @@ -45,50 +45,50 @@ prettyprint_node(pm_buffer_t *output_buffer, const pm_parser_t *parser, const pm <%- if !node.flags.nil? || node.fields.any? -%> pm_<%= node.human %>_t *cast = (pm_<%= node.human %>_t *) node; <%- end -%> - pm_buffer_append_string(output_buffer, "@ <%= node.name %> (location: ", <%= node.name.length + 14 %>); + PM_BUFFER_APPEND_LITERAL(output_buffer, "@ <%= node.name %> (location: "); prettyprint_location(output_buffer, parser, &node->location); - pm_buffer_append_string(output_buffer, ")\n", 2); + PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n"); <%- (fields = [*node.flags, *node.fields]).each_with_index do |field, index| -%> <%- preadd = index == fields.length - 1 ? " " : "| " -%> // <%= field.name %> { pm_buffer_concat(output_buffer, prefix_buffer); - pm_buffer_append_string(output_buffer, "+-- <%= field.name %>:", <%= 4 + field.name.length + 1 %>); + PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- <%= field.name %>:"); <%- case field -%> <%- when Prism::Template::NodeField -%> - pm_buffer_append_byte(output_buffer, '\n'); + PM_BUFFER_APPEND_LITERAL(output_buffer, "\n"); size_t prefix_length = prefix_buffer->length; - pm_buffer_append_string(prefix_buffer, "<%= preadd %>", 4); + PM_BUFFER_APPEND_LITERAL(prefix_buffer, "<%= preadd %>"); pm_buffer_concat(output_buffer, prefix_buffer); prettyprint_node(output_buffer, parser, (pm_node_t *) cast-><%= field.name %>, prefix_buffer); prefix_buffer->length = prefix_length; <%- when Prism::Template::OptionalNodeField -%> if (cast-><%= field.name %> == NULL) { - pm_buffer_append_string(output_buffer, " nil\n", 5); + PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n"); } else { - pm_buffer_append_byte(output_buffer, '\n'); + PM_BUFFER_APPEND_LITERAL(output_buffer, "\n"); size_t prefix_length = prefix_buffer->length; - pm_buffer_append_string(prefix_buffer, "<%= preadd %>", 4); + PM_BUFFER_APPEND_LITERAL(prefix_buffer, "<%= preadd %>"); pm_buffer_concat(output_buffer, prefix_buffer); prettyprint_node(output_buffer, parser, (pm_node_t *) cast-><%= field.name %>, prefix_buffer); prefix_buffer->length = prefix_length; } <%- when Prism::Template::StringField -%> - pm_buffer_append_string(output_buffer, " \"", 2); + PM_BUFFER_APPEND_LITERAL(output_buffer, " \""); pm_buffer_append_source(output_buffer, pm_string_source(&cast-><%= field.name %>), pm_string_length(&cast-><%= field.name %>), PM_BUFFER_ESCAPING_RUBY); - pm_buffer_append_string(output_buffer, "\"\n", 2); + PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n"); <%- when Prism::Template::NodeListField -%> pm_buffer_append_format(output_buffer, " (length: %lu)\n", (unsigned long) (cast-><%= field.name %>.size)); size_t last_index = cast-><%= field.name %>.size; for (uint32_t index = 0; index < last_index; index++) { size_t prefix_length = prefix_buffer->length; - pm_buffer_append_string(prefix_buffer, "<%= preadd %>", 4); + PM_BUFFER_APPEND_LITERAL(prefix_buffer, "<%= preadd %>"); pm_buffer_concat(output_buffer, prefix_buffer); - pm_buffer_append_string(output_buffer, "+-- ", 4); + PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- "); pm_buffer_append_string(prefix_buffer, (index == last_index - 1) ? " " : "| ", 4); prettyprint_node(output_buffer, parser, (pm_node_t *) cast-><%= field.name %>.nodes[index], prefix_buffer); prefix_buffer->length = prefix_length; @@ -99,36 +99,36 @@ prettyprint_node(pm_buffer_t *output_buffer, const pm_parser_t *parser, const pm pm_buffer_append_byte(output_buffer, '\n'); <%- when Prism::Template::OptionalConstantField -%> if (cast-><%= field.name %> == 0) { - pm_buffer_append_string(output_buffer, " nil\n", 5); + PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n"); } else { pm_buffer_append_byte(output_buffer, ' '); prettyprint_constant(output_buffer, parser, cast-><%= field.name %>); pm_buffer_append_byte(output_buffer, '\n'); } <%- when Prism::Template::ConstantListField -%> - pm_buffer_append_string(output_buffer, " [", 2); + PM_BUFFER_APPEND_LITERAL(output_buffer, " ["); for (uint32_t index = 0; index < cast-><%= field.name %>.size; index++) { - if (index != 0) pm_buffer_append_string(output_buffer, ", ", 2); + if (index != 0) PM_BUFFER_APPEND_LITERAL(output_buffer, ", "); prettyprint_constant(output_buffer, parser, cast-><%= field.name %>.ids[index]); } - pm_buffer_append_string(output_buffer, "]\n", 2); + PM_BUFFER_APPEND_LITERAL(output_buffer, "]\n"); <%- when Prism::Template::LocationField -%> pm_location_t *location = &cast-><%= field.name %>; pm_buffer_append_byte(output_buffer, ' '); prettyprint_location(output_buffer, parser, location); - pm_buffer_append_string(output_buffer, " = \"", 4); + PM_BUFFER_APPEND_LITERAL(output_buffer, " = \""); pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY); - pm_buffer_append_string(output_buffer, "\"\n", 2); + PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n"); <%- when Prism::Template::OptionalLocationField -%> pm_location_t *location = &cast-><%= field.name %>; if (location->length == 0) { - pm_buffer_append_string(output_buffer, " nil\n", 5); + PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n"); } else { pm_buffer_append_byte(output_buffer, ' '); prettyprint_location(output_buffer, parser, location); - pm_buffer_append_string(output_buffer, " = \"", 4); + PM_BUFFER_APPEND_LITERAL(output_buffer, " = \""); pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY); - pm_buffer_append_string(output_buffer, "\"\n", 2); + PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n"); } <%- when Prism::Template::UInt8Field -%> pm_buffer_append_format(output_buffer, " %" PRIu8 "\n", cast-><%= field.name %>); @@ -139,11 +139,11 @@ prettyprint_node(pm_buffer_t *output_buffer, const pm_parser_t *parser, const pm <%- field.values.each do |value| -%> if (cast->base.flags & PM_<%= field.human.upcase %>_<%= value.name %>) { if (found) pm_buffer_append_byte(output_buffer, ','); - pm_buffer_append_string(output_buffer, " <%= value.name.downcase %>", <%= value.name.bytesize + 1 %>); + PM_BUFFER_APPEND_LITERAL(output_buffer, " <%= value.name.downcase %>"); found = true; } <%- end -%> - if (!found) pm_buffer_append_string(output_buffer, " nil", 4); + if (!found) PM_BUFFER_APPEND_LITERAL(output_buffer, " nil"); pm_buffer_append_byte(output_buffer, '\n'); <%- when Prism::Template::IntegerField -%> const pm_integer_t *integer = &cast-><%= field.name %>;