Initial project import

tools/v/thirdparty/zstd/README.md

@@ -0,0 +1,44 @@
+# [facebook/zstd](https://github.com/facebook/zstd)
+
+Zstandard - Fast real-time compression algorithm.
+
+<!-- zstd.c patch:
+```c
+#if defined(__TINYC__) && defined(\_WIN32)
+#undef ZSTD_MULTITHREAD
+#define ZSTD_NO_INTRINSICS
+#endif
+``` -->
+
+## BSD License
+
+```
+For Zstandard software
+
+Copyright (c) Meta Platforms, Inc. and affiliates. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+ * 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.
+
+ * Neither the name Facebook, nor Meta, nor the names of its contributors may
+   be used to endorse or promote products derived from this software without
+   specific prior written permission.
+
+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 HOLDER 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.
+```

tools/v/thirdparty/zstd/fix.md

@@ -0,0 +1,7 @@
+The changes here are produced by modifying `thirdparty/zstd/zstd_v.patch`,
+and then running `v thirdparty/zstd/update.vsh` .
+
+You can generate a new patch by:
+`diff -u zstd-1.5.7/build/single_file_libs/zstd.c thirdparty/zstd/zstd.c > zstd_custom.patch`
+
+BTW, patch is between `/* >> v_patch start */` and `/* << v_patch end */` mostly.

tools/v/thirdparty/zstd/update.vsh

@@ -0,0 +1,22 @@
+// Use this script to update thirdparty/zstd to a future version of mbedtls.
+import os
+
+fn do(cmd string) {
+	println(cmd)
+	res := os.system(cmd)
+	if res != 0 {
+		panic('failed at: `${cmd}`')
+	}
+}
+
+os.chdir(os.dir(@VEXE))!
+
+version := '1.5.7'
+do('rm -rf zstd-${version}*')
+do('wget https://github.com/facebook/zstd/releases/download/v${version}/zstd-${version}.tar.gz')
+do('tar -xf zstd-${version}.tar.gz')
+do('pushd .; cd zstd-${version}/build/single_file_libs/; ./create_single_file_library.sh; popd')
+do('cp zstd-${version}/build/single_file_libs/zstd.c thirdparty/zstd/zstd.c')
+do('pushd .; cd thirdparty/zstd/; patch --verbose --unified -p0 --input zstd_v.patch; popd')
+do('rm -rf zstd-${version}*')
+println('DONE')

tools/v/thirdparty/zstd/zstd_v.patch

@@ -0,0 +1,117 @@
+--- zstd.c	2026-01-10 14:25:18.651952689 +0100
++++ zstd.c	2026-01-09 17:55:20.698628329 +0100
+@@ -50,6 +50,27 @@
+ /* TODO: Can't amalgamate ASM function */
+ #define ZSTD_DISABLE_ASM 1
+ 
++/* >> v_patch start */
++#if defined(__TINYC__)
++
++#if defined(_WIN32)
++#undef ZSTD_MULTITHREAD
++#define ZSTD_NO_INTRINSICS
++#endif
++
++/* tcc doesn't support ARM asm */
++#if defined(__arm__) || defined(__aarch64__)
++#define NO_PREFETCH
++#endif
++
++#if defined(__FreeBSD__) || defined(__OpenBSD__)
++/* tcc on FreeBSD/OpenBSD define __GNUC__, but it can't work here */
++#undef __GNUC__
++#endif
++
++#endif /* __TINYC__ */
++/* << v_patch end */
++
+ /* Include zstd_deps.h first with all the options we need enabled. */
+ #define ZSTD_DEPS_NEED_MALLOC
+ #define ZSTD_DEPS_NEED_MATH64
+@@ -698,7 +719,7 @@
+ /* vectorization
+  * older GCC (pre gcc-4.3 picked as the cutoff) uses a different syntax,
+  * and some compilers, like Intel ICC and MCST LCC, do not support it at all. */
+-#if !defined(__INTEL_COMPILER) && !defined(__clang__) && defined(__GNUC__) && !defined(__LCC__)
++#if !defined(__INTEL_COMPILER) && !defined(__clang__) && defined(__GNUC__) && !defined(__LCC__) && !defined(__TINYC__)
+ #  if (__GNUC__ == 4 && __GNUC_MINOR__ > 3) || (__GNUC__ >= 5)
+ #    define DONT_VECTORIZE __attribute__((optimize("no-tree-vectorize")))
+ #  else
+@@ -22353,7 +22374,7 @@
+ ZSTD_GEN_RECORD_FINGERPRINT(43, 8)
+ 
+ 
+-static U64 abs64(S64 s64) { return (U64)((s64 < 0) ? -s64 : s64); }
++static U64 zstd_abs64(S64 s64) { return (U64)((s64 < 0) ? -s64 : s64); }
+ 
+ static U64 fpDistance(const Fingerprint* fp1, const Fingerprint* fp2, unsigned hashLog)
+ {
+@@ -22362,7 +22383,7 @@
+     assert(hashLog <= HASHLOG_MAX);
+     for (n = 0; n < ((size_t)1 << hashLog); n++) {
+         distance +=
+-            abs64((S64)fp1->events[n] * (S64)fp2->nbEvents - (S64)fp2->events[n] * (S64)fp1->nbEvents);
++            zstd_abs64((S64)fp1->events[n] * (S64)fp2->nbEvents - (S64)fp2->events[n] * (S64)fp1->nbEvents);
+     }
+     return distance;
+ }
+@@ -22482,7 +22503,7 @@
+     {   U64 const distFromBegin = fpDistance(&fpstats->pastEvents, middleEvents, 8);
+         U64 const distFromEnd = fpDistance(&fpstats->newEvents, middleEvents, 8);
+         U64 const minDistance = SEGMENT_SIZE * SEGMENT_SIZE / 3;
+-        if (abs64((S64)distFromBegin - (S64)distFromEnd) < minDistance)
++        if (zstd_abs64((S64)distFromBegin - (S64)distFromEnd) < minDistance)
+             return 64 KB;
+         return (distFromBegin > distFromEnd) ? 32 KB : 96 KB;
+     }
+@@ -47318,8 +47339,9 @@
+   unsigned d;
+ } COVER_ctx_t;
+ 
+-#if !defined(_GNU_SOURCE) && !defined(__APPLE__) && !defined(_MSC_VER)
+-/* C90 only offers qsort() that needs a global context. */
++#if defined(ZSTD_USE_C90_QSORT) \
++  || (!defined(_GNU_SOURCE) && !defined(__APPLE__) && !defined(_MSC_VER))
++/* Use global context for non-reentrant sort functions */
+ static COVER_ctx_t *g_coverCtx = NULL;
+ #endif
+ 
+@@ -47390,7 +47412,7 @@ static int COVER_cmp8(COVER_ctx_t *ctx, const void *lp, const void *rp) {
+  * Same as COVER_cmp() except ties are broken by pointer value
+  */
+ #if (defined(_WIN32) && defined(_MSC_VER)) || defined(__APPLE__)
+ static int WIN_CDECL COVER_strict_cmp(void* g_coverCtx, const void* lp, const void* rp) {
+-#elif defined(_GNU_SOURCE)
++#elif defined(_GNU_SOURCE) && !defined(ZSTD_USE_C90_QSORT)
+ static int COVER_strict_cmp(const void *lp, const void *rp, void *g_coverCtx) {
+ #else /* C90 fallback.*/
+ static int COVER_strict_cmp(const void *lp, const void *rp) {
+@@ -47406,7 +47428,7 @@ static int COVER_strict_cmp(const void *lp, const void *rp) {
+  * Faster version for d <= 8.
+  */
+ #if (defined(_WIN32) && defined(_MSC_VER)) || defined(__APPLE__)
+ static int WIN_CDECL COVER_strict_cmp8(void* g_coverCtx, const void* lp, const void* rp) {
+-#elif defined(_GNU_SOURCE)
++#elif defined(_GNU_SOURCE) && !defined(ZSTD_USE_C90_QSORT)
+ static int COVER_strict_cmp8(const void *lp, const void *rp, void *g_coverCtx) {
+ #else /* C90 fallback.*/
+ static int COVER_strict_cmp8(const void *lp, const void *rp) {
+ 
+@@ -47405,7 +47427,7 @@
+     qsort_r(ctx->suffix, ctx->suffixSize, sizeof(U32),
+             ctx,
+             (ctx->d <= 8 ? &COVER_strict_cmp8 : &COVER_strict_cmp));
+-#elif defined(_GNU_SOURCE)
++#elif defined(_GNU_SOURCE) && !defined(ZSTD_USE_C90_QSORT)
+     qsort_r(ctx->suffix, ctx->suffixSize, sizeof(U32),
+             (ctx->d <= 8 ? &COVER_strict_cmp8 : &COVER_strict_cmp),
+             ctx);
+@@ -47419,7 +47441,7 @@
+           (ctx->d <= 8 ? &COVER_strict_cmp8 : &COVER_strict_cmp));
+ #else /* C90 fallback.*/
+     g_coverCtx = ctx;
+-    /* TODO(cavalcanti): implement a reentrant qsort() when is not available. */
++    /* TODO(cavalcanti): implement a reentrant qsort() when _r is not available. */
+     qsort(ctx->suffix, ctx->suffixSize, sizeof(U32),
+           (ctx->d <= 8 ? &COVER_strict_cmp8 : &COVER_strict_cmp));
+ #endif