rbs 4.1.0.pre.2-java

data/include/rbs/defines.h

@@ -0,0 +1,99 @@
+/**
+ * @file defines.h
+ *
+ * Macro definitions used throughout the rbs library.
+ *
+ * This file should be included first by any *.h or *.c in rbs for consistency
+ * and to ensure that the macros are defined before they are used.
+ */
+
+#ifndef RBS_DEFINES_H
+#define RBS_DEFINES_H
+
+/***********************************************************************************************************************
+ * Copied+modified subset of Prism's `include/prism/defines.h`                                                         *
+ **********************************************************************************************************************/
+
+/**
+ * Certain compilers support specifying that a function accepts variadic
+ * parameters that look like printf format strings to provide a better developer
+ * experience when someone is using the function. This macro does that in a
+ * compiler-agnostic way.
+ */
+#if defined(__GNUC__)
+#if defined(__MINGW_PRINTF_FORMAT)
+#define RBS_ATTRIBUTE_FORMAT(string_index, argument_index) __attribute__((format(__MINGW_PRINTF_FORMAT, string_index, argument_index)))
+#else
+#define RBS_ATTRIBUTE_FORMAT(string_index, argument_index) __attribute__((format(printf, string_index, argument_index)))
+#endif
+#elif defined(__clang__)
+#define RBS_ATTRIBUTE_FORMAT(string_index, argument_index) __attribute__((__format__(__printf__, string_index, argument_index)))
+#else
+#define RBS_ATTRIBUTE_FORMAT(string_index, argument_index)
+#endif
+
+/**
+ * Support RBS_LIKELY and RBS_UNLIKELY to help the compiler optimize its
+ * branch predication.
+ */
+#if defined(__GNUC__) || defined(__clang__)
+/** The compiler should predicate that this branch will be taken. */
+#define RBS_LIKELY(x) __builtin_expect(!!(x), 1)
+
+/** The compiler should predicate that this branch will not be taken. */
+#define RBS_UNLIKELY(x) __builtin_expect(!!(x), 0)
+#else
+/** Void because this platform does not support branch prediction hints. */
+#define RBS_LIKELY(x) (x)
+
+/** Void because this platform does not support branch prediction hints. */
+#define RBS_UNLIKELY(x) (x)
+#endif
+
+/**
+ * We use -Wimplicit-fallthrough to guard potentially unintended fall-through between cases of a switch.
+ * Use RBS_FALLTHROUGH to explicitly annotate cases where the fallthrough is intentional.
+ */
+#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 202311L // C23 or later
+#define RBS_FALLTHROUGH [[fallthrough]];
+#elif defined(__GNUC__) || defined(__clang__)
+#define RBS_FALLTHROUGH __attribute__((fallthrough));
+#elif defined(_MSC_VER)
+#define RBS_FALLTHROUGH __fallthrough;
+#else
+#define RBS_FALLTHROUGH
+#endif
+
+/***********************************************************************************************************************
+ * Custom defines for RBS                                                                                              *
+ **********************************************************************************************************************/
+
+#if defined(_MSC_VER)
+#define NODISCARD _Check_return_
+#else
+#define NODISCARD __attribute__((warn_unused_result))
+#endif
+
+/**
+ * Mark a function or variable as potentially unused to suppress compiler warnings.
+ */
+#if defined(__GNUC__) || defined(__clang__)
+#define RBS_ATTRIBUTE_UNUSED __attribute__((unused))
+#else
+#define RBS_ATTRIBUTE_UNUSED
+#endif
+
+/**
+ * Nullability annotations for pointer types.
+ * Clang supports _Nullable and _Nonnull to indicate whether a pointer may be NULL.
+ * On other compilers, these expand to nothing.
+ */
+#ifdef __clang__
+#define RBS_NULLABLE _Nullable
+#define RBS_NONNULL _Nonnull
+#else
+#define RBS_NULLABLE
+#define RBS_NONNULL
+#endif
+
+#endif

data/include/rbs/lexer.h

@@ -0,0 +1,207 @@
+#ifndef RBS__LEXER_H
+#define RBS__LEXER_H
+
+#include "string.h"
+#include "util/rbs_encoding.h"
+
+enum RBSTokenType {
+    NullType,   /* (Nothing) */
+    pEOF,       /* EOF */
+    ErrorToken, /* Error */
+
+    pLPAREN,   /* ( */
+    pRPAREN,   /* ) */
+    pCOLON,    /* : */
+    pCOLON2,   /* :: */
+    pLBRACKET, /* [ */
+    pRBRACKET, /* ] */
+    pLBRACE,   /* { */
+    pRBRACE,   /* } */
+    pHAT,      /* ^ */
+    pARROW,    /* -> */
+    pFATARROW, /* => */
+    pCOMMA,    /* , */
+    pBAR,      /* | */
+    pAMP,      /* & */
+    pSTAR,     /* * */
+    pSTAR2,    /* ** */
+    pDOT,      /* . */
+    pDOT3,     /* ... */
+    pBANG,     /* ! */
+    pQUESTION, /* ? */
+    pLT,       /* < */
+    pGT,       /* > */
+    pEQ,       /* = */
+
+    kALIAS,        /* alias */
+    kATTRACCESSOR, /* attr_accessor */
+    kATTRREADER,   /* attr_reader */
+    kATTRWRITER,   /* attr_writer */
+    kBOOL,         /* bool */
+    kBOT,          /* bot */
+    kCLASS,        /* class */
+    kCLASSALIAS,   /* class-alias */
+    kDEF,          /* def */
+    kEND,          /* end */
+    kEXTEND,       /* extend */
+    kFALSE,        /* false */
+    kIN,           /* in */
+    kINCLUDE,      /* include */
+    kINSTANCE,     /* instance */
+    kINTERFACE,    /* interface */
+    kMODULE,       /* module */
+    kMODULEALIAS,  /* module-alias */
+    kNIL,          /* nil */
+    kOUT,          /* out */
+    kPREPEND,      /* prepend */
+    kPRIVATE,      /* private */
+    kPUBLIC,       /* public */
+    kSELF,         /* self */
+    kSINGLETON,    /* singleton */
+    kTOP,          /* top */
+    kTRUE,         /* true */
+    kTYPE,         /* type */
+    kUNCHECKED,    /* unchecked */
+    kUNTYPED,      /* untyped */
+    kVOID,         /* void */
+    kUSE,          /* use */
+    kAS,           /* as */
+    k__TODO__,     /* __todo__ */
+    kATRBS,        /* @rbs */
+    kSKIP,         /* skip */
+    kRETURN,       /* return */
+    kMODULESELF,   /* module-self */
+
+    tLIDENT,    /* Identifiers starting with lower case */
+    tUIDENT,    /* Identifiers starting with upper case */
+    tULIDENT,   /* Identifiers starting with `_` followed by upper case */
+    tULLIDENT,  /* Identifiers starting with `_` followed by lower case */
+    tGIDENT,    /* Identifiers starting with `$` */
+    tAIDENT,    /* Identifiers starting with `@` */
+    tA2IDENT,   /* Identifiers starting with `@@` */
+    tBANGIDENT, /* Identifiers ending with `!` */
+    tEQIDENT,   /* Identifiers ending with `=` */
+    tQIDENT,    /* Quoted identifier */
+    pAREF_OPR,  /* [] */
+    tOPERATOR,  /* Operator identifier */
+
+    tCOMMENT,       /* Comment */
+    tLINECOMMENT,   /* Comment of all line */
+    tINLINECOMMENT, /* Comment in inline decl starting with -- */
+
+    tTRIVIA, /* Trivia tokens -- space and new line */
+
+    tDQSTRING,   /* Double quoted string */
+    tSQSTRING,   /* Single quoted string */
+    tINTEGER,    /* Integer */
+    tSYMBOL,     /* Symbol */
+    tDQSYMBOL,   /* Double quoted symbol */
+    tSQSYMBOL,   /* Single quoted symbol */
+    tANNOTATION, /* Annotation */
+};
+
+/**
+ * The `byte_pos` (or `char_pos`) is the primary data.
+ * The rest are cache.
+ *
+ * They can be computed from `byte_pos` (or `char_pos`), but it needs full scan from the beginning of the string (depending on the encoding).
+ * */
+typedef struct {
+    int byte_pos;
+    int char_pos;
+    int line;
+    int column;
+} rbs_position_t;
+
+typedef struct {
+    rbs_position_t start;
+    rbs_position_t end;
+} rbs_range_t;
+
+typedef struct {
+    enum RBSTokenType type;
+    rbs_range_t range;
+} rbs_token_t;
+
+/**
+ * The lexer state is the curren token.
+ *
+ * ```
+ #.   0.1.2.3.4.5.6.7.8.9.0.1.2.3.4.5.6
+ * ... " a   s t r i n g   t o k e n "
+ *    ^                                   start position (0)
+ *                ^                       current position (6)
+ *                 ^                      current character ('i', bytes = 1)
+ *     ~~~~~~~~~~~                        Token => "a str
+ * ```
+ * */
+typedef struct {
+    rbs_string_t string;
+    int start_pos;          /* The byte position that defines the start of the input */
+    int end_pos;            /* The byte position that defines the end of the input */
+    rbs_position_t current; /* The current position: just before the current_character */
+    rbs_position_t start;   /* The start position of the current token */
+
+    unsigned int current_code_point; /* Current character code point */
+    size_t current_character_bytes;  /* Current character byte length (0 or 1~4) */
+
+    bool first_token_of_line; /* This flag is used for tLINECOMMENT */
+
+    const rbs_encoding_t *encoding;
+} rbs_lexer_t;
+
+extern const rbs_token_t NullToken;
+extern const rbs_position_t NullPosition;
+extern const rbs_range_t NULL_RANGE;
+
+char *rbs_peek_token(rbs_lexer_t *lexer, rbs_token_t tok);
+int rbs_token_chars(rbs_token_t tok);
+int rbs_token_bytes(rbs_token_t tok);
+
+#define rbs_null_position_p(pos) (pos.byte_pos == -1)
+#define rbs_null_range_p(range) (range.start.byte_pos == -1)
+#define rbs_nonnull_pos_or(pos1, pos2) (rbs_null_position_p(pos1) ? pos2 : pos1)
+#define RBS_RANGE_BYTES(range) (range.end.byte_pos - range.start.byte_pos)
+
+const char *rbs_token_type_str(enum RBSTokenType type);
+
+/**
+ * Returns the next character.
+ * */
+unsigned int rbs_peek(rbs_lexer_t *lexer);
+
+/**
+ * Advances the current position by one character.
+ * */
+void rbs_skip(rbs_lexer_t *lexer);
+
+/**
+ * Read next character and store the codepoint and byte length to the given pointers.
+ * 
+ * This doesn't update the lexer state.
+ * Returns `true` if succeeded, or `false` if reached to EOF.
+ * */
+bool rbs_next_char(rbs_lexer_t *lexer, unsigned int *codepoint, size_t *bytes);
+
+/**
+ * Skip n characters.
+ * */
+void rbs_skipn(rbs_lexer_t *lexer, size_t size);
+
+/**
+ * Return new rbs_token_t with given type.
+ * */
+rbs_token_t rbs_next_token(rbs_lexer_t *lexer, enum RBSTokenType type);
+
+/**
+ * Return new rbs_token_t with EOF type.
+ * */
+rbs_token_t rbs_next_eof_token(rbs_lexer_t *lexer);
+
+rbs_token_t rbs_lexer_next_token(rbs_lexer_t *lexer);
+
+void rbs_print_token(rbs_token_t tok);
+
+void rbs_print_lexer(rbs_lexer_t *lexer);
+
+#endif

data/include/rbs/location.h

@@ -0,0 +1,40 @@
+#ifndef RBS__RBS_LOCATION_H
+#define RBS__RBS_LOCATION_H
+
+#include "rbs/util/rbs_allocator.h"
+
+#define RBS_LOCATION_NULL_RANGE ((rbs_location_range) { -1, -1, -1, -1 })
+#define RBS_LOCATION_NULL_RANGE_P(rg) ((rg).start_char == -1)
+
+/**
+ * Converts a lexer range (rbs_range_t) to an AST location range (rbs_location_range) by extracting character and byte positions.
+ */
+#define RBS_RANGE_LEX2AST(rg) ((rbs_location_range) { .start_char = (rg).start.char_pos, .start_byte = (rg).start.byte_pos, .end_char = (rg).end.char_pos, .end_byte = (rg).end.byte_pos })
+
+typedef struct {
+    int start_char;
+    int start_byte;
+
+    int end_char;
+    int end_byte;
+} rbs_location_range;
+
+typedef struct rbs_location_range_list_node {
+    rbs_location_range range;
+    struct rbs_location_range_list_node *next;
+} rbs_location_range_list_node_t;
+
+typedef struct rbs_location_range_list {
+    rbs_allocator_t *allocator;
+    struct rbs_location_range_list_node *head;
+    struct rbs_location_range_list_node *tail;
+    size_t length;
+} rbs_location_range_list_t;
+
+/**
+ * Allocate new rbs_location_range_list_t object through the given allocator.
+ */
+rbs_location_range_list_t *rbs_location_range_list_new(rbs_allocator_t *allocator);
+void rbs_location_range_list_append(rbs_location_range_list_t *list, rbs_location_range range);
+
+#endif

data/include/rbs/parser.h

@@ -0,0 +1,153 @@
+#ifndef RBS__PARSER_H
+#define RBS__PARSER_H
+
+#include "rbs/defines.h"
+#include "rbs/util/rbs_allocator.h"
+#include "rbs/util/rbs_constant_pool.h"
+#include "rbs/lexer.h"
+#include "rbs/ast.h"
+
+#include <stdbool.h>
+#include <stddef.h>
+
+/**
+ * comment represents a sequence of comment lines.
+ *
+ *     # Comment for the method.
+ *     #
+ *     # ```rb
+ *     # object.foo()  # Do something
+ *     # ```
+ *     #
+ *     def foo: () -> void
+ *
+ * A comment object represents the six lines of comments.
+ * */
+typedef struct rbs_comment_t {
+    rbs_position_t start;
+    rbs_position_t end;
+
+    size_t line_tokens_capacity;
+    size_t line_tokens_count;
+    rbs_token_t *line_tokens;
+
+    struct rbs_comment_t *next_comment;
+} rbs_comment_t;
+
+typedef struct rbs_error_t {
+    char *message;
+    rbs_token_t token;
+    bool syntax_error;
+} rbs_error_t;
+
+/**
+ * An RBS parser is a LL(3) parser.
+ * */
+typedef struct {
+    rbs_lexer_t *lexer;
+
+    rbs_token_t current_token;
+    rbs_token_t next_token;  /* The first lookahead token */
+    rbs_token_t next_token2; /* The second lookahead token */
+    rbs_token_t next_token3; /* The third lookahead token */
+
+    struct id_table *vars;       /* Known type variables */
+    rbs_comment_t *last_comment; /* Last read comment */
+
+    rbs_constant_pool_t constant_pool;
+    rbs_allocator_t *allocator;
+    rbs_error_t *error;
+} rbs_parser_t;
+
+/**
+ * Insert new table entry.
+ * Setting `reset` inserts a _reset_ entry, which stops searching.
+ *
+ * ```
+ * class Foo[A]
+ *          ^^^                      <= push new table with reset
+ *   def foo: [B] () -> [A, B]
+ *            ^^^                    <= push new table without reset
+ *
+ *   class Baz[C]
+ *            ^^^                    <= push new table with reset
+ *   end
+ * end
+ * ```
+ * */
+void rbs_parser_push_typevar_table(rbs_parser_t *parser, bool reset);
+
+/**
+ * Insert new type variable into the latest table.
+ * */
+NODISCARD bool rbs_parser_insert_typevar(rbs_parser_t *parser, rbs_constant_id_t id);
+
+/**
+ * Allocate new rbs_lexer_t object.
+ *
+ * ```
+ * VALUE string = rb_funcall(buffer, rb_intern("content"), 0);
+ * rbs_lexer_new(string, 0, 31)    // New rbs_lexer_t with buffer content
+ * ```
+ * */
+rbs_lexer_t *rbs_lexer_new(rbs_allocator_t *, rbs_string_t string, const rbs_encoding_t *encoding, int start_pos, int end_pos);
+
+/**
+ * Allocate new rbs_parser_t object.
+ *
+ * ```
+ * rbs_parser_new(buffer, string, encoding, 0, 1);
+ * ```
+ * */
+rbs_parser_t *rbs_parser_new(rbs_string_t string, const rbs_encoding_t *encoding, int start_pos, int end_pos);
+void rbs_parser_free(rbs_parser_t *parser);
+
+/**
+ * Advance one token.
+ * */
+void rbs_parser_advance(rbs_parser_t *parser);
+
+void rbs_parser_print(rbs_parser_t *parser);
+
+/**
+ * Returns a RBS::Comment object associated with an subject at `subject_line`.
+ *
+ * ```rbs
+ * # Comment1
+ * class Foo           # This is the subject line for Comment1
+ *
+ *   # Comment2
+ *   %a{annotation}    # This is the subject line for Comment2
+ *   def foo: () -> void
+ * end
+ * ```
+ * */
+rbs_ast_comment_t *rbs_parser_get_comment(rbs_parser_t *parser, int subject_line);
+
+void rbs_parser_set_error(rbs_parser_t *parser, rbs_token_t tok, bool syntax_error, const char *fmt, ...) RBS_ATTRIBUTE_FORMAT(4, 5);
+
+bool rbs_parse_type(rbs_parser_t *parser, rbs_node_t **type, bool void_allowed, bool self_allowed, bool classish_allowed);
+bool rbs_parse_method_type(rbs_parser_t *parser, rbs_method_type_t **method_type, bool require_eof, bool classish_allowed);
+bool rbs_parse_signature(rbs_parser_t *parser, rbs_signature_t **signature);
+
+bool rbs_parse_type_params(rbs_parser_t *parser, bool module_type_params, rbs_node_list_t **params);
+
+/**
+ * Parse an inline leading annotation from a string.
+ *
+ * @param parser The parser to use
+ * @param annotation Pointer to store the resulting annotation
+ * @return true if parsing succeeded, false otherwise
+ */
+bool rbs_parse_inline_leading_annotation(rbs_parser_t *parser, rbs_ast_ruby_annotations_t **annotation);
+
+/**
+ * Parse an inline trailing annotation from a string.
+ *
+ * @param parser The parser to use
+ * @param annotation Pointer to store the resulting annotation
+ * @return true if parsing succeeded, false otherwise
+ */
+bool rbs_parse_inline_trailing_annotation(rbs_parser_t *parser, rbs_ast_ruby_annotations_t **annotation);
+
+#endif

data/include/rbs/serialize.h

@@ -0,0 +1,39 @@
+/*----------------------------------------------------------------------------*/
+/* This file is generated by the templates/template.rb script and should not  */
+/* be modified manually.                                                      */
+/* To change the template see                                                 */
+/* templates/include/rbs/serialize.h.erb                                      */
+/*----------------------------------------------------------------------------*/
+
+#ifndef RBS__SERIALIZE_H
+#define RBS__SERIALIZE_H
+
+#include "rbs/ast.h"
+#include "rbs/string.h"
+#include "rbs/util/rbs_allocator.h"
+#include "rbs/util/rbs_constant_pool.h"
+
+/**
+ * Serialize a parsed AST node into a compact, portable binary buffer.
+ *
+ * The format is consumed by RBS::WASM::Deserializer on the Ruby side, which
+ * rebuilds the same `RBS::AST` objects that the C extension would have built
+ * directly. This is what lets RBS run on Ruby implementations that cannot load
+ * the C extension (notably JRuby): the parser runs inside WebAssembly, produces
+ * this buffer, and the host reconstructs the tree in pure Ruby.
+ *
+ * The buffer is allocated from `allocator`, so its lifetime is tied to that
+ * allocator. `constant_pool` must be the pool the node was parsed with; it is
+ * used to resolve interned symbol/identifier ids back into their bytes.
+ *
+ * See `docs/wasm_serialization.md` for the wire format.
+ */
+rbs_string_t rbs_serialize_node(rbs_allocator_t *allocator, rbs_constant_pool_t *constant_pool, rbs_node_t *node);
+
+/**
+ * Like rbs_serialize_node, but for a bare node list (e.g. the result of
+ * rbs_parse_type_params). Decoded by RBS::WASM::Deserializer.deserialize_node_list.
+ */
+rbs_string_t rbs_serialize_node_list(rbs_allocator_t *allocator, rbs_constant_pool_t *constant_pool, rbs_node_list_t *list);
+
+#endif

data/include/rbs/string.h

@@ -0,0 +1,47 @@
+#ifndef RBS__RBS_STRING_H
+#define RBS__RBS_STRING_H
+
+#include <stddef.h>
+#include <stdbool.h>
+#include "rbs/util/rbs_allocator.h"
+
+typedef struct {
+    const char *start;
+    const char *end;
+} rbs_string_t;
+
+#define RBS_STRING_NULL ((rbs_string_t) { \
+    .start = NULL,                        \
+    .end = NULL,                          \
+})
+
+/**
+ * Returns a new `rbs_string_t` struct
+ */
+rbs_string_t rbs_string_new(const char *start, const char *end);
+
+/**
+ * Copies a portion of the input string into a new owned string.
+ * @param start_inset Number of characters to exclude from the start
+ * @param length Number of characters to include
+ * @return A new owned string that will be freed when the allocator is freed.
+ */
+rbs_string_t rbs_string_copy_slice(rbs_allocator_t *, rbs_string_t *self, size_t start_inset, size_t length);
+
+/**
+ * Drops the leading and trailing whitespace from the given string, in-place.
+ * @returns A new string that provides a view into the original string `self`.
+ */
+rbs_string_t rbs_string_strip_whitespace(rbs_string_t *self);
+
+/**
+ * Returns the length of the string.
+ */
+size_t rbs_string_len(const rbs_string_t self);
+
+/**
+ * Compares two strings for equality.
+ */
+bool rbs_string_equal(const rbs_string_t lhs, const rbs_string_t rhs);
+
+#endif

data/include/rbs/util/rbs_allocator.h

@@ -0,0 +1,59 @@
+#ifndef RBS_ALLOCATOR_H
+#define RBS_ALLOCATOR_H
+
+#include <stddef.h>
+
+/* Include stdalign.h for C11 and later for alignof support */
+#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L
+#include <stdalign.h>
+#endif
+
+/*
+ * Define a portable alignment macro that works across all supported environments
+ */
+#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L
+/* C11 or later - use _Alignof directly (always available in C11+) */
+#define rbs_alignof(type) _Alignof(type)
+#elif defined(__cplusplus) && __cplusplus >= 201103L
+/* C++11 or later has alignof keyword */
+#define rbs_alignof(type) alignof(type)
+#elif defined(__GNUC__) || defined(__clang__)
+/* GCC and Clang provide __alignof__ */
+#define rbs_alignof(type) __alignof__(type)
+#elif defined(_MSC_VER)
+/* MSVC provides __alignof */
+#define rbs_alignof(type) __alignof(type)
+#else
+/* Fallback using offset trick for other compilers */
+#define rbs_alignof(type) offsetof( \
+    struct { char c; type member; },                     \
+    member                          \
+)
+#endif
+
+typedef struct rbs_allocator {
+    // The head of a linked list of pages, starting with the most recently allocated page.
+    struct rbs_allocator_page *page;
+
+    size_t default_page_payload_size;
+} rbs_allocator_t;
+
+rbs_allocator_t *rbs_allocator_init(void);
+void rbs_allocator_free(rbs_allocator_t *);
+void *rbs_allocator_malloc_impl(rbs_allocator_t *, /*    1    */ size_t size, size_t alignment);
+void *rbs_allocator_malloc_many_impl(rbs_allocator_t *, size_t count, size_t size, size_t alignment);
+void *rbs_allocator_calloc_impl(rbs_allocator_t *, size_t count, size_t size, size_t alignment);
+
+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), rbs_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), rbs_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), rbs_alignof(type)))
+#define rbs_allocator_realloc(allocator, ptr, old_size, new_size, type) ((type *) rbs_allocator_realloc_impl((allocator), (ptr), (old_size), (new_size), rbs_alignof(type)))
+
+#endif

data/include/rbs/util/rbs_assert.h

@@ -0,0 +1,20 @@
+#ifndef RBS_ASSERT_H
+#define RBS_ASSERT_H
+
+#include "rbs/defines.h"
+#include <stdbool.h>
+
+/**
+ * RBS_ASSERT macro that calls rbs_assert in debug builds and is removed in release builds.
+ * In debug mode, it forwards all arguments to the rbs_assert function.
+ * In release mode, it expands to nothing.
+ */
+#ifdef NDEBUG
+#define RBS_ASSERT(condition, ...) ((void) 0)
+#else
+#define RBS_ASSERT(condition, ...) rbs_assert_impl(condition, __VA_ARGS__)
+#endif
+
+void rbs_assert_impl(bool condition, const char *fmt, ...) RBS_ATTRIBUTE_FORMAT(2, 3);
+
+#endif