bare-buffer 2.5.9 → 2.5.11

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

@@ -1,110 +0,0 @@
-#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
-utf8_convert_to_utf32 (const utf8_t *data, size_t len, utf32_t *result) {
-  size_t pos = 0;
-  utf32_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;
-      }
-    }
-    uint8_t leading_byte = data[pos];
-    if (leading_byte < 0b10000000) {
-      *result++ = leading_byte;
-      pos++;
-    } else if ((leading_byte & 0b11100000) == 0b11000000) {
-      if (pos + 1 >= len) {
-        return 0;
-      }
-      if ((data[pos + 1] & 0b11000000) != 0b10000000) {
-        return 0;
-      }
-      uint32_t code_point = ((leading_byte & 0b00011111) << 6) |
-                            (data[pos + 1] & 0b00111111);
-      if (code_point < 0x80 || 0x7ff < code_point) {
-        return 0;
-      }
-      *result++ = code_point;
-      pos += 2;
-    } else if ((leading_byte & 0b11110000) == 0b11100000) {
-      if (pos + 2 >= len) {
-        return 0;
-      }
-      if ((data[pos + 1] & 0b11000000) != 0b10000000) {
-        return 0;
-      }
-      if ((data[pos + 2] & 0b11000000) != 0b10000000) {
-        return 0;
-      }
-      uint32_t code_point = ((leading_byte & 0b00001111) << 12) |
-                            ((data[pos + 1] & 0b00111111) << 6) |
-                            (data[pos + 2] & 0b00111111);
-      if (code_point < 0x800 || 0xffff < code_point || (0xd7ff < code_point && code_point < 0xe000)) {
-        return 0;
-      }
-      *result++ = code_point;
-      pos += 3;
-    } else if ((leading_byte & 0b11111000) == 0b11110000) {
-      if (pos + 3 >= len) {
-        return 0;
-      }
-      if ((data[pos + 1] & 0b11000000) != 0b10000000) {
-        return 0;
-      }
-      if ((data[pos + 2] & 0b11000000) != 0b10000000) {
-        return 0;
-      }
-      if ((data[pos + 3] & 0b11000000) != 0b10000000) {
-        return 0;
-      }
-      uint32_t code_point = ((leading_byte & 0b00000111) << 18) |
-                            ((data[pos + 1] & 0b00111111) << 12) |
-                            ((data[pos + 2] & 0b00111111) << 6) |
-                            (data[pos + 3] & 0b00111111);
-      if (code_point <= 0xffff || 0x10ffff < code_point) {
-        return 0;
-      }
-      *result++ = code_point;
-      pos += 4;
-    } else {
-      return 0;
-    }
-  }
-
-  return result - start;
-}

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

@@ -1,32 +0,0 @@
-#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
-utf8_length_from_latin1 (const latin1_t *data, size_t len) {
-  size_t counter = len;
-
-  for (size_t i = 0; i < len; i++) {
-    counter += data[i] >> 7;
-  }
-
-  return counter;
-}

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

@@ -1,44 +0,0 @@
-#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
-utf8_length_from_utf16le (const utf16_t *data, size_t len) {
-  size_t counter = 0;
-  uint16_t word;
-
-  for (size_t i = 0; i < len; i++) {
-    word = utf_is_be() ? utf_swap_uint16(data[i]) : data[i];
-    if (word <= 0x7f) {
-      counter++;
-    } else if (word <= 0x7ff) {
-      counter += 2;
-    } else if ((word <= 0xd7ff) || (word >= 0xe000)) {
-      counter += 3;
-    } else {
-      counter += 2;
-    }
-  }
-
-  return counter;
-}

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

@@ -1,35 +0,0 @@
-#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
-utf8_length_from_utf32 (const utf32_t *data, size_t len) {
-  size_t counter = 0;
-
-  for (size_t i = 0; i < len; i++) {
-    counter++;
-    counter += data[i] > 0x7f;
-    counter += data[i] > 0x7ff;
-    counter += data[i] > 0xffff;
-  }
-
-  return counter;
-}

package/vendor/libutf/src/utf8/string.c

@@ -1,149 +0,0 @@
-#include <stdbool.h>
-#include <stddef.h>
-
-#include "../../include/utf.h"
-#include "../../include/utf/string.h"
-
-extern void
-utf8_string_init (utf8_string_t *string);
-
-extern utf8_string_view_t
-utf8_string_view_init (const utf8_t *data, size_t len);
-
-extern void
-utf8_string_destroy (utf8_string_t *string);
-
-extern int
-utf8_string_reserve (utf8_string_t *string, size_t len);
-
-extern int
-utf8_string_shrink_to_fit (utf8_string_t *string);
-
-extern utf8_string_view_t
-utf8_string_view (const utf8_string_t *string);
-
-extern void
-utf8_string_clear (utf8_string_t *string);
-
-extern bool
-utf8_string_empty (const utf8_string_t *string);
-
-extern bool
-utf8_string_view_empty (const utf8_string_view_t view);
-
-extern int
-utf8_string_copy (const utf8_string_t *string, utf8_string_t *result);
-
-extern int
-utf8_string_view_copy (const utf8_string_view_t view, utf8_string_t *result);
-
-extern int
-utf8_string_append (utf8_string_t *string, const utf8_string_t *other);
-
-extern int
-utf8_string_append_view (utf8_string_t *string, const utf8_string_view_t view);
-
-extern int
-utf8_string_append_character (utf8_string_t *string, utf8_t c);
-
-extern int
-utf8_string_append_literal (utf8_string_t *string, const utf8_t *literal, size_t n);
-
-extern int
-utf8_string_prepend (utf8_string_t *string, const utf8_string_t *other);
-
-extern int
-utf8_string_prepend_view (utf8_string_t *string, const utf8_string_view_t view);
-
-extern int
-utf8_string_prepend_character (utf8_string_t *string, utf8_t c);
-
-extern int
-utf8_string_prepend_literal (utf8_string_t *string, const utf8_t *literal, size_t n);
-
-extern int
-utf8_string_insert (utf8_string_t *string, size_t pos, const utf8_string_t *other);
-
-extern int
-utf8_string_insert_view (utf8_string_t *string, size_t pos, const utf8_string_view_t other);
-
-extern int
-utf8_string_insert_character (utf8_string_t *string, size_t pos, utf8_t c);
-
-extern int
-utf8_string_insert_literal (utf8_string_t *string, size_t pos, const utf8_t *literal, size_t n);
-
-extern int
-utf8_string_replace (utf8_string_t *string, size_t pos, size_t len, const utf8_string_t *replacement);
-
-extern int
-utf8_string_replace_view (utf8_string_t *string, size_t pos, size_t len, const utf8_string_view_t replacement);
-
-extern int
-utf8_string_replace_character (utf8_string_t *string, size_t pos, size_t len, utf8_t c);
-
-extern int
-utf8_string_replace_literal (utf8_string_t *string, size_t pos, size_t len, const utf8_t *literal, size_t n);
-
-extern int
-utf8_string_erase (utf8_string_t *string, size_t pos, size_t len);
-
-extern int
-utf8_string_concat (const utf8_string_t *string, const utf8_string_t *other, utf8_string_t *result);
-
-extern int
-utf8_string_view_concat (const utf8_string_view_t view, const utf8_string_t *other, utf8_string_t *result);
-
-extern int
-utf8_string_concat_view (const utf8_string_t *string, const utf8_string_view_t other, utf8_string_t *result);
-
-extern int
-utf8_string_view_concat_view (const utf8_string_view_t view, const utf8_string_view_t other, utf8_string_t *result);
-
-extern int
-utf8_string_concat_character (const utf8_string_t *string, utf8_t c, utf8_string_t *result);
-
-extern int
-utf8_string_view_concat_character (const utf8_string_view_t view, utf8_t c, utf8_string_t *result);
-
-extern int
-utf8_string_concat_literal (const utf8_string_t *string, const utf8_t *literal, size_t n, utf8_string_t *result);
-
-extern int
-utf8_string_view_concat_literal (const utf8_string_view_t view, const utf8_t *literal, size_t n, utf8_string_t *result);
-
-extern int
-utf8_string_compare (const utf8_string_t *string, const utf8_string_t *other);
-
-extern int
-utf8_string_view_compare (const utf8_string_view_t view, const utf8_string_view_t other);
-
-extern int
-utf8_string_compare_literal (const utf8_string_t *string, const utf8_t *literal, size_t n);
-
-extern int
-utf8_string_view_compare_literal (const utf8_string_view_t view, const utf8_t *literal, size_t n);
-
-extern utf8_string_view_t
-utf8_string_substring (const utf8_string_t *string, size_t start, size_t end);
-
-extern utf8_string_view_t
-utf8_string_view_substring (const utf8_string_view_t view, size_t start, size_t end);
-
-extern int
-utf8_string_substring_copy (const utf8_string_t *string, size_t start, size_t end, utf8_string_t *result);
-
-extern int
-utf8_string_view_substring_copy (const utf8_string_view_t view, size_t start, size_t end, utf8_string_t *result);
-
-extern size_t
-utf8_string_index_of_character (const utf8_string_t *string, size_t pos, utf8_t c);
-
-extern size_t
-utf8_string_view_index_of_character (const utf8_string_view_t view, size_t pos, utf8_t c);
-
-extern size_t
-utf8_string_last_index_of_character (const utf8_string_t *string, size_t pos, utf8_t c);
-
-extern size_t
-utf8_string_view_last_index_of_character (const utf8_string_view_t view, size_t pos, utf8_t c);

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

@@ -1,107 +0,0 @@
-#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
-utf8_validate (const utf8_t *data, size_t len) {
-  uint64_t pos = 0;
-  uint8_t word;
-
-  while (pos < len) {
-    uint64_t next_pos = pos + 16;
-    if (next_pos <= 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) {
-        pos = next_pos;
-        continue;
-      }
-    }
-    word = data[pos];
-    while (word < 0b10000000) {
-      if (++pos == len) return true;
-      word = data[pos];
-    }
-    if ((word & 0b11100000) == 0b11000000) {
-      next_pos = pos + 2;
-      if (next_pos > len) {
-        return false;
-      }
-      if ((data[pos + 1] & 0b11000000) != 0b10000000) {
-        return false;
-      }
-      uint32_t code_point = ((word & 0b00011111) << 6) |
-                            (data[pos + 1] & 0b00111111);
-      if ((code_point < 0x80) || (0x7ff < code_point)) {
-        return false;
-      }
-    } else if ((word & 0b11110000) == 0b11100000) {
-      next_pos = pos + 3;
-      if (next_pos > len) {
-        return false;
-      }
-      if ((data[pos + 1] & 0b11000000) != 0b10000000) {
-        return false;
-      }
-      if ((data[pos + 2] & 0b11000000) != 0b10000000) {
-        return false;
-      }
-      uint32_t code_point = ((word & 0b00001111) << 12) |
-                            ((data[pos + 1] & 0b00111111) << 6) |
-                            (data[pos + 2] & 0b00111111);
-      if ((code_point < 0x800) || (0xffff < code_point) || (0xd7ff < code_point && code_point < 0xe000)) {
-        return false;
-      }
-    } else if ((word & 0b11111000) == 0b11110000) {
-      next_pos = pos + 4;
-      if (next_pos > len) {
-        return false;
-      }
-      if ((data[pos + 1] & 0b11000000) != 0b10000000) {
-        return false;
-      }
-      if ((data[pos + 2] & 0b11000000) != 0b10000000) {
-        return false;
-      }
-      if ((data[pos + 3] & 0b11000000) != 0b10000000) {
-        return false;
-      }
-      uint32_t code_point = ((word & 0b00000111) << 18) |
-                            ((data[pos + 1] & 0b00111111) << 12) |
-                            ((data[pos + 2] & 0b00111111) << 6) |
-                            (data[pos + 3] & 0b00111111);
-      if (code_point <= 0xffff || 0x10ffff < code_point) {
-        return false;
-      }
-    } else {
-      return false;
-    }
-    pos = next_pos;
-  }
-
-  return true;
-}