yarp 0.12.0 → 0.13.0

data/src/util/{yp_char.c → pm_char.c}

@@ -1,19 +1,19 @@
-#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 uint8_t yp_byte_table[256] = {
+#include "prism/util/pm_char.h"
+
+#define PRISM_CHAR_BIT_WHITESPACE (1 << 0)
+#define PRISM_CHAR_BIT_INLINE_WHITESPACE (1 << 1)
+#define PRISM_CHAR_BIT_REGEXP_OPTION (1 << 2)
+
+#define PRISM_NUMBER_BIT_BINARY_DIGIT (1 << 0)
+#define PRISM_NUMBER_BIT_BINARY_NUMBER (1 << 1)
+#define PRISM_NUMBER_BIT_OCTAL_DIGIT (1 << 2)
+#define PRISM_NUMBER_BIT_OCTAL_NUMBER (1 << 3)
+#define PRISM_NUMBER_BIT_DECIMAL_DIGIT (1 << 4)
+#define PRISM_NUMBER_BIT_DECIMAL_NUMBER (1 << 5)
+#define PRISM_NUMBER_BIT_HEXADECIMAL_DIGIT (1 << 6)
+#define PRISM_NUMBER_BIT_HEXADECIMAL_NUMBER (1 << 7)
+
+static const uint8_t pm_byte_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
@@ -33,7 +33,7 @@ static const uint8_t yp_byte_table[256] = {
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Fx
 };
 
-static const uint8_t yp_number_table[256] = {
+static const uint8_t pm_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
@@ -54,36 +54,36 @@ static const uint8_t yp_number_table[256] = {
 };
 
 static inline size_t
-yp_strspn_char_kind(const uint8_t *string, ptrdiff_t length, uint8_t kind) {
+pm_strspn_char_kind(const uint8_t *string, ptrdiff_t length, uint8_t kind) {
     if (length <= 0) return 0;
 
     size_t size = 0;
     size_t maximum = (size_t) length;
 
-    while (size < maximum && (yp_byte_table[string[size]] & kind)) size++;
+    while (size < maximum && (pm_byte_table[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 uint8_t *string, ptrdiff_t length) {
-    return yp_strspn_char_kind(string, length, YP_CHAR_BIT_WHITESPACE);
+pm_strspn_whitespace(const uint8_t *string, ptrdiff_t length) {
+    return pm_strspn_char_kind(string, length, PRISM_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 uint8_t *string, ptrdiff_t length, yp_newline_list_t *newline_list) {
+pm_strspn_whitespace_newlines(const uint8_t *string, ptrdiff_t length, pm_newline_list_t *newline_list) {
     if (length <= 0) return 0;
 
     size_t size = 0;
     size_t maximum = (size_t) length;
 
-    while (size < maximum && (yp_byte_table[string[size]] & YP_CHAR_BIT_WHITESPACE)) {
+    while (size < maximum && (pm_byte_table[string[size]] & PRISM_CHAR_BIT_WHITESPACE)) {
         if (string[size] == '\n') {
-            yp_newline_list_append(newline_list, string + size);
+            pm_newline_list_append(newline_list, string + size);
         }
 
         size++;
@@ -95,45 +95,45 @@ yp_strspn_whitespace_newlines(const uint8_t *string, ptrdiff_t length, yp_newlin
 // 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 uint8_t *string, ptrdiff_t length) {
-    return yp_strspn_char_kind(string, length, YP_CHAR_BIT_INLINE_WHITESPACE);
+pm_strspn_inline_whitespace(const uint8_t *string, ptrdiff_t length) {
+    return pm_strspn_char_kind(string, length, PRISM_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 uint8_t *string, ptrdiff_t length) {
-    return yp_strspn_char_kind(string, length, YP_CHAR_BIT_REGEXP_OPTION);
+pm_strspn_regexp_option(const uint8_t *string, ptrdiff_t length) {
+    return pm_strspn_char_kind(string, length, PRISM_CHAR_BIT_REGEXP_OPTION);
 }
 
 static inline bool
-yp_char_is_char_kind(const uint8_t b, uint8_t kind) {
-    return (yp_byte_table[b] & kind) != 0;
+pm_char_is_char_kind(const uint8_t b, uint8_t kind) {
+    return (pm_byte_table[b] & kind) != 0;
 }
 
 // Returns true if the given character is a whitespace character.
 bool
-yp_char_is_whitespace(const uint8_t b) {
-    return yp_char_is_char_kind(b, YP_CHAR_BIT_WHITESPACE);
+pm_char_is_whitespace(const uint8_t b) {
+    return pm_char_is_char_kind(b, PRISM_CHAR_BIT_WHITESPACE);
 }
 
 // Returns true if the given character is an inline whitespace character.
 bool
-yp_char_is_inline_whitespace(const uint8_t b) {
-    return yp_char_is_char_kind(b, YP_CHAR_BIT_INLINE_WHITESPACE);
+pm_char_is_inline_whitespace(const uint8_t b) {
+    return pm_char_is_char_kind(b, PRISM_CHAR_BIT_INLINE_WHITESPACE);
 }
 
 // Scan through the string and return the number of characters at the start of
 // the string that match the given kind. Disallows searching past the given
 // maximum number of characters.
 static inline size_t
-yp_strspn_number_kind(const uint8_t *string, ptrdiff_t length, uint8_t kind) {
+pm_strspn_number_kind(const uint8_t *string, ptrdiff_t length, uint8_t kind) {
     if (length <= 0) return 0;
 
     size_t size = 0;
     size_t maximum = (size_t) length;
 
-    while (size < maximum && (yp_number_table[string[size]] & kind)) size++;
+    while (size < maximum && (pm_number_table[string[size]] & kind)) size++;
     return size;
 }
 
@@ -144,14 +144,14 @@ yp_strspn_number_kind(const uint8_t *string, ptrdiff_t length, uint8_t kind) {
 // Additionally, report the location of the last invalid underscore character
 // found in the string through the out invalid parameter.
 static inline size_t
-yp_strspn_number_kind_underscores(const uint8_t *string, ptrdiff_t length, const uint8_t **invalid, uint8_t kind) {
+pm_strspn_number_kind_underscores(const uint8_t *string, ptrdiff_t length, const uint8_t **invalid, uint8_t kind) {
     if (length <= 0) return 0;
 
     size_t size = 0;
     size_t maximum = (size_t) length;
 
     bool underscore = false;
-    while (size < maximum && (yp_number_table[string[size]] & kind)) {
+    while (size < maximum && (pm_number_table[string[size]] & kind)) {
         if (string[size] == '_') {
             if (underscore) *invalid = string + size;
             underscore = true;
@@ -174,8 +174,8 @@ yp_strspn_number_kind_underscores(const uint8_t *string, ptrdiff_t length, const
 // found at the end of the number, then the invalid pointer is set to the index
 // of the first invalid underscore.
 size_t
-yp_strspn_binary_number(const uint8_t *string, ptrdiff_t length, const uint8_t **invalid) {
-    return yp_strspn_number_kind_underscores(string, length, invalid, YP_NUMBER_BIT_BINARY_NUMBER);
+pm_strspn_binary_number(const uint8_t *string, ptrdiff_t length, const uint8_t **invalid) {
+    return pm_strspn_number_kind_underscores(string, length, invalid, PRISM_NUMBER_BIT_BINARY_NUMBER);
 }
 
 // Returns the number of characters at the start of the string that are octal
@@ -186,15 +186,15 @@ yp_strspn_binary_number(const uint8_t *string, ptrdiff_t length, const uint8_t *
 // found at the end of the number, then the invalid pointer is set to the index
 // of the first invalid underscore.
 size_t
-yp_strspn_octal_number(const uint8_t *string, ptrdiff_t length, const uint8_t **invalid) {
-    return yp_strspn_number_kind_underscores(string, length, invalid, YP_NUMBER_BIT_OCTAL_NUMBER);
+pm_strspn_octal_number(const uint8_t *string, ptrdiff_t length, const uint8_t **invalid) {
+    return pm_strspn_number_kind_underscores(string, length, invalid, PRISM_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 uint8_t *string, ptrdiff_t length) {
-    return yp_strspn_number_kind(string, length, YP_NUMBER_BIT_DECIMAL_DIGIT);
+pm_strspn_decimal_digit(const uint8_t *string, ptrdiff_t length) {
+    return pm_strspn_number_kind(string, length, PRISM_NUMBER_BIT_DECIMAL_DIGIT);
 }
 
 // Returns the number of characters at the start of the string that are decimal
@@ -205,16 +205,16 @@ yp_strspn_decimal_digit(const uint8_t *string, ptrdiff_t length) {
 // found at the end of the number, then the invalid pointer is set to the index
 // of the first invalid underscore.
 size_t
-yp_strspn_decimal_number(const uint8_t *string, ptrdiff_t length, const uint8_t **invalid) {
-    return yp_strspn_number_kind_underscores(string, length, invalid, YP_NUMBER_BIT_DECIMAL_NUMBER);
+pm_strspn_decimal_number(const uint8_t *string, ptrdiff_t length, const uint8_t **invalid) {
+    return pm_strspn_number_kind_underscores(string, length, invalid, PRISM_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 uint8_t *string, ptrdiff_t length) {
-    return yp_strspn_number_kind(string, length, YP_NUMBER_BIT_HEXADECIMAL_DIGIT);
+pm_strspn_hexadecimal_digit(const uint8_t *string, ptrdiff_t length) {
+    return pm_strspn_number_kind(string, length, PRISM_NUMBER_BIT_HEXADECIMAL_DIGIT);
 }
 
 // Returns the number of characters at the start of the string that are
@@ -225,48 +225,48 @@ yp_strspn_hexadecimal_digit(const uint8_t *string, ptrdiff_t length) {
 // found at the end of the number, then the invalid pointer is set to the index
 // of the first invalid underscore.
 size_t
-yp_strspn_hexadecimal_number(const uint8_t *string, ptrdiff_t length, const uint8_t **invalid) {
-    return yp_strspn_number_kind_underscores(string, length, invalid, YP_NUMBER_BIT_HEXADECIMAL_NUMBER);
+pm_strspn_hexadecimal_number(const uint8_t *string, ptrdiff_t length, const uint8_t **invalid) {
+    return pm_strspn_number_kind_underscores(string, length, invalid, PRISM_NUMBER_BIT_HEXADECIMAL_NUMBER);
 }
 
 static inline bool
-yp_char_is_number_kind(const uint8_t b, uint8_t kind) {
-    return (yp_number_table[b] & kind) != 0;
+pm_char_is_number_kind(const uint8_t b, uint8_t kind) {
+    return (pm_number_table[b] & kind) != 0;
 }
 
 // Returns true if the given character is a binary digit.
 bool
-yp_char_is_binary_digit(const uint8_t b) {
-    return yp_char_is_number_kind(b, YP_NUMBER_BIT_BINARY_DIGIT);
+pm_char_is_binary_digit(const uint8_t b) {
+    return pm_char_is_number_kind(b, PRISM_NUMBER_BIT_BINARY_DIGIT);
 }
 
 // Returns true if the given character is an octal digit.
 bool
-yp_char_is_octal_digit(const uint8_t b) {
-    return yp_char_is_number_kind(b, YP_NUMBER_BIT_OCTAL_DIGIT);
+pm_char_is_octal_digit(const uint8_t b) {
+    return pm_char_is_number_kind(b, PRISM_NUMBER_BIT_OCTAL_DIGIT);
 }
 
 // Returns true if the given character is a decimal digit.
 bool
-yp_char_is_decimal_digit(const uint8_t b) {
-    return yp_char_is_number_kind(b, YP_NUMBER_BIT_DECIMAL_DIGIT);
+pm_char_is_decimal_digit(const uint8_t b) {
+    return pm_char_is_number_kind(b, PRISM_NUMBER_BIT_DECIMAL_DIGIT);
 }
 
 // Returns true if the given character is a hexadecimal digit.
 bool
-yp_char_is_hexadecimal_digit(const uint8_t b) {
-    return yp_char_is_number_kind(b, YP_NUMBER_BIT_HEXADECIMAL_DIGIT);
+pm_char_is_hexadecimal_digit(const uint8_t b) {
+    return pm_char_is_number_kind(b, PRISM_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
+#undef PRISM_CHAR_BIT_WHITESPACE
+#undef PRISM_CHAR_BIT_INLINE_WHITESPACE
+#undef PRISM_CHAR_BIT_REGEXP_OPTION
+
+#undef PRISM_NUMBER_BIT_BINARY_DIGIT
+#undef PRISM_NUMBER_BIT_BINARY_NUMBER
+#undef PRISM_NUMBER_BIT_OCTAL_DIGIT
+#undef PRISM_NUMBER_BIT_OCTAL_NUMBER
+#undef PRISM_NUMBER_BIT_DECIMAL_DIGIT
+#undef PRISM_NUMBER_BIT_DECIMAL_NUMBER
+#undef PRISM_NUMBER_BIT_HEXADECIMAL_NUMBER
+#undef PRISM_NUMBER_BIT_HEXADECIMAL_DIGIT

data/src/util/{yp_constant_pool.c → pm_constant_pool.c}

@@ -1,8 +1,8 @@
-#include "yarp/util/yp_constant_pool.h"
+#include "prism/util/pm_constant_pool.h"
 
 // Initialize a list of constant ids.
 void
-yp_constant_id_list_init(yp_constant_id_list_t *list) {
+pm_constant_id_list_init(pm_constant_id_list_t *list) {
     list->ids = NULL;
     list->size = 0;
     list->capacity = 0;
@@ -11,10 +11,10 @@ yp_constant_id_list_init(yp_constant_id_list_t *list) {
 // 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) {
+pm_constant_id_list_append(pm_constant_id_list_t *list, pm_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);
+        list->ids = (pm_constant_id_t *) realloc(list->ids, sizeof(pm_constant_id_t) * list->capacity);
         if (list->ids == NULL) return false;
     }
 
@@ -24,7 +24,7 @@ yp_constant_id_list_append(yp_constant_id_list_t *list, yp_constant_id_t id) {
 
 // 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) {
+pm_constant_id_list_includes(pm_constant_id_list_t *list, pm_constant_id_t id) {
     for (size_t index = 0; index < list->size; index++) {
         if (list->ids[index] == id) return true;
     }
@@ -33,13 +33,13 @@ yp_constant_id_list_includes(yp_constant_id_list_t *list, yp_constant_id_t id) {
 
 // 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));
+pm_constant_id_list_memsize(pm_constant_id_list_t *list) {
+    return sizeof(pm_constant_id_list_t) + (list->capacity * sizeof(pm_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) {
+pm_constant_id_list_free(pm_constant_id_list_t *list) {
     if (list->ids != NULL) {
         free(list->ids);
     }
@@ -47,10 +47,10 @@ yp_constant_id_list_free(yp_constant_id_list_t *list) {
 
 // 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 uint8_t *start, size_t length) {
+static inline uint32_t
+pm_constant_pool_hash(const uint8_t *start, size_t length) {
     // This is a prime number used as the initial value for the hash function.
-    size_t value = 5381;
+    uint32_t value = 5381;
 
     for (size_t index = 0; index < length; index++) {
         value = ((value << 5) + value) + start[index];
@@ -60,8 +60,8 @@ yp_constant_pool_hash(const uint8_t *start, size_t length) {
 }
 
 // https://graphics.stanford.edu/~seander/bithacks.html#RoundUpPowerOf2
-static size_t
-next_power_of_two(size_t v) {
+static uint32_t
+next_power_of_two(uint32_t v) {
     // Avoid underflow in subtraction on next line.
     if (v == 0) {
         // 1 is the nearest power of 2 to 0 (2^0)
@@ -73,92 +73,107 @@ next_power_of_two(size_t v) {
     v |= v >> 4;
     v |= v >> 8;
     v |= v >> 16;
-#if defined(__LP64__) || defined(_WIN64)
-    v |= v >> 32;
-#endif
     v++;
     return v;
 }
 
 #ifndef NDEBUG
 static bool
-is_power_of_two(size_t size) {
+is_power_of_two(uint32_t size) {
     return (size & (size - 1)) == 0;
 }
 #endif
 
 // Resize a constant pool to a given capacity.
 static inline bool
-yp_constant_pool_resize(yp_constant_pool_t *pool) {
+pm_constant_pool_resize(pm_constant_pool_t *pool) {
     assert(is_power_of_two(pool->capacity));
-    size_t next_capacity = pool->capacity * 2;
+
+    uint32_t next_capacity = pool->capacity * 2;
     if (next_capacity < pool->capacity) return false;
 
-    const size_t mask = next_capacity - 1;
-    yp_constant_t *next_constants = calloc(next_capacity, sizeof(yp_constant_t));
-    if (next_constants == NULL) return false;
+    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);
+    if (next == 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];
+    pm_constant_pool_bucket_t *next_buckets = next;
+    pm_constant_t *next_constants = (void *)(((char *) next) + next_capacity * sizeof(pm_constant_pool_bucket_t));
+
+    // For each bucket in the current constant pool, find the index in the
+    // next constant pool, and insert it.
+    for (uint32_t index = 0; index < pool->capacity; index++) {
+        pm_constant_pool_bucket_t *bucket = &pool->buckets[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 & mask;
+        if (bucket->id != 0) {
+            uint32_t next_index = bucket->hash & mask;
 
             // 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) {
+            while (next_buckets[next_index].id != 0) {
                 next_index = (next_index + 1) & mask;
             }
 
-            // Here we copy over the entire constant, which includes the id so
+            // Here we copy over the entire bucket, which includes the id so
             // that they are consistent between resizes.
-            next_constants[next_index] = *constant;
+            next_buckets[next_index] = *bucket;
         }
     }
 
-    free(pool->constants);
+    // The constants are stable with respect to hash table resizes.
+    memcpy(next_constants, pool->constants, pool->size * sizeof(pm_constant_t));
+
+    // pool->constants and pool->buckets are allocated out of the same chunk
+    // of memory, with the buckets coming first.
+    free(pool->buckets);
     pool->constants = next_constants;
+    pool->buckets = next_buckets;
     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) {
-    const size_t size_t_max = (~((size_t) 0));
-    if (capacity >= ((size_t_max / 2) + 1)) return false;
+pm_constant_pool_init(pm_constant_pool_t *pool, uint32_t capacity) {
+    const uint32_t maximum = (~((uint32_t) 0));
+    if (capacity >= ((maximum / 2) + 1)) return false;
 
     capacity = next_power_of_two(capacity);
-    pool->constants = calloc(capacity, sizeof(yp_constant_t));
-    if (pool->constants == NULL) return false;
+    const size_t element_size = sizeof(pm_constant_pool_bucket_t) + sizeof(pm_constant_t);
+    void *memory = calloc(capacity, element_size);
+    if (memory == NULL) return false;
 
+    pool->buckets = memory;
+    pool->constants = (void *)(((char *)memory) + capacity * sizeof(pm_constant_pool_bucket_t));
     pool->size = 0;
     pool->capacity = capacity;
     return true;
 }
 
 // Insert a constant into a constant pool and return its index in the pool.
-static inline yp_constant_id_t
-yp_constant_pool_insert(yp_constant_pool_t *pool, const uint8_t *start, size_t length, bool owned) {
+static inline pm_constant_id_t
+pm_constant_pool_insert(pm_constant_pool_t *pool, const uint8_t *start, size_t length, bool owned) {
     if (pool->size >= (pool->capacity / 4 * 3)) {
-        if (!yp_constant_pool_resize(pool)) return 0;
+        if (!pm_constant_pool_resize(pool)) return 0;
     }
 
     assert(is_power_of_two(pool->capacity));
-    const size_t mask = pool->capacity - 1;
-    size_t hash = yp_constant_pool_hash(start, length);
-    size_t index = hash & mask;
-    yp_constant_t *constant;
+    const uint32_t mask = pool->capacity - 1;
 
-    while (constant = &pool->constants[index], constant->id != 0) {
+    uint32_t hash = pm_constant_pool_hash(start, length);
+    uint32_t index = hash & mask;
+    pm_constant_pool_bucket_t *bucket;
+
+    while (bucket = &pool->buckets[index], bucket->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.
+        pm_constant_t *constant = &pool->constants[bucket->id - 1];
+
         if ((constant->length == length) && memcmp(constant->start, start, length) == 0) {
             // Since we have found a match, we need to check if this is
             // attempting to insert a shared or an owned constant. We want to
@@ -169,63 +184,69 @@ yp_constant_pool_insert(yp_constant_pool_t *pool, const uint8_t *start, size_t l
                 // memory. Either it's duplicated with the existing constant or
                 // it's not necessary because we have a shared version.
                 free((void *) start);
-            } else if (constant->owned) {
+            } else if (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);
                 constant->start = start;
-                constant->owned = false;
+                bucket->owned = false;
             }
 
-            return constant->id;
+            return bucket->id;
         }
 
         index = (index + 1) & mask;
     }
 
-    pool->size++;
-    assert(pool->size < ((size_t) (1 << 31)));
+    // IDs are allocated starting at 1, since the value 0 denotes a non-existant
+    // constant.
+    uint32_t id = ++pool->size;
+    assert(pool->size < ((uint32_t) (1 << 31)));
 
-    *constant = (yp_constant_t) {
-        .id = (unsigned int) (pool->size & 0x7FFFFFFF),
+    *bucket = (pm_constant_pool_bucket_t) {
+        .id = (unsigned int) (id & 0x7FFFFFFF),
         .owned = owned,
+        .hash = hash
+    };
+
+    pool->constants[id - 1]  = (pm_constant_t) {
         .start = start,
         .length = length,
-        .hash = hash
     };
 
-    return constant->id;
+    return id;
 }
 
 // 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_shared(yp_constant_pool_t *pool, const uint8_t *start, size_t length) {
-    return yp_constant_pool_insert(pool, start, length, false);
+pm_constant_id_t
+pm_constant_pool_insert_shared(pm_constant_pool_t *pool, const uint8_t *start, size_t length) {
+    return pm_constant_pool_insert(pool, start, length, false);
 }
 
 // Insert a constant into a constant pool from memory that is now owned by the
 // 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_owned(yp_constant_pool_t *pool, const uint8_t *start, size_t length) {
-    return yp_constant_pool_insert(pool, start, length, true);
+pm_constant_id_t
+pm_constant_pool_insert_owned(pm_constant_pool_t *pool, const uint8_t *start, size_t length) {
+    return pm_constant_pool_insert(pool, start, length, true);
 }
 
 // Free the memory associated with a constant pool.
 void
-yp_constant_pool_free(yp_constant_pool_t *pool) {
+pm_constant_pool_free(pm_constant_pool_t *pool) {
     // For each constant in the current constant pool, free the contents if the
     // contents are owned.
     for (uint32_t index = 0; index < pool->capacity; index++) {
-        yp_constant_t *constant = &pool->constants[index];
+        pm_constant_pool_bucket_t *bucket = &pool->buckets[index];
 
         // If an id is set on this constant, then we know we have content here.
-        if (constant->id != 0 && constant->owned) {
+        if (bucket->id != 0 && bucket->owned) {
+            pm_constant_t *constant = &pool->constants[bucket->id - 1];
             free((void *) constant->start);
         }
     }
 
-    free(pool->constants);
+    free(pool->buckets);
 }

data/src/util/{yp_list.c → pm_list.c}

@@ -1,20 +1,20 @@
-#include "yarp/util/yp_list.h"
+#include "prism/util/pm_list.h"
 
 // Returns true if the given list is empty.
-YP_EXPORTED_FUNCTION bool
-yp_list_empty_p(yp_list_t *list) {
+PRISM_EXPORTED_FUNCTION bool
+pm_list_empty_p(pm_list_t *list) {
     return list->head == NULL;
 }
 
 // Returns the size of the list.
-YP_EXPORTED_FUNCTION size_t
-yp_list_size(yp_list_t *list) {
+PRISM_EXPORTED_FUNCTION size_t
+pm_list_size(pm_list_t *list) {
     return list->size;
 }
 
 // Append a node to the given list.
 void
-yp_list_append(yp_list_t *list, yp_list_node_t *node) {
+pm_list_append(pm_list_t *list, pm_list_node_t *node) {
     if (list->head == NULL) {
         list->head = node;
     } else {
@@ -26,10 +26,10 @@ yp_list_append(yp_list_t *list, yp_list_node_t *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;
+PRISM_EXPORTED_FUNCTION void
+pm_list_free(pm_list_t *list) {
+    pm_list_node_t *node = list->head;
+    pm_list_node_t *next;
 
     while (node != NULL) {
         next = node->next;

data/src/util/{yp_memchr.c → pm_memchr.c}

@@ -1,13 +1,13 @@
-#include "yarp/util/yp_memchr.h"
+#include "prism/util/pm_memchr.h"
 
-#define YP_MEMCHR_TRAILING_BYTE_MINIMUM 0x40
+#define PRISM_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) {
+pm_memchr(const void *memory, int character, size_t number, bool encoding_changed, pm_encoding_t *encoding) {
+    if (encoding_changed && encoding->multibyte && character >= PRISM_MEMCHR_TRAILING_BYTE_MINIMUM) {
         const uint8_t *source = (const uint8_t *) memory;
         size_t index = 0;
 
@@ -29,3 +29,5 @@ yp_memchr(const void *memory, int character, size_t number, bool encoding_change
         return memchr(memory, character, number);
     }
 }
+
+#undef PRISM_MEMCHR_TRAILING_BYTE_MINIMUM