bare-buffer 2.5.4 → 2.5.6

package/CMakeLists.txt

@@ -1,8 +1,8 @@
 cmake_minimum_required(VERSION 3.25)
 
-project(bare_buffer C)
+find_package(cmake-bare REQUIRED PATHS node_modules/cmake-bare)
 
-include(bare)
+project(bare_buffer C)
 
 if(NOT TARGET utf)
   add_subdirectory(vendor/libutf EXCLUDE_FROM_ALL)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bare-buffer",
-  "version": "2.5.4",
+  "version": "2.5.6",
   "description": "Native buffers for JavaScript",
   "exports": {
     ".": "./index.js",
@@ -37,6 +37,7 @@
   "homepage": "https://github.com/holepunchto/bare-buffer#readme",
   "devDependencies": {
     "brittle": "^3.1.1",
+    "cmake-bare": "^1.1.6",
     "standard": "^17.0.0"
   }
 }

package/vendor/libutf/CMakeLists.txt

@@ -15,17 +15,33 @@ target_sources(
   utf
   INTERFACE
     include/utf.h
-    include/utf/endianness.h
     include/utf/string.h
   PRIVATE
     src/endianness.c
-    src/utf8/utf16-convert.c
-    src/utf8/utf16-length.c
-    src/utf8/validate.c
+    src/endianness.h
+    src/ascii/validate.c
+    src/utf8/convert-to-latin1.c
+    src/utf8/convert-to-utf16.c
+    src/utf8/convert-to-utf32.c
+    src/utf8/length-from-latin1.c
+    src/utf8/length-from-utf16.c
+    src/utf8/length-from-utf32.c
     src/utf8/string.c
-    src/utf16/utf8-convert.c
-    src/utf16/utf8-length.c
+    src/utf8/validate.c
+    src/utf16/convert-to-latin1.c
+    src/utf16/convert-to-utf8.c
+    src/utf16/convert-to-utf32.c
+    src/utf16/length-from-latin1.c
+    src/utf16/length-from-utf8.c
+    src/utf16/length-from-utf32.c
     src/utf16/validate.c
+    src/utf32/convert-to-latin1.c
+    src/utf32/convert-to-utf8.c
+    src/utf32/convert-to-utf16.c
+    src/utf32/length-from-latin1.c
+    src/utf32/length-from-utf8.c
+    src/utf32/length-from-utf16.c
+    src/utf32/validate.c
 )
 
 target_include_directories(
@@ -72,5 +88,6 @@ install(DIRECTORY include/utf DESTINATION include)
 
 if(PROJECT_IS_TOP_LEVEL)
   enable_testing()
+
   add_subdirectory(test)
 endif()

package/vendor/libutf/include/utf/string.h

@@ -24,7 +24,10 @@ typedef struct utf8_string_view_s utf8_string_view_t;
 struct utf8_string_s {
   utf8_t *data;
   size_t len;
-  size_t cap;
+  union {
+    size_t cap;
+    utf8_t buf[8];
+  };
 };
 
 struct utf8_string_view_s {
@@ -34,53 +37,77 @@ struct utf8_string_view_s {
 
 inline void
 utf8_string_init (utf8_string_t *string) {
+  string->data = string->buf;
   string->len = 0;
-  string->cap = 0;
-  string->data = NULL;
 }
 
 inline utf8_string_view_t
 utf8_string_view_init (const utf8_t *data, size_t len) {
-  return (utf8_string_view_t){data, len};
+  utf8_string_view_t view = {data, len};
+  return view;
 }
 
 inline void
 utf8_string_destroy (utf8_string_t *string) {
-  free(string->data);
+  if (string->data != string->buf) free(string->data);
 }
 
 inline int
 utf8_string_reserve (utf8_string_t *string, size_t len) {
-  size_t cap = string->cap;
+  size_t cap = string->data == string->buf ? sizeof(string->buf) : string->cap;
 
-  if (len < cap) return 0;
+  if (len <= cap) return 0;
 
-  if (cap == 0) cap = sizeof(utf8_string_t) - 1;
+  // https://graphics.stanford.edu/~seander/bithacks.html#RoundUpPowerOf2
+  len--;
+  len |= len >> 1;
+  len |= len >> 2;
+  len |= len >> 4;
+  len |= len >> 8;
+  len |= len >> 16;
+  if (sizeof(len) == 8) len |= len >> 32;
+  len++;
 
-  while (cap < len) {
-    cap = cap * 2 + 1;
-  }
+  cap = len;
+
+  utf8_t *data;
 
-  void *data = realloc(string->data, cap);
+  if (string->data == string->buf) {
+    data = (utf8_t *) malloc(cap);
+
+    memcpy(data, string->data, string->len);
+  } else {
+    data = (utf8_t *) realloc(string->data, cap);
+  }
 
   if (data == NULL) return -1;
 
-  string->cap = cap;
   string->data = data;
+  string->cap = cap;
 
   return 0;
 }
 
 inline int
 utf8_string_shrink_to_fit (utf8_string_t *string) {
-  size_t cap = string->len + 1;
+  if (string->data == string->buf) return 0;
 
-  void *data = realloc(string->data, cap);
+  size_t cap = string->len;
 
-  if (data == NULL) return -1;
+  if (cap <= sizeof(string->buf)) {
+    memcpy(string->buf, string->data, cap);
 
-  string->cap = cap;
-  string->data = data;
+    free(string->data);
+
+    string->data = string->buf;
+  } else {
+    utf8_t *data = (utf8_t *) realloc(string->data, cap);
+
+    if (data == NULL) return -1;
+
+    string->data = data;
+    string->cap = cap;
+  }
 
   return 0;
 }
@@ -96,7 +123,7 @@ utf8_string_clear (utf8_string_t *string) {
 }
 
 inline bool
-utf8_string_empty (utf8_string_t *string) {
+utf8_string_empty (const utf8_string_t *string) {
   return string->len == 0;
 }
 

package/vendor/libutf/include/utf.h

@@ -11,6 +11,9 @@ extern "C" {
 
 typedef uint_least8_t utf8_t;
 typedef uint_least16_t utf16_t;
+typedef uint_least32_t utf32_t;
+typedef uint_least8_t latin1_t;
+typedef uint_least8_t ascii_t;
 
 /**
  * UTF-8
@@ -22,9 +25,21 @@ utf8_validate (const utf8_t *data, size_t len);
 size_t
 utf8_length_from_utf16le (const utf16_t *data, size_t len);
 
+size_t
+utf8_length_from_utf32 (const utf32_t *data, size_t len);
+
+size_t
+utf8_length_from_latin1 (const latin1_t *data, size_t len);
+
 size_t
 utf8_convert_to_utf16le (const utf8_t *data, size_t len, utf16_t *result);
 
+size_t
+utf8_convert_to_utf32 (const utf8_t *data, size_t len, utf32_t *result);
+
+size_t
+utf8_convert_to_latin1 (const utf8_t *data, size_t len, latin1_t *result);
+
 /**
  * UTF-16
  */
@@ -35,9 +50,81 @@ utf16le_validate (const utf16_t *data, size_t len);
 size_t
 utf16_length_from_utf8 (const utf8_t *data, size_t len);
 
+size_t
+utf16_length_from_utf32 (const utf32_t *data, size_t len);
+
+size_t
+utf16_length_from_latin1 (const latin1_t *data, size_t len);
+
 size_t
 utf16le_convert_to_utf8 (const utf16_t *data, size_t len, utf8_t *result);
 
+size_t
+utf16le_convert_to_utf32 (const utf16_t *data, size_t len, utf32_t *result);
+
+size_t
+utf16le_convert_to_latin1 (const utf16_t *data, size_t len, latin1_t *result);
+
+/**
+ * UTF-32
+ */
+
+bool
+utf32_validate (const utf32_t *data, size_t len);
+
+size_t
+utf32_length_from_utf8 (const utf8_t *data, size_t len);
+
+size_t
+utf32_length_from_utf16le (const utf16_t *data, size_t len);
+
+size_t
+utf32_length_from_latin1 (const latin1_t *data, size_t len);
+
+size_t
+utf32_convert_to_utf8 (const utf32_t *data, size_t len, utf8_t *result);
+
+size_t
+utf32_convert_to_utf16le (const utf32_t *data, size_t len, utf16_t *result);
+
+size_t
+utf32_convert_to_latin1 (const utf32_t *data, size_t len, latin1_t *result);
+
+/**
+ * Latin-1
+ */
+
+size_t
+latin1_length_from_utf8 (const utf8_t *data, size_t len);
+
+size_t
+latin1_length_from_utf16le (const utf16_t *data, size_t len);
+
+size_t
+latin1_length_from_utf32 (const utf32_t *data, size_t len);
+
+size_t
+latin1_convert_to_utf8 (const latin1_t *data, size_t len, utf8_t *result);
+
+size_t
+latin1_convert_to_utf16le (const latin1_t *data, size_t len, utf16_t *result);
+
+size_t
+latin1_convert_to_utf32 (const latin1_t *data, size_t len, utf32_t *result);
+
+/**
+ * ASCII
+ */
+
+bool
+ascii_validate (const ascii_t *data, size_t len);
+
+/**
+ * Strings
+ */
+
+#include <utf/string.h>
+
 #ifdef __cplusplus
 }
 #endif

package/vendor/libutf/src/ascii/validate.c

@@ -0,0 +1,47 @@
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <string.h>
+
+#include "../../include/utf.h"
+
+/**
+ * Modified from https://github.com/simdutf/simdutf
+ *
+ * Copyright 2020 The simdutf authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+bool
+ascii_validate (const ascii_t *data, size_t len) {
+  uint64_t pos = 0;
+
+  for (; pos + 16 <= len; pos += 16) {
+    uint64_t v1;
+    memcpy(&v1, data + pos, sizeof(uint64_t));
+    uint64_t v2;
+    memcpy(&v2, data + pos + sizeof(uint64_t), sizeof(uint64_t));
+    uint64_t v = v1 | v2;
+    if ((v & 0x8080808080808080) != 0) {
+      return false;
+    }
+  }
+  for (; pos < len; pos++) {
+    if (data[pos] >= 0b10000000) {
+      return false;
+    }
+  }
+
+  return true;
+}

package/vendor/libutf/src/endianness.c

@@ -1,7 +1,7 @@
 #include <stdbool.h>
 #include <stdint.h>
 
-#include "../include/utf/endianness.h"
+#include "endianness.h"
 
 extern utf_endianness_t
 utf_endianness (void);

package/vendor/libutf/src/latin1/convert-to-utf16.c

@@ -0,0 +1,37 @@
+#include <stddef.h>
+#include <stdint.h>
+#include <string.h>
+
+#include "../../include/utf.h"
+#include "../endianness.h"
+
+/**
+ * Modified from https://github.com/simdutf/simdutf
+ *
+ * Copyright 2020 The simdutf authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+size_t
+latin1_convert_to_utf16le (const latin1_t *data, size_t len, utf16_t *result) {
+  size_t pos = 0;
+  utf16_t *start = result;
+
+  while (pos < len) {
+    *result++ = utf_is_be() ? utf_swap_uint16(data[pos]) : data[pos];
+    pos++;
+  }
+
+  return result - start;
+}

package/vendor/libutf/src/latin1/convert-to-utf32.c

@@ -0,0 +1,34 @@
+#include <stddef.h>
+#include <stdint.h>
+#include <string.h>
+
+#include "../../include/utf.h"
+
+/**
+ * Modified from https://github.com/simdutf/simdutf
+ *
+ * Copyright 2020 The simdutf authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+size_t
+latin1_convert_to_utf32 (const latin1_t *data, size_t len, utf32_t *result) {
+  utf32_t *start = result;
+
+  for (size_t i = 0; i < len; i++) {
+    *result++ = data[i];
+  }
+
+  return result - start;
+}

package/vendor/libutf/src/latin1/convert-to-utf8.c

@@ -0,0 +1,58 @@
+#include <stddef.h>
+#include <stdint.h>
+#include <string.h>
+
+#include "../../include/utf.h"
+
+/**
+ * Modified from https://github.com/simdutf/simdutf
+ *
+ * Copyright 2020 The simdutf authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+size_t
+latin1_convert_to_utf8 (const latin1_t *data, size_t len, utf8_t *result) {
+  size_t pos = 0;
+  utf8_t *start = result;
+
+  while (pos < len) {
+    if (pos + 16 <= len) {
+      uint64_t v1;
+      memcpy(&v1, data + pos, sizeof(uint64_t));
+      uint64_t v2;
+      memcpy(&v2, data + pos + sizeof(uint64_t), sizeof(uint64_t));
+      uint64_t v = v1 | v2;
+      if ((v & 0x8080808080808080) == 0) {
+        size_t final_pos = pos + 16;
+        while (pos < final_pos) {
+          *result++ = data[pos];
+          pos++;
+        }
+        continue;
+      }
+    }
+    unsigned char byte = data[pos];
+    if ((byte & 0x80) == 0) {
+      *result++ = byte;
+      pos++;
+    } else {
+      *result++ = (byte >> 6) | 0b11000000;
+      *result++ = (byte & 0b111111) | 0b10000000;
+      pos++;
+    }
+  }
+
+  return result - start;
+}

package/vendor/libutf/src/latin1/length-from-utf16.c

@@ -0,0 +1,26 @@
+#include <stddef.h>
+
+#include "../../include/utf.h"
+
+/**
+ * Modified from https://github.com/simdutf/simdutf
+ *
+ * Copyright 2020 The simdutf authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+size_t
+latin1_length_from_utf16le (const utf16_t *data, size_t len) {
+  return len;
+}

package/vendor/libutf/src/latin1/length-from-utf32.c

@@ -0,0 +1,26 @@
+#include <stddef.h>
+
+#include "../../include/utf.h"
+
+/**
+ * Modified from https://github.com/simdutf/simdutf
+ *
+ * Copyright 2020 The simdutf authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+size_t
+latin1_length_from_utf32 (const utf32_t *data, size_t len) {
+  return len;
+}

package/vendor/libutf/src/latin1/length-from-utf8.c

@@ -0,0 +1,34 @@
+#include <stddef.h>
+
+#include "../../include/utf.h"
+
+/**
+ * Modified from https://github.com/simdutf/simdutf
+ *
+ * Copyright 2020 The simdutf authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+size_t
+latin1_length_from_utf8 (const utf8_t *data, size_t len) {
+  size_t counter = 0;
+
+  for (size_t i = 0; i < len; i++) {
+    if ((int8_t) data[i] > -65) {
+      counter++;
+    }
+  }
+
+  return counter;
+}

package/vendor/libutf/src/utf16/convert-to-latin1.c

@@ -0,0 +1,41 @@
+#include <stddef.h>
+#include <stdint.h>
+
+#include "../../include/utf.h"
+#include "../endianness.h"
+
+/**
+ * Modified from https://github.com/simdutf/simdutf
+ *
+ * Copyright 2020 The simdutf authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+size_t
+utf16le_convert_to_latin1 (const utf16_t *data, size_t len, latin1_t *result) {
+  size_t pos = 0;
+  uint16_t word, overflow = 0;
+  latin1_t *start = result;
+
+  while (pos < len) {
+    word = utf_is_be() ? utf_swap_uint16(data[pos]) : data[pos];
+    overflow |= word;
+    *result++ = word & 0xff;
+    pos++;
+  }
+
+  if (overflow & 0xff00) return 0;
+
+  return result - start;
+}