@based/db 0.0.2 → 0.0.3

package/dist/lib/linux_aarch64/include/selva/find.h

@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) 2024 SAULX
+ * SPDX-License-Identifier: MIT
+ */
+#pragma once
+
+#include "selva/_export.h"
+#include "selva/types.h"
+#include "selva/traverse.h"
+
+struct SelvaFindParam {
+    SelvaTraversalNodeCallback node_cb;
+    void *node_arg;
+
+    /**
+     * Traverse field selector.
+     */
+    const struct FindFields {
+        uint8_t len;
+        struct {
+            node_type_t type;
+            field_t field;
+        } __packed data[];
+    } __packed *fields;
+
+    /**
+     * Skip the first n nodes in the traversal.
+     * This happens before filtering.
+     */
+    ssize_t skip;
+
+    /**
+     * Skip the first n - 1 results.
+     * This skipping is executed on the final result set.
+     * 0 for no offset.
+     */
+    ssize_t offset;
+
+    /**
+     * Limit the number of results.
+     * -1 for no limit (inf).
+     */
+    ssize_t limit;
+};
+
+SELVA_EXPORT
+int selva_find(struct SelvaDb *db, struct SelvaNode *node, const struct SelvaFindParam *param);

package/dist/lib/linux_aarch64/include/selva/lpf.h

@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) 2021-2022 SAULX
+ * SPDX-License-Identifier: MIT
+ */
+#pragma once
+#ifndef _UTIL_LPF_H_
+#define _UTIL_LPF_H_
+
+/**
+ * Calculate the alpha coefficient for the lpf.
+ */
+__constfn static inline float lpf_geta(float period, float sample_interval);
+static inline float lpf_geta(float period, float sample_interval) {
+    return __builtin_expf(-(sample_interval / period));
+}
+
+/**
+ * Calculate the next output value of the lpf.
+ * @param prev is the previous output of this function.
+ * @param a is the coefficient calculated by lpf_geta().
+ * @param sample is the current sample.
+ */
+__constfn static inline float lpf_calc_next(float a, float prev, float sample);
+static inline float lpf_calc_next(float a, float prev, float sample) {
+    return a * prev + (1.0f - a) * sample;
+}
+
+#endif /* _UTIL_LPF_H_ */

package/dist/lib/linux_aarch64/include/selva/node_id_set.h

@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2024 SAULX
+ * SPDX-License-Identifier: MIT
+ */
+#pragma once
+
+#include <stddef.h>
+#include <sys/types.h>
+#include "selva/types.h"
+
+/*
+ * node_id set is an array that is always sorted for fast lookups.
+ */
+
+/**
+ * Search from a node_id set.
+ */
+SELVA_EXPORT
+ssize_t node_id_set_bsearch(const node_id_t *a, size_t n, node_id_t x)
+    __attribute__((access(read_only, 1, 2)));
+
+static inline bool node_id_set_has(const node_id_t *set, size_t len, node_id_t id)
+{
+    if (len == 0) {
+        return false;
+    }
+
+    return node_id_set_bsearch(set, len, id) >= 0;
+}
+
+/**
+ * Sorted insert to a node_id set.
+ * @param set_p is an array allocated with jemalloc_selva.
+ */
+SELVA_EXPORT
+bool node_id_set_add(node_id_t **set_p, size_t *len, node_id_t id);
+
+/**
+ * Remove from a node_id set.
+ * @param set_p is an array allocated with jemalloc_selva.
+ */
+SELVA_EXPORT
+bool node_id_set_remove(node_id_t **set_p, size_t *len, node_id_t id);

package/dist/lib/linux_aarch64/include/selva/poptop.h

@@ -0,0 +1,114 @@
+/*
+ * Copyright (c) 2021-2022, 2025 SAULX
+ * SPDX-License-Identifier: MIT
+ */
+#pragma once
+
+#include "selva/_export.h"
+
+/**
+ * An element in the poptop list.
+ */
+struct poptop_list_el {
+    float score;
+    void *p;
+};
+
+/**
+ * A poptop structure.
+ * Poptop is a data structure that attempts to keep a list of the most popular
+ * entries based on a score seen on each insert. The list is kept at least
+ * half-full at all times.
+ *
+ * The data structure has a maximum size of `max_size` and a cutoff limit that's
+ * the median of the score of elements currently on the list. A new cutoff is
+ * calculated when `poptop_maintenance()` is called and each call to
+ * `poptop_maintenance_drop()` removes one element falling under the cutoff
+ * limit until every element of the list has no more elements with score under
+ * the cutoff limit.
+ *
+ * The list can be iterated using the `POPTOP_FOREACH()` macro.
+ *
+ * The list is not guaranteed to be ordered, in fact, it's typically unordered
+ * unless `poptop_maintenance()` was called and no new inserts have been made
+ * since that call.
+ */
+struct poptop {
+    /**
+     * Maximum size of the top list.
+     */
+    unsigned int max_size;
+    /**
+     * Current number of elements on the top list.
+     */
+    unsigned int current_size;
+    /**
+     * Minimum score.
+     * A long term minimum score for an element to get into and remain in the
+     * data structure. This is updated when poptop_maintenance() is called.
+     */
+    float cut_limit;
+    struct poptop_list_el *list;
+};
+
+/**
+ * An iterator for `struct poptop`.
+ * Note that the elements in the poptop list are not returned in any
+ * particular order.
+ * @param[out] _el_ is a pointer to a `poptop_list_el` structure. Can be NULL.
+ * @param _l_ is a pointer to the poptop instance to be iterated over.
+ */
+#define POPTOP_FOREACH(_el_, _l_) \
+    _el_ = (_l_)->list - 1; \
+    while (++_el_ != ((_l_)->list + (_l_)->max_size))
+
+/**
+ * Initialize a poptop structure.
+ * @param l is a pointer to an uninitalized poptop structure.
+ * @param max_size is the maximum number of elements allowed in the data
+ * structure. Poptop will attempt to maintain a list of about half of the
+ * maximum size.
+ * @param initial_cut is an initial value for the cut limit.
+ * @returns 0 if succeed; Otherwise a non-zero value is returned.
+ */
+SELVA_EXPORT
+int poptop_init(struct poptop *l, unsigned int max_size, float initial_cut);
+
+/**
+ * Deinit a poptop structure.
+ * @param l is a pointer to an initialized poptop structure.
+ */
+SELVA_EXPORT
+void poptop_deinit(struct poptop *l);
+
+/**
+ * Add an element to the top list if it's above the self-determined score limit.
+ * If the element already exists the score is updated.
+ * @param l is a pointer to the poptop structure.
+ */
+SELVA_EXPORT
+void poptop_maybe_add(struct poptop * restrict l, float score, void * restrict p);
+
+/**
+ * Remove an element from the top list.
+ * @param l is a pointer to the poptop structure.
+ */
+SELVA_EXPORT
+void poptop_remove(struct poptop * restrict l, const void * restrict p);
+
+/**
+ * Periodic maintenance.
+ * Find the median score and establish a new cut limit.
+ * @param l is a pointer to the poptop structure.
+ */
+SELVA_EXPORT
+int poptop_maintenance(struct poptop *l);
+
+/**
+ * Drop an element that has a score below the cut limit.
+ * This function should be called repeatedly until no entry is returned.
+ * @param l is a pointer to the poptop structure.
+ * @returns a pointer to the element that was removed from the data structure l.
+ */
+SELVA_EXPORT
+void *poptop_maintenance_drop(struct poptop *l);

package/dist/lib/linux_aarch64/include/selva/queue_r.h

@@ -0,0 +1,190 @@
+/**
+ *******************************************************************************
+ * @file    queue_r.h
+ * @author  Olli Vanhoja
+ * @brief   Thread-safe queue
+ * @section LICENSE
+ * Copyright (c) 2020-2021, 2023, 2025 SAULX
+ * Copyright (c) 2013, 2015, 2016 Olli Vanhoja <olli.vanhoja@cs.helsinki.fi>
+ * Copyright (c) 2012, 2013 Ninjaware Oy,
+ *                          Olli Vanhoja <olli.vanhoja@ninjaware.fi>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ *******************************************************************************
+ */
+
+/**
+ * @addtogroup queue_r
+ * @{
+ */
+
+#pragma once
+
+#include <stddef.h>
+#include "selva/_export.h"
+
+/**
+ * Queue control block.
+ */
+typedef struct queue_cb {
+    void * data;    /*!< Pointer to the data array used for queue. */
+    size_t b_size;  /*!< Block size in bytes. */
+    size_t a_len;   /*!< Array length. */
+    size_t m_write; /*!< Write index. */
+    size_t m_read;  /*!< Read index. */
+} queue_cb_t;
+
+#define QUEUE_INITIALIZER(data_array, block_size, array_size)   \
+    (struct queue_cb){                                          \
+        .data = (data_array),                                   \
+        .b_size = (block_size),                                 \
+        .a_len = (array_size / block_size),                     \
+        .m_write = 0,                                           \
+        .m_read = 0,                                            \
+    }
+
+/**
+ * Create a new queue control block.
+ * Initializes a new queue control block and returns it as a value.
+ * @param data_array an array where the actual queue data is stored.
+ * @param block_size the size of single data block/struct/data type in
+ *                   data_array in bytes.
+ * @param array_size the size of the data_array in bytes.
+ * @return a new queue_cb_t queue control block structure.
+ */
+SELVA_EXPORT
+queue_cb_t queue_create(void * data_array, size_t block_size,
+                        size_t array_size)
+    __attribute__((pure, access(read_only, 1, 3)));
+
+/**
+ * Push an element to the queue.
+ * @param cb is a pointer to the queue control block.
+ * @param element the new element to be copied.
+ * @return 0 if queue is already full; otherwise operation was succeed.
+ * @note element is always copied to the queue, so it is safe to remove the
+ * original data after a push.
+ */
+SELVA_EXPORT
+int queue_push(queue_cb_t * cb, const void * element)
+    __attribute__((access(read_write, 1)));
+
+/**
+ * Allocate an element from the queue.
+ * @param cb is a pointer to the queue control block.
+ * @return A pointer to the element in the queue.
+ */
+SELVA_EXPORT
+void * queue_alloc_get(queue_cb_t * cb)
+    __attribute__((access(read_write, 1)));
+
+/**
+ * Commit previous allocation from the queue.
+ * @note queue_push() should not be called between calls to queue_alloc_get()
+ *       and queue_alloc_commit().
+ */
+SELVA_EXPORT
+void queue_alloc_commit(queue_cb_t * cb)
+    __attribute__((access(read_write, 1)));
+
+/**
+ * Pop an element from the queue.
+ * @param cb is a pointer to the queue control block.
+ * @param element is the location where element is copied to from the queue.
+ * @return 0 if queue is empty; otherwise operation was succeed.
+ */
+SELVA_EXPORT
+int queue_pop(queue_cb_t * cb, void * element)
+    __attribute__((access(read_write, 1)));
+
+/**
+ * Peek an element from the queue.
+ * @param cb is a pointer to the queue control block.
+ * @param element is the location where element is copied to from the queue.
+ * @return 0 if queue is empty; otherwise operation was succeed.
+ */
+SELVA_EXPORT
+int queue_peek(queue_cb_t * cb, void ** element)
+    __attribute__((access(read_only, 1), access(write_only, 2)));
+
+/**
+ * Skip n number of elements in the queue.
+ * @param cb is a pointer to the queue control block.
+ * @return Returns the number of elements skipped.
+ */
+SELVA_EXPORT
+int queue_skip(queue_cb_t * cb, size_t n)
+    __attribute__((access(read_write, 1)));
+
+/**
+ * Clear the queue.
+ * This operation is considered safe when committed from the push end thread.
+ * @param cb is a pointer to the queue control block.
+ */
+SELVA_EXPORT
+void queue_clear_from_push_end(queue_cb_t * cb)
+    __attribute__((access(read_write, 1)));
+
+/**
+ * Clear the queue.
+ * This operation is considered safe when committed from the pop end thread.
+ * @param cb is a pointer to the queue control block.
+ */
+SELVA_EXPORT
+void queue_clear_from_pop_end(queue_cb_t * cb)
+    __attribute__((access(read_write, 1)));
+
+/**
+ * Check if the queue is empty.
+ * @param cb is a pointer to the queue control block.
+ * @return 0 if the queue is not empty.
+ */
+SELVA_EXPORT
+int queue_isempty(const queue_cb_t * cb)
+    __attribute__((access(read_only, 1)));
+
+/**
+ * Check if the queue is full.
+ * @param cb is a pointer to the queue control block.
+ * @return 0 if the queue is not full.
+ */
+SELVA_EXPORT
+int queue_isfull(const queue_cb_t * cb)
+    __attribute__((access(read_only, 1)));
+
+/**
+ * Seek queue.
+ * @param cb is a pointer to the queue control block.
+ * @param i index.
+ * @param[in] element returned element.
+ * @return 0 if failed; otherwise succeed.
+ */
+SELVA_EXPORT
+int seek(const queue_cb_t * cb, size_t i, void * element)
+    __attribute__((access(read_only, 1), access(write_only, 3)));
+
+/**
+ * @}
+ */

package/dist/lib/linux_aarch64/include/selva/selva_hash128.h

@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2024 SAULX
+ * SPDX-License-Identifier: MIT
+ */
+#pragma once
+#include "xxhash.h"
+#include "selva/types.h"
+
+typedef struct XXH3_state_s selva_hash_state_t;
+
+#define selva_hash_create_state XXH3_createState
+#define selva_hash_reset XXH3_128bits_reset
+#define selva_hash_free_state XXH3_freeState
+#define selva_hash_update XXH3_128bits_update
+
+SELVA_EXPORT
+selva_hash128_t selva_hash_digest_zig(selva_hash_state_t *hash_state);
+
+#ifdef __zig
+#define selva_hash_digest selva_hash_digest_zig
+#else
+static inline selva_hash128_t selva_hash_digest(selva_hash_state_t *hash_state)
+{
+    XXH128_hash_t res;
+
+retry:
+    res = XXH3_128bits_digest(hash_state);
+    if (res.low64 == 0 && res.high64 == 0) {
+        /*
+         * We don't allow zero hash.
+         * RFE Is this a good approach?
+         */
+        XXH3_128bits_update(hash_state, &(int64_t){ 1 }, sizeof(int64_t));
+        goto retry;
+    }
+
+    return (selva_hash128_t)res.low64 | (selva_hash128_t)res.high64 << 64;
+}
+#endif

package/dist/lib/linux_aarch64/include/selva/selva_lang.h

@@ -0,0 +1,105 @@
+/*
+ * Copyright (c) 2022, 2024-2025 SAULX
+ * SPDX-License-Identifier: MIT
+ */
+#pragma once
+
+#if defined(__APPLE__) && __MACH__
+#include <xlocale.h>
+#endif
+#include <locale.h>
+#include <wchar.h>
+#include <wctype.h>
+#include "selva/_export.h"
+#include "selva_lang_code.h"
+
+#define SELVA_LANG_NAME_MAX 4ul
+
+struct libdeflate_decompressor;
+struct libdeflate_block_state;
+
+int selva_lang_set_fallback(const char *lang_str, size_t lang_len);
+
+/**
+ * Get locale for a lang string.
+ * @param lang_str is a pointer to the language name.
+ * @param lang_len is the length of lang_str excluding any possible nul-character(s).
+ * @returns a POSIX locale.
+ */
+SELVA_EXPORT
+locale_t selva_lang_getlocale(const char *lang_str, size_t lang_len);
+
+SELVA_EXPORT
+locale_t selva_lang_getlocale2(enum selva_lang_code lang);
+
+/* TODO rename these */
+enum selva_langs_trans {
+    SELVA_LANGS_TRANS_NONE = 0,
+    SELVA_LANGS_TRANS_TOUPPER,
+    SELVA_LANGS_TRANS_TOLOWER,
+    SELVA_LANGS_TRANS_TOJHIRA, /*!< When lang is selva_lang_ja. */
+    SELVA_LANGS_TRANS_TOJKATA, /*!< When lang is selva_lang_ja. */
+};
+
+SELVA_EXPORT
+wctrans_t selva_lang_wctrans(enum selva_lang_code lang, enum selva_langs_trans trans);
+
+/**
+ * Transform a multibyte string.
+ * @returns a selva_malloc'd c-string.
+ */
+SELVA_EXPORT
+char *selva_mbstrans(locale_t loc, const char *src, size_t len, wctrans_t trans);
+
+/**
+ * Read a symbol from a multibyte string.
+ * @param wc symbol read from mbs_str.
+ * @returns bytes consumed from mbs_str.
+ */
+SELVA_EXPORT
+size_t selva_mbstowc(wchar_t *wc, const char *mbs_str, size_t mbs_len, mbstate_t *ps, wctrans_t trans, locale_t loc);
+
+/**
+ * Compare two multibyte strings by transforming each character.
+ * Unicode normalization and flattening is not supported.
+ */
+SELVA_EXPORT
+int selva_mbscmp(const char *mbs1_str, size_t mbs1_len, const char *mbs2_str, size_t mbs2_len, wctrans_t trans, locale_t loc);
+
+SELVA_EXPORT
+int selva_deflate_mbscmp(
+        struct libdeflate_decompressor *decompressor,
+        struct libdeflate_block_state *state,
+        const char *in_buf, size_t in_len,
+        const char *mbs2_str, size_t mbs2_len,
+        wctrans_t trans, locale_t loc);
+
+SELVA_EXPORT
+const char *selva_mbsstrstr(const char *mbs1_str, size_t mbs1_len, const char *mbs2_str, size_t mbs2_len, wctrans_t trans, locale_t loc);
+
+SELVA_EXPORT
+bool selva_deflate_mbsstrstr(
+        struct libdeflate_decompressor *decompressor,
+        struct libdeflate_block_state *state,
+        const char *in_buf, size_t in_len,
+        const void *needle_buf, size_t needle_len,
+        wctrans_t trans, locale_t loc);
+
+/**
+ * Constructs a value of type wctrans_t that describes a LC_CTYPE category of wide character mapping.
+ * - "" none
+ * - "toupper"
+ * - "tolower"
+ * - "tojhira" when lang is "jp"
+ * - "tojkata" when lang is "jp"
+ */
+static inline wctrans_t selva_wctrans(const char *class_str, size_t class_len, locale_t loc)
+{
+    char charclass[16] = {};
+
+    if (likely(class_len < sizeof(charclass))) {
+        __builtin_memcpy(charclass, class_str, class_len);
+    }
+
+    return wctrans_l(charclass, loc);
+}

package/dist/lib/linux_aarch64/include/selva/selva_math.h

@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2022-2024 SAULX
+ * SPDX-License-Identifier: MIT
+ */
+#pragma once
+#include <math.h>
+
+static inline double nan_undefined(void)
+{
+    return nan("1");
+}
+
+static inline int isnan_undefined(double x)
+{
+    long long i;
+
+    if (!isnan(x)) {
+      return 0;
+    }
+
+    __builtin_memcpy(&i, &x, sizeof(i));
+
+    return i & 1;
+}
+
+/**
+ * Mod (%) like it is in JS.
+ */
+static inline double js_fmod(double x, double y)
+{
+    double result = remainder(fabs(x), (y = fabs(y)));
+    if (signbit(result)) {
+        result += y;
+    }
+
+    return copysign(result, x);
+}