prism 0.16.0 → 0.17.0

data/include/prism/util/pm_constant_pool.h

@@ -1,8 +1,12 @@
-// The constant pool is a data structure that stores a set of strings. Each
-// string is assigned a unique id, which can be used to compare strings for
-// equality. This comparison ends up being much faster than strcmp, since it
-// only requires a single integer comparison.
-
+/**
+ * @file pm_constant_pool.h
+ *
+ * A data structure that stores a set of strings.
+ *
+ * Each string is assigned a unique id, which can be used to compare strings for
+ * equality. This comparison ends up being much faster than strcmp, since it
+ * only requires a single integer comparison.
+ */
 #ifndef PRISM_CONSTANT_POOL_H
 #define PRISM_CONSTANT_POOL_H
 
@@ -14,84 +18,174 @@
 #include <stdlib.h>
 #include <string.h>
 
+/**
+ * A constant id is a unique identifier for a constant in the constant pool.
+ */
 typedef uint32_t pm_constant_id_t;
 
+/**
+ * A list of constant IDs. Usually used to represent a set of locals.
+ */
 typedef struct {
-    pm_constant_id_t *ids;
+    /** The number of constant ids in the list. */
     size_t size;
+
+    /** The number of constant ids that have been allocated in the list. */
     size_t capacity;
+
+    /** The constant ids in the list. */
+    pm_constant_id_t *ids;
 } pm_constant_id_list_t;
 
-// Initialize a list of constant ids.
+/**
+ * Initialize a list of constant ids.
+ *
+ * @param list The list to initialize.
+ */
 void pm_constant_id_list_init(pm_constant_id_list_t *list);
 
-// Append a constant id to a list of constant ids. Returns false if any
-// potential reallocations fail.
+/**
+ * Append a constant id to a list of constant ids. Returns false if any
+ * potential reallocations fail.
+ *
+ * @param list The list to append to.
+ * @param id The id to append.
+ * @return Whether the append succeeded.
+ */
 bool pm_constant_id_list_append(pm_constant_id_list_t *list, pm_constant_id_t id);
 
-// Checks if the current constant id list includes the given constant id.
-bool
-pm_constant_id_list_includes(pm_constant_id_list_t *list, pm_constant_id_t id);
-
-// Get the memory size of a list of constant ids.
+/**
+ * Checks if the current constant id list includes the given constant id.
+ *
+ * @param list The list to check.
+ * @param id The id to check for.
+ * @return Whether the list includes the given id.
+ */
+bool pm_constant_id_list_includes(pm_constant_id_list_t *list, pm_constant_id_t id);
+
+/**
+ * Get the memory size of a list of constant ids.
+ *
+ * @param list The list to get the memory size of.
+ * @return The memory size of the list.
+ */
 size_t pm_constant_id_list_memsize(pm_constant_id_list_t *list);
 
-// Free the memory associated with a list of constant ids.
+/**
+ * Free the memory associated with a list of constant ids.
+ *
+ * @param list The list to free.
+ */
 void pm_constant_id_list_free(pm_constant_id_list_t *list);
 
-// Constant pool buckets can have a couple of different types.
+/**
+ * The type of bucket in the constant pool hash map. This determines how the
+ * bucket should be freed.
+ */
 typedef unsigned int pm_constant_pool_bucket_type_t;
 
-// By default, each constant is a slice of the source.
+/** By default, each constant is a slice of the source. */
 static const pm_constant_pool_bucket_type_t PM_CONSTANT_POOL_BUCKET_DEFAULT = 0;
 
-// An owned constant is one for which memory has been allocated.
+/** An owned constant is one for which memory has been allocated. */
 static const pm_constant_pool_bucket_type_t PM_CONSTANT_POOL_BUCKET_OWNED = 1;
 
-// A constant constant is known at compile time.
+/** A constant constant is known at compile time. */
 static const pm_constant_pool_bucket_type_t PM_CONSTANT_POOL_BUCKET_CONSTANT = 2;
 
+/** A bucket in the hash map. */
 typedef struct {
+    /** The incremental ID used for indexing back into the pool. */
     unsigned int id: 30;
+
+    /** The type of the bucket, which determines how to free it. */
     pm_constant_pool_bucket_type_t type: 2;
+
+    /** The hash of the bucket. */
     uint32_t hash;
 } pm_constant_pool_bucket_t;
 
+/** A constant in the pool which effectively stores a string. */
 typedef struct {
+    /** A pointer to the start of the string. */
     const uint8_t *start;
+
+    /** The length of the string. */
     size_t length;
 } pm_constant_t;
 
+/** The overall constant pool, which stores constants found while parsing. */
 typedef struct {
+    /** The buckets in the hash map. */
     pm_constant_pool_bucket_t *buckets;
+
+    /** The constants that are stored in the buckets. */
     pm_constant_t *constants;
+
+    /** The number of buckets in the hash map. */
     uint32_t size;
+
+    /** The number of buckets that have been allocated in the hash map. */
     uint32_t capacity;
 } pm_constant_pool_t;
 
-// Define an empty constant pool.
-#define PM_CONSTANT_POOL_EMPTY ((pm_constant_pool_t) { .buckets = NULL, .constants = NULL, .size = 0, .capacity = 0 })
-
-// Initialize a new constant pool with a given capacity.
+/**
+ * Initialize a new constant pool with a given capacity.
+ *
+ * @param pool The pool to initialize.
+ * @param capacity The initial capacity of the pool.
+ * @return Whether the initialization succeeded.
+ */
 bool pm_constant_pool_init(pm_constant_pool_t *pool, uint32_t capacity);
 
-// Return a pointer to the constant indicated by the given constant id.
+/**
+ * Return a pointer to the constant indicated by the given constant id.
+ *
+ * @param pool The pool to get the constant from.
+ * @param constant_id The id of the constant to get.
+ * @return A pointer to the constant.
+ */
 pm_constant_t * pm_constant_pool_id_to_constant(const pm_constant_pool_t *pool, pm_constant_id_t constant_id);
 
-// Insert a constant into a constant pool that is a slice of a source string.
-// Returns the id of the constant, or 0 if any potential calls to resize fail.
+/**
+ * Insert a constant into a constant pool that is a slice of a source string.
+ * Returns the id of the constant, or 0 if any potential calls to resize fail.
+ *
+ * @param pool The pool to insert the constant into.
+ * @param start A pointer to the start of the constant.
+ * @param length The length of the constant.
+ * @return The id of the constant.
+ */
 pm_constant_id_t pm_constant_pool_insert_shared(pm_constant_pool_t *pool, const uint8_t *start, size_t length);
 
-// 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.
+/**
+ * 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.
+ *
+ * @param pool The pool to insert the constant into.
+ * @param start A pointer to the start of the constant.
+ * @param length The length of the constant.
+ * @return The id of the constant.
+ */
 pm_constant_id_t pm_constant_pool_insert_owned(pm_constant_pool_t *pool, const uint8_t *start, size_t length);
 
-// Insert a constant into a constant pool from memory that is constant. Returns
-// the id of the constant, or 0 if any potential calls to resize fail.
+/**
+ * Insert a constant into a constant pool from memory that is constant. Returns
+ * the id of the constant, or 0 if any potential calls to resize fail.
+ *
+ * @param pool The pool to insert the constant into.
+ * @param start A pointer to the start of the constant.
+ * @param length The length of the constant.
+ * @return The id of the constant.
+ */
 pm_constant_id_t pm_constant_pool_insert_constant(pm_constant_pool_t *pool, const uint8_t *start, size_t length);
 
-// Free the memory associated with a constant pool.
+/**
+ * Free the memory associated with a constant pool.
+ *
+ * @param pool The pool to free.
+ */
 void pm_constant_pool_free(pm_constant_pool_t *pool);
 
 #endif

data/include/prism/util/pm_list.h

@@ -1,30 +1,8 @@
-// This struct represents an abstract linked list that provides common
-// functionality. It is meant to be used any time a linked list is necessary to
-// store data.
-//
-// The linked list itself operates off a set of pointers. Because the pointers
-// are not necessarily sequential, they can be of any size. We use this fact to
-// allow the consumer of this linked list to extend the node struct to include
-// any data they want. This is done by using the pm_list_node_t as the first
-// member of the struct.
-//
-// For example, if we want to store a list of integers, we can do the following:
-//
-//     typedef struct {
-//       pm_list_node_t node;
-//       int value;
-//     } pm_int_node_t;
-//
-//     pm_list_t list = PM_LIST_EMPTY;
-//     pm_int_node_t *node = malloc(sizeof(pm_int_node_t));
-//     node->value = 5;
-//
-//     pm_list_append(&list, &node->node);
-//
-// The pm_list_t struct is used to represent the overall linked list. It
-// contains a pointer to the head and tail of the list. This allows for easy
-// iteration and appending of new nodes.
-
+/**
+ * @file pm_list.h
+ *
+ * An abstract linked list.
+ */
 #ifndef PRISM_LIST_H
 #define PRISM_LIST_H
 
@@ -35,33 +13,85 @@
 #include <stdint.h>
 #include <stdlib.h>
 
-// This represents a node in the linked list.
+/**
+ * This struct represents an abstract linked list that provides common
+ * functionality. It is meant to be used any time a linked list is necessary to
+ * store data.
+ *
+ * The linked list itself operates off a set of pointers. Because the pointers
+ * are not necessarily sequential, they can be of any size. We use this fact to
+ * allow the consumer of this linked list to extend the node struct to include
+ * any data they want. This is done by using the pm_list_node_t as the first
+ * member of the struct.
+ *
+ * For example, if we want to store a list of integers, we can do the following:
+ *
+ * ```c
+ * typedef struct {
+ *     pm_list_node_t node;
+ *     int value;
+ * } pm_int_node_t;
+ *
+ * pm_list_t list = { 0 };
+ * pm_int_node_t *node = malloc(sizeof(pm_int_node_t));
+ * node->value = 5;
+ *
+ * pm_list_append(&list, &node->node);
+ * ```
+ *
+ * The pm_list_t struct is used to represent the overall linked list. It
+ * contains a pointer to the head and tail of the list. This allows for easy
+ * iteration and appending of new nodes.
+ */
 typedef struct pm_list_node {
+    /** A pointer to the next node in the list. */
     struct pm_list_node *next;
 } pm_list_node_t;
 
-// This represents the overall linked list. It keeps a pointer to the head and
-// tail so that iteration is easy and pushing new nodes is easy.
+/**
+ * This represents the overall linked list. It keeps a pointer to the head and
+ * tail so that iteration is easy and pushing new nodes is easy.
+ */
 typedef struct {
+    /** The size of the list. */
     size_t size;
+
+    /** A pointer to the head of the list. */
     pm_list_node_t *head;
+
+    /** A pointer to the tail of the list. */
     pm_list_node_t *tail;
 } pm_list_t;
 
-// This represents an empty list. It's used to initialize a stack-allocated list
-// as opposed to a method call.
-#define PM_LIST_EMPTY ((pm_list_t) { .size = 0, .head = NULL, .tail = NULL })
-
-// Returns true if the given list is empty.
+/**
+ * Returns true if the given list is empty.
+ *
+ * @param list The list to check.
+ * @return True if the given list is empty, otherwise false.
+ */
 PRISM_EXPORTED_FUNCTION bool pm_list_empty_p(pm_list_t *list);
 
-// Returns the size of the list.
+/**
+ * Returns the size of the list.
+ *
+ * @param list The list to check.
+ * @return The size of the list.
+ */
 PRISM_EXPORTED_FUNCTION size_t pm_list_size(pm_list_t *list);
 
-// Append a node to the given list.
+/**
+ * Append a node to the given list.
+ *
+ * @param list The list to append to.
+ * @param node The node to append.
+ */
 void pm_list_append(pm_list_t *list, pm_list_node_t *node);
 
-// Deallocate the internal state of the given list.
+/**
+ * Deallocate the internal state of the given list.
+ *
+ * @param list The list to free.
+ */
 PRISM_EXPORTED_FUNCTION void pm_list_free(pm_list_t *list);
 
 #endif

data/include/prism/util/pm_memchr.h

@@ -1,3 +1,8 @@
+/**
+ * @file pm_memchr.h
+ *
+ * A custom memchr implementation.
+ */
 #ifndef PRISM_MEMCHR_H
 #define PRISM_MEMCHR_H
 
@@ -6,9 +11,19 @@
 
 #include <stddef.h>
 
-// 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.
+/**
+ * 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.
+ *
+ * @param source The source string.
+ * @param character The character to search for.
+ * @param number The maximum number of bytes to search.
+ * @param encoding_changed Whether the encoding changed.
+ * @param encoding A pointer to the encoding.
+ * @return A pointer to the first occurrence of the character in the source
+ *     string, or NULL if no such character exists.
+ */
 void * pm_memchr(const void *source, int character, size_t number, bool encoding_changed, pm_encoding_t *encoding);
 
 #endif

data/include/prism/util/pm_newline_list.h

@@ -1,11 +1,16 @@
-// When compiling the syntax tree, it's necessary to know the line and column
-// of many nodes. This is necessary to support things like error messages,
-// tracepoints, etc.
-//
-// It's possible that we could store the start line, start column, end line, and
-// end column on every node in addition to the offsets that we already store,
-// but that would be quite a lot of memory overhead.
-
+/**
+ * @file pm_newline_list.h
+ *
+ * A list of byte offsets of newlines in a string.
+ *
+ * When compiling the syntax tree, it's necessary to know the line and column
+ * of many nodes. This is necessary to support things like error messages,
+ * tracepoints, etc.
+ *
+ * It's possible that we could store the start line, start column, end line, and
+ * end column on every node in addition to the offsets that we already store,
+ * but that would be quite a lot of memory overhead.
+ */
 #ifndef PRISM_NEWLINE_LIST_H
 #define PRISM_NEWLINE_LIST_H
 
@@ -16,46 +21,84 @@
 #include <stddef.h>
 #include <stdlib.h>
 
-// A list of offsets of newlines in a string. The offsets are assumed to be
-// sorted/inserted in ascending order.
+/**
+ * A list of offsets of newlines in a string. The offsets are assumed to be
+ * sorted/inserted in ascending order.
+ */
 typedef struct {
+    /** A pointer to the start of the source string. */
     const uint8_t *start;
 
-    size_t *offsets;
+    /** The number of offsets in the list. */
     size_t size;
+
+    /** The capacity of the list that has been allocated. */
     size_t capacity;
 
-    size_t last_offset;
-    size_t last_index;
+    /** The list of offsets. */
+    size_t *offsets;
 } pm_newline_list_t;
 
-// A line and column in a string.
+/**
+ * A line and column in a string.
+ */
 typedef struct {
+    /** The line number. */
     size_t line;
+
+    /** The column number. */
     size_t column;
 } pm_line_column_t;
 
-#define PM_NEWLINE_LIST_EMPTY ((pm_newline_list_t) { \
-    .start = NULL, .offsets = NULL, .size = 0, .capacity = 0, .last_offset = 0, .last_index = 0 \
-})
-
-// Initialize a new newline list with the given capacity. Returns true if the
-// allocation of the offsets succeeds, otherwise returns false.
+/**
+ * Initialize a new newline list with the given capacity. Returns true if the
+ * allocation of the offsets succeeds, otherwise returns false.
+ *
+ * @param list The list to initialize.
+ * @param start A pointer to the start of the source string.
+ * @param capacity The initial capacity of the list.
+ * @return True if the allocation of the offsets succeeds, otherwise false.
+ */
 bool pm_newline_list_init(pm_newline_list_t *list, const uint8_t *start, size_t capacity);
 
-// Append a new offset to the newline list. Returns true if the reallocation of
-// the offsets succeeds (if one was necessary), otherwise returns false.
+/**
+ * Append a new offset to the newline list. Returns true if the reallocation of
+ * the offsets succeeds (if one was necessary), otherwise returns false.
+ *
+ * @param list The list to append to.
+ * @param cursor A pointer to the offset to append.
+ * @return True if the reallocation of the offsets succeeds (if one was
+ *     necessary), otherwise false.
+ */
 bool pm_newline_list_append(pm_newline_list_t *list, const uint8_t *cursor);
 
-// Conditionally append a new offset to the newline list, if the value passed in is a newline.
+/**
+ * Conditionally append a new offset to the newline list, if the value passed in
+ * is a newline.
+ *
+ * @param list The list to append to.
+ * @param cursor A pointer to the offset to append.
+ * @return True if the reallocation of the offsets succeeds (if one was
+ *     necessary), otherwise false.
+ */
 bool pm_newline_list_check_append(pm_newline_list_t *list, const uint8_t *cursor);
 
-// 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.
+/**
+ * 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.
+ *
+ * @param list The list to search.
+ * @param cursor A pointer to the offset to search for.
+ * @return The line and column of the given offset.
+ */
 pm_line_column_t pm_newline_list_line_column(const pm_newline_list_t *list, const uint8_t *cursor);
 
-// Free the internal memory allocated for the newline list.
+/**
+ * Free the internal memory allocated for the newline list.
+ *
+ * @param list The list to free.
+ */
 void pm_newline_list_free(pm_newline_list_t *list);
 
 #endif

data/include/prism/util/pm_state_stack.h

@@ -1,3 +1,8 @@
+/**
+ * @file pm_state_stack.h
+ *
+ * A stack of boolean values.
+ */
 #ifndef PRISM_STATE_STACK_H
 #define PRISM_STATE_STACK_H
 
@@ -6,19 +11,32 @@
 #include <stdbool.h>
 #include <stdint.h>
 
-// A struct that represents a stack of bools.
+/**
+ * A struct that represents a stack of boolean values.
+ */
 typedef uint32_t pm_state_stack_t;
 
-// Initializes the state stack to an empty stack.
-#define PM_STATE_STACK_EMPTY ((pm_state_stack_t) 0)
-
-// Pushes a value onto the stack.
+/**
+ * Pushes a value onto the stack.
+ *
+ * @param stack The stack to push the value onto.
+ * @param value The value to push onto the stack.
+ */
 void pm_state_stack_push(pm_state_stack_t *stack, bool value);
 
-// Pops a value off the stack.
+/**
+ * Pops a value off the stack.
+ *
+ * @param stack The stack to pop the value off of.
+ */
 void pm_state_stack_pop(pm_state_stack_t *stack);
 
-// Returns the value at the top of the stack.
+/**
+ * Returns the value at the top of the stack.
+ *
+ * @param stack The stack to get the value from.
+ * @return The value at the top of the stack.
+ */
 bool pm_state_stack_p(pm_state_stack_t *stack);
 
 #endif