@ohos-ports/bare-buffer 3.7.1-beta.0

package/deps/libutf/src/utf16/length-from-latin1.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
+utf16_length_from_latin1(const utf8_t *data, size_t len) {
+  return len;
+}

package/deps/libutf/src/utf16/length-from-utf32.c

@@ -0,0 +1,33 @@
+#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
+utf16_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] > 0xffff;
+  }
+
+  return counter;
+}

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

@@ -0,0 +1,38 @@
+#include <stddef.h>
+#include <stdint.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
+utf16_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++;
+    }
+    if (data[i] >= 240) {
+      counter++;
+    }
+  }
+
+  return counter;
+}

package/deps/libutf/src/utf16/validate.c

@@ -0,0 +1,53 @@
+#include <stdbool.h>
+#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.
+ */
+
+bool
+utf16le_validate(const utf16_t *data, size_t len) {
+  uint64_t pos = 0;
+  uint16_t word, diff;
+
+  while (pos < len) {
+    word = utf_is_be() ? utf_swap_uint16(data[pos]) : data[pos];
+    if ((word & 0xf800) == 0xd800) {
+      if (pos + 1 >= len) {
+        return false;
+      }
+      diff = word - 0xd800;
+      if (diff > 0x3ff) {
+        return false;
+      }
+      word = utf_is_be() ? utf_swap_uint16(data[pos + 1]) : data[pos + 1];
+      diff = word - 0xdc00;
+      if (diff > 0x3ff) {
+        return false;
+      }
+      pos += 2;
+    } else {
+      pos++;
+    }
+  }
+
+  return true;
+}

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

@@ -0,0 +1,40 @@
+#include <stddef.h>
+#include <stdint.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
+utf32_convert_to_latin1(const utf32_t *data, size_t len, latin1_t *result) {
+  size_t pos = 0;
+  uint32_t word, overflow = 0;
+  latin1_t *start = result;
+
+  while (pos < len) {
+    word = data[pos];
+    overflow |= word;
+    *result++ = word & 0xff;
+    pos++;
+  }
+
+  if (overflow & 0xffffff00) return 0;
+
+  return (size_t) (result - start);
+}

package/deps/libutf/src/utf32/convert-to-utf16.c

@@ -0,0 +1,56 @@
+#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
+utf32_convert_to_utf16le(const utf32_t *data, size_t len, utf16_t *result) {
+  size_t pos = 0;
+  uint32_t word;
+  utf16_t *start = result;
+
+  while (pos < len) {
+    word = data[pos];
+    if ((word & 0xffff0000) == 0) {
+      if (word >= 0xd800 && word <= 0xdfff) {
+        return 0;
+      }
+      *result++ = utf_is_be() ? utf_swap_uint16((uint16_t) word) : (uint16_t) word;
+    } else {
+      if (word > 0x10ffff) {
+        return 0;
+      }
+      word -= 0x10000;
+      uint16_t high_surrogate = (uint16_t) (0xd800 + (word >> 10));
+      uint16_t low_surrogate = (uint16_t) (0xdc00 + (word & 0x3ff));
+      if (utf_is_be()) {
+        high_surrogate = utf_swap_uint16(high_surrogate);
+        low_surrogate = utf_swap_uint16(low_surrogate);
+      }
+      *result++ = high_surrogate;
+      *result++ = low_surrogate;
+    }
+    pos++;
+  }
+
+  return (size_t) (result - start);
+}

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

@@ -0,0 +1,71 @@
+#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
+utf32_convert_to_utf8(const utf32_t *data, size_t len, utf8_t *result) {
+  size_t pos = 0;
+  uint32_t word;
+  utf8_t *start = result;
+
+  while (pos < len) {
+    if (pos + 2 <= len) {
+      uint64_t v;
+      memcpy(&v, data + pos, sizeof(v));
+      if ((v & 0xffffff80ffffff80) == 0) {
+        *result++ = (uint8_t) data[pos];
+        *result++ = (uint8_t) data[pos + 1];
+        pos += 2;
+        continue;
+      }
+    }
+    word = data[pos];
+    if ((word & 0xffffff80) == 0) {
+      *result++ = (uint8_t) word;
+      pos++;
+    } else if ((word & 0xfffff800) == 0) {
+      *result++ = (uint8_t) (word >> 6) | 0b11000000;
+      *result++ = (word & 0b111111) | 0b10000000;
+      pos++;
+    } else if ((word & 0xffff0000) == 0) {
+      if (word >= 0xd800 && word <= 0xdfff) {
+        return 0;
+      }
+      *result++ = (uint8_t) (word >> 12) | 0b11100000;
+      *result++ = ((word >> 6) & 0b111111) | 0b10000000;
+      *result++ = (word & 0b111111) | 0b10000000;
+      pos++;
+    } else {
+      if (word > 0x10ffff) {
+        return 0;
+      }
+      *result++ = (uint8_t) (word >> 18) | 0b11110000;
+      *result++ = ((word >> 12) & 0b111111) | 0b10000000;
+      *result++ = ((word >> 6) & 0b111111) | 0b10000000;
+      *result++ = (word & 0b111111) | 0b10000000;
+      pos++;
+    }
+  }
+
+  return (size_t) (result - start);
+}

package/deps/libutf/src/utf32/length-from-latin1.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
+utf32_length_from_latin1(const utf8_t *data, size_t len) {
+  return len;
+}

package/deps/libutf/src/utf32/length-from-utf16.c

@@ -0,0 +1,35 @@
+#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
+utf32_length_from_utf16le(const utf16_t *data, size_t len) {
+  size_t counter = 0;
+
+  for (size_t i = 0; i < len; i++) {
+    uint16_t word = utf_is_be() ? utf_swap_uint16(data[i]) : data[i];
+    counter += ((word & 0xfc00) != 0xdc00);
+  }
+
+  return counter;
+}

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

@@ -0,0 +1,35 @@
+#include <stddef.h>
+#include <stdint.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
+utf32_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/deps/libutf/src/utf32/string.c

@@ -0,0 +1,149 @@
+#include <stdbool.h>
+#include <stddef.h>
+
+#include "../../include/utf.h"
+#include "../../include/utf/string.h"
+
+extern void
+utf32_string_init(utf32_string_t *string);
+
+extern utf32_string_view_t
+utf32_string_view_init(const utf32_t *data, size_t len);
+
+extern void
+utf32_string_destroy(utf32_string_t *string);
+
+extern int
+utf32_string_reserve(utf32_string_t *string, size_t len);
+
+extern int
+utf32_string_shrink_to_fit(utf32_string_t *string);
+
+extern utf32_string_view_t
+utf32_string_view(const utf32_string_t *string);
+
+extern void
+utf32_string_clear(utf32_string_t *string);
+
+extern bool
+utf32_string_empty(const utf32_string_t *string);
+
+extern bool
+utf32_string_view_empty(const utf32_string_view_t view);
+
+extern int
+utf32_string_copy(const utf32_string_t *string, utf32_string_t *result);
+
+extern int
+utf32_string_view_copy(const utf32_string_view_t view, utf32_string_t *result);
+
+extern int
+utf32_string_append(utf32_string_t *string, const utf32_string_t *other);
+
+extern int
+utf32_string_append_view(utf32_string_t *string, const utf32_string_view_t view);
+
+extern int
+utf32_string_append_character(utf32_string_t *string, utf32_t c);
+
+extern int
+utf32_string_append_literal(utf32_string_t *string, const utf32_t *literal, size_t n);
+
+extern int
+utf32_string_prepend(utf32_string_t *string, const utf32_string_t *other);
+
+extern int
+utf32_string_prepend_view(utf32_string_t *string, const utf32_string_view_t view);
+
+extern int
+utf32_string_prepend_character(utf32_string_t *string, utf32_t c);
+
+extern int
+utf32_string_prepend_literal(utf32_string_t *string, const utf32_t *literal, size_t n);
+
+extern int
+utf32_string_insert(utf32_string_t *string, size_t pos, const utf32_string_t *other);
+
+extern int
+utf32_string_insert_view(utf32_string_t *string, size_t pos, const utf32_string_view_t other);
+
+extern int
+utf32_string_insert_character(utf32_string_t *string, size_t pos, utf32_t c);
+
+extern int
+utf32_string_insert_literal(utf32_string_t *string, size_t pos, const utf32_t *literal, size_t n);
+
+extern int
+utf32_string_replace(utf32_string_t *string, size_t pos, size_t len, const utf32_string_t *replacement);
+
+extern int
+utf32_string_replace_view(utf32_string_t *string, size_t pos, size_t len, const utf32_string_view_t replacement);
+
+extern int
+utf32_string_replace_character(utf32_string_t *string, size_t pos, size_t len, utf32_t c);
+
+extern int
+utf32_string_replace_literal(utf32_string_t *string, size_t pos, size_t len, const utf32_t *literal, size_t n);
+
+extern int
+utf32_string_erase(utf32_string_t *string, size_t pos, size_t len);
+
+extern int
+utf32_string_concat(const utf32_string_t *string, const utf32_string_t *other, utf32_string_t *result);
+
+extern int
+utf32_string_view_concat(const utf32_string_view_t view, const utf32_string_t *other, utf32_string_t *result);
+
+extern int
+utf32_string_concat_view(const utf32_string_t *string, const utf32_string_view_t other, utf32_string_t *result);
+
+extern int
+utf32_string_view_concat_view(const utf32_string_view_t view, const utf32_string_view_t other, utf32_string_t *result);
+
+extern int
+utf32_string_concat_character(const utf32_string_t *string, utf32_t c, utf32_string_t *result);
+
+extern int
+utf32_string_view_concat_character(const utf32_string_view_t view, utf32_t c, utf32_string_t *result);
+
+extern int
+utf32_string_concat_literal(const utf32_string_t *string, const utf32_t *literal, size_t n, utf32_string_t *result);
+
+extern int
+utf32_string_view_concat_literal(const utf32_string_view_t view, const utf32_t *literal, size_t n, utf32_string_t *result);
+
+extern int
+utf32_string_compare(const utf32_string_t *string, const utf32_string_t *other);
+
+extern int
+utf32_string_view_compare(const utf32_string_view_t view, const utf32_string_view_t other);
+
+extern int
+utf32_string_compare_literal(const utf32_string_t *string, const utf32_t *literal, size_t n);
+
+extern int
+utf32_string_view_compare_literal(const utf32_string_view_t view, const utf32_t *literal, size_t n);
+
+extern utf32_string_view_t
+utf32_string_substring(const utf32_string_t *string, size_t start, size_t end);
+
+extern utf32_string_view_t
+utf32_string_view_substring(const utf32_string_view_t view, size_t start, size_t end);
+
+extern int
+utf32_string_substring_copy(const utf32_string_t *string, size_t start, size_t end, utf32_string_t *result);
+
+extern int
+utf32_string_view_substring_copy(const utf32_string_view_t view, size_t start, size_t end, utf32_string_t *result);
+
+extern size_t
+utf32_string_index_of_character(const utf32_string_t *string, size_t pos, utf32_t c);
+
+extern size_t
+utf32_string_view_index_of_character(const utf32_string_view_t view, size_t pos, utf32_t c);
+
+extern size_t
+utf32_string_last_index_of_character(const utf32_string_t *string, size_t pos, utf32_t c);
+
+extern size_t
+utf32_string_view_last_index_of_character(const utf32_string_view_t view, size_t pos, utf32_t c);

package/deps/libutf/src/utf32/validate.c

@@ -0,0 +1,39 @@
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.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
+utf32_validate(const utf32_t *data, size_t len) {
+  uint64_t pos = 0;
+  uint32_t word;
+
+  while (pos < len) {
+    word = data[pos];
+    if (word > 0x10ffff || (word >= 0xd800 && word <= 0xdfff)) {
+      return false;
+    }
+    pos++;
+  }
+
+  return true;
+}

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

@@ -0,0 +1,70 @@
+#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_latin1(const utf8_t *data, size_t len, latin1_t *result) {
+  size_t pos = 0;
+  latin1_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 = (uint32_t) (((leading_byte & 0b00011111) << 6) |
+                                        (data[pos + 1] & 0b00111111));
+      if (code_point < 0x80 || code_point > 0xff) {
+        return 0;
+      }
+      *result++ = (uint8_t) code_point;
+      pos += 2;
+    } else {
+      return 0;
+    }
+  }
+
+  return (size_t) (result - start);
+}