Add Chromium-only Blender WebEngine parity work

blender-5.2.0/intern/utfconv/CMakeLists.txt

@@ -0,0 +1,33 @@
+# SPDX-FileCopyrightText: 2012-2022 Blender Authors
+#
+# SPDX-License-Identifier: GPL-2.0-or-later
+
+set(INC
+  PUBLIC .
+)
+
+set(INC_SYS
+
+)
+
+set(SRC
+  utfconv.cc
+
+  utfconv.hh
+)
+
+set(LIB
+)
+
+# This is odd but leave it for now...
+# Why have win32 check here? - this is only used for windows.
+# ... because one day we might want to use it on other platforms.
+if(WIN32)
+  list(APPEND SRC
+    utf_winfunc.cc
+    utf_winfunc.hh
+  )
+endif()
+
+blender_add_lib(bf_intern_utfconv "${SRC}" "${INC}" "${INC_SYS}" "${LIB}")
+add_library(bf::intern::utfconv ALIAS bf_intern_utfconv)

blender-5.2.0/intern/utfconv/utf_winfunc.cc

@@ -0,0 +1,175 @@
+/* SPDX-FileCopyrightText: 2012 Blender Authors
+ *
+ * SPDX-License-Identifier: GPL-2.0-or-later */
+
+/** \file
+ * \ingroup intern_utf_conv
+ */
+
+#ifndef _WIN32_IE
+#  define _WIN32_IE 0x0501
+#endif
+
+#include "utf_winfunc.hh"
+#include "utfconv.hh"
+#include <cwchar>
+#include <io.h>
+#include <windows.h>
+
+FILE *ufopen(const char *filename, const char *mode)
+{
+  FILE *f = nullptr;
+  UTF16_ENCODE(filename);
+  UTF16_ENCODE(mode);
+
+  if (filename_16 && mode_16) {
+    f = _wfopen(filename_16, mode_16);
+  }
+
+  UTF16_UN_ENCODE(mode);
+  UTF16_UN_ENCODE(filename);
+
+  if (!f) {
+    if ((f = fopen(filename, mode))) {
+      printf("WARNING: %s is not utf path. Please update it.\n", filename);
+    }
+  }
+
+  return f;
+}
+
+int uopen(const char *filename, int oflag, int pmode)
+{
+  int f = -1;
+  UTF16_ENCODE(filename);
+
+  if (filename_16) {
+    f = _wopen(filename_16, oflag, pmode);
+  }
+
+  UTF16_UN_ENCODE(filename);
+
+  if (f == -1) {
+    if ((f = open(filename, oflag, pmode)) != -1) {
+      printf("WARNING: %s is not utf path. Please update it.\n", filename);
+    }
+  }
+
+  return f;
+}
+
+int uaccess(const char *filename, int mode)
+{
+  int r = -1;
+  UTF16_ENCODE(filename);
+
+  if (filename_16) {
+    r = _waccess(filename_16, mode);
+  }
+
+  UTF16_UN_ENCODE(filename);
+
+  return r;
+}
+
+int urename(const char *oldname, const char *newname, const bool do_replace)
+{
+  int r = -1;
+  UTF16_ENCODE(oldname);
+  UTF16_ENCODE(newname);
+
+  if (oldname_16 && newname_16) {
+    /* Closer to UNIX `rename` behavior, as it at least allows to replace an existing file.
+     * Return value logic is inverted however (returns non-zero on sucess, 0 on failure).
+     * Note that the operation will still fail if the 'newname' existing file is opened anywhere.
+     */
+    r = (MoveFileExW(oldname_16, newname_16, do_replace ? MOVEFILE_REPLACE_EXISTING : 0) == 0);
+  }
+
+  UTF16_UN_ENCODE(newname);
+  UTF16_UN_ENCODE(oldname);
+  return r;
+}
+
+int umkdir(const char *pathname)
+{
+
+  BOOL r = 0;
+  UTF16_ENCODE(pathname);
+
+  if (pathname_16) {
+    r = CreateDirectoryW(pathname_16, NULL);
+  }
+
+  UTF16_UN_ENCODE(pathname);
+
+  return r ? 0 : -1;
+}
+
+char *u_alloc_getenv(const char *varname)
+{
+  char *r = nullptr;
+  wchar_t *str;
+  UTF16_ENCODE(varname);
+  if (varname_16) {
+    str = _wgetenv(varname_16);
+    r = alloc_utf_8_from_16(str, 0);
+  }
+  UTF16_UN_ENCODE(varname);
+
+  return r;
+}
+void u_free_getenv(char *val)
+{
+  free(val);
+}
+
+int uput_getenv(const char *varname, char *value, size_t buffsize)
+{
+  int r = 0;
+  wchar_t *str;
+
+  if (!buffsize) {
+    return r;
+  }
+
+  UTF16_ENCODE(varname);
+  if (varname_16) {
+    str = _wgetenv(varname_16);
+    conv_utf_16_to_8(str, value, buffsize);
+    r = 1;
+  }
+  UTF16_UN_ENCODE(varname);
+
+  if (!r) {
+    value[0] = 0;
+  }
+
+  return r;
+}
+
+int uputenv(const char *name, const char *value)
+{
+  int r = -1;
+  UTF16_ENCODE(name);
+
+  if (value) {
+    /* set */
+    UTF16_ENCODE(value);
+
+    if (name_16 && value_16) {
+      r = (SetEnvironmentVariableW(name_16, value_16) != 0) ? 0 : -1;
+    }
+    UTF16_UN_ENCODE(value);
+  }
+  else {
+    /* clear */
+    if (name_16) {
+      r = (SetEnvironmentVariableW(name_16, NULL) != 0) ? 0 : -1;
+    }
+  }
+
+  UTF16_UN_ENCODE(name);
+
+  return r;
+}

blender-5.2.0/intern/utfconv/utf_winfunc.hh

@@ -0,0 +1,31 @@
+/* SPDX-FileCopyrightText: 2012 Blender Authors
+ *
+ * SPDX-License-Identifier: GPL-2.0-or-later */
+
+/** \file
+ * \ingroup intern_utf_conv
+ */
+
+#ifndef __UTF_WINFUNC_H__
+#define __UTF_WINFUNC_H__
+
+#ifndef WIN32
+#  error "This file can only compile on windows"
+#endif
+
+#include <cstdio>
+
+FILE *ufopen(const char *filename, const char *mode);
+int uopen(const char *filename, int oflag, int pmode);
+int uaccess(const char *filename, int mode);
+int urename(const char *oldname, const char *newname, const bool do_replace);
+
+char *u_alloc_getenv(const char *varname);
+void u_free_getenv(char *val);
+
+int uput_getenv(const char *varname, char *value, size_t buffsize);
+int uputenv(const char *name, const char *value);
+
+int umkdir(const char *pathname);
+
+#endif /* __UTF_WINFUNC_H__ */

blender-5.2.0/intern/utfconv/utfconv.cc

@@ -0,0 +1,304 @@
+/* SPDX-FileCopyrightText: 2012 Blender Authors
+ *
+ * SPDX-License-Identifier: GPL-2.0-or-later */
+
+/** \file
+ * \ingroup intern_utf_conv
+ */
+
+#include "utfconv.hh"
+
+size_t count_utf_8_from_16(const wchar_t *string16)
+{
+  int i;
+  size_t count = 0;
+  wchar_t u = 0;
+  if (!string16) {
+    return 0;
+  }
+
+  for (i = 0; (u = string16[i]); i++) {
+    if (u < 0x0080) {
+      count += 1;
+    }
+    else {
+      if (u < 0x0800) {
+        count += 2;
+      }
+      else {
+        if (u < 0xD800) {
+          count += 3;
+        }
+        else {
+          if (u < 0xDC00) {
+            i++;
+            if ((u = string16[i]) == 0) {
+              break;
+            }
+            if (u >= 0xDC00 && u < 0xE000) {
+              count += 4;
+            }
+          }
+          else {
+            if (u < 0xE000) {
+              /* Illegal. */
+            }
+            else {
+              count += 3;
+            }
+          }
+        }
+      }
+    }
+  }
+
+  return ++count;
+}
+
+size_t count_utf_16_from_8(const char *string8)
+{
+  size_t count = 0;
+  char u;
+  char type = 0;
+  unsigned int u32 = 0;
+
+  if (!string8) {
+    return 0;
+  }
+
+  for (; (u = *string8); string8++) {
+    if (type == 0) {
+      if ((u & 0x01 << 7) == 0) {
+        count++;
+        u32 = 0;
+        continue;
+      }  // 1 utf-8 char
+      if ((u & 0x07 << 5) == 0xC0) {
+        type = 1;
+        u32 = u & 0x1F;
+        continue;
+      }  // 2 utf-8 char
+      if ((u & 0x0F << 4) == 0xE0) {
+        type = 2;
+        u32 = u & 0x0F;
+        continue;
+      }  // 3 utf-8 char
+      if ((u & 0x1F << 3) == 0xF0) {
+        type = 3;
+        u32 = u & 0x07;
+        continue;
+      }  // 4 utf-8 char
+      continue;
+    }
+    if ((u & 0xC0) == 0x80) {
+      u32 = (u32 << 6) | (u & 0x3F);
+      type--;
+    }
+    else {
+      u32 = 0;
+      type = 0;
+    }
+
+    if (type == 0) {
+      if ((0 < u32 && u32 < 0xD800) || (0xE000 <= u32 && u32 < 0x10000)) {
+        count++;
+      }
+      else if (0x10000 <= u32 && u32 < 0x110000) {
+        count += 2;
+      }
+      u32 = 0;
+    }
+  }
+
+  return ++count;
+}
+
+int conv_utf_16_to_8(const wchar_t *in16, char *out8, size_t size8)
+{
+  char *out8end = out8 + size8;
+  wchar_t u = 0;
+  int err = 0;
+  if (!size8 || !in16 || !out8) {
+    return UTF_ERROR_NULL_IN;
+  }
+  out8end--;
+
+  for (; out8 < out8end && (u = *in16); in16++, out8++) {
+    if (u < 0x0080) {
+      *out8 = u;
+    }
+    else if (u < 0x0800) {
+      if (out8 + 1 >= out8end) {
+        break;
+      }
+      *out8++ = (0x3 << 6) | (0x1F & (u >> 6));
+      *out8 = (0x1 << 7) | (0x3F & (u));
+    }
+    else if (u < 0xD800 || u >= 0xE000) {
+      if (out8 + 2 >= out8end) {
+        break;
+      }
+      *out8++ = (0x7 << 5) | (0xF & (u >> 12));
+      *out8++ = (0x1 << 7) | (0x3F & (u >> 6));
+      *out8 = (0x1 << 7) | (0x3F & (u));
+    }
+    else if (u < 0xDC00) {
+      wchar_t u2 = *++in16;
+
+      if (!u2) {
+        break;
+      }
+      if (u2 >= 0xDC00 && u2 < 0xE000) {
+        if (out8 + 3 >= out8end) {
+          break;
+        }
+        unsigned int uc = 0x10000 + (u2 - 0xDC00) + ((u - 0xD800) << 10);
+
+        *out8++ = (0xF << 4) | (0x7 & (uc >> 18));
+        *out8++ = (0x1 << 7) | (0x3F & (uc >> 12));
+        *out8++ = (0x1 << 7) | (0x3F & (uc >> 6));
+        *out8 = (0x1 << 7) | (0x3F & (uc));
+      }
+      else {
+        out8--;
+        err |= UTF_ERROR_ILLCHAR;
+      }
+    }
+    else if (u < 0xE000) {
+      out8--;
+      err |= UTF_ERROR_ILLCHAR;
+    }
+  }
+
+  *out8 = *out8end = 0;
+
+  if (*in16) {
+    err |= UTF_ERROR_SMALL;
+  }
+
+  return err;
+}
+
+int conv_utf_8_to_16(const char *in8, wchar_t *out16, size_t size16)
+{
+  char u;
+  char type = 0;
+  unsigned int u32 = 0;
+  wchar_t *out16end = out16 + size16;
+  int err = 0;
+  if (!size16 || !in8 || !out16) {
+    return UTF_ERROR_NULL_IN;
+  }
+  out16end--;
+
+  for (; out16 < out16end && (u = *in8); in8++) {
+    if (type == 0) {
+      if ((u & 0x01 << 7) == 0) {
+        *out16 = u;
+        out16++;
+        u32 = 0;
+        continue;
+      }  // 1 utf-8 char
+      if ((u & 0x07 << 5) == 0xC0) {
+        type = 1;
+        u32 = u & 0x1F;
+        continue;
+      }  // 2 utf-8 char
+      if ((u & 0x0F << 4) == 0xE0) {
+        type = 2;
+        u32 = u & 0x0F;
+        continue;
+      }  // 3 utf-8 char
+      if ((u & 0x1F << 3) == 0xF0) {
+        type = 3;
+        u32 = u & 0x07;
+        continue;
+      }  // 4 utf-8 char
+      err |= UTF_ERROR_ILLCHAR;
+      continue;
+    }
+    if ((u & 0xC0) == 0x80) {
+      u32 = (u32 << 6) | (u & 0x3F);
+      type--;
+    }
+    else {
+      u32 = 0;
+      type = 0;
+      err |= UTF_ERROR_ILLSEQ;
+    }
+
+    if (type == 0) {
+      if ((0 < u32 && u32 < 0xD800) || (0xE000 <= u32 && u32 < 0x10000)) {
+        *out16 = u32;
+        out16++;
+      }
+      else if (0x10000 <= u32 && u32 < 0x110000) {
+        if (out16 + 1 >= out16end) {
+          break;
+        }
+        u32 -= 0x10000;
+        *out16 = 0xD800 + (u32 >> 10);
+        out16++;
+        *out16 = 0xDC00 + (u32 & 0x3FF);
+        out16++;
+      }
+      u32 = 0;
+    }
+  }
+
+  *out16 = *out16end = 0;
+
+  if (*in8) {
+    err |= UTF_ERROR_SMALL;
+  }
+
+  return err;
+}
+
+/* UNUSED FUNCTIONS */
+#if 0
+static int is_ascii(const char *in8)
+{
+  for (; *in8; in8++) {
+    if (0x80 & *in8) {
+      return 0;
+    }
+  }
+
+  return 1;
+}
+
+static void utf_8_cut_end(char *inout8, size_t maxcutpoint)
+{
+  char *cur = inout8 + maxcutpoint;
+  char cc;
+  if (!inout8) {
+    return;
+  }
+  cc = *cur;
+}
+#endif
+
+char *alloc_utf_8_from_16(const wchar_t *in16, size_t add)
+{
+  size_t bsize = count_utf_8_from_16(in16);
+  char *out8 = nullptr;
+  if (!bsize) {
+    return nullptr;
+  }
+  out8 = (char *)malloc(sizeof(char) * (bsize + add));
+  conv_utf_16_to_8(in16, out8, bsize);
+  return out8;
+}
+
+wchar_t *alloc_utf16_from_8(const char *in8, size_t add)
+{
+  size_t bsize = count_utf_16_from_8(in8);
+  wchar_t *out16 = nullptr;
+  if (!bsize) {
+    return nullptr;
+  }
+  out16 = (wchar_t *)malloc(sizeof(wchar_t) * (bsize + add));
+  conv_utf_8_to_16(in8, out16, bsize);
+  return out16;
+}

blender-5.2.0/intern/utfconv/utfconv.hh

@@ -0,0 +1,89 @@
+/* SPDX-FileCopyrightText: 2012 Blender Authors
+ *
+ * SPDX-License-Identifier: GPL-2.0-or-later */
+
+/** \file
+ * \ingroup intern_utf_conv
+ */
+
+#ifndef __UTFCONV_H__
+#define __UTFCONV_H__
+
+#include <cstdio>
+#include <cstdlib>
+#include <cwchar>
+
+/**
+ * Counts how many bytes is required for future utf-8 string using utf-16
+ * \param string16: pointer to working utf-16 string
+ * \return How many bytes must be allocated including NULL.
+ */
+size_t count_utf_8_from_16(const wchar_t *string16);
+
+/**
+ * Counts how many wchar_t (two byte) is required for future utf-16 string using utf-8
+ * \param string8: pointer to working utf-8 string
+ * \return How many bytes must be allocated including NULL.
+ */
+size_t count_utf_16_from_8(const char *string8);
+
+/*
+ * conv_utf_*** errors
+ */
+
+/** Error occurs when required parameter is missing. */
+#define UTF_ERROR_NULL_IN (1 << 0)
+/** Error if character is in illegal UTF range. */
+#define UTF_ERROR_ILLCHAR (1 << 1)
+/** Passed size is to small. It gives legal string with character missing at the end. */
+#define UTF_ERROR_SMALL (1 << 2)
+/** Error if sequence is broken and doesn't finish. */
+#define UTF_ERROR_ILLSEQ (1 << 3)
+
+/**
+ * Converts utf-16 string to allocated utf-8 string
+ * \param in16: utf-16 string to convert
+ * \param out8: utf-8 string to string the conversion
+ * \param size8: the allocated size in bytes of out8
+ * \return Returns any errors occurred during conversion. See the block above,
+ */
+int conv_utf_16_to_8(const wchar_t *in16, char *out8, size_t size8);
+
+/**
+ * Converts utf-8 string to allocated utf-16 string
+ * \param in8: utf-8 string to convert
+ * \param out16: utf-16 string to string the conversion
+ * \param size16: the allocated size in wchar_t (two byte) of out16
+ * \return Returns any errors occurred during conversion. See the block above,
+ */
+int conv_utf_8_to_16(const char *in8, wchar_t *out16, size_t size16);
+
+/**
+ * Allocates and converts the utf-8 string from utf-16
+ * \param in16: utf-16 string to convert
+ * \param add: any additional size which will be allocated for new utf-8 string in bytes
+ * \return New allocated and converted utf-8 string or NULL if in16 is 0.
+ */
+char *alloc_utf_8_from_16(const wchar_t *in16, size_t add);
+
+/**
+ * Allocates and converts the utf-16 string from utf-8
+ * \param in8: utf-8 string to convert
+ * \param add: any additional size which will be allocated for new utf-16 string
+ * in wchar_t (two bytes)
+ * \return New allocated and converted utf-16 string or NULL if in8 is 0.
+ */
+wchar_t *alloc_utf16_from_8(const char *in8, size_t add);
+
+/* Easy allocation and conversion of new utf-16 string. New string has _16 suffix.
+ * Must be deallocated with UTF16_UN_ENCODE in right order. */
+#define UTF16_ENCODE(in8str) \
+  if (1) { \
+    wchar_t *in8str##_16 = alloc_utf16_from_8((const char *)in8str, 0)
+
+#define UTF16_UN_ENCODE(in8str) \
+  free(in8str##_16); \
+  } \
+  (void)0
+
+#endif /* __UTFCONV_H__ */