From 042e43247f396a9000fead59d9bff87bf12806d6 Mon Sep 17 00:00:00 2001
From: Thomas Voss <mail@thomasvoss.com>
Date: Wed, 30 Oct 2024 01:51:14 +0100
Subject: Completely revamp the grab source code

Some of the (many) few changes are:
- Multithreading for significantly faster performance
- The -p/--predicate flag
- Byte offsets as the default
- No customizable colors (maybe this will come back later)
- Newer edition of mlib (formerly librune)
---
 src/da.h | 121 ---------------------------------------------------------------
 1 file changed, 121 deletions(-)
 delete mode 100644 src/da.h

(limited to 'src/da.h')

diff --git a/src/da.h b/src/da.h
deleted file mode 100644
index 8891971..0000000
--- a/src/da.h
+++ /dev/null
@@ -1,121 +0,0 @@
-/*
- * Simple & stupid dynamic array single-header implementation.  You can use the
- * macros defined in this file with any structure that has the following fields:
- *
- *  struct dyn_array {
- *      T *buf  // Array of items
- *      N  len  // Length of array
- *      N  cap  // Capacity of array
- *  }
- *
- * The type ‘T’ is whatever type you want to store.  The type ‘N’ is any numeric
- * type — most likely ‘size_t’ — but it could be sized as well.
- *
- * The daremove() macro also doesn’t bother with shrinking your array when the
- * length is far lower than the capacity.  If you care about that, do it
- * yourself.
- *
- * Remember to call free() on your dynamic arrays ‘buf’ field after use.
- *
- *
- * Macro Overview
- * ――――――――――――――
- * The argument ‘a’ to all of the below macros is a pointer to the dynamic array
- * structure.
- *
- * dainit(a, n)              Initialize the array with a capacity of ‘n’ items.
- * dapush(a, x)              Append the item ‘x’ to the array
- * daremove(a, x)            Remove the item at index ‘x’ from the array
- * da_remove_range(a, x, y)  Remove the items between the range [x, y)
- * da_foreach(a, p)          Iterate the pointer ‘p’ over each element of the
- *                           array.  The type of ‘p’ is inferred.
- *
- * The ‘dapush()’ macro will double the arrays capacity when it gets full.  If
- * you would like your arrays to grow with a different scale, edit this file.
- *
- *
- * Example
- * ―――――――
- *
- * struct {
- *     int *buf;
- *     size_t len, cap;
- * } nums;
- *
- * // Initialize nums with capacity == 4
- * dainit(&nums, 4);
- *
- * // Append 69, 1337, and 420 to nums
- * dapush(&nums, 69);
- * dapush(&nums, 1337);
- * dapush(&nums, 420);
- *
- * da_foreach (&nums, n) {
- *     int x = *n << 1;
- *     printf("n = %d; n² = %d\n", *n, x);
- * }
- *
- * // Remove 1337 and 420 from nums
- * da_remove_range(&nums, 1, 3);
- *
- * // Remove 69 from nums
- * daremove(&nums, 0);
- */
-
-#ifndef MANGO_DA_H
-#define MANGO_DA_H
-
-#include <err.h>
-#include <errno.h>
-#include <stddef.h>
-#include <stdint.h>
-#include <stdlib.h>
-#include <string.h>
-
-#if __STDC_VERSION__ >= 202311L
-#	define DA_NULL nullptr
-#else
-#	define DA_NULL NULL
-#endif
-
-#define DA_ALLOC(p, n) \
-	do { \
-		if ((n) && SIZE_MAX / (n) < sizeof(*(p))) { \
-			errno = EOVERFLOW; \
-			err(EXIT_FAILURE, "realloc"); \
-		} \
-		if (!((p) = realloc((p), (n) * sizeof(*(p))))) \
-			err(EXIT_FAILURE, "realloc"); \
-	} while (0)
-
-#define dainit(a, n) \
-	do { \
-		(a)->buf = DA_NULL; \
-		(a)->cap = (n); \
-		(a)->len = 0; \
-		if (n) \
-			DA_ALLOC((a)->buf, (a)->cap); \
-	} while (0)
-
-#define dapush(a, x) \
-	do { \
-		if ((a)->len >= (a)->cap) { \
-			(a)->cap = (a)->cap ? (a)->cap * 2 : 1; \
-			DA_ALLOC((a)->buf, (a)->cap); \
-		} \
-		(a)->buf[(a)->len++] = (x); \
-	} while (0)
-
-#define daremove(a, i) da_remove_range((a), (i), (i) + 1)
-
-#define da_remove_range(a, i, j) \
-	do { \
-		memmove((a)->buf + (i), (a)->buf + (j), \
-		        ((a)->len - (j)) * sizeof(*(a)->buf)); \
-		(a)->len -= j - i; \
-	} while (0)
-
-#define da_foreach(a, p) \
-	for (typeof((a)->buf) p = (a)->buf; (size_t)(p - (a)->buf) < (a)->len; p++)
-
-#endif /* !MANGO_DA_H */
-- 
cgit v1.2.3