@simonklee/opentui-tex-native-source 0.2.0

package/native/vendor/microtex/lib/utils/utf.cpp

@@ -0,0 +1,115 @@
+#include "utf.h"
+
+using namespace std;
+using namespace microtex;
+
+bool microtex::isVariationSelector(c32 code) {
+  if (code <= 0x7ff) return false;
+  // variation selectors (Unicode block)
+  if (code >= 0xFE00 && code <= 0xFE0F) {
+    return true;
+  }
+  // variation selectors supplement
+  if (code >= 0xE0100 && code <= 0xE01EF) {
+    return true;
+  }
+  // Mongolian variation selectors
+  if (code >= 0x180B && code <= 0x180D) {
+    return true;
+  }
+  return false;
+}
+
+bool microtex::isZWJ(c32 code) {
+  return code == 0x200D;
+}
+
+bool microtex::isZWNJ(c32 code) {
+  return code == 0x200C;
+}
+
+bool microtex::isJoiner(c32 code) {
+  return isZWJ(code) || isZWNJ(code);
+}
+
+void microtex::appendToUtf8(std::string& out, c32 code) {
+  if (code <= 0x7f) {
+    out.append(1, static_cast<char>(code));
+  } else if (code <= 0x7ff) {
+    out.append(1, static_cast<char>(0xc0 | ((code >> 6) & 0x1f)));
+    out.append(1, static_cast<char>(0x80 | (code & 0x3f)));
+  } else if (code <= 0xffff) {
+    out.append(1, static_cast<char>(0xe0 | ((code >> 12) & 0x0f)));
+    out.append(1, static_cast<char>(0x80 | ((code >> 6) & 0x3f)));
+    out.append(1, static_cast<char>(0x80 | (code & 0x3f)));
+  } else {
+    out.append(1, static_cast<char>(0xf0 | ((code >> 18) & 0x07)));
+    out.append(1, static_cast<char>(0x80 | ((code >> 12) & 0x3f)));
+    out.append(1, static_cast<char>(0x80 | ((code >> 6) & 0x3f)));
+    out.append(1, static_cast<char>(0x80 | (code & 0x3f)));
+  }
+}
+
+c32 microtex::nextUnicode(const std::string& src, int i, int& cnt) {
+  const auto l = src.length();
+  if (i >= l) {
+    cnt = 0;
+    return 0;
+  }
+  const char* in = src.c_str() + i;
+  auto ch = static_cast<unsigned char>(*in);
+  // 1 byte
+  cnt = 1;
+  if (ch <= 0b01111111) {
+    return static_cast<c32>(ch);
+  }
+  // multi-bytes
+  c32 code = 0;
+  if (ch <= 0b11011111) {
+    code = (ch & 0b00011111) << 6;
+    cnt = 2;
+  } else if (ch <= 0b11101111) {
+    code = (ch & 0b00001111) << 12;
+    cnt = 3;
+  } else if (ch <= 0b11110111) {
+    code = (ch & 0b00000111) << 18;
+    cnt = 4;
+  } else if (ch <= 0b11111011) {
+    code = (ch & 0b00000011) << 24;
+    cnt = 5;
+  } else if (ch <= 0b11111101) {
+    code = (ch & 0b00000001) << 30;
+    cnt = 6;
+  }
+  // otherwise, the utf-8 string is malformed
+  for (int j = 1; j < cnt; j++) {
+    // malformed utf-8 string, we ignore it
+    if (i + j >= l) break;
+    auto c = static_cast<unsigned char>(*(in + j));
+    code |= (c & 0b00111111) << (6 * (cnt - j - 1));
+  }
+  return code;
+}
+
+void microtex::scanContinuedUnicodes(
+  const std::function<c32()>& next,
+  const std::function<void(c32)>& collect
+) {
+  const c32 x = next();
+  collect(x);
+  while (true) {
+    const c32 a = next();
+    if (microtex::isVariationSelector(a)) {
+      collect(a);
+    } else if (microtex::isJoiner(a)) {
+      collect(a);
+      c32 b = 0;
+      do {
+        b = next();
+        collect(b);
+      } while (isJoiner(b));
+    } else {
+      break;
+    }
+  }
+}

package/native/vendor/microtex/lib/utils/utf.h

@@ -0,0 +1,58 @@
+#ifndef UTF_H_INCLUDED
+#define UTF_H_INCLUDED
+
+#include <string>
+
+#include "utils/utils.h"
+
+namespace microtex {
+
+/** Append an Unicode code-point to an utf-8 string */
+void appendToUtf8(std::string& out, c32 code);
+
+/**
+ * Get the next Unicode code-point from the given utf-8 string
+ * start from #i, the bytes count consumed in the byte sequence
+ * was given by #cnt after the code-point was decoded.
+ */
+c32 nextUnicode(const std::string& src, int i, int& cnt);
+
+/**
+ * Test if a given Unicode code-point is a variation-selector.
+ * See [https://en.m.wikipedia.org/wiki/Variant_form_(Unicode)]
+ * for details.
+ */
+bool isVariationSelector(c32 code);
+
+/**
+ * Test if a given Unicode code-point is a zero-width joiner.
+ * See [https://en.wikipedia.org/wiki/Zero-width_joiner]
+ * for details.
+ */
+bool isZWJ(c32 code);
+
+/**
+ * Test if a given Unicode code-point is a zero-width non-joiner.
+ * See [https://en.wikipedia.org/wiki/Zero-width_non-joiner]
+ * for details
+ */
+bool isZWNJ(c32 code);
+
+/** Test if a given Unicode code-point is a joiner. */
+bool isJoiner(c32 code);
+
+/**
+ * Scan Unicodes that cannot be split from a sequence and collect
+ * it into an arbitrary container.
+ *
+ * @param next function to get the next Unicode code-point, 0 terminated
+ * @param collect function to collect the given Unicode-point
+ */
+void scanContinuedUnicodes(
+  const std::function<c32()>& next,
+  const std::function<void(c32)>& collect
+);
+
+}  // namespace microtex
+
+#endif

package/native/vendor/microtex/lib/utils/utils.cpp

@@ -0,0 +1,40 @@
+#include "utils/utils.h"
+
+const std::locale& microtex::defaultLocale() {
+#if !defined(__WIN32__)
+  static const std::locale locale("en_US.UTF-8");
+#else
+  static const std::locale locale("C");
+#endif
+  return locale;
+}
+
+bool microtex::isUnicodeLower(c32 code) {
+  // the type-cast is necessary, or a std::bad_cast will be thrown,
+  // because std::toupper is a template function
+  return std::islower((wchar_t)code, defaultLocale());
+}
+
+bool microtex::isUnicodeDigit(c32 code) {
+  return std::isdigit((wchar_t)code, defaultLocale());
+}
+
+microtex::c32 microtex::toUnicodeUpper(c32 code) {
+  return std::toupper((wchar_t)code, defaultLocale());
+}
+
+microtex::c32 microtex::toUnicodeLower(c32 code) {
+  return std::tolower((wchar_t)code, defaultLocale());
+}
+
+int microtex::binIndexOf(int count, const std::function<int(int)>& compare, bool returnClosest) {
+  if (count == 0) return -1;
+  int l = 0, h = count - 1;
+  while (l <= h) {
+    const int m = l + ((h - l) >> 1);
+    const int cmp = compare(m);
+    if (cmp == 0) return m;
+    cmp < 0 ? h = m - 1 : l = m + 1;
+  }
+  return returnClosest ? std::max(0, l - 1) : -1;
+}

package/native/vendor/microtex/lib/utils/utils.h

@@ -0,0 +1,88 @@
+#ifndef UTILS_INCLUDED
+#define UTILS_INCLUDED
+
+#include <algorithm>
+#include <functional>
+#include <locale>
+#include <map>
+#include <vector>
+
+#include "types.h"
+
+#define no_copy_assign(T) \
+  T(const T&) = delete;   \
+  void operator=(const T&) = delete
+
+namespace microtex {
+
+template <typename T, typename... Args>
+inline sptr<T> sptrOf(Args&&... args) {
+  return std::make_shared<T>(std::forward<Args>(args)...);
+}
+
+template <typename T, typename... Args>
+inline uptr<T> uptrOf(Args&&... args) {
+  return std::make_unique<T>(std::forward<Args>(args)...);
+}
+
+inline bool isAlpha(char c) {
+  return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z');
+}
+
+template <typename K, typename V>
+inline std::vector<K> keys(const std::map<K, V>& map) {
+  std::vector<K> v;
+  for (auto& it : map) {
+    v.push_back(it.first);
+  }
+  return v;
+}
+
+/** Template version to find the max value of the given list */
+template <typename T, typename... Args>
+inline T maxOf(Args&&... args) {
+  return std::max({args...});
+}
+
+/** Get number of set bits in binary representation of the given number */
+template <typename T>
+u32 countSetBits(T n) {
+  u32 cnt = 0;
+  while (n) {
+    n &= (n - 1);
+    cnt++;
+  }
+  return cnt;
+}
+
+/** The default locale */
+const std::locale& defaultLocale();
+
+/** Test if a Unicode code point is lower case */
+bool isUnicodeLower(c32 code);
+
+/** Test if a Unicode code point is digit */
+bool isUnicodeDigit(c32 code);
+
+/** Convert given Unicode code point to upper case */
+c32 toUnicodeUpper(c32 code);
+
+/** Convert given Unicode code point to lower case */
+c32 toUnicodeLower(c32 code);
+
+/**
+ * Binary-search for the index of the given target in a container. The items in the container must
+ * be sorted.
+ *
+ * @param count total count of elements in the container
+ * @param compare function to compare between the target value and the value at the given index
+ * @param returnClosest whether return the closest index while not found, default is false
+ *
+ * @return the index which the target value found at, or the closest index if returnClosest is true,
+ * or -1 otherwise
+ */
+int binIndexOf(int count, const std::function<int(int)>& compare, bool returnClosest = false);
+
+}  // namespace microtex
+
+#endif

package/native/vendor/microtex/lib/wrapper/byte_seq.cpp

@@ -0,0 +1,46 @@
+#ifdef HAVE_CWRAPPER
+
+#include "wrapper/byte_seq.h"
+
+#include <cstdlib>
+
+#include "utils/log.h"
+
+namespace microtex {
+
+ByteSeq::ByteSeq() {
+  _data = malloc(CHUNK_SIZE);
+  // the first 4 bytes is the bytes size used
+  _index = 4;
+  _capacity = CHUNK_SIZE;
+}
+
+void ByteSeq::_put(const char* str) {
+  auto l = sizeOf(str);
+  strcpy((char*)_data + _index, str);
+  _index += l;
+}
+
+void ByteSeq::ensureCapacity(len_t required) {
+  if (_index + required < _capacity) {
+    return;
+  }
+#ifdef HAVE_LOG
+  logv("grow buffer, _capacity: %u, to be add: %u\n", _capacity, required);
+#endif
+  _data = realloc(_data, _capacity + CHUNK_SIZE);
+  _capacity += CHUNK_SIZE;
+}
+
+void* ByteSeq::finish() {
+#ifdef HAVE_LOG
+  logv("finish drawing commands, bytes: %u\n", _index);
+#endif
+  auto ptr = (unsigned int*)_data;
+  *ptr = _index;
+  return _data;
+}
+
+}  // namespace microtex
+
+#endif  // HAVE_CWRAPPER

package/native/vendor/microtex/lib/wrapper/byte_seq.h

@@ -0,0 +1,70 @@
+#ifndef MICROTEX_BYTE_SEQ_H
+#define MICROTEX_BYTE_SEQ_H
+
+#ifdef HAVE_CWRAPPER
+
+#include <cstring>
+
+#include "utils/utils.h"
+
+namespace microtex {
+
+using len_t = unsigned int;
+
+class ByteSeq {
+private:
+  static constexpr len_t CHUNK_SIZE = 4 * 1024;  // 4KB
+
+  static inline len_t sizeOf() { return 0; }
+
+  static inline len_t sizeOf(const char* str) { return strlen(str) + 1; }
+
+  template <typename T, typename... Ts>
+  static len_t sizeOf(const T& t, const Ts&... ts) {
+    return sizeof(T) + sizeOf(ts...);
+  }
+
+  len_t _index;
+  len_t _capacity;
+  void* _data;
+
+  inline void _put() {}
+
+  void _put(const char* str);
+
+  template <typename T>
+  void _put(T t) {
+    auto l = sizeof(T);
+    T* ptr = (T*)((char*)_data + _index);
+    *ptr = t;
+    _index += l;
+  }
+
+  template <typename T, typename... Ts>
+  void _put(T t, Ts... ts) {
+    _put(t);
+    _put(ts...);
+  }
+
+  void ensureCapacity(len_t required);
+
+public:
+  no_copy_assign(ByteSeq);
+
+  ByteSeq();
+
+  template <typename T, typename... Ts>
+  void put(T t, Ts... ts) {
+    auto l = sizeOf(t, ts...);
+    ensureCapacity(l);
+    _put(t, ts...);
+  }
+
+  void* finish();
+};
+
+}  // namespace microtex
+
+#endif  // HAVE_CWRAPPER
+
+#endif  // MICROTEX_BYTE_SEQ_H

package/native/vendor/microtex/lib/wrapper/callback.cpp

@@ -0,0 +1,10 @@
+#ifdef HAVE_CWRAPPER
+
+#include "wrapper/callback.h"
+
+CBCreateTextLayout microtex_createTextLayout = nullptr;
+CBGetTextLayoutBounds microtex_getTextLayoutBounds = nullptr;
+CBReleaseTextLayout microtex_releaseTextLayout = nullptr;
+CBIsPathExists microtex_isPathExists = nullptr;
+
+#endif

package/native/vendor/microtex/lib/wrapper/callback.h

@@ -0,0 +1,72 @@
+#ifndef MICROTEX_CALLBACK_H
+#define MICROTEX_CALLBACK_H
+
+#ifdef HAVE_CWRAPPER
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** Simple struct to represents the bounds of a text layout. */
+typedef struct {
+  float width;
+  float height;
+  float ascent;
+} TextLayoutBounds;
+
+/**
+ * Simple struct to represents the description to create a font to
+ * layout and draw a text-layout.
+ *
+ * Unlike the font the engine using internally, you are free to create
+ * the font you want based on the given description, the description
+ * is for reference, not a constraint.
+ */
+typedef struct {
+  bool isBold;
+  bool isItalic;
+  bool isSansSerif;
+  bool isMonospace;
+  float fontSize;
+} FontDesc;
+
+/**
+ * Callback to create a text-layout from given text and font description,
+ * it should returns the id of the created text-layout, and then the id
+ * will be used to retrieve the bounds and draw.
+ *
+ * See [lib/wrapper/graphic_wrapper.h: TextLayout_wrapper::draw].
+ */
+typedef unsigned int (*CBCreateTextLayout)(const char* txt, FontDesc* f);
+
+/**
+ * Callback to retrieve the bounds of the text-layout created by callback
+ * [CBCreateTextLayout] before.
+ */
+typedef void (*CBGetTextLayoutBounds)(unsigned int id, TextLayoutBounds* b);
+
+/**
+ * Callback to release the text-layout created by callback [CBCreateTextLayout]
+ * before.
+ */
+typedef void (*CBReleaseTextLayout)(unsigned int id);
+
+/**
+ * Callback to check if a (glyph) path given by id is in cache. It will be used
+ * by [lib/graphic/graphic.h: Graphic2D::drawPath] to determine if a path is in
+ * cache, if it does, the following path drawing command will be ignored.
+ */
+typedef bool (*CBIsPathExists)(unsigned int id);
+
+extern CBCreateTextLayout microtex_createTextLayout;
+extern CBGetTextLayoutBounds microtex_getTextLayoutBounds;
+extern CBReleaseTextLayout microtex_releaseTextLayout;
+extern CBIsPathExists microtex_isPathExists;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
+#endif  // MICROTEX_CALLBACK_H

package/native/vendor/microtex/lib/wrapper/cwrapper.cpp

@@ -0,0 +1,206 @@
+#ifdef HAVE_CWRAPPER
+
+#include "wrapper/cwrapper.h"
+
+#include "microtex.h"
+#include "utils/log.h"
+#include "wrapper/graphic_wrapper.h"
+
+using namespace microtex;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+MICROTEX_CAPI const char* microtex_version() {
+  // No need to copy, [MicroTeX::version] returns a static string
+  return MicroTeX::version().c_str();
+}
+
+MICROTEX_CAPI void microtex_registerCallbacks(
+  CBCreateTextLayout createTextLayout,
+  CBGetTextLayoutBounds getTextLayoutBounds,
+  CBReleaseTextLayout releaseTextLayout,
+  CBIsPathExists isPathExists
+) {
+  microtex_createTextLayout = createTextLayout;
+  microtex_getTextLayoutBounds = getTextLayoutBounds;
+  microtex_releaseTextLayout = releaseTextLayout;
+  microtex_isPathExists = isPathExists;
+}
+
+MICROTEX_CAPI void
+microtex_setTextLayoutBounds(TextLayoutBounds* b, float width, float height, float ascent) {
+  b->width = width;
+  b->height = height;
+  b->ascent = ascent;
+}
+
+MICROTEX_CAPI bool microtex_isBold(FontDesc* desc) {
+  return desc->isBold;
+}
+
+MICROTEX_CAPI bool microtex_isItalic(FontDesc* desc) {
+  return desc->isItalic;
+}
+
+MICROTEX_CAPI bool microtex_isSansSerif(FontDesc* desc) {
+  return desc->isSansSerif;
+}
+
+MICROTEX_CAPI bool microtex_isMonospace(FontDesc* desc) {
+  return desc->isMonospace;
+}
+
+MICROTEX_CAPI float microtex_fontSize(FontDesc* desc) {
+  return desc->fontSize;
+}
+
+MICROTEX_CAPI FontMetaPtr microtex_init(unsigned long len, const unsigned char* data) {
+  auto factory = std::make_unique<PlatformFactory_wrapper>();
+  PlatformFactory::registerFactory("__wrapper__", std::move(factory));
+  PlatformFactory::activate("__wrapper__");
+  FontSrcData src{len, data};
+  auto meta = MicroTeX::init(src);
+  return new FontMeta(meta);
+}
+
+MICROTEX_CAPI void microtex_release() {
+  MicroTeX::release();
+}
+
+MICROTEX_CAPI bool microtex_isInited() {
+  return MicroTeX::isInited();
+}
+
+MICROTEX_CAPI FontMetaPtr microtex_addFont(unsigned long len, const unsigned char* data) {
+  FontSrcData src{len, data};
+  auto meta = MicroTeX::addFont(src);
+  // create a new FontMeta from heap
+  // [microtex_releaseFontMeta] must be called after this object has no usages.
+  return new FontMeta(meta);
+}
+
+MICROTEX_CAPI const char* microtex_getFontFamily(FontMetaPtr ptr) {
+  auto* meta = (FontMeta*)ptr;
+  // no need to copy
+  return meta->family.c_str();
+}
+
+MICROTEX_CAPI const char* microtex_getFontName(FontMetaPtr ptr) {
+  auto* meta = (FontMeta*)ptr;
+  // no need to copy
+  return meta->name.c_str();
+}
+
+MICROTEX_CAPI bool microtex_isMathFont(FontMetaPtr ptr) {
+  auto* meta = (FontMeta*)ptr;
+  return meta->isMathFont;
+}
+
+MICROTEX_CAPI void microtex_releaseFontMeta(FontMetaPtr ptr) {
+  auto* meta = (FontMeta*)ptr;
+  delete meta;
+}
+
+MICROTEX_CAPI void microtex_setDefaultMathFont(const char* name) {
+  MicroTeX::setDefaultMathFont(name);
+}
+
+MICROTEX_CAPI void microtex_setDefaultMainFont(const char* name) {
+  MicroTeX::setDefaultMainFont(name);
+}
+
+MICROTEX_CAPI bool microtex_hasGlyphPathRender() {
+  return MicroTeX::hasGlyphPathRender();
+}
+
+MICROTEX_CAPI void microtex_setRenderGlyphUsePath(bool use) {
+  return MicroTeX::setRenderGlyphUsePath(use);
+}
+
+MICROTEX_CAPI bool microtex_isRenderGlyphUsePath() {
+  return MicroTeX::isRenderGlyphUsePath();
+}
+
+MICROTEX_CAPI RenderPtr microtex_parseRender(
+  const char* tex,
+  int width,
+  float textSize,
+  float lineSpace,
+  unsigned int color,
+  bool fillWidth,
+  bool enableOverrideTeXStyle,
+  unsigned int texStyle
+) {
+#ifdef HAVE_LOG
+  logv("parse: %s\n", tex);
+#endif
+  auto r = MicroTeX::parse(
+    tex,
+    width,
+    textSize,
+    lineSpace,
+    color,
+    fillWidth,
+    {enableOverrideTeXStyle, static_cast<TexStyle>(texStyle)}
+  );
+  return reinterpret_cast<RenderPtr>(r);
+}
+
+MICROTEX_CAPI void microtex_deleteRender(RenderPtr render) {
+  auto r = reinterpret_cast<Render*>(render);
+  delete r;
+}
+
+MICROTEX_CAPI DrawingData microtex_getDrawingData(RenderPtr render, int x, int y) {
+  auto r = reinterpret_cast<Render*>(render);
+  Graphics2D_wrapper g2;
+  r->draw(g2, x, y);
+  return g2.getDrawingData();
+}
+
+MICROTEX_CAPI void microtex_freeDrawingData(DrawingData data) {
+  free(data);
+}
+
+MICROTEX_CAPI bool microtex_isLittleEndian() {
+  int n = 1;
+  return *((char*)&n) == 1;
+}
+
+MICROTEX_CAPI int microtex_getRenderWidth(RenderPtr render) {
+  auto r = reinterpret_cast<Render*>(render);
+  return r->getWidth();
+}
+
+MICROTEX_CAPI int microtex_getRenderHeight(RenderPtr render) {
+  auto r = reinterpret_cast<Render*>(render);
+  return r->getHeight();
+}
+
+MICROTEX_CAPI int microtex_getRenderDepth(RenderPtr render) {
+  auto r = reinterpret_cast<Render*>(render);
+  return r->getDepth();
+}
+
+MICROTEX_CAPI bool microtex_isRenderSplit(RenderPtr render) {
+  auto r = reinterpret_cast<Render*>(render);
+  return r->isSplit();
+}
+
+MICROTEX_CAPI void microtex_setRenderTextSize(RenderPtr render, float size) {
+  auto r = reinterpret_cast<Render*>(render);
+  r->setTextSize(size);
+}
+
+MICROTEX_CAPI void microtex_setRenderForeground(RenderPtr render, color c) {
+  auto r = reinterpret_cast<Render*>(render);
+  r->setForeground(c);
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // HAVE_CWRAPPER