@based/db 0.0.1 → 0.0.2

package/dist/lib/linux_aarch64/include/cdefs.h

@@ -1,317 +0,0 @@
-/*
- * Copyright (c) 2020-2024 SAULX
- * SPDX-License-Identifier: BSD-2-Clause
- */
-
-#pragma once
-#ifndef _UTIL_CDEFS_H_
-#define _UTIL_CDEFS_H_
-
-#if __STDC_VERSION__ < 202311L
-#define static_assert _Static_assert
-#if defined(__clang__) && !defined(unreachable)
-#define unreachable __builtin_unreachable
-#endif
-#endif
-
-#if defined(__linux__)
-/**
- * Force linking against a specific version of a GLIBC symbol.
- * Use this at the top-level of a source file.
- */
-#define GLIBC_COMPAT_SYMBOL(SYM, VER) \
-    __asm__(".symver " #SYM "," #SYM "@GLIBC_" #VER);
-#else
-#define GLIBC_COMPAT_SYMBOL(SYM, VER)
-#endif
-
-#if defined(__GNUC__) && !defined(__clang__)
-/**
- * The char array isn't a NUL terminated C-string.
- * Using this attribute will help to get better warnings at compilation time.
- */
-#define __nonstring __attribute__((nonstring))
-/**
- * Annotate a pure function.
- * The function has no side effects and the value returned depends on the
- * arguments and the state of global variables. Therefore it is safe for
- * the optimizer to eliminate repeated calls with unchanged arguments.
- */
-#define __purefn __attribute__((pure))
-/**
- * Annotate a const function.
- * The return value of the function is solely a function of its arguments,
- * and if any of the arguments are pointers, then the pointers are not be
- * dereferenced.
- */
-#define __constfn __attribute__((const))
-#else
-#define __nonstring
-#define __purefn
-#define __constfn
-#endif
-
-#define __sentinel __attribute__((sentinel))
-
-#if __has_c_attribute(noreturn)
-#define __noreturn [[noreturn]]
-#else
-#define __noreturn __attribute__((noreturn))
-#endif
-
-#define __transparent_union __attribute__((__transparent_union__))
-
-#define CONCATENATE(arg1, arg2)   CONCATENATE1(arg1, arg2)
-#define CONCATENATE1(arg1, arg2)  CONCATENATE2(arg1, arg2)
-#define CONCATENATE2(arg1, arg2)  arg1##arg2
-
-#define UTIL_NARG(...) \
-    UTIL_NARG_(__VA_ARGS__, UTIL_RSEQ_N())
-#define UTIL_NARG_(...) UTIL_ARG_N(__VA_ARGS__)
-#define UTIL_ARG_N( \
-     _1,  _2,  _3,  _4,  _5,  _6,  _7,  _8,  _9, _10, _11, _12, _13, _14, \
-    _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, \
-    _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, \
-    _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, \
-    _57, _58, _59, _60, _61, _62, _63, N, ...) N
-# define UTIL_RSEQ_N() \
-    63, 62, 61, 60, 59, 58, 57, 56, 55, 54, 53, 52, 51, 50, 49, 48, 47, \
-    46, 45, 44, 43, 42, 41, 40, 39, 38, 37, 36, 35, 34, 33, 32, 31, 30, \
-    29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, \
-    12, 11, 10,  9,  8,  7,  6,  5,  4,  3,  2,  1,  0
-
-#define _S__LINE__S(x) #x
-#define _S__LINE__S2(x) _S__LINE__S(x)
-/**
- * Current line number as a string.
- */
-#define S__LINE__ _S__LINE__S2(__LINE__)
-
-#ifndef __GLOBL1
-#define  __GLOBL1(sym) __asm__(".globl " #sym)
-/**
- * Make the symbol `sym` visible to the linker.
- */
-#define  __GLOBL(sym) __GLOBL1(sym)
-#endif
-
-#ifndef __weak_sym
-/**
- * Emit the declaration as a weak symbol.
- * A weak symbol can be overridden at linking. This is particularly useful for
- * functions.
- *
- */
-#define __weak_sym __attribute__((weak))
-#endif
-
-#ifndef __used
-/**
- * The function or variable is used.
- * Inform the compiler that the fuction is used and the code must be emitted
- * even if the function name is not referenced.
- */
-#define __used __attribute__((__used__))
-#endif
-
-#ifndef __unused
-/**
- * The function or variable is unused on purpose.
- */
-#define __unused __attribute__((__unused__))
-#endif
-
-#ifndef __section
-/**
- * Store the variable or function in a named section.
- */
-#define __section(x) __attribute__((__section__(x)))
-#endif
-
-#if defined(__APPLE__)
-#define __lazy_alloc_glob
-#else
-/**
- * Lazy alloc global variable.
- * On many system (especially Linux) user defined sections are not zeroed on
- * startup and thus implicitly neither allocated until accessed. This allows
- * us to create global variables that are allocated lazily.
- */
-#define __lazy_alloc_glob __attribute__((__section__("lazy")))
-#endif
-
-/**
- * A function that must be called before `main()`.
- * The function is called automatically before executing `main()`.
- */
-#define __constructor   __attribute__((constructor))
-
-/**
- * A function that must be called after `main()` exits.
- * The function is called automatically after `main()` exits.
- */
-#define __destructor    __attribute__((destructor))
-
-#ifndef __hot
-/**
- * Inform the compiler that the function is a hotspot.
- * Hot functions might be placed closely together in memory to improve locality.
- */
-#define __hot __attribute__((hot))
-#endif
-
-#ifndef __cold
-/**
- * Inform the compiler that the function is unlikely to be executed.
- */
-#define __cold __attribute__((cold))
-#endif
-
-#ifndef __packed
-/**
- * Use the minimum required memory to represent the type.
- * The enum, union, structure, or a structure member should have the smallest
- * possible alignment.
- */
-#define __packed __attribute__((packed))
-#endif
-
-#ifndef __counted_by
-#if __has_attribute(__counted_by__)
-/**
- * struct foo {
- *     unsigned int len;
- *     char buf[] __counted_by(len);
- * };
- * __builtin_dynamic_object_size(p->buf) == p->len * sizeof(*p->buf)
- */
-#define __counted_by(member) __attribute__((__counted_by__(member)))
-#else
-#define __counted_by(member)
-#endif
-#endif
-
-#ifndef __pcounted_by
-#if __has_attribute(__counted_by__) && !defined(__clang__)
-/**
- * struct foo {
- *     unsigned int len;
- *     char *buf __pcounted_by(len);
- * };
- * __builtin_dynamic_object_size(p->buf) == p->len * sizeof(*p->buf)
- */
-#define __pcounted_by(member) __attribute__((__counted_by__(member)))
-#else
-#define __pcounted_by(member)
-#endif
-#endif
-
-#ifndef __designated_init
-#if __has_attribute(__designated_init__)
-/**
- * Must use a designated initializer with a struct.
- */
-#define __designated_init __attribute__((__designated_init__))
-#else
-#define __designated_init
-#endif
-#endif
-
-/* This should come with C23 */
-#ifndef alignas
-#define alignas(x) _Alignas(x)
-#endif
-
-/* This should come with C23 */
-#ifndef alignof
-#define alignof(x) _Alignof(x)
-#endif
-
-/**
- * It's likely that `x` is always truthy in runtime.
- */
-#define likely(x)   __builtin_expect(!!(x), 1)
-#define unlikely(x) __builtin_expect(!!(x), 0)
-
-#if __has_builtin(__builtin_speculation_safe_value)
-#define speculation_safe_value(x) __builtin_speculation_safe_value(x)
-#else
-#define speculation_safe_value(x) x
-#endif
-
-#define same_type(a, b) __builtin_types_compatible_p(typeof(a), typeof(b))
-
-/**
- * Statically assert that VAR is compatible with the type TYPE.
- */
-#define ASSERT_TYPE(TYPE, VAR) \
-    static_assert(__builtin_types_compatible_p(TYPE, typeof(VAR)))
-
-/**
- * Returns the smaller of the given values.
- */
-#define min(a, b) \
-    ({ __typeof__ (a) _a = (a); \
-       __typeof__ (b) _b = (b); \
-       _a < _b ? _a : _b; })
-
-/**
- * Returns the greater of the given values.
- */
-#define max(a, b) \
-    ({ __typeof__ (a) _a = (a); \
-      __typeof__ (b) _b = (b); \
-      _a > _b ? _a : _b; })
-
-/**
- * Get the struct that contains `m`.
- * This macro can be only used if we know for certain that `x` is a pointer to
- * the member `m` in type `s`.
- * @param x is a pointer to the member `m` in a struct of type `s`.
- * @param s is a struct type.
- * @param m is the name of the member in `s`.
- */
-#define containerof(x, s, m) ({                     \
-        const __typeof(((s *)0)->m) *__x = (x);     \
-        ((s *)((uint8_t *)(__x) - offsetof(s, m))); \
-})
-
-/**
- * Get the number of elements in an array.
- */
-#define num_elem(x) (sizeof(x) / sizeof(*(x)))
-
-/**
- * Size of struct field.
- */
-#define typeof_field(t, f) typeof(((t*)0)->f)
-
-/**
- * Size of struct field.
- */
-#define sizeof_field(t, f) (sizeof(((t*)0)->f))
-
-/**
- * Size of a struct with its flexible array member.
- */
-#define sizeof_wflex(t, f, count) \
-    max(sizeof(t), offsetof(t, f[0]) + count * sizeof(((t*)0)->f[0]))
-
-/**
- * Check if pointer has a const qualifier.
- */
-#define IS_POINTER_CONST(P) \
-    _Generic(1 ? (P) : (void *)(P), \
-            void const *: 1, \
-            default : 0)
-
-/**
- * Static ternary if.
- * Selects either T or E depending on P.
- */
-#define STATIC_IF(P, T, E) \
-    _Generic (&(char [!!(P) + 1]) {0}, \
-            char (*) [2] : T, \
-            char (*) [1] : E)
-
-#endif /* _UTIL_CDEFS_H_ */

package/dist/lib/linux_aarch64/include/libdeflate.h

@@ -1,322 +0,0 @@
-/*
- * libdeflate.h - public header for libdeflate
- * Copyright (c) 2024 SAULX
- * Copyright 2023 housisong
- * Copyright 2016 Eric Biggers
- *
- * SPDX-License-Identifier: MIT
- */
-
-#ifndef LIBDEFLATE_H
-#define LIBDEFLATE_H
-
-#define LIBDEFLATE_VERSION_MAJOR	2
-#define LIBDEFLATE_VERSION_MINOR	0
-#define LIBDEFLATE_VERSION_STRING	"2.0"
-
-#include <stddef.h>
-#include <stdint.h>
-
-#ifndef LIBDEFLATEEXPORT
-#ifdef BUILDING_LIBDEFLATE
-#define LIBDEFLATEEXPORT __attribute__((visibility("default")))
-#else
-#define LIBDEFLATEEXPORT
-#endif
-#endif
-
-/* ========================================================================== */
-/*                             Compression                                    */
-/* ========================================================================== */
-
-struct libdeflate_compressor;
-
-/**
- * libdeflate_alloc_compressor() allocates a new compressor.
- * 'compression_level' is the compression level on a zlib-like scale but with a
- * higher maximum value (1 = fastest, 6 = medium/default, 9 = slow, 12 = slowest).
- * Level 0 is also supported and means "no compression", specifically "create a
- * valid stream, but only emit uncompressed blocks" (this will expand the data
- * slightly).
- *
- * The return value is a pointer to the new compressor, or NULL if out of memory
- * or if the compression level is invalid (i.e. outside the range [0, 12]).
- *
- * Note: for compression, the sliding window size is defined at compilation time
- * to 32768, the largest size permissible in the DEFLATE format.  It cannot be
- * changed at runtime.
- *
- * A single compressor is not safe to use by multiple threads concurrently.
- * However, different threads may use different compressors concurrently.
- */
-LIBDEFLATEEXPORT struct libdeflate_compressor *
-libdeflate_alloc_compressor(int compression_level);
-
-LIBDEFLATEEXPORT struct libdeflate_compressor *
-libdeflate_alloc_compressor2(int compression_level, const void *shared_dict);
-
-/**
- * libdeflate_compress() performs raw DEFLATE compression on a buffer of
- * data.  The function attempts to compress 'in_nbytes' bytes of data located at
- * 'in' and write the results to 'out', which has space for 'out_nbytes_avail'
- * bytes.  The return value is the compressed size in bytes, or 0 if the data
- * could not be compressed to 'out_nbytes_avail' bytes or fewer.
- */
-LIBDEFLATEEXPORT size_t
-libdeflate_compress(struct libdeflate_compressor *compressor,
-			    const void *in, size_t in_nbytes,
-			    void *out, size_t out_nbytes_avail);
-
-/**
- * libdeflate_compress_bound() returns a worst-case upper bound on the
- * number of bytes of compressed data that may be produced by compressing any
- * buffer of length less than or equal to 'in_nbytes' using
- * libdeflate_compress() with the specified compressor.  Mathematically,
- * this bound will necessarily be a number greater than or equal to 'in_nbytes'.
- * It may be an overestimate of the true upper bound.  The return value is
- * guaranteed to be the same for all invocations with the same compressor and
- * same 'in_nbytes'.
- *
- * Note that this function is not necessary in many applications.  With
- * block-based compression, it is usually preferable to separately store the
- * uncompressed size of each block and to store any blocks that did not compress
- * to less than their original size uncompressed.  In that scenario, there is no
- * need to know the worst-case compressed size, since the maximum number of
- * bytes of compressed data that may be used would always be one less than the
- * input length.  You can just pass a buffer of that size to
- * libdeflate_compress() and store the data uncompressed if
- * libdeflate_compress() returns 0, indicating that the compressed data
- * did not fit into the provided output buffer.
- */
-LIBDEFLATEEXPORT size_t
-libdeflate_compress_bound(size_t in_nbytes);
-
-static inline size_t
-libdeflate_compress_bound_block(size_t in_block_nbytes)
-{
-    return libdeflate_compress_bound(in_block_nbytes) + 5;
-}
-
-/**
- * libdeflate_free_compressor() frees a compressor that was allocated with
- * libdeflate_alloc_compressor().
- * If a NULL pointer is passed in, no action is taken.
- */
-LIBDEFLATEEXPORT void
-libdeflate_free_compressor(struct libdeflate_compressor *compressor);
-
-/* ========================================================================== */
-/*                             Decompression                                  */
-/* ========================================================================== */
-
-struct libdeflate_decompressor;
-
-/**
- * libdeflate_alloc_decompressor() allocates a new decompressor.
- * The return value is a pointer to
- * the new decompressor, or NULL if out of memory.
- *
- * This function takes no parameters, and the returned decompressor is valid for
- * decompressing data that was compressed at any compression level and with any
- * sliding window size.
- *
- * A single decompressor is not safe to use by multiple threads concurrently.
- * However, different threads may use different decompressors concurrently.
- */
-LIBDEFLATEEXPORT struct libdeflate_decompressor *
-libdeflate_alloc_decompressor(void);
-
-/**
- * Result of a call to libdeflate_decompress().
- */
-enum libdeflate_result {
-    /**
-     * Decompression was successful.
-     */
-    LIBDEFLATE_SUCCESS = 0,
-
-    /**
-     * Decompressed failed because the compressed data was invalid, corrupt,
-     * or otherwise unsupported.
-     */
-    LIBDEFLATE_BAD_DATA = 1,
-
-    /**
-     * A NULL 'actual_out_nbytes_ret' was provided, but the data would have
-     * decompressed to fewer than 'out_nbytes_avail' bytes.
-     */
-    LIBDEFLATE_SHORT_OUTPUT = 2,
-
-    /**
-     * The data would have decompressed to more than 'out_nbytes_avail'
-     * bytes.
-     */
-    LIBDEFLATE_INSUFFICIENT_SPACE = 3,
-
-    /**
-     * More blocks availbled for decompression.
-     * Only returned by libdeflate_decompress_block().
-     */
-    LIBDEFLATE_MORE = 4,
-};
-
-/**
- * libdeflate_decompress() decompresses the DEFLATE-compressed stream
- * from the buffer 'in' with compressed size up to 'in_nbytes' bytes.
- * The uncompressed data is written to 'out', a buffer with size 'out_nbytes_avail'
- * bytes.  If decompression succeeds, then 0 (LIBDEFLATE_SUCCESS) is returned.
- * Otherwise, a nonzero result code such as LIBDEFLATE_BAD_DATA is returned.  If
- * a nonzero result code is returned, then the contents of the output buffer are
- * undefined.
- *
- * Decompression stops at the end of the DEFLATE stream (as indicated by the
- * BFINAL flag), even if it is actually shorter than 'in_nbytes' bytes.
- *
- * libdeflate_decompress() can be used in cases where the actual
- * uncompressed size is known (recommended) or unknown (not recommended):
- *
- *   - If the actual uncompressed size is known, then pass the actual
- *     uncompressed size as 'out_nbytes_avail' and pass NULL for
- *     'actual_out_nbytes_ret'.  This makes libdeflate_decompress() fail
- *     with LIBDEFLATE_SHORT_OUTPUT if the data decompressed to fewer than the
- *     specified number of bytes.
- *
- *   - If the actual uncompressed size is unknown, then provide a non-NULL
- *     'actual_out_nbytes_ret' and provide a buffer with some size
- *     'out_nbytes_avail' that you think is large enough to hold all the
- *     uncompressed data.  In this case, if the data decompresses to less than
- *     or equal to 'out_nbytes_avail' bytes, then
- *     libdeflate_decompress() will write the actual uncompressed size
- *     to *actual_out_nbytes_ret and return 0 (LIBDEFLATE_SUCCESS).  Otherwise,
- *     it will return LIBDEFLATE_INSUFFICIENT_SPACE if the provided buffer was
- *     not large enough but no other problems were encountered, or another
- *     nonzero result code if decompression failed for another reason.
- */
-LIBDEFLATEEXPORT enum libdeflate_result
-libdeflate_decompress(struct libdeflate_decompressor *decompressor,
-			      const void *in, size_t in_nbytes,
-			      void *out, size_t out_nbytes_avail,
-			      size_t *actual_out_nbytes_ret);
-
-/**
- * Like libdeflate_decompress(), but adds the 'actual_in_nbytes_ret'
- * argument.
- * If decompression succeeds and 'actual_in_nbytes_ret' is not NULL,
- * then the actual compressed size of the DEFLATE stream (aligned to the next
- * byte boundary) is written to *actual_in_nbytes_ret.
- */
-LIBDEFLATEEXPORT enum libdeflate_result
-libdeflate_decompress_ex(struct libdeflate_decompressor *decompressor,
-				 const void *in, size_t in_nbytes,
-				 void *out, size_t out_nbytes_avail,
-				 size_t *actual_in_nbytes_ret,
-				 size_t *actual_out_nbytes_ret);
-
-/**
- * ctrl libdeflate_decompress_block() stop condition
- */
-enum libdeflate_decompress_stop_by {
-    LIBDEFLATE_STOP_BY_FINAL_BLOCK                = 0,
-    LIBDEFLATE_STOP_BY_ANY_BLOCK                  = 1,
-    LIBDEFLATE_STOP_BY_ANY_BLOCK_AND_FULL_INPUT   = 2,
-    LIBDEFLATE_STOP_BY_ANY_BLOCK_AND_FULL_OUTPUT  = 3,
-    LIBDEFLATE_STOP_BY_ANY_BLOCK_AND_FULL_OUTPUT_AND_IN_BYTE_ALIGN = 4,
-};
-
-/**
- * Decompress a DEFLATE block.
- * Large stream data can be decompress by calling libdeflate_decompress_block()
- * multiple times.  Each time call this function, 'out_block_with_in_dict' have
- * 'in_dict_nbytes' repeat of the last called's tail outputted uncompressed data
- * as dictionary data, and 'out_block_nbytes' new uncompressed data want be
- * decompressed;
- * The dictionary data size in_dict_nbytes<=32k, if it is greater than 32k, the extra
- * part of the previous part of the dictionary data is invalid.
- * libdeflate_compress_bound_block(out_block_nbytes) can get the upper limit
- * of 'in_part' required space 'in_part_nbytes_bound'.
- * 'is_final_block_ret' can be NULL.
- *
- * WARNING: This function must decompressed one full DEFLATE block before stop;
- * so 'in_part_nbytes_bound' must possess a block end flag, and "out_block_nbytes"
- * must be able to store uncompressed data of this block decompressed;
- * This feature is not compatible with the DEFLATE stream decoding standard,
- * this function can't support a single DEFLATE block that may have any length.
- */
-LIBDEFLATEEXPORT enum libdeflate_result
-libdeflate_decompress_block(struct libdeflate_decompressor *decompressor,
-                 const void *in_part, size_t in_part_nbytes_bound,
-                 void *out_block_with_in_dict, size_t in_dict_nbytes, size_t out_block_nbytes,
-                 size_t *actual_in_nbytes_ret, size_t *actual_out_nbytes_ret,
-                 enum libdeflate_decompress_stop_by stop_type);
-
-/**
- * Clear the block decompressor save state.
- * Clear the state saved between calls libdeflate_decompress_block();
- * if you know the next block does not depend on the inputted data of the previous
- * block, you can call this function reset 'decompressor';
- * Note: if next block depend on the inputted data of the previous block, reset will
- * cause libdeflate_decompress_block() to fail.
- */
-LIBDEFLATEEXPORT void
-libdeflate_decompress_block_reset(struct libdeflate_decompressor *decompressor);
-
-struct libdeflate_block_state {
-    size_t cur_block_size;
-    size_t data_cur;
-    size_t out_cur;
-    size_t data_buf_size;
-    uint8_t *data_buf;
-};
-
-/**
- * Initialize a block state struct.
- * struct libdeflate_block_state is used with libdeflate_decompress_stream().
- */
-LIBDEFLATEEXPORT struct libdeflate_block_state
-libdeflate_block_state_init(size_t max_block_size);
-
-/**
- * Increase the buffer size in a struct libdeflate_block_state.
- * This function should be called if libdeflate_decompress_stream() returns with
- * LIBDEFLATE_INSUFFICIENT_SPACE. Decompression should be retried only if this
- * function returns `true`.
- * @return value `true` if a larger buffer was allocated;
- *               `false` if the buffer wasn't changed.
- */
-LIBDEFLATEEXPORT bool
-libdeflate_block_state_growbuf(struct libdeflate_block_state *state);
-
-/**
- * Deinitialize struct libdeflate_block_state.
- * This frees data_buf.
- */
-LIBDEFLATEEXPORT void
-libdeflate_block_state_deinit(struct libdeflate_block_state *state);
-
-typedef int (*libdeflate_decompress_stream_cb_t)(void * ctx, const uint8_t * buf, size_t dict_len, size_t data_len);
-
-/**
- * Decompress deflated string in_buf block by block.
- * Call libdeflate_block_state_init() before and libdeflate_block_state_deinit() after.
- * @param cb is a callback that will be called for each decompressed block.
- *           Decompression is interrupted if the callback returns a non-zero value.
- * @param result returns the non-zero return value of cb.
- */
-LIBDEFLATEEXPORT enum libdeflate_result
-libdeflate_decompress_stream(
-        struct libdeflate_decompressor *decompressor,
-        struct libdeflate_block_state *state,
-        const char *in_buf, size_t in_len,
-        libdeflate_decompress_stream_cb_t cb, void *ctx,
-        int *result);
-
-/**
- * Free a decompressor.
- * libdeflate_free_decompressor() frees a decompressor that was allocated with
- * libdeflate_alloc_decompressor().  If a NULL pointer is passed in, no action
- * is taken.
- */
-LIBDEFLATEEXPORT void
-libdeflate_free_decompressor(struct libdeflate_decompressor *decompressor);
-
-#endif /* LIBDEFLATE_H */

package/dist/lib/linux_aarch64/include/libdeflate_strings.h

@@ -1,35 +0,0 @@
-/*
- * Copyright (c) 2024 SAULX
- * SPDX-License-Identifier: MIT
- */
-#pragma once
-
-#include <stddef.h>
-#include <stdint.h>
-
-#ifndef LIBDEFLATEEXPORT
-#ifdef BUILDING_LIBDEFLATE
-#define LIBDEFLATEEXPORT __attribute__((visibility("default")))
-#else
-#define LIBDEFLATEEXPORT
-#endif
-#endif
-
-struct libdeflate_block_state;
-struct libdeflate_decompressor;
-
-/**
- * Test if the compressed string in_buf is equivalent to the buffer poited by ptr2_buf.
- * First string deflated and second not
- * @return Same as memcmp().
-  */
-LIBDEFLATEEXPORT int
-libdeflate_memcmp(struct libdeflate_decompressor *decompressor, struct libdeflate_block_state *state, const char *in_buf, size_t in_len, const void *ptr2_buf, size_t ptr2_len);
-
-/**
- * Test if the compressed string in_buf includes the string needle_buf.
- * First string deflated and second not
- * @return Same as memmem().
-  */
-LIBDEFLATEEXPORT int64_t
-libdeflate_memmem(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);