vlang
diff --git a/Collapse file
‎thirdparty/libgc/gc.c‎
Copy file name to clipboard
+37,641-33,847Lines changed: 37641 additions & 33847 deletions b/Collapse file
‎thirdparty/libgc/gc.c‎
Copy file name to clipboard
+37,641-33,847Lines changed: 37641 additions & 33847 deletions
diff --git a/Collapse file
‎thirdparty/libgc/include/gc/cord.h‎
Copy file name to clipboard
+323-280Lines changed: 323 additions & 280 deletions b/Collapse file
‎thirdparty/libgc/include/gc/cord.h‎
Copy file name to clipboard
+323-280Lines changed: 323 additions & 280 deletions
diff --git a/Collapse file
‎thirdparty/libgc/include/gc/cord_pos.h‎
Copy file name to clipboard
+99-80Lines changed: 99 additions & 80 deletions b/Collapse file
‎thirdparty/libgc/include/gc/cord_pos.h‎
Copy file name to clipboard
+99-80Lines changed: 99 additions & 80 deletions
diff --git a/Collapse file
‎thirdparty/libgc/include/gc/ec.h‎
Copy file name to clipboard
+44-39Lines changed: 44 additions & 39 deletions b/Collapse file
‎thirdparty/libgc/include/gc/ec.h‎
Copy file name to clipboard
+44-39Lines changed: 44 additions & 39 deletions
@@ -11,122 +11,141 @@
  * modified is included with the above copyright notice.
  */
 
-/* This should never be included directly; included only from cord.h.   */
+/* This should never be included directly; included only from `cord.h` file. */
 #if !defined(CORD_POSITION_H) && defined(CORD_H)
-#define CORD_POSITION_H
+#  define CORD_POSITION_H
 
-#ifdef __cplusplus
-  extern "C" {
-#endif
+#  ifdef __cplusplus
+extern "C" {
+#  endif
 
-/* The representation of CORD_position.  This is private to the */
-/* implementation, but the size is known to clients.  Also      */
-/* the implementation of some exported macros relies on it.     */
-/* Don't use anything defined here and not in cord.h.           */
+/*
+ * The representation of `CORD_position`.  This is private to the
+ * implementation, but the size is known to clients.  Also the implementation
+ * of some exported macros relies on it.  Do not use anything defined here
+ * and not in `cord.h` file.
+ */
 
-#define CORD_MAX_DEPTH 48
-        /* The maximum depth of a balanced cord + 1.            */
-        /* We do not let cords get deeper than this maximum.    */
+/**
+ * The maximum depth of a balanced cord plus one.  We do not let cords get
+ * deeper than this maximum.
+ */
+#  define CORD_MAX_DEPTH 48
 
 struct CORD_pe {
-    CORD pe_cord;
-    size_t pe_start_pos;
+  CORD pe_cord;
+  size_t pe_start_pos;
 };
 
-/* A structure describing an entry on the path from the root    */
-/* to current position.                                         */
+/**
+ * A structure describing an entry on the path from the root to current
+ * position.
+ */
 typedef struct CORD_Pos {
-    size_t cur_pos;
-
-    int path_len;
-#       define CORD_POS_INVALID 0x55555555
-                /* path_len == CORD_POS_INVALID <==> position invalid   */
-
-    const char *cur_leaf;       /* Current leaf, if it is a string.     */
-                                /* If the current leaf is a function,   */
-                                /* then this may point to function_buf  */
-                                /* containing the next few characters.  */
-                                /* Always points to a valid string      */
-                                /* containing the current character     */
-                                /* unless cur_end is 0.                 */
-    size_t cur_start;   /* Start position of cur_leaf.  */
-    size_t cur_end;     /* Ending position of cur_leaf; */
-                        /* 0 if cur_leaf is invalid.    */
-    struct CORD_pe path[CORD_MAX_DEPTH + 1];
-        /* path[path_len] is the leaf corresponding to cur_pos  */
-        /* path[0].pe_cord is the cord we point to.             */
-#   define CORD_FUNCTION_BUF_SZ 8
-    char function_buf[CORD_FUNCTION_BUF_SZ];
-                                        /* Space for next few chars */
-                                        /* from function node.      */
+  size_t cur_pos;
+
+  int path_len;
+
+  /* `path_len` is `CORD_POS_INVALID` if and only if position is invalid. */
+#  define CORD_POS_INVALID 0x55555555
+
+  /*
+   * Current leaf, if it is a string.  If the current leaf is a function,
+   * then this may point to `function_buf` containing the next few characters.
+   * Always points to a valid string containing the current character
+   * unless `cur_end` is zero.
+   */
+  const char *cur_leaf;
+
+  /* Start position of `cur_leaf`. */
+  size_t cur_start;
+
+  /* Ending position of `cur_leaf`; zero if `cur_leaf` is invalid. */
+  size_t cur_end;
+
+  /*
+   * `path[path_len]` is the leaf corresponding to `cur_pos`;
+   * `path[0].pe_cord` is the cord we point to.
+   */
+  struct CORD_pe path[CORD_MAX_DEPTH + 1];
+
+#  define CORD_FUNCTION_BUF_SZ 8
+
+  /* Space for next few chars from function node. */
+  char function_buf[CORD_FUNCTION_BUF_SZ];
 } CORD_pos[1];
 
-/* Extract the cord from a position.    */
+/** Extract the cord from a position. */
 CORD_API CORD CORD_pos_to_cord(CORD_pos);
 
-/* Extract the current index from a position.   */
+/** Extract the current index from a position. */
 CORD_API size_t CORD_pos_to_index(CORD_pos);
 
-/* Fetch the character located at the given position.   */
+/** Fetch the character located at the given position. */
 CORD_API char CORD_pos_fetch(CORD_pos);
 
-/* Initialize the position to refer to the given cord and index.    */
-/* Note that this is the most expensive function on positions.      */
-CORD_API void CORD_set_pos(CORD_pos, CORD, size_t /* index */);
+/**
+ * Initialize the position to refer to the given cord and `index`.
+ * Note that this is the most expensive function on positions.
+ */
+CORD_API void CORD_set_pos(CORD_pos, CORD, size_t /* `index` */);
 
-/* Advance the position to the next character.  */
-/* p must be initialized and valid.             */
-/* Invalidates p if past end.                   */
-CORD_API void CORD_next(CORD_pos /* p */);
+/**
+ * Advance the position to the next character.  `p` must be initialized
+ * and valid.  Invalidates `p` if past end.
+ */
+CORD_API void CORD_next(CORD_pos /* `p` */);
 
-/* Move the position to the preceding character.        */
-/* p must be initialized and valid.                     */
-/* Invalidates p if past beginning.                     */
-CORD_API void CORD_prev(CORD_pos /* p */);
+/**
+ * Move the position to the preceding character.  `p` must be initialized
+ * and valid.  Invalidates `p` if past beginning.
+ */
+CORD_API void CORD_prev(CORD_pos /* `p` */);
 
-/* Is the position valid, i.e. inside the cord?         */
+/** Is the position valid, i.e. inside the cord? */
 CORD_API int CORD_pos_valid(CORD_pos);
 
 CORD_API char CORD__pos_fetch(CORD_pos);
 CORD_API void CORD__next(CORD_pos);
 CORD_API void CORD__prev(CORD_pos);
 
-#define CORD_pos_fetch(p) \
-    ((p)[0].cur_end != 0 ? \
-        (p)[0].cur_leaf[(p)[0].cur_pos - (p)[0].cur_start] \
-        : CORD__pos_fetch(p))
+#  define CORD_pos_fetch(p)                                                   \
+    ((p)[0].cur_end != 0 ? (p)[0].cur_leaf[(p)[0].cur_pos - (p)[0].cur_start] \
+                         : CORD__pos_fetch(p))
 
-#define CORD_next(p) \
-    ((p)[0].cur_pos + 1 < (p)[0].cur_end ? \
-        (p)[0].cur_pos++ \
-        : (CORD__next(p), 0U))
+#  define CORD_next(p)                                      \
+    ((p)[0].cur_pos + 1 < (p)[0].cur_end ? (p)[0].cur_pos++ \
+                                         : (CORD__next(p), 0U))
 
-#define CORD_prev(p) \
-    ((p)[0].cur_end != 0 && (p)[0].cur_pos > (p)[0].cur_start ? \
-        (p)[0].cur_pos-- \
-        : (CORD__prev(p), 0U))
+#  define CORD_prev(p)                                        \
+    ((p)[0].cur_end != 0 && (p)[0].cur_pos > (p)[0].cur_start \
+         ? (p)[0].cur_pos--                                   \
+         : (CORD__prev(p), 0U))
 
-#define CORD_pos_to_index(p) ((p)[0].cur_pos)
+#  define CORD_pos_to_index(p) ((p)[0].cur_pos)
 
-#define CORD_pos_to_cord(p) ((p)[0].path[0].pe_cord)
+#  define CORD_pos_to_cord(p) ((p)[0].path[0].pe_cord)
 
-#define CORD_pos_valid(p) ((p)[0].path_len != CORD_POS_INVALID)
+#  define CORD_pos_valid(p) ((p)[0].path_len != CORD_POS_INVALID)
 
-/* Some grubby stuff for performance-critical friends:  */
+/* Some grubby stuff for performance-critical friends. */
 
-#define CORD_pos_chars_left(p) ((long)(p)[0].cur_end - (long)(p)[0].cur_pos)
-        /* Number of characters in cache.  <= 0 ==> none        */
+/** Number of characters in cache.  A non-positive value means none. */
+#  define CORD_pos_chars_left(p) ((long)(p)[0].cur_end - (long)(p)[0].cur_pos)
 
-#define CORD_pos_advance(p,n) ((p)[0].cur_pos += (n) - 1, CORD_next(p))
-        /* Advance position by n characters;    */
-        /* 0 < n < CORD_pos_chars_left(p).      */
+/**
+ * Advance position by `n` characters; `n` should be positive and less
+ * than `CORD_pos_chars_left(p)`.
+ */
+#  define CORD_pos_advance(p, n) \
+    ((p)[0].cur_pos += (n) - (size_t)1, CORD_next(p))
 
-#define CORD_pos_cur_char_addr(p) \
+/** Address of the current character in cache. */
+#  define CORD_pos_cur_char_addr(p) \
     ((p)[0].cur_leaf + ((p)[0].cur_pos - (p)[0].cur_start))
-        /* Address of the current character in cache.   */
 
-#ifdef __cplusplus
-  } /* extern "C" */
-#endif
+#  ifdef __cplusplus
+} /* extern "C" */
+#  endif
 
 #endif
@@ -15,72 +15,77 @@
 #define EC_H
 
 #ifndef CORD_H
-# include "cord.h"
+#  include "cord.h"
 #endif
 
 #ifdef __cplusplus
-  extern "C" {
+extern "C" {
 #endif
 
-/* Extensible cords are strings that may be destructively appended to.  */
-/* They allow fast construction of cords from characters that are       */
-/* being read from a stream.                                            */
 /*
- * A client might look like:
+ * Extensible cords are strings that may be destructively appended to.
+ * They allow fast construction of cords from characters that are being
+ * read from a stream.
  *
- *      {
- *          CORD_ec x;
- *          CORD result;
- *          char c;
- *          FILE *f;
+ * A client might look like:
+ * ```
+ *   CORD_ec x;
+ *   CORD result;
+ *   char c;
+ *   FILE *f;
  *
- *          ...
- *          CORD_ec_init(x);
- *          while (...) {
- *              c = getc(f);
- *              ...
- *              CORD_ec_append(x, c);
- *          }
- *          result = CORD_balance(CORD_ec_to_cord(x));
+ *   CORD_ec_init(x);
+ *   while (...) {
+ *       c = getc(f);
+ *       ...
+ *       CORD_ec_append(x, c);
+ *   }
+ *   result = CORD_balance(CORD_ec_to_cord(x));
+ * ```
  *
- * If a C string is desired as the final result, the call to CORD_balance
- * may be replaced by a call to CORD_to_char_star.
+ * If a C string is desired as the final result, the call to `CORD_balance`
+ * may be replaced by a call to `CORD_to_char_star`.
  */
 
 #ifndef CORD_BUFSZ
-#   define CORD_BUFSZ 128
+#  define CORD_BUFSZ 128
 #endif
 
-/* This structure represents the concatenation of ec_cord with  */
-/* ec_buf[0 .. ec_bufptr-ec_buf-1].                             */
+/**
+ * This structure represents the concatenation of `ec_cord` with
+ * `ec_buf[0 .. ec_bufptr - ec_buf - 1]`.
+ */
 typedef struct CORD_ec_struct {
-    CORD ec_cord;
-    char * ec_bufptr;
-    char ec_buf[CORD_BUFSZ+1];
+  CORD ec_cord;
+  char *ec_bufptr;
+  char ec_buf[CORD_BUFSZ + 1];
 } CORD_ec[1];
 
-/* Flush the buffer part of the extended cord into ec_cord.     */
+/** Flush the buffer part of the extended cord into extensible cord. */
 CORD_API void CORD_ec_flush_buf(CORD_ec);
 
-/* Convert an extensible cord to a cord. */
+/** Convert an extensible cord to a cord. */
 #define CORD_ec_to_cord(x) (CORD_ec_flush_buf(x), (x)[0].ec_cord)
 
-/* Initialize an extensible cord. */
+/** Initialize an extensible cord. */
 #define CORD_ec_init(x) \
-                ((x)[0].ec_cord = 0, (void)((x)[0].ec_bufptr = (x)[0].ec_buf))
+  ((x)[0].ec_cord = 0, (void)((x)[0].ec_bufptr = (x)[0].ec_buf))
 
-/* Append a character to an extensible cord.    */
-#define CORD_ec_append(x, c) \
-                ((void)((x)[0].ec_bufptr == (x)[0].ec_buf + CORD_BUFSZ \
-                        ? (CORD_ec_flush_buf(x), 0) : 0), \
-                 (void)(*(x)[0].ec_bufptr++ = (c)))
+/** Append a character to an extensible cord. */
+#define CORD_ec_append(x, c)                             \
+  ((void)((x)[0].ec_bufptr == (x)[0].ec_buf + CORD_BUFSZ \
+              ? (CORD_ec_flush_buf(x), 0)                \
+              : 0),                                      \
+   (void)(*(x)[0].ec_bufptr++ = (c)))
 
-/* Append a cord to an extensible cord.  Structure remains shared with  */
-/* original.                                                            */
+/**
+ * Append a cord to an extensible cord.  Structure remains shared with
+ * the original.
+ */
 CORD_API void CORD_ec_append_cord(CORD_ec, CORD);
 
 #ifdef __cplusplus
-  } /* extern "C" */
+} /* extern "C" */
 #endif
 
 #endif /* EC_H */