rbs 3.9.5 → 3.10.0.pre.1

data/include/rbs/defines.h

@@ -0,0 +1,86 @@
+/**
+ * @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
+
+#endif

data/include/rbs/lexer.h

@@ -0,0 +1,199 @@
+#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,       /* < */
+    pEQ,       /* = */
+
+    kALIAS,        /* alias */
+    kATTRACCESSOR, /* attr_accessor */
+    kATTRREADER,   /* attr_reader */
+    kATTRWRITER,   /* attr_writer */
+    kBOOL,         /* bool */
+    kBOT,          /* bot */
+    kCLASS,        /* class */
+    kDEF,          /* def */
+    kEND,          /* end */
+    kEXTEND,       /* extend */
+    kFALSE,        /* false */
+    kIN,           /* in */
+    kINCLUDE,      /* include */
+    kINSTANCE,     /* instance */
+    kINTERFACE,    /* interface */
+    kMODULE,       /* module */
+    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__ */
+
+    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 */
+
+    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 character position that defines the start of the input */
+    int end_pos;            /* The character 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,59 @@
+#ifndef RBS__RBS_LOCATION_H
+#define RBS__RBS_LOCATION_H
+
+#include "lexer.h"
+
+#include "rbs/util/rbs_constant_pool.h"
+#include "rbs/util/rbs_allocator.h"
+
+typedef struct {
+    int start;
+    int end;
+} rbs_loc_range;
+
+typedef struct {
+    rbs_constant_id_t name;
+    rbs_loc_range rg;
+} rbs_loc_entry;
+
+typedef unsigned int rbs_loc_entry_bitmap;
+
+// The flexible array always allocates, but it's okay.
+// This struct is not allocated when the `rbs_loc` doesn't have children.
+typedef struct {
+    unsigned short len;
+    unsigned short cap;
+    rbs_loc_entry_bitmap required_p;
+    rbs_loc_entry entries[1];
+} rbs_loc_children;
+
+typedef struct rbs_location {
+    rbs_range_t rg;
+    rbs_loc_children *children;
+} rbs_location_t;
+
+typedef struct rbs_location_list_node {
+    rbs_location_t *loc;
+    struct rbs_location_list_node *next;
+} rbs_location_list_node_t;
+
+typedef struct rbs_location_list {
+    rbs_allocator_t *allocator;
+    rbs_location_list_node_t *head;
+    rbs_location_list_node_t *tail;
+    size_t length;
+} rbs_location_list_t;
+
+void rbs_loc_alloc_children(rbs_allocator_t *, rbs_location_t *loc, size_t capacity);
+void rbs_loc_add_required_child(rbs_location_t *loc, rbs_constant_id_t name, rbs_range_t r);
+void rbs_loc_add_optional_child(rbs_location_t *loc, rbs_constant_id_t name, rbs_range_t r);
+
+/**
+ * Allocate new rbs_location_t object through the given allocator.
+ * */
+rbs_location_t *rbs_location_new(rbs_allocator_t *, rbs_range_t rg);
+
+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);
+
+#endif

data/include/rbs/parser.h

@@ -0,0 +1,135 @@
+#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 *rbs_lexer_t;
+
+    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 rbs_parse_method_type(rbs_parser_t *parser, rbs_method_type_t **method_type);
+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);
+
+#endif

data/include/rbs/string.h

@@ -0,0 +1,49 @@
+#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);
+
+unsigned int rbs_utf8_string_to_codepoint(const rbs_string_t string);
+
+#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

data/include/rbs/util/rbs_buffer.h

@@ -0,0 +1,83 @@
+#ifndef RBS__RBS_BUFFER_H
+#define RBS__RBS_BUFFER_H
+
+#include "rbs/util/rbs_allocator.h"
+#include "rbs/string.h"
+
+#include <stdbool.h>
+#include <stdlib.h>
+#include <string.h>
+
+/**
+ * The default capacity of a rbs_buffer_t.
+ * If the buffer needs to grow beyond this capacity, it will be doubled.
+ */
+#define RBS_BUFFER_DEFAULT_CAPACITY 128
+
+/**
+ * A rbs_buffer_t is a simple memory buffer that stores data in a contiguous block of memory.
+ */
+typedef struct {
+    /** The length of the buffer in bytes. */
+    size_t length;
+
+    /** The capacity of the buffer in bytes that has been allocated. */
+    size_t capacity;
+
+    /** A pointer to the start of the buffer. */
+    char *value;
+} rbs_buffer_t;
+
+/**
+ * Initialize a rbs_buffer_t with its default values.
+ *
+ * @param allocator The allocator to use.
+ * @param buffer The buffer to initialize.
+ * @returns True if the buffer was initialized successfully, false otherwise.
+ */
+bool rbs_buffer_init(rbs_allocator_t *, rbs_buffer_t *buffer);
+
+/**
+ * Return the value of the buffer.
+ *
+ * @param buffer The buffer to get the value of.
+ * @returns The value of the buffer.
+ */
+char *rbs_buffer_value(const rbs_buffer_t *buffer);
+
+/**
+ * Return the length of the buffer.
+ *
+ * @param buffer The buffer to get the length of.
+ * @returns The length of the buffer.
+ */
+size_t rbs_buffer_length(const rbs_buffer_t *buffer);
+
+/**
+ * Append a C string to the buffer.
+ *
+ * @param allocator The allocator to use.
+ * @param buffer The buffer to append to.
+ * @param value The C string to append.
+ */
+void rbs_buffer_append_cstr(rbs_allocator_t *, rbs_buffer_t *buffer, const char *value);
+
+/**
+ * Append a string to the buffer.
+ *
+ * @param allocator The allocator to use.
+ * @param buffer The buffer to append to.
+ * @param value The string to append.
+ * @param length The length of the string to append.
+ */
+void rbs_buffer_append_string(rbs_allocator_t *, rbs_buffer_t *buffer, const char *value, size_t length);
+
+/**
+ * Convert the buffer to a rbs_string_t.
+ *
+ * @param buffer The buffer to convert.
+ * @returns The converted rbs_string_t.
+ */
+rbs_string_t rbs_buffer_to_string(rbs_buffer_t *buffer);
+
+#endif