Shorten allocation macro names

Author: amomchilov

include/rbs/util/rbs_allocator.h

@@ -26,13 +26,11 @@ void *rbs_allocator_calloc_impl(rbs_allocator_t *, size_t count, size_t size, si
 void *rbs_allocator_realloc_impl(rbs_allocator_t *, void *ptr, size_t old_size, size_t new_size, size_t alignment);
 
 // Use this when allocating memory for a single instance of a type.
-#define rbs_allocator_alloc(allocator, type) ((type *) rbs_allocator_malloc_impl((allocator), sizeof(type), alignof(type)))
-// Use this when allocating memory that will be immediately written to in full.
-// Such as allocating strings
-#define rbs_allocator_alloc_many(allocator, count, type) ((type *) rbs_allocator_malloc_many_impl((allocator), (count), sizeof(type), alignof(type)))
-// Use this when allocating memory that will NOT be immediately written to in full.
-// Such as allocating buffers
-#define rbs_allocator_calloc(allocator, count, type) ((type *) rbs_allocator_calloc_impl((allocator), (count), sizeof(type), alignof(type)))
-#define rbs_allocator_realloc(allocator, ptr, old_size, new_size, type) ((type *) rbs_allocator_realloc_impl((allocator), (ptr), (old_size), (new_size), alignof(type)))
+#define rbs_alloc(allocator, type) ((type *) rbs_allocator_malloc_impl((allocator), sizeof(type), alignof(type)))
+// Use this when allocating memory that will be immediately written to in full, such as allocating strings
+#define rbs_alloc_many(allocator, count, type) ((type *) rbs_allocator_malloc_many_impl((allocator), (count), sizeof(type), alignof(type)))
+// Use this when allocating memory that will NOT be immediately written to in full, such as allocating buffers
+#define rbs_calloc(allocator, count, type) ((type *) rbs_allocator_calloc_impl((allocator), (count), sizeof(type), alignof(type)))
+#define rbs_realloc(allocator, ptr, old_size, new_size, type) ((type *) rbs_allocator_realloc_impl((allocator), (ptr), (old_size), (new_size), alignof(type)))
 
 #endif

src/ast.c

@@ -31,7 +31,7 @@ void rbs_loc_add_required_child(rbs_location_t *loc, rbs_constant_id_t name, rbs
 }
 
 rbs_location_t *rbs_location_new(rbs_allocator_t *allocator, rbs_range_t rg) {
-    rbs_location_t *location = rbs_allocator_alloc(allocator, rbs_location_t);
+    rbs_location_t *location = rbs_alloc(allocator, rbs_location_t);
     *location = (rbs_location_t) {
         .rg = rg,
         .children = NULL,
@@ -41,7 +41,7 @@ rbs_location_t *rbs_location_new(rbs_allocator_t *allocator, rbs_range_t rg) {
 }
 
 rbs_location_list_t *rbs_location_list_new(rbs_allocator_t *allocator) {
-    rbs_location_list_t *list = rbs_allocator_alloc(allocator, rbs_location_list_t);
+    rbs_location_list_t *list = rbs_alloc(allocator, rbs_location_list_t);
     *list = (rbs_location_list_t) {
         .allocator = allocator,
         .head = NULL,
@@ -53,7 +53,7 @@ rbs_location_list_t *rbs_location_list_new(rbs_allocator_t *allocator) {
 }
 
 void rbs_location_list_append(rbs_location_list_t *list, rbs_location_t *loc) {
-    rbs_location_list_node_t *node = rbs_allocator_alloc(list->allocator, rbs_location_list_node_t);
+    rbs_location_list_node_t *node = rbs_alloc(list->allocator, rbs_location_list_node_t);
     *node = (rbs_location_list_node_t) {
         .loc = loc,
         .next = NULL,

src/location.c

@@ -807,7 +807,7 @@ static bool parse_function(rbs_parser_t *parser, bool accept_type_binding, parse
 NODISCARD
 static bool parse_proc_type(rbs_parser_t *parser, rbs_types_proc_t **proc) {
     rbs_position_t start = parser->current_token.range.start;
-    parse_function_result *result = rbs_allocator_alloc(ALLOCATOR(), parse_function_result);
+    parse_function_result *result = rbs_alloc(ALLOCATOR(), parse_function_result);
     CHECK_PARSE(parse_function(parser, true, &result));
 
     rbs_position_t end = parser->current_token.range.end;
@@ -1472,7 +1472,7 @@ bool rbs_parse_method_type(rbs_parser_t *parser, rbs_method_type_t **method_type
     rbs_range_t type_range;
     type_range.start = parser->next_token.range.start;
 
-    parse_function_result *result = rbs_allocator_alloc(ALLOCATOR(), parse_function_result);
+    parse_function_result *result = rbs_alloc(ALLOCATOR(), parse_function_result);
     CHECK_PARSE(parse_function(parser, false, &result));
 
     rg.end = parser->current_token.range.end;
@@ -3167,7 +3167,7 @@ static void comment_insert_new_line(rbs_allocator_t *allocator, rbs_comment_t *c
 }
 
 static rbs_comment_t *alloc_comment(rbs_allocator_t *allocator, rbs_token_t comment_token, rbs_comment_t *last_comment) {
-    rbs_comment_t *new_comment = rbs_allocator_alloc(allocator, rbs_comment_t);
+    rbs_comment_t *new_comment = rbs_alloc(allocator, rbs_comment_t);
 
     *new_comment = (rbs_comment_t) {
         .start = comment_token.range.start,
@@ -3251,20 +3251,20 @@ bool rbs_parse_type_params(rbs_parser_t *parser, bool module_type_params, rbs_no
 }
 
 id_table *alloc_empty_table(rbs_allocator_t *allocator) {
-    id_table *table = rbs_allocator_alloc(allocator, id_table);
+    id_table *table = rbs_alloc(allocator, id_table);
 
     *table = (id_table) {
         .size = 10,
         .count = 0,
-        .ids = rbs_allocator_calloc(allocator, 10, rbs_constant_id_t),
+        .ids = rbs_calloc(allocator, 10, rbs_constant_id_t),
         .next = NULL,
     };
 
     return table;
 }
 
 id_table *alloc_reset_table(rbs_allocator_t *allocator) {
-    id_table *table = rbs_allocator_alloc(allocator, id_table);
+    id_table *table = rbs_alloc(allocator, id_table);
 
     *table = (id_table) {
         .size = 0,
@@ -3301,7 +3301,7 @@ bool rbs_parser_insert_typevar(rbs_parser_t *parser, rbs_constant_id_t id) {
         // expand
         rbs_constant_id_t *ptr = table->ids;
         table->size += 10;
-        table->ids = rbs_allocator_calloc(ALLOCATOR(), table->size, rbs_constant_id_t);
+        table->ids = rbs_calloc(ALLOCATOR(), table->size, rbs_constant_id_t);
         memcpy(table->ids, ptr, sizeof(rbs_constant_id_t) * table->count);
     }
 
@@ -3363,7 +3363,7 @@ rbs_ast_comment_t *rbs_parser_get_comment(rbs_parser_t *parser, int subject_line
 }
 
 rbs_lexer_t *rbs_lexer_new(rbs_allocator_t *allocator, rbs_string_t string, const rbs_encoding_t *encoding, int start_pos, int end_pos) {
-    rbs_lexer_t *lexer = rbs_allocator_alloc(allocator, rbs_lexer_t);
+    rbs_lexer_t *lexer = rbs_alloc(allocator, rbs_lexer_t);
 
     rbs_position_t start_position = (rbs_position_t) {
         .byte_pos = 0,
@@ -3394,7 +3394,7 @@ rbs_parser_t *rbs_parser_new(rbs_string_t string, const rbs_encoding_t *encoding
     rbs_allocator_t *allocator = rbs_allocator_init();
 
     rbs_lexer_t *lexer = rbs_lexer_new(allocator, string, encoding, start_pos, end_pos);
-    rbs_parser_t *parser = rbs_allocator_alloc(allocator, rbs_parser_t);
+    rbs_parser_t *parser = rbs_alloc(allocator, rbs_parser_t);
 
     *parser = (rbs_parser_t) {
         .rbs_lexer_t = lexer,
@@ -3455,13 +3455,13 @@ void rbs_parser_set_error(rbs_parser_t *parser, rbs_token_t tok, bool syntax_err
     int length = vsnprintf(NULL, 0, fmt, args);
     va_end(args);
 
-    char *message = rbs_allocator_alloc_many(ALLOCATOR(), length + 1, char);
+    char *message = rbs_alloc_many(ALLOCATOR(), length + 1, char);
 
     va_start(args, fmt);
     vsnprintf(message, length + 1, fmt, args);
     va_end(args);
 
-    parser->error = rbs_allocator_alloc(ALLOCATOR(), rbs_error_t);
+    parser->error = rbs_alloc(ALLOCATOR(), rbs_error_t);
     parser->error->token = tok;
     parser->error->message = message;
     parser->error->syntax_error = syntax_error;

src/parser.c

@@ -15,7 +15,7 @@ bool rbs_buffer_init_with_capacity(rbs_allocator_t *allocator, rbs_buffer_t *buf
     *buffer = (rbs_buffer_t) {
         .length = 0,
         .capacity = capacity,
-        .value = rbs_allocator_calloc(allocator, capacity, char),
+        .value = rbs_calloc(allocator, capacity, char),
     };
 
     return buffer->value != NULL;
@@ -43,7 +43,7 @@ void rbs_buffer_append_string(rbs_allocator_t *allocator, rbs_buffer_t *buffer,
             new_capacity *= 2;
         }
 
-        char *new_value = rbs_allocator_realloc(allocator, buffer->value, old_capacity, new_capacity, char);
+        char *new_value = rbs_realloc(allocator, buffer->value, old_capacity, new_capacity, char);
         rbs_assert(new_value != NULL, "Failed to append to buffer. Old capacity: %zu, new capacity: %zu", old_capacity, new_capacity);
 
         buffer->value = new_value;

src/util/rbs_buffer.c

@@ -56,7 +56,7 @@ rbs_string_t unescape_string(rbs_allocator_t *allocator, const rbs_string_t stri
     size_t len = string.end - string.start;
     const char *input = string.start;
 
-    char *output = rbs_allocator_alloc_many(allocator, len + 1, char);
+    char *output = rbs_alloc_many(allocator, len + 1, char);
     if (!output) return RBS_STRING_NULL;
 
     size_t i = 0, j = 0;

src/util/rbs_unescape.c

@@ -20,7 +20,7 @@ const char *rbs_node_type_name(rbs_node_t *node) {
 /* rbs_node_list */
 
 rbs_node_list_t *rbs_node_list_new(rbs_allocator_t *allocator) {
-    rbs_node_list_t *list = rbs_allocator_alloc(allocator, rbs_node_list_t);
+    rbs_node_list_t *list = rbs_alloc(allocator, rbs_node_list_t);
     *list = (rbs_node_list_t) {
         .allocator = allocator,
         .head = NULL,
@@ -32,7 +32,7 @@ rbs_node_list_t *rbs_node_list_new(rbs_allocator_t *allocator) {
 }
 
 void rbs_node_list_append(rbs_node_list_t *list, rbs_node_t *node) {
-    rbs_node_list_node_t *new_node = rbs_allocator_alloc(list->allocator, rbs_node_list_node_t);
+    rbs_node_list_node_t *new_node = rbs_alloc(list->allocator, rbs_node_list_node_t);
     *new_node = (rbs_node_list_node_t) {
         .node = node,
         .next = NULL,
@@ -52,7 +52,7 @@ void rbs_node_list_append(rbs_node_list_t *list, rbs_node_t *node) {
 /* rbs_hash */
 
 rbs_hash_t *rbs_hash_new(rbs_allocator_t *allocator) {
-    rbs_hash_t *hash = rbs_allocator_alloc(allocator, rbs_hash_t);
+    rbs_hash_t *hash = rbs_alloc(allocator, rbs_hash_t);
     *hash = (rbs_hash_t) {
         .allocator = allocator,
         .head = NULL,
@@ -104,7 +104,7 @@ void rbs_hash_set(rbs_hash_t *hash, rbs_node_t *key, rbs_node_t *value) {
         return;
     }
 
-    rbs_hash_node_t *new_node = rbs_allocator_alloc(hash->allocator, rbs_hash_node_t);
+    rbs_hash_node_t *new_node = rbs_alloc(hash->allocator, rbs_hash_node_t);
     new_node->key = key;
     new_node->value = value;
     new_node->next = NULL;
@@ -124,7 +124,7 @@ rbs_node_t *rbs_hash_get(rbs_hash_t *hash, rbs_node_t *key) {
 }
 
 rbs_keyword_t *rbs_keyword_new(rbs_allocator_t *allocator, rbs_location_t *location, rbs_constant_id_t constant_id) {
-    rbs_keyword_t *instance = rbs_allocator_alloc(allocator, rbs_keyword_t);
+    rbs_keyword_t *instance = rbs_alloc(allocator, rbs_keyword_t);
 
     *instance = (rbs_keyword_t) {
         .base = (rbs_node_t) {
@@ -138,7 +138,7 @@ rbs_keyword_t *rbs_keyword_new(rbs_allocator_t *allocator, rbs_location_t *locat
 }
 
 rbs_ast_symbol_t *rbs_ast_symbol_new(rbs_allocator_t *allocator, rbs_location_t *location, rbs_constant_pool_t *constant_pool, rbs_constant_id_t constant_id) {
-    rbs_ast_symbol_t *instance = rbs_allocator_alloc(allocator, rbs_ast_symbol_t);
+    rbs_ast_symbol_t *instance = rbs_alloc(allocator, rbs_ast_symbol_t);
 
     *instance = (rbs_ast_symbol_t) {
         .base = (rbs_node_t) {
@@ -154,7 +154,7 @@ rbs_ast_symbol_t *rbs_ast_symbol_new(rbs_allocator_t *allocator, rbs_location_t
 <%- nodes.each do |node| -%>
 #line <%= __LINE__ + 1 %> "prism/templates/src/<%= File.basename(__FILE__) %>"
 <%= node.c_type_name %> *<%= node.c_constructor_function_name %>(<%= node.constructor_params.map(&:parameter_decl).join(", ") %>) {
-    <%= node.c_type_name %> *instance = rbs_allocator_alloc(allocator, <%= node.c_type_name %>);
+    <%= node.c_type_name %> *instance = rbs_alloc(allocator, <%= node.c_type_name %>);
     <%- node.fields.filter { |f| f.c_type == "VALUE" }.each do |f| -%>
     rb_gc_register_mark_object(<%= f.c_name %>);
     <%- end -%>