yarp 0.6.0

data/src/util/yp_char.c

@@ -0,0 +1,229 @@
+#include "yarp/util/yp_char.h"
+
+#define YP_CHAR_BIT_WHITESPACE (1 << 0)
+#define YP_CHAR_BIT_INLINE_WHITESPACE (1 << 1)
+#define YP_CHAR_BIT_REGEXP_OPTION (1 << 2)
+
+#define YP_NUMBER_BIT_BINARY_DIGIT (1 << 0)
+#define YP_NUMBER_BIT_BINARY_NUMBER (1 << 1)
+#define YP_NUMBER_BIT_OCTAL_DIGIT (1 << 2)
+#define YP_NUMBER_BIT_OCTAL_NUMBER (1 << 3)
+#define YP_NUMBER_BIT_DECIMAL_DIGIT (1 << 4)
+#define YP_NUMBER_BIT_DECIMAL_NUMBER (1 << 5)
+#define YP_NUMBER_BIT_HEXADECIMAL_DIGIT (1 << 6)
+#define YP_NUMBER_BIT_HEXADECIMAL_NUMBER (1 << 7)
+
+static const unsigned char yp_char_table[256] = {
+//0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 1, 3, 3, 3, 0, 0, // 0x
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 1x
+    3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 2x
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 3x
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 4x
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 5x
+    0, 0, 0, 0, 0, 4, 0, 0, 0, 4, 0, 0, 0, 4, 4, 4, // 6x
+    0, 0, 0, 4, 0, 4, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, // 7x
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 8x
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 9x
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Ax
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Bx
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Cx
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Dx
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Ex
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Fx
+};
+
+static const unsigned char yp_number_table[256] = {
+    // 0     1     2     3     4     5     6     7     8     9     A     B     C     D     E     F
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 1x
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 2x
+    0xff, 0xff, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xf0, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 3x
+    0x00, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 4x
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xaa, // 5x
+    0x00, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 6x
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 7x
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 8x
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 9x
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Ax
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Bx
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Cx
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Dx
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Ex
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Fx
+};
+
+static inline size_t
+yp_strspn_char_kind(const char *string, ptrdiff_t length, unsigned char kind) {
+    if (length <= 0) return 0;
+
+    size_t size = 0;
+    size_t maximum = (size_t) length;
+
+    while (size < maximum && (yp_char_table[(unsigned char) string[size]] & kind)) size++;
+    return size;
+}
+
+// Returns the number of characters at the start of the string that are
+// whitespace. Disallows searching past the given maximum number of characters.
+size_t
+yp_strspn_whitespace(const char *string, ptrdiff_t length) {
+    return yp_strspn_char_kind(string, length, YP_CHAR_BIT_WHITESPACE);
+}
+
+// Returns the number of characters at the start of the string that are
+// whitespace while also tracking the location of each newline. Disallows
+// searching past the given maximum number of characters.
+size_t
+yp_strspn_whitespace_newlines(const char *string, ptrdiff_t length, yp_newline_list_t *newline_list, bool stop_at_newline) {
+    if (length <= 0) return 0;
+
+    size_t size = 0;
+    size_t maximum = (size_t) length;
+
+    while (size < maximum && (yp_char_table[(unsigned char) string[size]] & YP_CHAR_BIT_WHITESPACE)) {
+        if (string[size] == '\n') {
+            if (stop_at_newline) {
+                return size + 1;
+            }
+            else {
+                yp_newline_list_append(newline_list, string + size);
+            }
+        }
+
+        size++;
+    }
+
+    return size;
+}
+
+// Returns the number of characters at the start of the string that are inline
+// whitespace. Disallows searching past the given maximum number of characters.
+size_t
+yp_strspn_inline_whitespace(const char *string, ptrdiff_t length) {
+    return yp_strspn_char_kind(string, length, YP_CHAR_BIT_INLINE_WHITESPACE);
+}
+
+// Returns the number of characters at the start of the string that are regexp
+// options. Disallows searching past the given maximum number of characters.
+size_t
+yp_strspn_regexp_option(const char *string, ptrdiff_t length) {
+    return yp_strspn_char_kind(string, length, YP_CHAR_BIT_REGEXP_OPTION);
+}
+
+static inline bool
+yp_char_is_char_kind(const char c, unsigned char kind) {
+    return (yp_char_table[(unsigned char) c] & kind) != 0;
+}
+
+// Returns true if the given character is a whitespace character.
+bool
+yp_char_is_whitespace(const char c) {
+    return yp_char_is_char_kind(c, YP_CHAR_BIT_WHITESPACE);
+}
+
+// Returns true if the given character is an inline whitespace character.
+bool
+yp_char_is_inline_whitespace(const char c) {
+    return yp_char_is_char_kind(c, YP_CHAR_BIT_INLINE_WHITESPACE);
+}
+
+static inline size_t
+yp_strspn_number_kind(const char *string, ptrdiff_t length, unsigned char kind) {
+    if (length <= 0) return 0;
+
+    size_t size = 0;
+    size_t maximum = (size_t) length;
+
+    while (size < maximum && (yp_number_table[(unsigned char) string[size]] & kind)) size++;
+    return size;
+}
+
+// Returns the number of characters at the start of the string that are binary
+// digits or underscores. Disallows searching past the given maximum number of
+// characters.
+size_t
+yp_strspn_binary_number(const char *string, ptrdiff_t length) {
+    return yp_strspn_number_kind(string, length, YP_NUMBER_BIT_BINARY_NUMBER);
+}
+
+// Returns the number of characters at the start of the string that are octal
+// digits or underscores.  Disallows searching past the given maximum number of
+// characters.
+size_t
+yp_strspn_octal_number(const char *string, ptrdiff_t length) {
+    return yp_strspn_number_kind(string, length, YP_NUMBER_BIT_OCTAL_NUMBER);
+}
+
+// Returns the number of characters at the start of the string that are decimal
+// digits. Disallows searching past the given maximum number of characters.
+size_t
+yp_strspn_decimal_digit(const char *string, ptrdiff_t length) {
+    return yp_strspn_number_kind(string, length, YP_NUMBER_BIT_DECIMAL_DIGIT);
+}
+
+// Returns the number of characters at the start of the string that are decimal
+// digits or underscores. Disallows searching past the given maximum number of
+// characters.
+size_t
+yp_strspn_decimal_number(const char *string, ptrdiff_t length) {
+    return yp_strspn_number_kind(string, length, YP_NUMBER_BIT_DECIMAL_NUMBER);
+}
+
+// Returns the number of characters at the start of the string that are
+// hexadecimal digits. Disallows searching past the given maximum number of
+// characters.
+size_t
+yp_strspn_hexadecimal_digit(const char *string, ptrdiff_t length) {
+    return yp_strspn_number_kind(string, length, YP_NUMBER_BIT_HEXADECIMAL_DIGIT);
+}
+
+// Returns the number of characters at the start of the string that are
+// hexadecimal digits or underscores. Disallows searching past the given maximum
+// number of characters.
+size_t
+yp_strspn_hexadecimal_number(const char *string, ptrdiff_t length) {
+    return yp_strspn_number_kind(string, length, YP_NUMBER_BIT_HEXADECIMAL_NUMBER);
+}
+
+static inline bool
+yp_char_is_number_kind(const char c, unsigned char kind) {
+    return (yp_number_table[(unsigned char) c] & kind) != 0;
+}
+
+// Returns true if the given character is a binary digit.
+bool
+yp_char_is_binary_digit(const char c) {
+    return yp_char_is_number_kind(c, YP_NUMBER_BIT_BINARY_DIGIT);
+}
+
+// Returns true if the given character is an octal digit.
+bool
+yp_char_is_octal_digit(const char c) {
+    return yp_char_is_number_kind(c, YP_NUMBER_BIT_OCTAL_DIGIT);
+}
+
+// Returns true if the given character is a decimal digit.
+bool
+yp_char_is_decimal_digit(const char c) {
+    return yp_char_is_number_kind(c, YP_NUMBER_BIT_DECIMAL_DIGIT);
+}
+
+// Returns true if the given character is a hexadecimal digit.
+bool
+yp_char_is_hexadecimal_digit(const char c) {
+    return yp_char_is_number_kind(c, YP_NUMBER_BIT_HEXADECIMAL_DIGIT);
+}
+
+#undef YP_CHAR_BIT_WHITESPACE
+#undef YP_CHAR_BIT_INLINE_WHITESPACE
+#undef YP_CHAR_BIT_REGEXP_OPTION
+
+#undef YP_NUMBER_BIT_BINARY_DIGIT
+#undef YP_NUMBER_BIT_BINARY_NUMBER
+#undef YP_NUMBER_BIT_OCTAL_DIGIT
+#undef YP_NUMBER_BIT_OCTAL_NUMBER
+#undef YP_NUMBER_BIT_DECIMAL_DIGIT
+#undef YP_NUMBER_BIT_DECIMAL_NUMBER
+#undef YP_NUMBER_BIT_HEXADECIMAL_NUMBER
+#undef YP_NUMBER_BIT_HEXADECIMAL_DIGIT

data/src/util/yp_constant_pool.c

@@ -0,0 +1,147 @@
+#include "yarp/util/yp_constant_pool.h"
+
+// Initialize a list of constant ids.
+void
+yp_constant_id_list_init(yp_constant_id_list_t *list) {
+    list->ids = NULL;
+    list->size = 0;
+    list->capacity = 0;
+}
+
+// Append a constant id to a list of constant ids. Returns false if any
+// potential reallocations fail.
+bool
+yp_constant_id_list_append(yp_constant_id_list_t *list, yp_constant_id_t id) {
+    if (list->size >= list->capacity) {
+        list->capacity = list->capacity == 0 ? 8 : list->capacity * 2;
+        list->ids = (yp_constant_id_t *) realloc(list->ids, sizeof(yp_constant_id_t) * list->capacity);
+        if (list->ids == NULL) return false;
+    }
+
+    list->ids[list->size++] = id;
+    return true;
+}
+
+// Checks if the current constant id list includes the given constant id.
+bool
+yp_constant_id_list_includes(yp_constant_id_list_t *list, yp_constant_id_t id) {
+    for (size_t index = 0; index < list->size; index++) {
+        if (list->ids[index] == id) return true;
+    }
+    return false;
+}
+
+// Get the memory size of a list of constant ids.
+size_t
+yp_constant_id_list_memsize(yp_constant_id_list_t *list) {
+    return sizeof(yp_constant_id_list_t) + (list->capacity * sizeof(yp_constant_id_t));
+}
+
+// Free the memory associated with a list of constant ids.
+void
+yp_constant_id_list_free(yp_constant_id_list_t *list) {
+    if (list->ids != NULL) {
+        free(list->ids);
+    }
+}
+
+// A relatively simple hash function (djb2) that is used to hash strings. We are
+// optimizing here for simplicity and speed.
+static inline size_t
+yp_constant_pool_hash(const char *start, size_t length) {
+    // This is a prime number used as the initial value for the hash function.
+    size_t value = 5381;
+
+    for (size_t index = 0; index < length; index++) {
+        value = ((value << 5) + value) + ((unsigned char) start[index]);
+    }
+
+    return value;
+}
+
+// Resize a constant pool to a given capacity.
+static inline bool
+yp_constant_pool_resize(yp_constant_pool_t *pool) {
+    size_t next_capacity = pool->capacity * 2;
+    yp_constant_t *next_constants = calloc(next_capacity, sizeof(yp_constant_t));
+    if (next_constants == NULL) return false;
+
+    // For each constant in the current constant pool, rehash the content, find
+    // the index in the next constant pool, and insert it.
+    for (size_t index = 0; index < pool->capacity; index++) {
+        yp_constant_t *constant = &pool->constants[index];
+
+        // If an id is set on this constant, then we know we have content here.
+        // In this case we need to insert it into the next constant pool.
+        if (constant->id != 0) {
+            size_t next_index = constant->hash % next_capacity;
+
+            // This implements linear scanning to find the next available slot
+            // in case this index is already taken. We don't need to bother
+            // comparing the values since we know that the hash is unique.
+            while (next_constants[next_index].id != 0) {
+                next_index = (next_index + 1) % next_capacity;
+            }
+
+            // Here we copy over the entire constant, which includes the id so
+            // that they are consistent between resizes.
+            next_constants[next_index] = *constant;
+        }
+    }
+
+    free(pool->constants);
+    pool->constants = next_constants;
+    pool->capacity = next_capacity;
+    return true;
+}
+
+// Initialize a new constant pool with a given capacity.
+bool
+yp_constant_pool_init(yp_constant_pool_t *pool, size_t capacity) {
+    pool->constants = calloc(capacity, sizeof(yp_constant_t));
+    if (pool->constants == NULL) return false;
+
+    pool->size = 0;
+    pool->capacity = capacity;
+    return true;
+}
+
+// Insert a constant into a constant pool. Returns the id of the constant, or 0
+// if any potential calls to resize fail.
+yp_constant_id_t
+yp_constant_pool_insert(yp_constant_pool_t *pool, const char *start, size_t length) {
+    if (pool->size >= (pool->capacity / 4 * 3)) {
+        if (!yp_constant_pool_resize(pool)) return 0;
+    }
+
+    size_t hash = yp_constant_pool_hash(start, length);
+    size_t index = hash % pool->capacity;
+    yp_constant_t *constant;
+
+    while (constant = &pool->constants[index], constant->id != 0) {
+        // If there is a collision, then we need to check if the content is the
+        // same as the content we are trying to insert. If it is, then we can
+        // return the id of the existing constant.
+        if ((constant->length == length) && strncmp(constant->start, start, length) == 0) {
+            return pool->constants[index].id;
+        }
+
+        index = (index + 1) % pool->capacity;
+    }
+
+    yp_constant_id_t id = (yp_constant_id_t)++pool->size;
+    pool->constants[index] = (yp_constant_t) {
+        .id = id,
+        .start = start,
+        .length = length,
+        .hash = hash
+    };
+
+    return id;
+}
+
+// Free the memory associated with a constant pool.
+void
+yp_constant_pool_free(yp_constant_pool_t *pool) {
+    free(pool->constants);
+}

data/src/util/yp_list.c

@@ -0,0 +1,50 @@
+#include "yarp/util/yp_list.h"
+
+// Initializes a new list.
+YP_EXPORTED_FUNCTION void
+yp_list_init(yp_list_t *list) {
+    *list = (yp_list_t) { .head = NULL, .tail = NULL };
+}
+
+// Returns true if the given list is empty.
+YP_EXPORTED_FUNCTION bool
+yp_list_empty_p(yp_list_t *list) {
+    return list->head == NULL;
+}
+
+YP_EXPORTED_FUNCTION uint32_t
+yp_list_size(yp_list_t *list) {
+    yp_list_node_t *node = list->head;
+    uint32_t length = 0;
+
+    while (node != NULL) {
+        length++;
+        node = node->next;
+    }
+
+    return length;
+}
+
+// Append a node to the given list.
+void
+yp_list_append(yp_list_t *list, yp_list_node_t *node) {
+    if (list->head == NULL) {
+        list->head = node;
+    } else {
+        list->tail->next = node;
+    }
+    list->tail = node;
+}
+
+// Deallocate the internal state of the given list.
+YP_EXPORTED_FUNCTION void
+yp_list_free(yp_list_t *list) {
+    yp_list_node_t *node = list->head;
+    yp_list_node_t *next;
+
+    while (node != NULL) {
+        next = node->next;
+        free(node);
+        node = next;
+    }
+}

data/src/util/yp_memchr.c

@@ -0,0 +1,31 @@
+#include "yarp/util/yp_memchr.h"
+
+#define YP_MEMCHR_TRAILING_BYTE_MINIMUM 0x40
+
+// We need to roll our own memchr to handle cases where the encoding changes and
+// we need to search for a character in a buffer that could be the trailing byte
+// of a multibyte character.
+void *
+yp_memchr(const void *memory, int character, size_t number, bool encoding_changed, yp_encoding_t *encoding) {
+    if (encoding_changed && encoding->multibyte && character >= YP_MEMCHR_TRAILING_BYTE_MINIMUM) {
+        const char *source = (const char *) memory;
+        size_t index = 0;
+
+        while (index < number) {
+            if (source[index] == character) {
+                return (void *) (source + index);
+            }
+
+            size_t width = encoding->char_width(source + index, (ptrdiff_t) (number - index));
+            if (width == 0) {
+                return NULL;
+            }
+
+            index += width;
+        }
+
+        return NULL;
+    } else {
+        return memchr(memory, character, number);
+    }
+}

data/src/util/yp_newline_list.c

@@ -0,0 +1,119 @@
+#include "yarp/util/yp_newline_list.h"
+
+// Initialize a new newline list with the given capacity. Returns true if the
+// allocation of the offsets succeeds, otherwise returns false.
+bool
+yp_newline_list_init(yp_newline_list_t *list, const char *start, size_t capacity) {
+    list->offsets = (size_t *) calloc(capacity, sizeof(size_t));
+    if (list->offsets == NULL) return false;
+
+    list->start = start;
+
+    // This is 1 instead of 0 because we want to include the first line of the
+    // file as having offset 0, which is set because of calloc.
+    list->size = 1;
+    list->capacity = capacity;
+
+    list->last_index = 0;
+    list->last_offset = 0;
+
+    return true;
+}
+
+// Append a new offset to the newline list. Returns true if the reallocation of
+// the offsets succeeds (if one was necessary), otherwise returns false.
+bool
+yp_newline_list_append(yp_newline_list_t *list, const char *cursor) {
+    if (list->size == list->capacity) {
+        list->capacity = (list->capacity * 3) / 2;
+        list->offsets = (size_t *) realloc(list->offsets, list->capacity * sizeof(size_t));
+        if (list->offsets == NULL) return false;
+    }
+
+    assert(cursor >= list->start);
+    size_t newline_offset = (size_t) (cursor - list->start + 1);
+    assert(list->size == 0 || newline_offset > list->offsets[list->size - 1]);
+    list->offsets[list->size++] = newline_offset;
+
+    return true;
+}
+
+// Returns the line and column of the given offset, assuming we don't have any
+// information about the previous index that we found.
+static yp_line_column_t
+yp_newline_list_line_column_search(yp_newline_list_t *list, size_t offset) {
+    size_t left = 0;
+    size_t right = list->size - 1;
+
+    while (left <= right) {
+        size_t mid = left + (right - left) / 2;
+
+        if (list->offsets[mid] == offset) {
+            return ((yp_line_column_t) { mid, 0 });
+        }
+
+        if (list->offsets[mid] < offset) {
+            left = mid + 1;
+        } else {
+            right = mid - 1;
+        }
+    }
+
+    return ((yp_line_column_t) { left - 1, offset - list->offsets[left - 1] });
+}
+
+// Returns the line and column of the given offset, assuming we know the last
+// index that we found.
+static yp_line_column_t
+yp_newline_list_line_column_scan(yp_newline_list_t *list, size_t offset) {
+    if (offset > list->last_offset) {
+        size_t index = list->last_index;
+        while (index < list->size && list->offsets[index] < offset) {
+            index++;
+        }
+
+        if (index == list->size) {
+            return ((yp_line_column_t) { index - 1, offset - list->offsets[index - 1] });
+        }
+
+        return ((yp_line_column_t) { index, 0 });
+    } else {
+        size_t index = list->last_index;
+        while (index > 0 && list->offsets[index] > offset) {
+            index--;
+        }
+
+        if (index == 0) {
+            return ((yp_line_column_t) { 0, offset });
+        }
+
+        return ((yp_line_column_t) { index, offset - list->offsets[index - 1] });
+    }
+}
+
+// Returns the line and column of the given offset. If the offset is not in the
+// list, the line and column of the closest offset less than the given offset
+// are returned.
+yp_line_column_t
+yp_newline_list_line_column(yp_newline_list_t *list, const char *cursor) {
+    assert(cursor >= list->start);
+    size_t offset = (size_t) (cursor - list->start);
+    yp_line_column_t result;
+
+    if (list->last_offset == 0) {
+        result = yp_newline_list_line_column_search(list, offset);
+    } else {
+        result = yp_newline_list_line_column_scan(list, offset);
+    }
+
+    list->last_index = result.line;
+    list->last_offset = offset;
+
+    return result;
+}
+
+// Free the internal memory allocated for the newline list.
+void
+yp_newline_list_free(yp_newline_list_t *list) {
+    free(list->offsets);
+}

data/src/util/yp_state_stack.c

@@ -0,0 +1,25 @@
+#include "yarp/util/yp_state_stack.h"
+
+// Initializes the state stack to an empty stack.
+void
+yp_state_stack_init(yp_state_stack_t *stack) {
+    *stack = 0;
+}
+
+// Pushes a value onto the stack.
+void
+yp_state_stack_push(yp_state_stack_t *stack, bool value) {
+    *stack = (*stack << 1) | (value & 1);
+}
+
+// Pops a value off the stack.
+void
+yp_state_stack_pop(yp_state_stack_t *stack) {
+    *stack >>= 1;
+}
+
+// Returns the value at the top of the stack.
+bool
+yp_state_stack_p(yp_state_stack_t *stack) {
+    return *stack & 1;
+}