OSSForks/node
1
0
Fork 0
mirror of https://github.com/zebrajr/node.git synced 2026-01-15 12:15:26 +00:00
Code Issues Actions 8 Packages Projects Releases Wiki Activity

deps: update nbytes and add update script

Browse Source 
PR-URL: https://github.com/nodejs/node/pull/53790
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
This commit is contained in:
Yagiz Nizipli
2024-07-12 09:58:08 -04:00
committed by GitHub
parent 24648b5769
commit bcdbf88374
15 changed files with 423 additions and 225 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
.github/workflows/tools.yml vendored
View File

@@ -31,6 +31,7 @@ on:
- lint-md-dependencies
- llhttp
- minimatch
- nbytes
- nghttp2
- nghttp3
- ngtcp2
@@ -220,6 +221,14 @@ jobs:
cat temp-output
tail -n1 temp-output | grep "NEW_VERSION=" >> "$GITHUB_ENV" || true
rm temp-output
- id: nbytes
subsystem: deps
label: dependencies
run: |
./tools/dep_updaters/update-nbytes.sh > temp-output
cat temp-output
tail -n1 temp-output | grep "NEW_VERSION=" >> "$GITHUB_ENV" || true
rm temp-output
- id: nghttp2
subsystem: deps
label: dependencies

2
deps/nbytes/.clang-format vendored Normal file
View File

@@ -0,0 +1,2 @@
BasedOnStyle: Google
SortIncludes: Never

2
deps/nbytes/.gitignore vendored Normal file
View File

@@ -0,0 +1,2 @@
cmake-build-debug
build

1
deps/nbytes/.python-version vendored Normal file
View File

@@ -0,0 +1 @@
3.12

42
deps/nbytes/CMakeLists.txt vendored Normal file
View File

@@ -0,0 +1,42 @@
cmake_minimum_required(VERSION 3.28)
project(nbytes)
set(CMAKE_CXX_STANDARD 20)
set(CMAKE_CXX_STANDARD_REQUIRED True)
if (NOT CMAKE_BUILD_TYPE)
message(STATUS "No build type selected, default to Release")
set(CMAKE_BUILD_TYPE Release CACHE STRING "Choose the type of build." FORCE)
endif()
option(NBYTES_DEVELOPMENT_CHECKS "Enable development checks" OFF)
include(GNUInstallDirs)
include(FetchContent)
FetchContent_Declare(
googletest
URL https://github.com/google/googletest/archive/03597a01ee50ed33e9dfd640b249b4be3799d395.zip
)
# For Windows: Prevent overriding the parent project's compiler/linker settings
set(gtest_force_shared_crt ON CACHE BOOL "" FORCE)
FetchContent_MakeAvailable(googletest)
add_subdirectory(src)
enable_testing()
add_subdirectory(tests)
install(
FILES include/nbytes.h
DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}"
COMPONENT nbytes_development
)
install(
TARGETS nbytes
EXPORT nbytes_targets
RUNTIME COMPONENT nbytes_runtime
LIBRARY COMPONENT nbytes_runtime
NAMELINK_COMPONENT nbytes_development
ARCHIVE COMPONENT nbytes_development
INCLUDES DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}"
)

21
deps/nbytes/LICENSE vendored Normal file
View File

@@ -0,0 +1,21 @@
MIT License
Copyright (c) 2024 Node.js
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

262
deps/nbytes/nbytes.h → deps/nbytes/include/nbytes.h vendored
View File

@@ -1,24 +1,24 @@
#pragma once
#ifndef NBYTES_H
#define NBYTES_H
#include <algorithm>
#include <string>
#include <cmath>
#include <cstddef>
#include <cstdint>
#include <cstring>
#include <cmath>
#include <string>
namespace nbytes {
#if NBYTES_DEVELOPMENT_CHECKS
#define NBYTES_STR(x) #x
#define NBYTES_REQUIRE(EXPR) \
{ \
#define NBYTES_REQUIRE(EXPR) \
{ \
if (!(EXPR) { abort(); }) }
#define NBYTES_FAIL(MESSAGE) \
do { \
std::cerr << "FAIL: " << (MESSAGE) << std::endl; \
abort(); \
#define NBYTES_FAIL(MESSAGE) \
do { \
std::cerr << "FAIL: " << (MESSAGE) << std::endl; \
abort(); \
} while (0);
#define NBYTES_ASSERT_EQUAL(LHS, RHS, MESSAGE) \
do { \
@@ -27,13 +27,13 @@ namespace nbytes {
NBYTES_FAIL(MESSAGE); \
} \
} while (0);
#define NBYTES_ASSERT_TRUE(COND) \
do { \
if (!(COND)) { \
std::cerr << "Assert at line " << __LINE__ << " of file " << __FILE__ \
<< std::endl; \
NBYTES_FAIL(NBYTES_STR(COND)); \
} \
#define NBYTES_ASSERT_TRUE(COND) \
do { \
if (!(COND)) { \
std::cerr << "Assert at line " << __LINE__ << " of file " << __FILE__ \
<< std::endl; \
NBYTES_FAIL(NBYTES_STR(COND)); \
} \
} while (0);
#else
#define NBYTES_FAIL(MESSAGE)
@@ -64,8 +64,8 @@ constexpr T RoundUp(T a, T b) {
// Align ptr to an `alignment`-bytes boundary.
template <typename T, typename U>
constexpr T* AlignUp(T* ptr, U alignment) {
return reinterpret_cast<T*>(
constexpr T *AlignUp(T *ptr, U alignment) {
return reinterpret_cast<T *>(
RoundUp(reinterpret_cast<uintptr_t>(ptr), alignment));
}
@@ -85,17 +85,17 @@ inline T MultiplyWithOverflowCheck(T a, T b) {
return ret;
}
void ForceAsciiSlow(const char* src, char* dst, size_t len);
void ForceAscii(const char* src, char* dst, size_t len);
void ForceAsciiSlow(const char *src, char *dst, size_t len);
void ForceAscii(const char *src, char *dst, size_t len);
// ============================================================================
// Byte Swapping
// Swaps bytes in place. nbytes is the number of bytes to swap and must be a
// multiple of the word size (checked by function).
bool SwapBytes16(void* data, size_t nbytes);
bool SwapBytes32(void* data, size_t nbytes);
bool SwapBytes64(void* data, size_t nbytes);
bool SwapBytes16(void *data, size_t nbytes);
bool SwapBytes32(void *data, size_t nbytes);
bool SwapBytes64(void *data, size_t nbytes);
// ============================================================================
// Base64 (legacy)
@@ -109,22 +109,22 @@ bool SwapBytes64(void* data, size_t nbytes);
extern const int8_t unbase64_table[256];
template <typename TypeName>
bool Base64DecodeGroupSlow(char* const dst, const size_t dstlen,
const TypeName* const src, const size_t srclen,
size_t* const i, size_t* const k) {
bool Base64DecodeGroupSlow(char *const dst, const size_t dstlen,
const TypeName *const src, const size_t srclen,
size_t *const i, size_t *const k) {
uint8_t hi;
uint8_t lo;
#define V(expr) \
for (;;) { \
const uint8_t c = static_cast<uint8_t>(src[*i]); \
lo = unbase64_table[c]; \
*i += 1; \
if (lo < 64) break; /* Legal character. */ \
if (c == '=' || *i >= srclen) return false; /* Stop decoding. */ \
} \
expr; \
if (*i >= srclen) return false; \
if (*k >= dstlen) return false; \
#define V(expr) \
for (;;) { \
const uint8_t c = static_cast<uint8_t>(src[*i]); \
lo = unbase64_table[c]; \
*i += 1; \
if (lo < 64) break; /* Legal character. */ \
if (c == '=' || *i >= srclen) return false; /* Stop decoding. */ \
} \
expr; \
if (*i >= srclen) return false; \
if (*k >= dstlen) return false; \
hi = lo;
V(/* Nothing. */);
V(dst[(*k)++] = ((hi & 0x3F) << 2) | ((lo & 0x30) >> 4));
@@ -134,14 +134,10 @@ bool Base64DecodeGroupSlow(char* const dst, const size_t dstlen,
return true; // Continue decoding.
}
enum class Base64Mode {
NORMAL,
URL
};
enum class Base64Mode { NORMAL, URL };
inline constexpr size_t Base64EncodedSize(
size_t size,
Base64Mode mode = Base64Mode::NORMAL) {
size_t size, Base64Mode mode = Base64Mode::NORMAL) {
return mode == Base64Mode::NORMAL ? ((size + 2) / 3 * 4)
: static_cast<size_t>(std::ceil(
static_cast<double>(size * 4) / 3));
@@ -153,30 +149,27 @@ inline constexpr size_t Base64DecodedSizeFast(size_t size) {
return size > 1 ? (size / 4) * 3 + (size % 4 + 1) / 2 : 0;
}
inline uint32_t ReadUint32BE(const unsigned char* p) {
inline uint32_t ReadUint32BE(const unsigned char *p) {
return static_cast<uint32_t>(p[0] << 24U) |
static_cast<uint32_t>(p[1] << 16U) |
static_cast<uint32_t>(p[2] << 8U) |
static_cast<uint32_t>(p[3]);
static_cast<uint32_t>(p[2] << 8U) | static_cast<uint32_t>(p[3]);
}
template <typename TypeName>
size_t Base64DecodedSize(const TypeName* src, size_t size) {
size_t Base64DecodedSize(const TypeName *src, size_t size) {
// 1-byte input cannot be decoded
if (size < 2)
return 0;
if (size < 2) return 0;
if (src[size - 1] == '=') {
size--;
if (src[size - 1] == '=')
size--;
if (src[size - 1] == '=') size--;
}
return Base64DecodedSizeFast(size);
}
template <typename TypeName>
size_t Base64DecodeFast(char* const dst, const size_t dstlen,
const TypeName* const src, const size_t srclen,
size_t Base64DecodeFast(char *const dst, const size_t dstlen,
const TypeName *const src, const size_t srclen,
const size_t decoded_size) {
const size_t available = dstlen < decoded_size ? dstlen : decoded_size;
const size_t max_k = available / 3 * 3;
@@ -185,22 +178,25 @@ size_t Base64DecodeFast(char* const dst, const size_t dstlen,
size_t k = 0;
while (i < max_i && k < max_k) {
const unsigned char txt[] = {
static_cast<unsigned char>(unbase64_table[static_cast<uint8_t>(src[i + 0])]),
static_cast<unsigned char>(unbase64_table[static_cast<uint8_t>(src[i + 1])]),
static_cast<unsigned char>(unbase64_table[static_cast<uint8_t>(src[i + 2])]),
static_cast<unsigned char>(unbase64_table[static_cast<uint8_t>(src[i + 3])]),
static_cast<unsigned char>(
unbase64_table[static_cast<uint8_t>(src[i + 0])]),
static_cast<unsigned char>(
unbase64_table[static_cast<uint8_t>(src[i + 1])]),
static_cast<unsigned char>(
unbase64_table[static_cast<uint8_t>(src[i + 2])]),
static_cast<unsigned char>(
unbase64_table[static_cast<uint8_t>(src[i + 3])]),
};
const uint32_t v = ReadUint32BE(txt);
// If MSB is set, input contains whitespace or is not valid base64.
if (v & 0x80808080) {
if (!Base64DecodeGroupSlow(dst, dstlen, src, srclen, &i, &k))
return k;
if (!Base64DecodeGroupSlow(dst, dstlen, src, srclen, &i, &k)) return k;
max_i = i + (srclen - i) / 4 * 4; // Align max_i again.
} else {
dst[k + 0] = ((v >> 22) & 0xFC) | ((v >> 20) & 0x03);
dst[k + 1] = ((v >> 12) & 0xF0) | ((v >> 10) & 0x0F);
dst[k + 2] = ((v >> 2) & 0xC0) | ((v >> 0) & 0x3F);
dst[k + 2] = ((v >> 2) & 0xC0) | ((v >> 0) & 0x3F);
i += 4;
k += 3;
}
@@ -212,8 +208,8 @@ size_t Base64DecodeFast(char* const dst, const size_t dstlen,
}
template <typename TypeName>
size_t Base64Decode(char* const dst, const size_t dstlen,
const TypeName* const src, const size_t srclen) {
size_t Base64Decode(char *const dst, const size_t dstlen,
const TypeName *const src, const size_t srclen) {
const size_t decoded_size = Base64DecodedSize(src, srclen);
return Base64DecodeFast(dst, dstlen, src, srclen, decoded_size);
}
@@ -228,29 +224,22 @@ size_t Base64Decode(char* const dst, const size_t dstlen,
extern const int8_t unhex_table[256];
template <typename TypeName>
static size_t HexDecode(char* buf,
size_t len,
const TypeName* src,
static size_t HexDecode(char *buf, size_t len, const TypeName *src,
const size_t srcLen) {
size_t i;
for (i = 0; i < len && i * 2 + 1 < srcLen; ++i) {
unsigned a = unhex_table[static_cast<uint8_t>(src[i * 2 + 0])];
unsigned b = unhex_table[static_cast<uint8_t>(src[i * 2 + 1])];
if (!~a || !~b)
return i;
if (!~a || !~b) return i;
buf[i] = (a << 4) | b;
}
return i;
}
size_t HexEncode(
const char* src,
size_t slen,
char* dst,
size_t dlen);
size_t HexEncode(const char *src, size_t slen, char *dst, size_t dlen);
std::string HexEncode(const char* src, size_t slen);
std::string HexEncode(const char *src, size_t slen);
// ============================================================================
// StringSearch
@@ -260,14 +249,14 @@ namespace stringsearch {
template <typename T>
class Vector {
public:
Vector(T* data, size_t length, bool isForward)
Vector(T *data, size_t length, bool isForward)
: start_(data), length_(length), is_forward_(isForward) {
CHECK(length > 0 && data != nullptr);
}
// Returns the start of the memory range.
// For vector v this is NOT necessarily &v[0], see forward().
const T* start() const { return start_; }
const T *start() const { return start_; }
// Returns the length of the vector, in characters.
size_t length() const { return length_; }
@@ -277,13 +266,13 @@ class Vector {
bool forward() const { return is_forward_; }
// Access individual vector elements - checks bounds in debug mode.
T& operator[](size_t index) const {
T &operator[](size_t index) const {
NBYTES_ASSERT_TRUE(index < length_);
return start_[is_forward_ ? index : (length_ - index - 1)];
}
private:
T* start_;
T *start_;
size_t length_;
bool is_forward_;
};
@@ -331,8 +320,7 @@ class StringSearch : private StringSearchBase {
public:
typedef stringsearch::Vector<const Char> Vector;
explicit StringSearch(Vector pattern)
: pattern_(pattern), start_(0) {
explicit StringSearch(Vector pattern) : pattern_(pattern), start_(0) {
if (pattern.length() >= kBMMaxShift) {
start_ = pattern.length() - kBMMaxShift;
}
@@ -375,9 +363,9 @@ class StringSearch : private StringSearchBase {
return kUC16AlphabetSize;
}
static_assert(sizeof(Char) == sizeof(uint8_t) ||
sizeof(Char) == sizeof(uint16_t),
"sizeof(Char) == sizeof(uint16_t) || sizeof(uint8_t)");
static_assert(
sizeof(Char) == sizeof(uint8_t) || sizeof(Char) == sizeof(uint16_t),
"sizeof(Char) == sizeof(uint16_t) || sizeof(uint8_t)");
}
private:
@@ -392,8 +380,7 @@ class StringSearch : private StringSearchBase {
void PopulateBoyerMooreTable();
static inline int CharOccurrence(int* bad_char_occurrence,
Char char_code) {
static inline int CharOccurrence(int *bad_char_occurrence, Char char_code) {
if (sizeof(Char) == 1) {
return bad_char_occurrence[static_cast<int>(char_code)];
}
@@ -427,12 +414,12 @@ inline uint8_t GetHighestValueByte(uint8_t character) { return character; }
// Searches for a byte value in a memory buffer, back to front.
// Uses memrchr(3) on systems which support it, for speed.
// Falls back to a vanilla for loop on non-GNU systems such as Windows.
inline const void* MemrchrFill(const void* haystack, uint8_t needle,
inline const void *MemrchrFill(const void *haystack, uint8_t needle,
size_t haystack_len) {
#ifdef _GNU_SOURCE
return memrchr(haystack, needle, haystack_len);
#else
const uint8_t* haystack8 = static_cast<const uint8_t*>(haystack);
const uint8_t *haystack8 = static_cast<const uint8_t *>(haystack);
for (size_t i = haystack_len - 1; i != static_cast<size_t>(-1); i--) {
if (haystack8[i] == needle) {
return haystack8 + i;
@@ -456,7 +443,7 @@ inline size_t FindFirstCharacter(Vector<const Char> pattern,
size_t pos = index;
do {
const size_t bytes_to_search = (max_n - pos) * sizeof(Char);
const void* void_pos;
const void *void_pos;
if (subject.forward()) {
// Assert that bytes_to_search won't overflow
NBYTES_ASSERT_TRUE(pos <= max_n);
@@ -466,12 +453,10 @@ inline size_t FindFirstCharacter(Vector<const Char> pattern,
NBYTES_ASSERT_TRUE(pos <= subject.length());
NBYTES_ASSERT_TRUE(subject.length() - pos <= SIZE_MAX / sizeof(Char));
void_pos = MemrchrFill(subject.start() + pattern.length() - 1,
search_byte,
bytes_to_search);
search_byte, bytes_to_search);
}
const Char* char_pos = static_cast<const Char*>(void_pos);
if (char_pos == nullptr)
return subject.length();
const Char *char_pos = static_cast<const Char *>(void_pos);
if (char_pos == nullptr) return subject.length();
// Then, for each match, verify that the full two bytes match pattern[0].
char_pos = AlignDown(char_pos, sizeof(Char));
@@ -491,21 +476,19 @@ inline size_t FindFirstCharacter(Vector<const Char> pattern,
// Does not verify that the whole pattern matches.
template <>
inline size_t FindFirstCharacter(Vector<const uint8_t> pattern,
Vector<const uint8_t> subject,
size_t index) {
Vector<const uint8_t> subject, size_t index) {
const uint8_t pattern_first_char = pattern[0];
const size_t subj_len = subject.length();
const size_t max_n = (subject.length() - pattern.length() + 1);
const void* pos;
const void *pos;
if (subject.forward()) {
pos = memchr(subject.start() + index, pattern_first_char, max_n - index);
} else {
pos = MemrchrFill(subject.start() + pattern.length() - 1,
pattern_first_char,
max_n - index);
pattern_first_char, max_n - index);
}
const uint8_t* char_pos = static_cast<const uint8_t*>(pos);
const uint8_t *char_pos = static_cast<const uint8_t *>(pos);
if (char_pos == nullptr) {
return subj_len;
}
@@ -519,9 +502,7 @@ inline size_t FindFirstCharacter(Vector<const uint8_t> pattern,
//---------------------------------------------------------------------
template <typename Char>
size_t StringSearch<Char>::SingleCharSearch(
Vector subject,
size_t index) {
size_t StringSearch<Char>::SingleCharSearch(Vector subject, size_t index) {
NBYTES_ASSERT_TRUE(1 == pattern_.length());
return FindFirstCharacter(pattern_, subject, index);
}
@@ -532,15 +513,12 @@ size_t StringSearch<Char>::SingleCharSearch(
// Simple linear search for short patterns. Never bails out.
template <typename Char>
size_t StringSearch<Char>::LinearSearch(
Vector subject,
size_t index) {
size_t StringSearch<Char>::LinearSearch(Vector subject, size_t index) {
NBYTES_ASSERT_TRUE(pattern_.length() > 1);
const size_t n = subject.length() - pattern_.length();
for (size_t i = index; i <= n; i++) {
i = FindFirstCharacter(pattern_, subject, i);
if (i == subject.length())
return subject.length();
if (i == subject.length()) return subject.length();
NBYTES_ASSERT_TRUE(i <= n);
bool matches = true;
@@ -562,16 +540,15 @@ size_t StringSearch<Char>::LinearSearch(
//---------------------------------------------------------------------
template <typename Char>
size_t StringSearch<Char>::BoyerMooreSearch(
Vector subject,
size_t start_index) {
size_t StringSearch<Char>::BoyerMooreSearch(Vector subject,
size_t start_index) {
const size_t subject_length = subject.length();
const size_t pattern_length = pattern_.length();
// Only preprocess at most kBMMaxShift last characters of pattern.
size_t start = start_;
int* bad_char_occurrence = bad_char_shift_table_;
int* good_suffix_shift = good_suffix_shift_table_ - start_;
int *bad_char_occurrence = bad_char_shift_table_;
int *good_suffix_shift = good_suffix_shift_table_ - start_;
Char last_char = pattern_[pattern_length - 1];
size_t index = start_index;
@@ -595,8 +572,8 @@ size_t StringSearch<Char>::BoyerMooreSearch(
if (j < start) {
// we have matched more than our tables allow us to be smart about.
// Fall back on BMH shift.
index += pattern_length - 1 -
CharOccurrence(bad_char_occurrence, last_char);
index +=
pattern_length - 1 - CharOccurrence(bad_char_occurrence, last_char);
} else {
int gs_shift = good_suffix_shift[j + 1];
int bc_occ = CharOccurrence(bad_char_occurrence, c);
@@ -621,8 +598,8 @@ void StringSearch<Char>::PopulateBoyerMooreTable() {
// Biased tables so that we can use pattern indices as table indices,
// even if we only cover the part of the pattern from offset start.
int* shift_table = good_suffix_shift_table_ - start_;
int* suffix_table = suffix_table_ - start_;
int *shift_table = good_suffix_shift_table_ - start_;
int *suffix_table = suffix_table_ - start_;
// Initialize table.
for (size_t i = start; i < pattern_length; i++) {
@@ -681,19 +658,17 @@ void StringSearch<Char>::PopulateBoyerMooreTable() {
//---------------------------------------------------------------------
template <typename Char>
size_t StringSearch<Char>::BoyerMooreHorspoolSearch(
Vector subject,
size_t start_index) {
size_t StringSearch<Char>::BoyerMooreHorspoolSearch(Vector subject,
size_t start_index) {
const size_t subject_length = subject.length();
const size_t pattern_length = pattern_.length();
int* char_occurrences = bad_char_shift_table_;
int *char_occurrences = bad_char_shift_table_;
int64_t badness = -static_cast<int64_t>(pattern_length);
// How bad we are doing without a good-suffix table.
Char last_char = pattern_[pattern_length - 1];
int last_char_shift =
pattern_length - 1 -
CharOccurrence(char_occurrences, last_char);
pattern_length - 1 - CharOccurrence(char_occurrences, last_char);
// Perform search
size_t index = start_index; // No matches found prior to this index.
@@ -735,7 +710,7 @@ template <typename Char>
void StringSearch<Char>::PopulateBoyerMooreHorspoolTable() {
const size_t pattern_length = pattern_.length();
int* bad_char_occurrence = bad_char_shift_table_;
int *bad_char_occurrence = bad_char_shift_table_;
// Only preprocess at most kBMMaxShift last characters of pattern.
const size_t start = start_;
@@ -765,9 +740,7 @@ void StringSearch<Char>::PopulateBoyerMooreHorspoolTable() {
// Simple linear search for short patterns, which bails out if the string
// isn't found very early in the subject. Upgrades to BoyerMooreHorspool.
template <typename Char>
size_t StringSearch<Char>::InitialSearch(
Vector subject,
size_t index) {
size_t StringSearch<Char>::InitialSearch(Vector subject, size_t index) {
const size_t pattern_length = pattern_.length();
// Badness is a count of how much work we have done. When we have
// done enough work we decide it's probably worth switching to a better
@@ -780,8 +753,7 @@ size_t StringSearch<Char>::InitialSearch(
badness++;
if (badness <= 0) {
i = FindFirstCharacter(pattern_, subject, i);
if (i == subject.length())
return subject.length();
if (i == subject.length()) return subject.length();
NBYTES_ASSERT_TRUE(i <= n);
size_t j = 1;
do {
@@ -808,8 +780,7 @@ size_t StringSearch<Char>::InitialSearch(
// object should be constructed once and the Search function then called
// for each search.
template <typename Char>
size_t SearchString(Vector<const Char> subject,
Vector<const Char> pattern,
size_t SearchString(Vector<const Char> subject, Vector<const Char> pattern,
size_t start_index) {
StringSearch<Char> search(pattern);
return search.Search(subject, start_index);
@@ -817,20 +788,17 @@ size_t SearchString(Vector<const Char> subject,
} // namespace stringsearch
template <typename Char>
size_t SearchString(const Char* haystack,
size_t haystack_length,
const Char* needle,
size_t needle_length,
size_t start_index,
bool is_forward) {
size_t SearchString(const Char *haystack, size_t haystack_length,
const Char *needle, size_t needle_length,
size_t start_index, bool is_forward) {
if (haystack_length < needle_length) return haystack_length;
// To do a reverse search (lastIndexOf instead of indexOf) without redundant
// code, create two vectors that are reversed views into the input strings.
// For example, v_needle[0] would return the *last* character of the needle.
// So we're searching for the first instance of rev(needle) in rev(haystack)
stringsearch::Vector<const Char> v_needle(needle, needle_length, is_forward);
stringsearch::Vector<const Char> v_haystack(
haystack, haystack_length, is_forward);
stringsearch::Vector<const Char> v_haystack(haystack, haystack_length,
is_forward);
size_t diff = haystack_length - needle_length;
size_t relative_start_index;
if (is_forward) {
@@ -840,8 +808,8 @@ size_t SearchString(const Char* haystack,
} else {
relative_start_index = diff - start_index;
}
size_t pos = stringsearch::SearchString(
v_haystack, v_needle, relative_start_index);
size_t pos =
stringsearch::SearchString(v_haystack, v_needle, relative_start_index);
if (pos == haystack_length) {
// not found
return pos;
@@ -850,21 +818,23 @@ size_t SearchString(const Char* haystack,
}
template <size_t N>
size_t SearchString(const char* haystack, size_t haystack_length,
size_t SearchString(const char *haystack, size_t haystack_length,
const char (&needle)[N]) {
return SearchString(
reinterpret_cast<const uint8_t*>(haystack), haystack_length,
reinterpret_cast<const uint8_t*>(needle), N - 1, 0, true);
reinterpret_cast<const uint8_t *>(haystack), haystack_length,
reinterpret_cast<const uint8_t *>(needle), N - 1, 0, true);
}
// ============================================================================
// Version metadata
#define NBYTES_VERSION "0.0.1"
#define NBYTES_VERSION "0.1.0"
enum {
NBYTES_VERSION_MAJOR = 0,
NBYTES_VERSION_MINOR = 0,
NBYTES_VERSION_REVISION = 1,
NBYTES_VERSION_MINOR = 1,
NBYTES_VERSION_REVISION = 0,
};
} // namespace nbytes
#endif // NBYTES_H

6
deps/nbytes/nbytes.gyp vendored
View File

@@ -1,14 +1,14 @@
{
'variables': {
'nbytes_sources': [ 'nbytes.cpp' ],
'nbytes_sources': [ 'src/nbytes.cpp' ],
},
'targets': [
{
'target_name': 'nbytes',
'type': 'static_library',
'include_dirs': ['.'],
'include_dirs': ['src', 'include'],
'direct_dependent_settings': {
'include_dirs': ['.'],
'include_dirs': ['src', 'include'],
},
'sources': [ '<@(nbytes_sources)' ]
},

38
deps/nbytes/pyproject.toml vendored Normal file
View File

@@ -0,0 +1,38 @@
[project]
name = "nbytes"
requires-python = ">=3.12"
[tool.ruff]
line-length = 120
target-version = "py312"
[tool.ruff.format]
quote-style = "single"
indent-style = "space"
docstring-code-format = true
[tool.ruff.lint]
select = [
"C90", # McCabe cyclomatic complexity
"E", # pycodestyle
"F", # Pyflakes
"ICN", # flake8-import-conventions
"INT", # flake8-gettext
"PLC", # Pylint conventions
"PLE", # Pylint errors
"PLR09", # Pylint refactoring: max-args, max-branches, max returns, max-statements
"PYI", # flake8-pyi
"RSE", # flake8-raise
"RUF", # Ruff-specific rules
"T10", # flake8-debugger
"TCH", # flake8-type-checking
"TID", # flake8-tidy-imports
"W", # pycodestyle
"YTT", # flake8-2020
"ANN" # flake8-annotations
]
ignore = [
"E722", # Do not use bare `except`
"ANN101", # Missing type annotation for self in method
"TID252", # Prefer absolute imports over relative imports from parent modules
]

6
deps/nbytes/src/CMakeLists.txt vendored Normal file
View File

@@ -0,0 +1,6 @@
add_library(nbytes nbytes.cpp)
target_include_directories(nbytes
PUBLIC
$<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/include>
$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
)

139
deps/nbytes/nbytes.cpp → deps/nbytes/src/nbytes.cpp vendored
View File

@@ -1,7 +1,7 @@
#include "nbytes.h"
#include <string.h>
#include <cmath>
#include <cstddef>
#include <string.h>
namespace nbytes {
@@ -12,13 +12,13 @@ namespace {
// These are defined by <sys/byteorder.h> or <netinet/in.h> on some systems.
// To avoid warnings, undefine them before redefining them.
#ifdef BSWAP_2
# undef BSWAP_2
#undef BSWAP_2
#endif
#ifdef BSWAP_4
# undef BSWAP_4
#undef BSWAP_4
#endif
#ifdef BSWAP_8
# undef BSWAP_8
#undef BSWAP_8
#endif
#if defined(_MSC_VER)
@@ -28,30 +28,28 @@ namespace {
#define BSWAP_8(x) _byteswap_uint64(x)
#else
#define BSWAP_2(x) ((x) << 8) | ((x) >> 8)
#define BSWAP_4(x) \
(((x) & 0xFF) << 24) | \
(((x) & 0xFF00) << 8) | \
(((x) >> 8) & 0xFF00) | \
(((x) >> 24) & 0xFF)
#define BSWAP_8(x) \
(((x) & 0xFF00000000000000ull) >> 56) | \
(((x) & 0x00FF000000000000ull) >> 40) | \
(((x) & 0x0000FF0000000000ull) >> 24) | \
(((x) & 0x000000FF00000000ull) >> 8) | \
(((x) & 0x00000000FF000000ull) << 8) | \
(((x) & 0x0000000000FF0000ull) << 24) | \
(((x) & 0x000000000000FF00ull) << 40) | \
(((x) & 0x00000000000000FFull) << 56)
#define BSWAP_4(x) \
(((x) & 0xFF) << 24) | (((x) & 0xFF00) << 8) | (((x) >> 8) & 0xFF00) | \
(((x) >> 24) & 0xFF)
#define BSWAP_8(x) \
(((x) & 0xFF00000000000000ull) >> 56) | \
(((x) & 0x00FF000000000000ull) >> 40) | \
(((x) & 0x0000FF0000000000ull) >> 24) | \
(((x) & 0x000000FF00000000ull) >> 8) | \
(((x) & 0x00000000FF000000ull) << 8) | \
(((x) & 0x0000000000FF0000ull) << 24) | \
(((x) & 0x000000000000FF00ull) << 40) | \
(((x) & 0x00000000000000FFull) << 56)
#endif
} // namespace
bool SwapBytes16(void* data, size_t nbytes) {
bool SwapBytes16(void *data, size_t nbytes) {
if (nbytes % sizeof(uint16_t) != 0) return false;
#if defined(_MSC_VER)
if (AlignUp(data, sizeof(uint16_t)) == data) {
// MSVC has no strict aliasing, and is able to highly optimize this case.
uint16_t* data16 = reinterpret_cast<uint16_t*>(data);
uint16_t *data16 = reinterpret_cast<uint16_t *>(data);
size_t len16 = nbytes / sizeof(uint16_t);
for (size_t i = 0; i < len16; i++) {
data16[i] = BSWAP_2(data16[i]);
@@ -61,7 +59,7 @@ bool SwapBytes16(void* data, size_t nbytes) {
#endif
uint16_t temp;
uint8_t* ptr = reinterpret_cast<uint8_t*>(data);
uint8_t *ptr = reinterpret_cast<uint8_t *>(data);
for (size_t i = 0; i < nbytes; i += sizeof(uint16_t)) {
memcpy(&temp, &ptr[i], sizeof(uint16_t));
temp = BSWAP_2(temp);
@@ -71,13 +69,13 @@ bool SwapBytes16(void* data, size_t nbytes) {
return true;
}
bool SwapBytes32(void* data, size_t nbytes) {
bool SwapBytes32(void *data, size_t nbytes) {
if (nbytes % sizeof(uint32_t) != 0) return false;
#if defined(_MSC_VER)
// MSVC has no strict aliasing, and is able to highly optimize this case.
if (AlignUp(data, sizeof(uint32_t)) == data) {
uint32_t* data32 = reinterpret_cast<uint32_t*>(data);
uint32_t *data32 = reinterpret_cast<uint32_t *>(data);
size_t len32 = nbytes / sizeof(uint32_t);
for (size_t i = 0; i < len32; i++) {
data32[i] = BSWAP_4(data32[i]);
@@ -87,7 +85,7 @@ bool SwapBytes32(void* data, size_t nbytes) {
#endif
uint32_t temp = 0;
uint8_t* ptr = reinterpret_cast<uint8_t*>(data);
uint8_t *ptr = reinterpret_cast<uint8_t *>(data);
for (size_t i = 0; i < nbytes; i += sizeof(uint32_t)) {
memcpy(&temp, &ptr[i], sizeof(uint32_t));
temp = BSWAP_4(temp);
@@ -97,13 +95,13 @@ bool SwapBytes32(void* data, size_t nbytes) {
return true;
}
bool SwapBytes64(void* data, size_t nbytes) {
bool SwapBytes64(void *data, size_t nbytes) {
if (nbytes % sizeof(uint64_t) != 0) return false;
#if defined(_MSC_VER)
if (AlignUp(data, sizeof(uint64_t)) == data) {
// MSVC has no strict aliasing, and is able to highly optimize this case.
uint64_t* data64 = reinterpret_cast<uint64_t*>(data);
uint64_t *data64 = reinterpret_cast<uint64_t *>(data);
size_t len64 = nbytes / sizeof(uint64_t);
for (size_t i = 0; i < len64; i++) {
data64[i] = BSWAP_8(data64[i]);
@@ -113,7 +111,7 @@ bool SwapBytes64(void* data, size_t nbytes) {
#endif
uint64_t temp = 0;
uint8_t* ptr = reinterpret_cast<uint8_t*>(data);
uint8_t *ptr = reinterpret_cast<uint8_t *>(data);
for (size_t i = 0; i < nbytes; i += sizeof(uint64_t)) {
memcpy(&temp, &ptr[i], sizeof(uint64_t));
temp = BSWAP_8(temp);
@@ -127,56 +125,45 @@ bool SwapBytes64(void* data, size_t nbytes) {
// Base64 (legacy)
// supports regular and URL-safe base64
const int8_t unbase64_table[256] =
{ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -2, -1, -1, -2, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 62, -1, 62, -1, 63,
52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -1, -1, -1, -1, -1, -1,
-1, 0, 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, -1, -1, -1, -1, 63,
-1, 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, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
};
const int8_t unbase64_table[256] = {
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -2, -1, -1, -2, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -2, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, 62, -1, 62, -1, 63, 52, 53, 54, 55, 56, 57, 58, 59, 60,
61, -1, -1, -1, -1, -1, -1, -1, 0, 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, -1, -1, -1, -1,
63, -1, 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, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1};
// ============================================================================
// Hex
const int8_t unhex_table[256] =
{ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -1, -1, -1, -1, -1, -1,
-1, 10, 11, 12, 13, 14, 15, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, 10, 11, 12, 13, 14, 15, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
};
const int8_t unhex_table[256] = {
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8,
9, -1, -1, -1, -1, -1, -1, -1, 10, 11, 12, 13, 14, 15, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, 10, 11, 12, 13, 14, 15, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1};
size_t HexEncode(
const char* src,
size_t slen,
char* dst,
size_t dlen) {
size_t HexEncode(const char *src, size_t slen, char *dst, size_t dlen) {
// We know how much we'll write, just make sure that there's space.
NBYTES_ASSERT_TRUE(
dlen >= MultiplyWithOverflowCheck<size_t>(slen, 2u) &&
"not enough space provided for hex encode");
NBYTES_ASSERT_TRUE(dlen >= MultiplyWithOverflowCheck<size_t>(slen, 2u) &&
"not enough space provided for hex encode");
dlen = slen * 2;
for (size_t i = 0, k = 0; k < dlen; i += 1, k += 2) {
@@ -189,7 +176,7 @@ size_t HexEncode(
return dlen;
}
std::string HexEncode(const char* src, size_t slen) {
std::string HexEncode(const char *src, size_t slen) {
size_t dlen = slen * 2;
std::string dst(dlen, '\0');
HexEncode(src, slen, dst.data(), dlen);
@@ -198,13 +185,13 @@ std::string HexEncode(const char* src, size_t slen) {
// ============================================================================
void ForceAsciiSlow(const char* src, char* dst, size_t len) {
void ForceAsciiSlow(const char *src, char *dst, size_t len) {
for (size_t i = 0; i < len; ++i) {
dst[i] = src[i] & 0x7f;
}
}
void ForceAscii(const char* src, char* dst, size_t len) {
void ForceAscii(const char *src, char *dst, size_t len) {
if (len < 16) {
ForceAsciiSlow(src, dst, len);
return;
@@ -234,8 +221,8 @@ void ForceAscii(const char* src, char* dst, size_t len) {
const uintptr_t mask = ~0x80808080l;
#endif
const uintptr_t* srcw = reinterpret_cast<const uintptr_t*>(src);
uintptr_t* dstw = reinterpret_cast<uintptr_t*>(dst);
const uintptr_t *srcw = reinterpret_cast<const uintptr_t *>(src);
uintptr_t *dstw = reinterpret_cast<uintptr_t *>(dst);
for (size_t i = 0, n = len / bytes_per_word; i < n; ++i) {
dstw[i] = srcw[i] & mask;

10
deps/nbytes/tests/CMakeLists.txt vendored Normal file
View File

@@ -0,0 +1,10 @@
include(GoogleTest)
include(CTest)
add_executable(basic basic.cpp)
target_link_libraries(
basic
GTest::gtest_main
)
target_link_libraries(basic nbytes)
add_test(basic_test basic)
gtest_discover_tests(basic)

7
deps/nbytes/tests/basic.cpp vendored Normal file
View File

@@ -0,0 +1,7 @@
#include <format>
#include <nbytes.h>
#include <vector>
#include <gtest/gtest.h>
TEST(basic, it_works) { SUCCEED(); }

42
deps/nbytes/tools/run-clang-format.sh vendored Executable file
View File

@@ -0,0 +1,42 @@
#!/usr/bin/env bash
# Copyright 2023 Yagiz Nizipli and Daniel Lemire
# Permission is hereby granted, free of charge, to any person obtaining a copy of
# this software and associated documentation files (the "Software"), to deal in
# the Software without restriction, including without limitation the rights to
# use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
# the Software, and to permit persons to whom the Software is furnished to do so,
# subject to the following conditions:
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
# FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
# COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
# IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
set -e
COMMAND=$*
SCRIPTPATH="$( cd "$(dirname "$0")" ; pwd -P )"
MAINSOURCE=$SCRIPTPATH/..
ALL_FILES=$(cd $MAINSOURCE && git ls-tree --full-tree --name-only -r HEAD | grep -e ".*\.\(c\|h\|cc\|cpp\|hh\)\$")
if clang-format-17 --version 2>/dev/null | grep -qF 'version 17.'; then
cd $MAINSOURCE; clang-format-17 --style=file --verbose -i "$@" $ALL_FILES
exit 0
elif clang-format --version 2>/dev/null | grep -qF 'version 17.'; then
cd $MAINSOURCE; clang-format --style=file --verbose -i "$@" $ALL_FILES
exit 0
fi
echo "Trying to use docker"
command -v docker >/dev/null 2>&1 || { echo >&2 "Please install docker. E.g., go to https://www.docker.com/products/docker-desktop Type 'docker' to diagnose the problem."; exit 1; }
docker info >/dev/null 2>&1 || { echo >&2 "Docker server is not running? type 'docker info'."; exit 1; }
if [ -t 0 ]; then DOCKER_ARGS=-it; fi
docker pull kszonek/clang-format-17
docker run --rm $DOCKER_ARGS -v "$MAINSOURCE":"$MAINSOURCE":Z -w "$MAINSOURCE" -u "$(id -u $USER):$(id -g $USER)" kszonek/clang-format-17 --style=file --verbose -i "$@" $ALL_FILES

61
tools/dep_updaters/update-nbytes.sh Executable file
View File

@@ -0,0 +1,61 @@
#!/bin/sh
set -e
# Shell script to update nbytes in the source tree to a specific version
BASE_DIR=$(cd "$(dirname "$0")/../.." && pwd)
DEPS_DIR="$BASE_DIR/deps"
[ -z "$NODE" ] && NODE="$BASE_DIR/out/Release/node"
[ -x "$NODE" ] || NODE=$(command -v node)
# shellcheck disable=SC1091
. "$BASE_DIR/tools/dep_updaters/utils.sh"
NEW_VERSION="$("$NODE" --input-type=module <<'EOF'
const res = await fetch('https://api.github.com/repos/nodejs/nbytes/releases/latest',
process.env.GITHUB_TOKEN && {
headers: {
"Authorization": `Bearer ${process.env.GITHUB_TOKEN}`
},
});
if (!res.ok) throw new Error(`FetchError: ${res.status} ${res.statusText}`, { cause: res });
const { tag_name } = await res.json();
console.log(tag_name.replace('v', ''));
EOF
)"
CURRENT_VERSION=$(grep "#define NBYTES_VERSION" "$DEPS_DIR/nbytes/nbytes.h" | sed -n "s/^.*VERSION \"\(.*\)\"/\1/p")
# This function exit with 0 if new version and current version are the same
compare_dependency_version "nbytes" "$NEW_VERSION" "$CURRENT_VERSION"
echo "Making temporary workspace..."
WORKSPACE=$(mktemp -d 2> /dev/null || mktemp -d -t 'tmp')
cleanup () {
EXIT_CODE=$?
[ -d "$WORKSPACE" ] && rm -rf "$WORKSPACE"
exit $EXIT_CODE
}
trap cleanup INT TERM EXIT
cd "$WORKSPACE"
echo "Fetching nbytes source archive..."
NBYTES_TARBALL="nbytes-v$NEW_VERSION.tar.gz"
curl -sL -o "$NBYTES_TARBALL" "https://api.github.com/repos/nodejs/nbytes/tarball/v$NEW_VERSION"
log_and_verify_sha256sum "nbytes" "$NBYTES_TARBALL"
gzip -dc "$NBYTES_TARBALL" | tar xf -
mv nodejs-nbytes-* source
rm "$NBYTES_TARBALL"
echo "Replacing existing nbytes (except GYP and GN build files)"
mv "$DEPS_DIR/nbytes/"*.gyp "$DEPS_DIR/nbytes/"*.gn "$DEPS_DIR/nbytes/"*.gni "$DEPS_DIR/nbytes/README.md" "$WORKSPACE/source"
rm -rf "$DEPS_DIR/nbytes"
mv "$WORKSPACE/source" "$DEPS_DIR/nbytes"
# Update the version number on maintaining-dependencies.md
# and print the new version as the last line of the script as we need
# to add it to $GITHUB_ENV variable
finalize_version_update "nbytes" "$NEW_VERSION"