bare-buffer 2.5.9 → 2.5.11

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

@@ -1,33 +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
-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/vendor/libutf/src/utf16/length-from-utf8.c

@@ -1,38 +0,0 @@
-#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/vendor/libutf/src/utf16/validate.c

@@ -1,53 +0,0 @@
-#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/vendor/libutf/src/utf32/convert-to-latin1.c

@@ -1,40 +0,0 @@
-#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 result - start;
-}

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

@@ -1,56 +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
-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(data[pos]) : data[pos];
-    } else {
-      if (word > 0x10ffff) {
-        return 0;
-      }
-      word -= 0x10000;
-      uint16_t high_surrogate = 0xd800 + (word >> 10);
-      uint16_t low_surrogate = 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 result - start;
-}

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

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

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

@@ -1,26 +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
-utf32_length_from_latin1 (const utf8_t *data, size_t len) {
-  return len;
-}

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

@@ -1,35 +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
-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/vendor/libutf/src/utf32/length-from-utf8.c

@@ -1,35 +0,0 @@
-#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/vendor/libutf/src/utf32/validate.c

@@ -1,39 +0,0 @@
-#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/vendor/libutf/src/utf8/convert-to-latin1.c

@@ -1,70 +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_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 = ((leading_byte & 0b00011111) << 6) |
-                            (data[pos + 1] & 0b00111111);
-      if (code_point < 0x80 || 0xff < code_point) {
-        return 0;
-      }
-      *result++ = code_point;
-      pos += 2;
-    } else {
-      return 0;
-    }
-  }
-
-  return result - start;
-}

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

@@ -1,95 +0,0 @@
-#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
-utf8_convert_to_utf16le (const utf8_t *data, size_t len, utf16_t *result) {
-  size_t pos = 0;
-  utf16_t *start = result;
-
-  while (pos < len) {
-    if (pos + 8 <= len) {
-      uint64_t v;
-      memcpy(&v, data + pos, sizeof(uint64_t));
-      if ((v & 0x8080808080808080) == 0) {
-        size_t final_pos = pos + 8;
-        while (pos < final_pos) {
-          *result++ = utf_is_be() ? utf_swap_uint16(data[pos]) : data[pos];
-          pos++;
-        }
-        continue;
-      }
-    }
-    uint8_t leading_byte = data[pos];
-    if (leading_byte < 0b10000000) {
-      *result++ = utf_is_be() ? utf_swap_uint16(leading_byte) : leading_byte;
-      pos++;
-    } else if ((leading_byte & 0b11100000) == 0b11000000) {
-      if (pos + 1 >= len) {
-        break;
-      }
-      uint16_t code_point = ((leading_byte & 0b00011111) << 6) |
-                            (data[pos + 1] & 0b00111111);
-      if (utf_is_be()) {
-        code_point = utf_swap_uint16(code_point);
-      }
-      *result++ = code_point;
-      pos += 2;
-    } else if ((leading_byte & 0b11110000) == 0b11100000) {
-      if (pos + 2 >= len) {
-        break;
-      }
-      uint16_t code_point = ((leading_byte & 0b00001111) << 12) |
-                            ((data[pos + 1] & 0b00111111) << 6) |
-                            (data[pos + 2] & 0b00111111);
-      if (utf_is_be()) {
-        code_point = utf_swap_uint16(code_point);
-      }
-      *result++ = code_point;
-      pos += 3;
-    } else if ((leading_byte & 0b11111000) == 0b11110000) {
-      if (pos + 3 >= len) {
-        break;
-      }
-      uint32_t code_point = ((leading_byte & 0b00000111) << 18) |
-                            ((data[pos + 1] & 0b00111111) << 12) |
-                            ((data[pos + 2] & 0b00111111) << 6) |
-                            (data[pos + 3] & 0b00111111);
-      code_point -= 0x10000;
-      uint16_t high_surrogate = 0xd800 + (code_point >> 10);
-      uint16_t low_surrogate = 0xdc00 + (code_point & 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 += 4;
-    } else {
-      return 0;
-    }
-  }
-
-  return result - start;
-}