herb 0.11.1 → 0.11.2

data/vendor/prism/include/prism/{encoding.h → internal/encoding.h}

@@ -1,128 +1,95 @@
-/**
- * @file encoding.h
- *
- * The encoding interface and implementations used by the parser.
- */
-#ifndef PRISM_ENCODING_H
-#define PRISM_ENCODING_H
-
-#include "prism/defines.h"
-#include "prism/util/pm_strncasecmp.h"
+#ifndef PRISM_INTERNAL_ENCODING_H
+#define PRISM_INTERNAL_ENCODING_H
 
-#include <assert.h>
 #include <stdbool.h>
 #include <stddef.h>
 #include <stdint.h>
 
-/**
+/*
  * This struct defines the functions necessary to implement the encoding
  * interface so we can determine how many bytes the subsequent character takes.
  * Each callback should return the number of bytes, or 0 if the next bytes are
  * invalid for the encoding and type.
  */
 typedef struct {
-    /**
+    /*
      * Return the number of bytes that the next character takes if it is valid
      * in the encoding. Does not read more than n bytes. It is assumed that n is
      * at least 1.
      */
     size_t (*char_width)(const uint8_t *b, ptrdiff_t n);
 
-    /**
+    /*
      * Return the number of bytes that the next character takes if it is valid
      * in the encoding and is alphabetical. Does not read more than n bytes. It
      * is assumed that n is at least 1.
      */
     size_t (*alpha_char)(const uint8_t *b, ptrdiff_t n);
 
-    /**
+    /*
      * Return the number of bytes that the next character takes if it is valid
      * in the encoding and is alphanumeric. Does not read more than n bytes. It
      * is assumed that n is at least 1.
      */
     size_t (*alnum_char)(const uint8_t *b, ptrdiff_t n);
 
-    /**
+    /*
      * Return true if the next character is valid in the encoding and is an
      * uppercase character. Does not read more than n bytes. It is assumed that
      * n is at least 1.
      */
     bool (*isupper_char)(const uint8_t *b, ptrdiff_t n);
 
-    /**
+    /*
      * The name of the encoding. This should correspond to a value that can be
      * passed to Encoding.find in Ruby.
      */
     const char *name;
 
-    /**
-     * Return true if the encoding is a multibyte encoding.
-     */
+    /* Return true if the encoding is a multibyte encoding. */
     bool multibyte;
 } pm_encoding_t;
 
-/**
+/*
  * All of the lookup tables use the first bit of each embedded byte to indicate
  * whether the codepoint is alphabetical.
  */
 #define PRISM_ENCODING_ALPHABETIC_BIT 1 << 0
 
-/**
+/*
  * All of the lookup tables use the second bit of each embedded byte to indicate
  * whether the codepoint is alphanumeric.
  */
 #define PRISM_ENCODING_ALPHANUMERIC_BIT 1 << 1
 
-/**
+/*
  * All of the lookup tables use the third bit of each embedded byte to indicate
  * whether the codepoint is uppercase.
  */
 #define PRISM_ENCODING_UPPERCASE_BIT 1 << 2
 
-/**
- * Return the size of the next character in the UTF-8 encoding.
- *
- * @param b The bytes to read.
- * @param n The number of bytes that can be read.
- * @returns The number of bytes that the next character takes if it is valid in
- *     the encoding, or 0 if it is not.
- */
+/* Return the size of the next character in the UTF-8 encoding. */
 size_t pm_encoding_utf_8_char_width(const uint8_t *b, ptrdiff_t n);
 
-/**
+/*
  * Return the size of the next character in the UTF-8 encoding if it is an
  * alphabetical character.
- *
- * @param b The bytes to read.
- * @param n The number of bytes that can be read.
- * @returns The number of bytes that the next character takes if it is valid in
- *     the encoding, or 0 if it is not.
  */
 size_t pm_encoding_utf_8_alpha_char(const uint8_t *b, ptrdiff_t n);
 
-/**
+/*
  * Return the size of the next character in the UTF-8 encoding if it is an
  * alphanumeric character.
- *
- * @param b The bytes to read.
- * @param n The number of bytes that can be read.
- * @returns The number of bytes that the next character takes if it is valid in
- *     the encoding, or 0 if it is not.
  */
 size_t pm_encoding_utf_8_alnum_char(const uint8_t *b, ptrdiff_t n);
 
-/**
+/*
  * Return true if the next character in the UTF-8 encoding if it is an uppercase
  * character.
- *
- * @param b The bytes to read.
- * @param n The number of bytes that can be read.
- * @returns True if the next character is valid in the encoding and is an
- *     uppercase character, or false if it is not.
  */
 bool pm_encoding_utf_8_isupper_char(const uint8_t *b, ptrdiff_t n);
 
-/**
+/*
  * This lookup table is referenced in both the UTF-8 encoding file and the
  * parser directly in order to speed up the default encoding processing. It is
  * used to indicate whether a character is alphabetical, alphanumeric, or
@@ -130,9 +97,7 @@ bool pm_encoding_utf_8_isupper_char(const uint8_t *b, ptrdiff_t n);
  */
 extern const uint8_t pm_encoding_unicode_table[256];
 
-/**
- * These are all of the encodings that prism supports.
- */
+/* These are all of the encodings that prism supports. */
 typedef enum {
     PM_ENCODING_UTF_8 = 0,
     PM_ENCODING_US_ASCII,
@@ -140,8 +105,8 @@ typedef enum {
     PM_ENCODING_EUC_JP,
     PM_ENCODING_WINDOWS_31J,
 
-// We optionally support excluding the full set of encodings to only support the
-// minimum necessary to process Ruby code without encoding comments.
+/* We optionally support excluding the full set of encodings to only support the
+ * minimum necessary to process Ruby code without encoding comments. */
 #ifndef PRISM_ENCODING_EXCLUDE_FULL
     PM_ENCODING_BIG5,
     PM_ENCODING_BIG5_HKSCS,
@@ -233,50 +198,44 @@ typedef enum {
     PM_ENCODING_MAXIMUM
 } pm_encoding_type_t;
 
-/**
- * This is the table of all of the encodings that prism supports.
- */
+/* This is the table of all of the encodings that prism supports. */
 extern const pm_encoding_t pm_encodings[PM_ENCODING_MAXIMUM];
 
-/**
+/*
  * This is the default UTF-8 encoding. We need a reference to it to quickly
  * create parsers.
  */
 #define PM_ENCODING_UTF_8_ENTRY (&pm_encodings[PM_ENCODING_UTF_8])
 
-/**
+/*
  * This is the US-ASCII encoding. We need a reference to it to be able to
  * compare against it when a string is being created because it could possibly
  * need to fall back to ASCII-8BIT.
  */
 #define PM_ENCODING_US_ASCII_ENTRY (&pm_encodings[PM_ENCODING_US_ASCII])
 
-/**
+/*
  * This is the ASCII-8BIT encoding. We need a reference to it so that pm_strpbrk
  * can compare against it because invalid multibyte characters are not a thing
  * in this encoding. It is also needed for handling Regexp encoding flags.
  */
 #define PM_ENCODING_ASCII_8BIT_ENTRY (&pm_encodings[PM_ENCODING_ASCII_8BIT])
 
-/**
+/*
  * This is the EUC-JP encoding. We need a reference to it to quickly process
  * regular expression modifiers.
  */
 #define PM_ENCODING_EUC_JP_ENTRY (&pm_encodings[PM_ENCODING_EUC_JP])
 
-/**
+/*
  * This is the Windows-31J encoding. We need a reference to it to quickly
  * process regular expression modifiers.
  */
 #define PM_ENCODING_WINDOWS_31J_ENTRY (&pm_encodings[PM_ENCODING_WINDOWS_31J])
 
-/**
+/*
  * Parse the given name of an encoding and return a pointer to the corresponding
  * encoding struct if one can be found, otherwise return NULL.
- *
- * @param start A pointer to the first byte of the name.
- * @param end A pointer to the last byte of the name.
- * @returns A pointer to the encoding struct if one is found, otherwise NULL.
  */
 const pm_encoding_t * pm_encoding_find(const uint8_t *start, const uint8_t *end);
 

data/vendor/prism/include/prism/internal/integer.h

@@ -0,0 +1,68 @@
+/*
+ * This module provides functions for working with arbitrary-sized integers.
+ */
+#ifndef PRISM_INTERNAL_INTEGER_H
+#define PRISM_INTERNAL_INTEGER_H
+
+#include "prism/buffer.h"
+#include "prism/integer.h"
+
+#include <stdint.h>
+
+/*
+ * An enum controlling the base of an integer. It is expected that the base is
+ * already known before parsing the integer, even though it could be derived
+ * from the string itself.
+ */
+typedef enum {
+    /* The default decimal base, with no prefix. Leading 0s will be ignored. */
+    PM_INTEGER_BASE_DEFAULT,
+
+    /* The binary base, indicated by a 0b or 0B prefix. */
+    PM_INTEGER_BASE_BINARY,
+
+    /* The octal base, indicated by a 0, 0o, or 0O prefix. */
+    PM_INTEGER_BASE_OCTAL,
+
+    /* The decimal base, indicated by a 0d, 0D, or empty prefix. */
+    PM_INTEGER_BASE_DECIMAL,
+
+    /* The hexadecimal base, indicated by a 0x or 0X prefix. */
+    PM_INTEGER_BASE_HEXADECIMAL,
+
+    /*
+     * An unknown base, in which case pm_integer_parse will derive it based on
+     * the content of the string. This is less efficient and does more
+     * comparisons, so if callers know the base ahead of time, they should use
+     * that instead.
+     */
+    PM_INTEGER_BASE_UNKNOWN
+} pm_integer_base_t;
+
+/*
+ * Parse an integer from a string. This assumes that the format of the integer
+ * has already been validated, as internal validation checks are not performed
+ * here.
+ */
+void pm_integer_parse(pm_integer_t *integer, pm_integer_base_t base, const uint8_t *start, const uint8_t *end);
+
+/*
+ * Compare two integers. This function returns -1 if the left integer is less
+ * than the right integer, 0 if they are equal, and 1 if the left integer is
+ * greater than the right integer.
+ */
+int pm_integer_compare(const pm_integer_t *left, const pm_integer_t *right);
+
+/*
+ * Reduce a ratio of integers to its simplest form.
+ *
+ * If either the numerator or denominator do not fit into a 32-bit integer, then
+ * this function is a no-op. In the future, we may consider reducing even the
+ * larger numbers, but for now we're going to keep it simple.
+ */
+void pm_integers_reduce(pm_integer_t *numerator, pm_integer_t *denominator);
+
+/* Convert an integer to a decimal string. */
+void pm_integer_string(pm_buffer_t *buffer, const pm_integer_t *integer);
+
+#endif

data/vendor/prism/include/prism/internal/isinf.h

@@ -0,0 +1,16 @@
+#ifndef PRISM_INTERNAL_ISINF_H
+#define PRISM_INTERNAL_ISINF_H
+
+/*
+ * isinf on POSIX systems accepts a float, a double, or a long double. But mingw
+ * didn't provide an isinf macro, only an isinf function that only accepts
+ * floats, so we need to use _finite instead.
+ */
+#ifdef __MINGW64__
+    #include <float.h>
+    #define PRISM_ISINF(x) (!_finite(x))
+#else
+    #define PRISM_ISINF(x) isinf(x)
+#endif
+
+#endif

data/vendor/prism/include/prism/internal/line_offset_list.h

@@ -0,0 +1,34 @@
+#ifndef PRISM_INTERNAL_LINE_OFFSET_LIST_H
+#define PRISM_INTERNAL_LINE_OFFSET_LIST_H
+
+#include "prism/compiler/force_inline.h"
+
+#include "prism/arena.h"
+#include "prism/line_offset_list.h"
+
+/* Initialize a new line offset list with the given capacity. */
+void pm_line_offset_list_init(pm_arena_t *arena, pm_line_offset_list_t *list, size_t capacity);
+
+/* Clear out the offsets that have been appended to the list. */
+void pm_line_offset_list_clear(pm_line_offset_list_t *list);
+
+/* Append a new offset to the list (slow path with resize). */
+void pm_line_offset_list_append_slow(pm_arena_t *arena, pm_line_offset_list_t *list, uint32_t cursor);
+
+/* Append a new offset to the list. */
+static PRISM_FORCE_INLINE void
+pm_line_offset_list_append(pm_arena_t *arena, pm_line_offset_list_t *list, uint32_t cursor) {
+    if (list->size < list->capacity) {
+        list->offsets[list->size++] = cursor;
+    } else {
+        pm_line_offset_list_append_slow(arena, list, cursor);
+    }
+}
+
+/*
+ * Returns the line of the given offset. If the offset is not in the list, the
+ * line of the closest offset less than the given offset is returned.
+ */
+int32_t pm_line_offset_list_line(const pm_line_offset_list_t *list, uint32_t cursor, int32_t start_line);
+
+#endif

data/vendor/prism/include/prism/{util/pm_list.h → internal/list.h}

@@ -1,19 +1,9 @@
-/**
- * @file pm_list.h
- *
- * An abstract linked list.
- */
-#ifndef PRISM_LIST_H
-#define PRISM_LIST_H
+#ifndef PRISM_INTERNAL_LIST_H
+#define PRISM_INTERNAL_LIST_H
 
-#include "prism/defines.h"
-
-#include <stdbool.h>
 #include <stddef.h>
-#include <stdint.h>
-#include <stdlib.h>
 
-/**
+/*
  * 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.
@@ -44,60 +34,29 @@
  * iteration and appending of new nodes.
  */
 typedef struct pm_list_node {
-    /** A pointer to the next node in the list. */
+    /* 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.
  */
 typedef struct {
-    /** The size of the list. */
+    /* The size of the list. */
     size_t size;
 
-    /** A pointer to the head of the list. */
+    /* A pointer to the head of the list. */
     pm_list_node_t *head;
 
-    /** A pointer to the tail of the list. */
+    /* A pointer to the tail of the list. */
     pm_list_node_t *tail;
 } pm_list_t;
 
-/**
- * Returns true if the given list is empty.
- *
- * @param list The list to check.
- * @return True if the given list is empty, otherwise false.
- *
- * \public \memberof pm_list_t
- */
-PRISM_EXPORTED_FUNCTION bool pm_list_empty_p(pm_list_t *list);
-
-/**
- * Returns the size of the list.
- *
- * @param list The list to check.
- * @return The size of the list.
- *
- * \public \memberof pm_list_t
- */
-PRISM_EXPORTED_FUNCTION size_t pm_list_size(pm_list_t *list);
+/* Returns the size of the list. */
+size_t pm_list_size(pm_list_t *list);
 
-/**
- * Append a node to the given list.
- *
- * @param list The list to append to.
- * @param node The node to append.
- */
+/* Append a node to the given list. */
 void pm_list_append(pm_list_t *list, pm_list_node_t *node);
 
-/**
- * Deallocate the internal state of the given list.
- *
- * @param list The list to free.
- *
- * \public \memberof pm_list_t
- */
-PRISM_EXPORTED_FUNCTION void pm_list_free(pm_list_t *list);
-
 #endif

data/vendor/prism/include/prism/internal/magic_comments.h

@@ -0,0 +1,23 @@
+#ifndef PRISM_INTERNAL_MAGIC_COMMENTS_H
+#define PRISM_INTERNAL_MAGIC_COMMENTS_H
+
+#include "prism/magic_comments.h"
+
+#include "prism/internal/list.h"
+
+/*
+ * This is a node in the linked list of magic comments that we've found while
+ * parsing.
+ */
+struct pm_magic_comment_t {
+    /* The embedded base node. */
+    pm_list_node_t node;
+
+    /* The key of the magic comment. */
+    pm_location_t key;
+
+    /* The value of the magic comment. */
+    pm_location_t value;
+};
+
+#endif

data/vendor/prism/include/prism/internal/memchr.h

@@ -0,0 +1,15 @@
+#ifndef PRISM_INTERNAL_MEMCHR_H
+#define PRISM_INTERNAL_MEMCHR_H
+
+#include "prism/internal/encoding.h"
+
+#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.
+ */
+const void * pm_memchr(const void *source, int character, size_t number, bool encoding_changed, const pm_encoding_t *encoding);
+
+#endif

data/vendor/prism/include/prism/internal/node.h

@@ -0,0 +1,42 @@
+#ifndef PRISM_INTERNAL_NODE_H
+#define PRISM_INTERNAL_NODE_H
+
+#include "prism/node.h"
+
+#include "prism/compiler/force_inline.h"
+
+#include "prism/arena.h"
+
+/* The offset of the start of the given location. */
+#define PM_LOCATION_START(location_) ((location_)->start)
+
+/* The offset just past the end of the given location. */
+#define PM_LOCATION_END(location_) ((location_)->start + (location_)->length)
+
+/*
+ * Slow path for pm_node_list_append_inline: grow the list and append the node.
+ * Do not call directly — use pm_node_list_append_inline instead.
+ */
+void pm_node_list_append_slow(pm_arena_t *arena, pm_node_list_t *list, pm_node_t *node);
+
+/*
+ * Append a new node onto the end of the node list, handling the common case
+ * inline and growing the list through pm_node_list_append_slow. This is the
+ * version for prism's own code; others call the exported pm_node_list_append.
+ */
+static PRISM_FORCE_INLINE void
+pm_node_list_append_inline(pm_arena_t *arena, pm_node_list_t *list, pm_node_t *node) {
+    if (list->size < list->capacity) {
+        list->nodes[list->size++] = node;
+    } else {
+        pm_node_list_append_slow(arena, list, node);
+    }
+}
+
+/* Prepend a new node onto the beginning of the node list. */
+void pm_node_list_prepend(pm_arena_t *arena, pm_node_list_t *list, pm_node_t *node);
+
+/* Concatenate the given node list onto the end of the other node list. */
+void pm_node_list_concat(pm_arena_t *arena, pm_node_list_t *list, pm_node_list_t *other);
+
+#endif