[ruby/prism] Make alloc interface replaceable
- Add `x` prefix to malloc, calloc, realloc, and free (eg: malloc -> xmalloc) - By default, they are replaced with stdlib's functions at build - You can use custom functions by defining `PRISM_CUSTOM_ALLOCATOR` macro https://github.com/ruby/prism/commit/7a878af619
This commit is contained in:
HASUMI Hitoshi
git
parent
61ea202f8b
commit
c4bd6da298
@ -125,4 +125,27 @@
|
||||
# define isinf(x) (sizeof(x) == sizeof(float) ? !_finitef(x) : !_finite(x))
|
||||
#endif
|
||||
|
||||
/**
|
||||
* If you build prism with a custom allocator, configure it with "-D PRISM_CUSTOM_ALLOCATOR"
|
||||
* to use your own allocator that defines xmalloc, xrealloc, xcalloc, and xfree.
|
||||
* For example, your `custom_allocator.h` file could look like this:
|
||||
* ```
|
||||
* #ifndef PRISM_CUSTOM_ALLOCATOR_H
|
||||
* #define PRISM_CUSTOM_ALLOCATOR_H
|
||||
* #define xmalloc my_malloc
|
||||
* #define xrealloc my_realloc
|
||||
* #define xcalloc my_calloc
|
||||
* #define xfree my_free
|
||||
* #endif
|
||||
* ```
|
||||
*/
|
||||
#ifdef PRISM_CUSTOM_ALLOCATOR
|
||||
# include "custom_allocator.h"
|
||||
#else
|
||||
# define xmalloc malloc
|
||||
# define xrealloc realloc
|
||||
# define xcalloc calloc
|
||||
# define xfree free
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
||||
@ -336,7 +336,7 @@ pm_diagnostic_level(pm_diagnostic_id_t diag_id) {
|
||||
*/
|
||||
bool
|
||||
pm_diagnostic_list_append(pm_list_t *list, const uint8_t *start, const uint8_t *end, pm_diagnostic_id_t diag_id) {
|
||||
pm_diagnostic_t *diagnostic = (pm_diagnostic_t *) calloc(sizeof(pm_diagnostic_t), 1);
|
||||
pm_diagnostic_t *diagnostic = (pm_diagnostic_t *) xcalloc(sizeof(pm_diagnostic_t), 1);
|
||||
if (diagnostic == NULL) return false;
|
||||
|
||||
*diagnostic = (pm_diagnostic_t) {
|
||||
@ -367,15 +367,15 @@ pm_diagnostic_list_append_format(pm_list_t *list, const uint8_t *start, const ui
|
||||
return false;
|
||||
}
|
||||
|
||||
pm_diagnostic_t *diagnostic = (pm_diagnostic_t *) calloc(sizeof(pm_diagnostic_t), 1);
|
||||
pm_diagnostic_t *diagnostic = (pm_diagnostic_t *) xcalloc(sizeof(pm_diagnostic_t), 1);
|
||||
if (diagnostic == NULL) {
|
||||
return false;
|
||||
}
|
||||
|
||||
size_t length = (size_t) (result + 1);
|
||||
char *message = (char *) malloc(length);
|
||||
char *message = (char *) xmalloc(length);
|
||||
if (message == NULL) {
|
||||
free(diagnostic);
|
||||
xfree(diagnostic);
|
||||
return false;
|
||||
}
|
||||
|
||||
@ -404,8 +404,8 @@ pm_diagnostic_list_free(pm_list_t *list) {
|
||||
while (node != NULL) {
|
||||
pm_diagnostic_t *next = (pm_diagnostic_t *) node->node.next;
|
||||
|
||||
if (node->owned) free((void *) node->message);
|
||||
free(node);
|
||||
if (node->owned) xfree((void *) node->message);
|
||||
xfree(node);
|
||||
|
||||
node = next;
|
||||
}
|
||||
|
||||
@ -310,7 +310,7 @@ dump(int argc, VALUE *argv, VALUE self) {
|
||||
|
||||
#ifdef PRISM_DEBUG_MODE_BUILD
|
||||
size_t length = pm_string_length(&input);
|
||||
char* dup = malloc(length);
|
||||
char* dup = xmalloc(length);
|
||||
memcpy(dup, pm_string_source(&input), length);
|
||||
pm_string_constant_init(&input, dup, length);
|
||||
#endif
|
||||
@ -318,7 +318,7 @@ dump(int argc, VALUE *argv, VALUE self) {
|
||||
VALUE value = dump_input(&input, &options);
|
||||
|
||||
#ifdef PRISM_DEBUG_MODE_BUILD
|
||||
free(dup);
|
||||
xfree(dup);
|
||||
#endif
|
||||
|
||||
pm_string_free(&input);
|
||||
@ -733,7 +733,7 @@ parse(int argc, VALUE *argv, VALUE self) {
|
||||
|
||||
#ifdef PRISM_DEBUG_MODE_BUILD
|
||||
size_t length = pm_string_length(&input);
|
||||
char* dup = malloc(length);
|
||||
char* dup = xmalloc(length);
|
||||
memcpy(dup, pm_string_source(&input), length);
|
||||
pm_string_constant_init(&input, dup, length);
|
||||
#endif
|
||||
@ -741,7 +741,7 @@ parse(int argc, VALUE *argv, VALUE self) {
|
||||
VALUE value = parse_input(&input, &options);
|
||||
|
||||
#ifdef PRISM_DEBUG_MODE_BUILD
|
||||
free(dup);
|
||||
xfree(dup);
|
||||
#endif
|
||||
|
||||
pm_string_free(&input);
|
||||
|
||||
@ -86,7 +86,7 @@ pm_options_version_set(pm_options_t *options, const char *version, size_t length
|
||||
PRISM_EXPORTED_FUNCTION bool
|
||||
pm_options_scopes_init(pm_options_t *options, size_t scopes_count) {
|
||||
options->scopes_count = scopes_count;
|
||||
options->scopes = calloc(scopes_count, sizeof(pm_options_scope_t));
|
||||
options->scopes = xcalloc(scopes_count, sizeof(pm_options_scope_t));
|
||||
return options->scopes != NULL;
|
||||
}
|
||||
|
||||
@ -105,7 +105,7 @@ pm_options_scope_get(const pm_options_t *options, size_t index) {
|
||||
PRISM_EXPORTED_FUNCTION bool
|
||||
pm_options_scope_init(pm_options_scope_t *scope, size_t locals_count) {
|
||||
scope->locals_count = locals_count;
|
||||
scope->locals = calloc(locals_count, sizeof(pm_string_t));
|
||||
scope->locals = xcalloc(locals_count, sizeof(pm_string_t));
|
||||
return scope->locals != NULL;
|
||||
}
|
||||
|
||||
@ -132,10 +132,10 @@ pm_options_free(pm_options_t *options) {
|
||||
pm_string_free(&scope->locals[local_index]);
|
||||
}
|
||||
|
||||
free(scope->locals);
|
||||
xfree(scope->locals);
|
||||
}
|
||||
|
||||
free(options->scopes);
|
||||
xfree(options->scopes);
|
||||
}
|
||||
|
||||
/**
|
||||
|
||||
@ -226,7 +226,7 @@ lex_mode_push(pm_parser_t *parser, pm_lex_mode_t lex_mode) {
|
||||
parser->lex_modes.index++;
|
||||
|
||||
if (parser->lex_modes.index > PM_LEX_STACK_SIZE - 1) {
|
||||
parser->lex_modes.current = (pm_lex_mode_t *) malloc(sizeof(pm_lex_mode_t));
|
||||
parser->lex_modes.current = (pm_lex_mode_t *) xmalloc(sizeof(pm_lex_mode_t));
|
||||
if (parser->lex_modes.current == NULL) return false;
|
||||
|
||||
*parser->lex_modes.current = lex_mode;
|
||||
@ -387,7 +387,7 @@ lex_mode_pop(pm_parser_t *parser) {
|
||||
} else {
|
||||
parser->lex_modes.index--;
|
||||
pm_lex_mode_t *prev = parser->lex_modes.current->prev;
|
||||
free(parser->lex_modes.current);
|
||||
xfree(parser->lex_modes.current);
|
||||
parser->lex_modes.current = prev;
|
||||
}
|
||||
}
|
||||
@ -1063,7 +1063,7 @@ parse_decimal_number(pm_parser_t *parser, const uint8_t *start, const uint8_t *e
|
||||
assert(diff > 0 && ((unsigned long) diff < SIZE_MAX));
|
||||
size_t length = (size_t) diff;
|
||||
|
||||
char *digits = calloc(length + 1, sizeof(char));
|
||||
char *digits = xcalloc(length + 1, sizeof(char));
|
||||
memcpy(digits, start, length);
|
||||
digits[length] = '\0';
|
||||
|
||||
@ -1076,7 +1076,7 @@ parse_decimal_number(pm_parser_t *parser, const uint8_t *start, const uint8_t *e
|
||||
value = UINT32_MAX;
|
||||
}
|
||||
|
||||
free(digits);
|
||||
xfree(digits);
|
||||
|
||||
if (value > UINT32_MAX) {
|
||||
pm_parser_err(parser, start, end, PM_ERR_INVALID_NUMBER_DECIMAL);
|
||||
@ -1138,7 +1138,7 @@ pm_statements_node_body_length(pm_statements_node_t *node);
|
||||
*/
|
||||
static inline void *
|
||||
pm_alloc_node(PRISM_ATTRIBUTE_UNUSED pm_parser_t *parser, size_t size) {
|
||||
void *memory = calloc(1, size);
|
||||
void *memory = xcalloc(1, size);
|
||||
if (memory == NULL) {
|
||||
fprintf(stderr, "Failed to allocate %d bytes\n", (int) size);
|
||||
abort();
|
||||
@ -2120,7 +2120,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;
|
||||
|
||||
void *memory = malloc(length);
|
||||
void *memory = xmalloc(length);
|
||||
memcpy(memory, write_constant->start, length);
|
||||
|
||||
*read_name = pm_constant_pool_insert_owned(&parser->constant_pool, (uint8_t *) memory, length);
|
||||
@ -2162,7 +2162,7 @@ pm_call_and_write_node_create(pm_parser_t *parser, pm_call_node_t *target, const
|
||||
// Here we're going to free the target, since it is no longer necessary.
|
||||
// However, we don't want to call `pm_node_destroy` because we want to keep
|
||||
// around all of its children since we just reused them.
|
||||
free(target);
|
||||
xfree(target);
|
||||
|
||||
return node;
|
||||
}
|
||||
@ -2197,7 +2197,7 @@ pm_index_and_write_node_create(pm_parser_t *parser, pm_call_node_t *target, cons
|
||||
// Here we're going to free the target, since it is no longer necessary.
|
||||
// However, we don't want to call `pm_node_destroy` because we want to keep
|
||||
// around all of its children since we just reused them.
|
||||
free(target);
|
||||
xfree(target);
|
||||
|
||||
return node;
|
||||
}
|
||||
@ -2234,7 +2234,7 @@ pm_call_operator_write_node_create(pm_parser_t *parser, pm_call_node_t *target,
|
||||
// Here we're going to free the target, since it is no longer necessary.
|
||||
// However, we don't want to call `pm_node_destroy` because we want to keep
|
||||
// around all of its children since we just reused them.
|
||||
free(target);
|
||||
xfree(target);
|
||||
|
||||
return node;
|
||||
}
|
||||
@ -2269,7 +2269,7 @@ pm_index_operator_write_node_create(pm_parser_t *parser, pm_call_node_t *target,
|
||||
// Here we're going to free the target, since it is no longer necessary.
|
||||
// However, we don't want to call `pm_node_destroy` because we want to keep
|
||||
// around all of its children since we just reused them.
|
||||
free(target);
|
||||
xfree(target);
|
||||
|
||||
return node;
|
||||
}
|
||||
@ -2306,7 +2306,7 @@ pm_call_or_write_node_create(pm_parser_t *parser, pm_call_node_t *target, const
|
||||
// Here we're going to free the target, since it is no longer necessary.
|
||||
// However, we don't want to call `pm_node_destroy` because we want to keep
|
||||
// around all of its children since we just reused them.
|
||||
free(target);
|
||||
xfree(target);
|
||||
|
||||
return node;
|
||||
}
|
||||
@ -2341,7 +2341,7 @@ pm_index_or_write_node_create(pm_parser_t *parser, pm_call_node_t *target, const
|
||||
// Here we're going to free the target, since it is no longer necessary.
|
||||
// However, we don't want to call `pm_node_destroy` because we want to keep
|
||||
// around all of its children since we just reused them.
|
||||
free(target);
|
||||
xfree(target);
|
||||
|
||||
return node;
|
||||
}
|
||||
@ -2369,7 +2369,7 @@ pm_call_target_node_create(pm_parser_t *parser, pm_call_node_t *target) {
|
||||
// Here we're going to free the target, since it is no longer necessary.
|
||||
// However, we don't want to call `pm_node_destroy` because we want to keep
|
||||
// around all of its children since we just reused them.
|
||||
free(target);
|
||||
xfree(target);
|
||||
|
||||
return node;
|
||||
}
|
||||
@ -2399,7 +2399,7 @@ pm_index_target_node_create(pm_parser_t *parser, pm_call_node_t *target) {
|
||||
// Here we're going to free the target, since it is no longer necessary.
|
||||
// However, we don't want to call `pm_node_destroy` because we want to keep
|
||||
// around all of its children since we just reused them.
|
||||
free(target);
|
||||
xfree(target);
|
||||
|
||||
return node;
|
||||
}
|
||||
@ -3206,7 +3206,7 @@ pm_double_parse(pm_parser_t *parser, const pm_token_t *token) {
|
||||
|
||||
// First, get a buffer of the content.
|
||||
size_t length = (size_t) diff;
|
||||
char *buffer = malloc(sizeof(char) * (length + 1));
|
||||
char *buffer = xmalloc(sizeof(char) * (length + 1));
|
||||
memcpy((void *) buffer, token->start, length);
|
||||
|
||||
// Next, handle underscores by removing them from the buffer.
|
||||
@ -3232,7 +3232,7 @@ pm_double_parse(pm_parser_t *parser, const pm_token_t *token) {
|
||||
// is in a valid format. However it's good to be safe.
|
||||
if ((eptr != buffer + length) || (errno != 0 && errno != ERANGE)) {
|
||||
PM_PARSER_ERR_TOKEN_FORMAT_CONTENT(parser, (*token), PM_ERR_FLOAT_PARSE);
|
||||
free((void *) buffer);
|
||||
xfree((void *) buffer);
|
||||
return 0.0;
|
||||
}
|
||||
|
||||
@ -3255,7 +3255,7 @@ pm_double_parse(pm_parser_t *parser, const pm_token_t *token) {
|
||||
}
|
||||
|
||||
// Finally we can free the buffer and return the value.
|
||||
free((void *) buffer);
|
||||
xfree((void *) buffer);
|
||||
return value;
|
||||
}
|
||||
|
||||
@ -4967,7 +4967,7 @@ pm_multi_write_node_create(pm_parser_t *parser, pm_multi_target_node_t *target,
|
||||
|
||||
// Explicitly do not call pm_node_destroy here because we want to keep
|
||||
// around all of the information within the MultiWriteNode node.
|
||||
free(target);
|
||||
xfree(target);
|
||||
|
||||
return node;
|
||||
}
|
||||
@ -6080,7 +6080,7 @@ pm_string_node_to_symbol_node(pm_parser_t *parser, pm_string_node_t *node, const
|
||||
// We are explicitly _not_ using pm_node_destroy here because we don't want
|
||||
// to trash the unescaped string. We could instead copy the string if we
|
||||
// know that it is owned, but we're taking the fast path for now.
|
||||
free(node);
|
||||
xfree(node);
|
||||
|
||||
return new_node;
|
||||
}
|
||||
@ -6112,7 +6112,7 @@ pm_symbol_node_to_string_node(pm_parser_t *parser, pm_symbol_node_t *node) {
|
||||
// We are explicitly _not_ using pm_node_destroy here because we don't want
|
||||
// to trash the unescaped string. We could instead copy the string if we
|
||||
// know that it is owned, but we're taking the fast path for now.
|
||||
free(node);
|
||||
xfree(node);
|
||||
|
||||
return new_node;
|
||||
}
|
||||
@ -6502,7 +6502,7 @@ pm_yield_node_create(pm_parser_t *parser, const pm_token_t *keyword, const pm_lo
|
||||
*/
|
||||
static bool
|
||||
pm_parser_scope_push(pm_parser_t *parser, bool closed) {
|
||||
pm_scope_t *scope = (pm_scope_t *) malloc(sizeof(pm_scope_t));
|
||||
pm_scope_t *scope = (pm_scope_t *) xmalloc(sizeof(pm_scope_t));
|
||||
if (scope == NULL) return false;
|
||||
|
||||
*scope = (pm_scope_t) {
|
||||
@ -6741,7 +6741,7 @@ static void
|
||||
pm_parser_scope_pop(pm_parser_t *parser) {
|
||||
pm_scope_t *scope = parser->current_scope;
|
||||
parser->current_scope = scope->previous;
|
||||
free(scope);
|
||||
xfree(scope);
|
||||
}
|
||||
|
||||
/******************************************************************************/
|
||||
@ -7074,7 +7074,7 @@ parser_lex_magic_comment(pm_parser_t *parser, bool semantic_token_seen) {
|
||||
pm_string_shared_init(&key, key_start, key_end);
|
||||
} else {
|
||||
size_t width = (size_t) (key_end - key_start);
|
||||
uint8_t *buffer = malloc(width);
|
||||
uint8_t *buffer = xmalloc(width);
|
||||
if (buffer == NULL) break;
|
||||
|
||||
memcpy(buffer, key_start, width);
|
||||
@ -7116,7 +7116,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;
|
||||
if ((magic_comment = (pm_magic_comment_t *) calloc(sizeof(pm_magic_comment_t), 1)) != NULL) {
|
||||
if ((magic_comment = (pm_magic_comment_t *) xcalloc(sizeof(pm_magic_comment_t), 1)) != NULL) {
|
||||
magic_comment->key_start = key_start;
|
||||
magic_comment->value_start = value_start;
|
||||
magic_comment->key_length = (uint32_t) key_length;
|
||||
@ -7210,7 +7210,7 @@ context_recoverable(const pm_parser_t *parser, pm_token_t *token) {
|
||||
|
||||
static bool
|
||||
context_push(pm_parser_t *parser, pm_context_t context) {
|
||||
pm_context_node_t *context_node = (pm_context_node_t *) malloc(sizeof(pm_context_node_t));
|
||||
pm_context_node_t *context_node = (pm_context_node_t *) xmalloc(sizeof(pm_context_node_t));
|
||||
if (context_node == NULL) return false;
|
||||
|
||||
*context_node = (pm_context_node_t) { .context = context, .prev = NULL };
|
||||
@ -7228,7 +7228,7 @@ context_push(pm_parser_t *parser, pm_context_t context) {
|
||||
static void
|
||||
context_pop(pm_parser_t *parser) {
|
||||
pm_context_node_t *prev = parser->current_context->prev;
|
||||
free(parser->current_context);
|
||||
xfree(parser->current_context);
|
||||
parser->current_context = prev;
|
||||
}
|
||||
|
||||
@ -8555,7 +8555,7 @@ parser_lex_callback(pm_parser_t *parser) {
|
||||
*/
|
||||
static inline pm_comment_t *
|
||||
parser_comment(pm_parser_t *parser, pm_comment_type_t type) {
|
||||
pm_comment_t *comment = (pm_comment_t *) calloc(sizeof(pm_comment_t), 1);
|
||||
pm_comment_t *comment = (pm_comment_t *) xcalloc(sizeof(pm_comment_t), 1);
|
||||
if (comment == NULL) return NULL;
|
||||
|
||||
*comment = (pm_comment_t) {
|
||||
@ -11397,7 +11397,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 = calloc(length + 1, sizeof(uint8_t));
|
||||
uint8_t *name = xcalloc(length + 1, sizeof(uint8_t));
|
||||
if (name == NULL) return;
|
||||
|
||||
memcpy(name, constant->start, length);
|
||||
@ -14141,7 +14141,7 @@ parse_pattern_hash(pm_parser_t *parser, pm_node_t *first_node) {
|
||||
}
|
||||
|
||||
pm_hash_pattern_node_t *node = pm_hash_pattern_node_node_list_create(parser, &assocs, rest);
|
||||
free(assocs.nodes);
|
||||
xfree(assocs.nodes);
|
||||
|
||||
return node;
|
||||
}
|
||||
@ -14576,7 +14576,7 @@ parse_pattern(pm_parser_t *parser, bool top_pattern, pm_diagnostic_id_t diag_id)
|
||||
node = (pm_node_t *) pm_array_pattern_node_node_list_create(parser, &nodes);
|
||||
}
|
||||
|
||||
free(nodes.nodes);
|
||||
xfree(nodes.nodes);
|
||||
} else if (leading_rest) {
|
||||
// Otherwise, if we parsed a single splat pattern, then we know we have an
|
||||
// array pattern, so we can go ahead and create that node.
|
||||
@ -17355,7 +17355,7 @@ parse_regular_expression_named_captures(pm_parser_t *parser, const pm_string_t *
|
||||
// in which case we need to copy it out into a new string.
|
||||
location = call->receiver->location;
|
||||
|
||||
void *memory = malloc(length);
|
||||
void *memory = xmalloc(length);
|
||||
if (memory == NULL) abort();
|
||||
|
||||
memcpy(memory, source, length);
|
||||
@ -17843,7 +17843,7 @@ parse_expression_infix(pm_parser_t *parser, pm_node_t *node, pm_binding_power_t
|
||||
}
|
||||
|
||||
if (!interpolated && total_length > 0) {
|
||||
void *memory = malloc(total_length);
|
||||
void *memory = xmalloc(total_length);
|
||||
if (!memory) abort();
|
||||
|
||||
uint8_t *cursor = memory;
|
||||
@ -18519,7 +18519,7 @@ pm_parser_init(pm_parser_t *parser, const uint8_t *source, size_t size, const pm
|
||||
const uint8_t *source = pm_string_source(local);
|
||||
size_t length = pm_string_length(local);
|
||||
|
||||
void *allocated = malloc(length);
|
||||
void *allocated = xmalloc(length);
|
||||
if (allocated == NULL) continue;
|
||||
|
||||
memcpy(allocated, source, length);
|
||||
@ -18566,7 +18566,7 @@ pm_comment_list_free(pm_list_t *list) {
|
||||
next = node->next;
|
||||
|
||||
pm_comment_t *comment = (pm_comment_t *) node;
|
||||
free(comment);
|
||||
xfree(comment);
|
||||
}
|
||||
}
|
||||
|
||||
@ -18581,7 +18581,7 @@ pm_magic_comment_list_free(pm_list_t *list) {
|
||||
next = node->next;
|
||||
|
||||
pm_magic_comment_t *magic_comment = (pm_magic_comment_t *) node;
|
||||
free(magic_comment);
|
||||
xfree(magic_comment);
|
||||
}
|
||||
}
|
||||
|
||||
@ -18732,7 +18732,7 @@ typedef struct {
|
||||
|
||||
static inline pm_error_t *
|
||||
pm_parser_errors_format_sort(const pm_parser_t *parser, const pm_list_t *error_list, const pm_newline_list_t *newline_list) {
|
||||
pm_error_t *errors = calloc(error_list->size, sizeof(pm_error_t));
|
||||
pm_error_t *errors = xcalloc(error_list->size, sizeof(pm_error_t));
|
||||
if (errors == NULL) return NULL;
|
||||
|
||||
int32_t start_line = parser->start_line;
|
||||
@ -18989,7 +18989,7 @@ pm_parser_errors_format(const pm_parser_t *parser, pm_buffer_t *buffer, bool col
|
||||
}
|
||||
|
||||
// Finally, we'll free the array of errors that we allocated.
|
||||
free(errors);
|
||||
xfree(errors);
|
||||
}
|
||||
|
||||
#undef PM_COLOR_GRAY
|
||||
|
||||
@ -76,7 +76,7 @@ typedef struct pm_node_stack_node {
|
||||
|
||||
static void
|
||||
pm_node_stack_push(pm_node_stack_node_t **stack, const pm_node_t *visit) {
|
||||
pm_node_stack_node_t *node = malloc(sizeof(pm_node_stack_node_t));
|
||||
pm_node_stack_node_t *node = xmalloc(sizeof(pm_node_stack_node_t));
|
||||
node->prev = *stack;
|
||||
node->visit = visit;
|
||||
node->visited = false;
|
||||
@ -89,14 +89,14 @@ pm_node_stack_pop(pm_node_stack_node_t **stack) {
|
||||
const pm_node_t *visit = current->visit;
|
||||
|
||||
*stack = current->prev;
|
||||
free(current);
|
||||
xfree(current);
|
||||
|
||||
return visit;
|
||||
}
|
||||
|
||||
VALUE
|
||||
pm_ast_new(const pm_parser_t *parser, const pm_node_t *node, rb_encoding *encoding, VALUE source) {
|
||||
ID *constants = calloc(parser->constant_pool.size, sizeof(ID));
|
||||
ID *constants = xcalloc(parser->constant_pool.size, sizeof(ID));
|
||||
|
||||
for (uint32_t index = 0; index < parser->constant_pool.size; index++) {
|
||||
pm_constant_t *constant = &parser->constant_pool.constants[index];
|
||||
@ -235,7 +235,7 @@ pm_ast_new(const pm_parser_t *parser, const pm_node_t *node, rb_encoding *encodi
|
||||
}
|
||||
|
||||
VALUE result = rb_ary_pop(value_stack);
|
||||
free(constants);
|
||||
xfree(constants);
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
@ -26,7 +26,7 @@ bool
|
||||
pm_node_list_grow(pm_node_list_t *list) {
|
||||
if (list->size == list->capacity) {
|
||||
list->capacity = list->capacity == 0 ? 4 : list->capacity * 2;
|
||||
list->nodes = (pm_node_t **) realloc(list->nodes, sizeof(pm_node_t *) * list->capacity);
|
||||
list->nodes = (pm_node_t **) xrealloc(list->nodes, sizeof(pm_node_t *) * list->capacity);
|
||||
return list->nodes != NULL;
|
||||
}
|
||||
return true;
|
||||
@ -60,7 +60,7 @@ pm_node_list_prepend(pm_node_list_t *list, pm_node_t *node) {
|
||||
void
|
||||
pm_node_list_free(pm_node_list_t *list) {
|
||||
if (list->capacity > 0) {
|
||||
free(list->nodes);
|
||||
xfree(list->nodes);
|
||||
*list = (pm_node_list_t) { 0 };
|
||||
}
|
||||
}
|
||||
@ -123,7 +123,7 @@ pm_node_destroy(pm_parser_t *parser, pm_node_t *node) {
|
||||
assert(false && "unreachable");
|
||||
break;
|
||||
}
|
||||
free(node);
|
||||
xfree(node);
|
||||
}
|
||||
|
||||
static void
|
||||
|
||||
@ -16,7 +16,7 @@ pm_buffer_init_capacity(pm_buffer_t *buffer, size_t capacity) {
|
||||
buffer->length = 0;
|
||||
buffer->capacity = capacity;
|
||||
|
||||
buffer->value = (char *) malloc(capacity);
|
||||
buffer->value = (char *) xmalloc(capacity);
|
||||
return buffer->value != NULL;
|
||||
}
|
||||
|
||||
@ -60,7 +60,7 @@ pm_buffer_append_length(pm_buffer_t *buffer, size_t length) {
|
||||
buffer->capacity *= 2;
|
||||
}
|
||||
|
||||
buffer->value = realloc(buffer->value, buffer->capacity);
|
||||
buffer->value = xrealloc(buffer->value, buffer->capacity);
|
||||
if (buffer->value == NULL) return false;
|
||||
}
|
||||
|
||||
@ -288,5 +288,5 @@ pm_buffer_rstrip(pm_buffer_t *buffer) {
|
||||
*/
|
||||
void
|
||||
pm_buffer_free(pm_buffer_t *buffer) {
|
||||
free(buffer->value);
|
||||
xfree(buffer->value);
|
||||
}
|
||||
|
||||
@ -51,7 +51,7 @@ pm_constant_id_list_memsize(pm_constant_id_list_t *list) {
|
||||
void
|
||||
pm_constant_id_list_free(pm_constant_id_list_t *list) {
|
||||
if (list->ids != NULL) {
|
||||
free(list->ids);
|
||||
xfree(list->ids);
|
||||
}
|
||||
}
|
||||
|
||||
@ -111,7 +111,7 @@ pm_constant_pool_resize(pm_constant_pool_t *pool) {
|
||||
const uint32_t mask = next_capacity - 1;
|
||||
const size_t element_size = sizeof(pm_constant_pool_bucket_t) + sizeof(pm_constant_t);
|
||||
|
||||
void *next = calloc(next_capacity, element_size);
|
||||
void *next = xcalloc(next_capacity, element_size);
|
||||
if (next == NULL) return false;
|
||||
|
||||
pm_constant_pool_bucket_t *next_buckets = next;
|
||||
@ -145,7 +145,7 @@ pm_constant_pool_resize(pm_constant_pool_t *pool) {
|
||||
|
||||
// pool->constants and pool->buckets are allocated out of the same chunk
|
||||
// of memory, with the buckets coming first.
|
||||
free(pool->buckets);
|
||||
xfree(pool->buckets);
|
||||
pool->constants = next_constants;
|
||||
pool->buckets = next_buckets;
|
||||
pool->capacity = next_capacity;
|
||||
@ -162,7 +162,7 @@ pm_constant_pool_init(pm_constant_pool_t *pool, uint32_t capacity) {
|
||||
|
||||
capacity = next_power_of_two(capacity);
|
||||
const size_t element_size = sizeof(pm_constant_pool_bucket_t) + sizeof(pm_constant_t);
|
||||
void *memory = calloc(capacity, element_size);
|
||||
void *memory = xcalloc(capacity, element_size);
|
||||
if (memory == NULL) return false;
|
||||
|
||||
pool->buckets = memory;
|
||||
@ -237,12 +237,12 @@ pm_constant_pool_insert(pm_constant_pool_t *pool, const uint8_t *start, size_t l
|
||||
// an existing constant, then either way we don't want the given
|
||||
// memory. Either it's duplicated with the existing constant or
|
||||
// it's not necessary because we have a shared version.
|
||||
free((void *) start);
|
||||
xfree((void *) start);
|
||||
} else if (bucket->type == PM_CONSTANT_POOL_BUCKET_OWNED) {
|
||||
// If we're attempting to insert a shared constant and the
|
||||
// existing constant is owned, then we can free the owned
|
||||
// constant and replace it with the shared constant.
|
||||
free((void *) constant->start);
|
||||
xfree((void *) constant->start);
|
||||
constant->start = start;
|
||||
bucket->type = (unsigned int) (PM_CONSTANT_POOL_BUCKET_DEFAULT & 0x3);
|
||||
}
|
||||
@ -314,9 +314,9 @@ pm_constant_pool_free(pm_constant_pool_t *pool) {
|
||||
// If an id is set on this constant, then we know we have content here.
|
||||
if (bucket->id != PM_CONSTANT_ID_UNSET && bucket->type == PM_CONSTANT_POOL_BUCKET_OWNED) {
|
||||
pm_constant_t *constant = &pool->constants[bucket->id - 1];
|
||||
free((void *) constant->start);
|
||||
xfree((void *) constant->start);
|
||||
}
|
||||
}
|
||||
|
||||
free(pool->buckets);
|
||||
xfree(pool->buckets);
|
||||
}
|
||||
|
||||
@ -7,7 +7,7 @@ static pm_integer_word_t *
|
||||
pm_integer_node_create(pm_integer_t *integer, uint32_t value) {
|
||||
integer->length++;
|
||||
|
||||
pm_integer_word_t *node = malloc(sizeof(pm_integer_word_t));
|
||||
pm_integer_word_t *node = xmalloc(sizeof(pm_integer_word_t));
|
||||
if (node == NULL) return NULL;
|
||||
|
||||
*node = (pm_integer_word_t) { .next = NULL, .value = value };
|
||||
@ -94,7 +94,7 @@ pm_integer_divide_word(pm_integer_t *integer, pm_integer_word_t *word, uint32_t
|
||||
remainder = pm_integer_divide_word(integer, word->next, dividend);
|
||||
|
||||
if (integer->length > 0 && word->next->value == 0) {
|
||||
free(word->next);
|
||||
xfree(word->next);
|
||||
word->next = NULL;
|
||||
integer->length--;
|
||||
}
|
||||
@ -256,7 +256,7 @@ pm_integer_string(pm_buffer_t *buffer, const pm_integer_t *integer) {
|
||||
default: {
|
||||
// First, allocate a buffer that we'll copy the decimal digits into.
|
||||
size_t length = (integer->length + 1) * 10;
|
||||
char *digits = calloc(length, sizeof(char));
|
||||
char *digits = xcalloc(length, sizeof(char));
|
||||
if (digits == NULL) return;
|
||||
|
||||
// Next, create a new integer that we'll use to store the result of
|
||||
@ -276,7 +276,7 @@ pm_integer_string(pm_buffer_t *buffer, const pm_integer_t *integer) {
|
||||
|
||||
// Finally, append the string to the buffer and free the digits.
|
||||
pm_buffer_append_string(buffer, current + 1, (size_t) (ending - current));
|
||||
free(digits);
|
||||
xfree(digits);
|
||||
return;
|
||||
}
|
||||
}
|
||||
@ -291,7 +291,7 @@ pm_integer_word_destroy(pm_integer_word_t *integer) {
|
||||
pm_integer_word_destroy(integer->next);
|
||||
}
|
||||
|
||||
free(integer);
|
||||
xfree(integer);
|
||||
}
|
||||
|
||||
/**
|
||||
|
||||
@ -41,7 +41,7 @@ pm_list_free(pm_list_t *list) {
|
||||
|
||||
while (node != NULL) {
|
||||
next = node->next;
|
||||
free(node);
|
||||
xfree(node);
|
||||
node = next;
|
||||
}
|
||||
|
||||
|
||||
@ -33,7 +33,7 @@
|
||||
* } pm_int_node_t;
|
||||
*
|
||||
* pm_list_t list = { 0 };
|
||||
* pm_int_node_t *node = malloc(sizeof(pm_int_node_t));
|
||||
* pm_int_node_t *node = xmalloc(sizeof(pm_int_node_t));
|
||||
* node->value = 5;
|
||||
*
|
||||
* pm_list_append(&list, &node->node);
|
||||
|
||||
@ -6,7 +6,7 @@
|
||||
*/
|
||||
bool
|
||||
pm_newline_list_init(pm_newline_list_t *list, const uint8_t *start, size_t capacity) {
|
||||
list->offsets = (size_t *) calloc(capacity, sizeof(size_t));
|
||||
list->offsets = (size_t *) xcalloc(capacity, sizeof(size_t));
|
||||
if (list->offsets == NULL) return false;
|
||||
|
||||
list->start = start;
|
||||
@ -29,11 +29,11 @@ pm_newline_list_append(pm_newline_list_t *list, const uint8_t *cursor) {
|
||||
size_t *original_offsets = list->offsets;
|
||||
|
||||
list->capacity = (list->capacity * 3) / 2;
|
||||
list->offsets = (size_t *) calloc(list->capacity, sizeof(size_t));
|
||||
list->offsets = (size_t *) xcalloc(list->capacity, sizeof(size_t));
|
||||
if (list->offsets == NULL) return false;
|
||||
|
||||
memcpy(list->offsets, original_offsets, list->size * sizeof(size_t));
|
||||
free(original_offsets);
|
||||
xfree(original_offsets);
|
||||
}
|
||||
|
||||
assert(*cursor == '\n');
|
||||
@ -84,5 +84,5 @@ pm_newline_list_line_column(const pm_newline_list_t *list, const uint8_t *cursor
|
||||
*/
|
||||
void
|
||||
pm_newline_list_free(pm_newline_list_t *list) {
|
||||
free(list->offsets);
|
||||
xfree(list->offsets);
|
||||
}
|
||||
|
||||
@ -166,7 +166,7 @@ pm_string_ensure_owned(pm_string_t *string) {
|
||||
size_t length = pm_string_length(string);
|
||||
const uint8_t *source = pm_string_source(string);
|
||||
|
||||
uint8_t *memory = malloc(length);
|
||||
uint8_t *memory = xmalloc(length);
|
||||
if (!memory) return;
|
||||
|
||||
pm_string_owned_init(string, memory, length);
|
||||
@ -217,7 +217,7 @@ pm_string_free(pm_string_t *string) {
|
||||
void *memory = (void *) string->source;
|
||||
|
||||
if (string->type == PM_STRING_OWNED) {
|
||||
free(memory);
|
||||
xfree(memory);
|
||||
#ifdef PRISM_HAS_MMAP
|
||||
} else if (string->type == PM_STRING_MAPPED && string->length) {
|
||||
#if defined(_WIN32)
|
||||
|
||||
@ -12,7 +12,7 @@ pm_string_list_append(pm_string_list_t *string_list, pm_string_t *string) {
|
||||
string_list->capacity *= 2;
|
||||
}
|
||||
|
||||
string_list->strings = realloc(string_list->strings, string_list->capacity * sizeof(pm_string_t));
|
||||
string_list->strings = xrealloc(string_list->strings, string_list->capacity * sizeof(pm_string_t));
|
||||
if (string_list->strings == NULL) abort();
|
||||
}
|
||||
|
||||
@ -24,5 +24,5 @@ pm_string_list_append(pm_string_list_t *string_list, pm_string_t *string) {
|
||||
*/
|
||||
void
|
||||
pm_string_list_free(pm_string_list_t *string_list) {
|
||||
free(string_list->strings);
|
||||
xfree(string_list->strings);
|
||||
}
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user