@simonklee/opentui-tex-native-source 0.2.0

package/native/vendor/microtex/lib/otf/clm.cpp

@@ -0,0 +1,405 @@
+#include "otf/clm.h"
+
+#include <cstring>
+
+#include "utils/exceptions.h"
+#include "utils/string_utils.h"
+
+namespace microtex {
+
+class BinaryReader {
+public:
+  virtual ~BinaryReader() = default;
+
+  virtual const u8* readBytes(size_t bytes) = 0;
+
+  virtual size_t lookfwd(u8 until) = 0;
+
+  template <typename T>
+  T read() {
+    const auto bytes = sizeof(T);
+    const u8* p = readBytes(bytes);
+    auto shift = bytes - 1;
+    T t = 0;
+    for (std::size_t i = 0; i < bytes; i++) {
+      t |= static_cast<T>(*(p + i)) << ((shift - i) * 8);
+    }
+    return t;
+  }
+
+  const char* readString() {
+    size_t len = lookfwd(0x00);
+    const char* ret = (const char*)readBytes(len);
+    return ret;
+  }
+};
+
+class BinaryFileReader : public BinaryReader {
+private:
+  constexpr static const u32 CHUNK_SIZE = 10 * 1024;
+  FILE* _file;
+  u8 _buff[CHUNK_SIZE]{};
+  u32 _currentSize = 0;
+  u32 _index = 0;
+  bool _eof = false;
+
+  void readChunk(u32 remain = 0) {
+    if (_eof) return;
+    const auto size = CHUNK_SIZE - remain;
+    memcpy(_buff, _buff + size, remain);
+    auto read = fread(_buff + remain, 1, size, _file);
+    if (read < size) _eof = true;
+    _currentSize = read + remain;
+    _index = 0;
+  }
+
+public:
+  explicit BinaryFileReader(const char* filePath) {
+    _file = fopen(filePath, "rb");
+    if (_file == nullptr) {
+      throw ex_file_not_found(std::string(filePath) + " cannot be opened.");
+    }
+  }
+
+  const u8* readBytes(size_t bytes) override {
+    const auto remain = _currentSize - _index;
+    if (remain < bytes) readChunk(remain);
+    if (_index >= _currentSize) throw ex_eof("end of data");
+    const u8* p = _buff + _index;
+    _index += bytes;
+    return p;
+  }
+
+  size_t lookfwd(u8 until) override {
+    size_t len = 0;
+    u8 active = 0x00;
+    while (active != until || len == 0) {
+      const auto remain = _currentSize - (_index + len);
+      if (remain < 32) readChunk(32);
+
+      if (_index + len >= _currentSize) throw ex_eof("end of data");
+      active = _buff[_index + len];
+      len++;
+    }
+    return len;
+  }
+
+  ~BinaryFileReader() override {
+    if (_file != nullptr) fclose(_file);
+  }
+};
+
+class BinaryDataReader : public BinaryReader {
+private:
+  const u8* _data;
+  const size_t _len;
+  u32 _index = 0;
+
+public:
+  explicit BinaryDataReader(size_t len, const u8* data) : _len(len), _data(data) {}
+
+  const u8* readBytes(size_t bytes) override {
+    if (_index >= _len) throw ex_eof("end of data");
+    const u8* p = _data + _index;
+    _index += bytes;
+    return p;
+  }
+
+  size_t lookfwd(u8 until) override {
+    size_t len = 0;
+    u8 active = 0x00;
+    while (active != until || len == 0) {
+      if (_index + len >= _len) throw ex_eof("end of data");
+      active = _data[_index + len];
+      len++;
+    }
+    return len;
+  }
+};
+
+void CLMReader::readMeta(Otf& font, BinaryReader& reader) {
+  font._name = std::string(reader.readString());
+  font._family = std::string(reader.readString());
+  font._isMathFont = reader.read<u8>();
+  font._style = reader.read<u16>();
+  font._em = reader.read<u16>();
+  font._xHeight = reader.read<u16>();
+  font._ascent = reader.read<u16>();
+  font._descent = reader.read<u16>();
+  u16 count = reader.read<u16>();
+  u32* unicodes = new u32[count];
+  u16* glyphs = new u16[count];
+  for (u16 i = 0; i < count; i++) {
+    unicodes[i] = reader.read<u32>();
+    glyphs[i] = reader.read<u16>();
+  }
+  font._unicodeCount = count;
+  font._unicodes = unicodes;
+  font._unicodeGlyphs = glyphs;
+}
+
+std::pair<u16, u16*> CLMReader::readClassKerningGlyphs(BinaryReader& reader) {
+  const u16 count = reader.read<u16>();
+  u16* glyphs = new u16[count * 2];
+  for (u16 i = 0; i < count; i++) {
+    glyphs[i << 1] = reader.read<u16>();
+    glyphs[(i << 1) + 1] = reader.read<u16>();
+  }
+  return std::make_pair(count, glyphs);
+}
+
+ClassKerning* CLMReader::readClassKerning(BinaryReader& reader) {
+  auto* ptr = new ClassKerning();
+  ClassKerning& ck = *ptr;
+  // read left glyphs
+  ck._rowLength = reader.read<u16>();
+  auto [lc, lg] = readClassKerningGlyphs(reader);
+  ck._leftCount = lc;
+  ck._lefts = lg;
+  // read right glyphs
+  ck._columnLength = reader.read<u16>();
+  auto [rc, rg] = readClassKerningGlyphs(reader);
+  ck._rightCount = rc;
+  ck._rights = rg;
+  // read table
+  const u32 size = (u32)ck._rowLength * (u32)ck._columnLength;
+  i16* table = new i16[size];
+  for (u32 i = 0; i < size; i++) {
+    table[i] = reader.read<i16>();
+  }
+  ck._table = table;
+  return ptr;
+}
+
+void CLMReader::readClassKernings(Otf& font, BinaryReader& reader) {
+  const u16 count = reader.read<u16>();
+  font._classKerningCount = count;
+  if (count == 0) {
+    font._classKernings = nullptr;
+    return;
+  }
+  font._classKernings = new ClassKerning*[count];
+  for (u16 i = 0; i < count; i++) {
+    font._classKernings[i] = readClassKerning(reader);
+  }
+}
+
+LigaTable* CLMReader::readLigatures(BinaryReader& reader) {
+  const u16 glyph = reader.read<u16>();
+  const i32 liga = reader.read<i32>();
+  const u16 childCount = reader.read<u16>();
+  auto* t = new LigaTable(glyph, liga, childCount);
+  for (u16 i = 0; i < childCount; i++) {
+    t->child(i) = readLigatures(reader);
+  }
+  return t;
+}
+
+MathConsts* CLMReader::readMathConsts(BinaryReader& reader) {
+  auto* consts = new MathConsts();
+  for (i16& _field : consts->_fields) {
+    _field = reader.read<i16>();
+  }
+  return consts;
+}
+
+KernRecord* CLMReader::readKerns(BinaryReader& reader) {
+  const u16 count = reader.read<u16>();
+  if (count == 0) return nullptr;
+  auto* record = new KernRecord(count);
+  for (u16 i = 0; i < count; i++) {
+    record->_fields[i << 1] = reader.read<u16>();
+    record->_fields[(i << 1) + 1] = reader.read<i16>();
+  }
+  return record;
+}
+
+Variants* CLMReader::readVariants(BinaryReader& reader) {
+  const u16 count = reader.read<u16>();
+  if (count == 0) return nullptr;
+  auto* variants = new Variants(count);
+  for (u16 i = 0; i < count; i++) {
+    variants->_glyphs[i] = reader.read<u16>();
+  }
+  return variants;
+}
+
+GlyphAssembly* CLMReader::readGlyphAssembly(BinaryReader& reader) {
+  const bool isPresent = reader.read<u8>();
+  if (!isPresent) return nullptr;
+  const u16 partCount = reader.read<u16>();
+  auto* assembly = new GlyphAssembly(partCount);
+  assembly->_italicsCorrection = reader.read<i16>();
+  for (u16 i = 0; i < partCount; i++) {
+    GlyphPart& part = assembly->_parts[i];
+    part._glyph = reader.read<u16>();
+    part._flags = reader.read<u16>();
+    part._startConnectorLength = reader.read<u16>();
+    part._endConnectorLength = reader.read<u16>();
+    part._fullAdvance = reader.read<u16>();
+  }
+  return assembly;
+}
+
+Math* CLMReader::readMath(BinaryReader& reader) {
+  Math* ptr = new Math(0);
+  Math& math = *ptr;
+  math._italicsCorrection = reader.read<i16>();
+  math._topAccentAttachment = reader.read<i16>();
+  // variants
+  Variants* hv = readVariants(reader);
+  math._horizontalVariants = hv == nullptr ? &Variants::empty : hv;
+  Variants* vv = readVariants(reader);
+  math._verticalVariants = vv == nullptr ? &Variants::empty : vv;
+  Variants* ss = readVariants(reader);
+  math._scriptsVariants = ss == nullptr ? &Variants::empty : ss;
+  // glyph assembly
+  GlyphAssembly* hg = readGlyphAssembly(reader);
+  math._horizontalAssembly = hg == nullptr ? &GlyphAssembly::empty : hg;
+  GlyphAssembly* vg = readGlyphAssembly(reader);
+  math._verticalAssembly = vg == nullptr ? &GlyphAssembly::empty : vg;
+  // kern record
+  auto* record = new MathKernRecord(0);
+  for (auto& field : record->_fields) {
+    const u16 count = reader.read<u16>();
+    if (count == 0) {
+      field = &MathKern::empty;
+      continue;
+    }
+    auto* kern = new MathKern(count);
+    for (u16 i = 0; i < count; i++) {
+      kern->_fields[i << 1] = reader.read<i16>();
+      kern->_fields[(i << 1) + 1] = reader.read<i16>();
+    }
+    field = kern;
+  }
+  math._kernRecord = record;
+  return ptr;
+}
+
+#ifdef HAVE_GLYPH_RENDER_PATH
+
+Path* CLMReader::readPath(BinaryReader& reader) {
+  // !NOT THREAD SAFE
+  static i32 id = 0;
+
+  const auto len = reader.read<u16>();
+  if (len == 0) return nullptr;
+  auto cmds = new PathCmd*[len];
+  for (u16 i = 0; i < len; i++) {
+    const auto cmd = reader.read<char>();
+    const auto cnt = microtex::pathCmdArgsCount(cmd);
+    auto args = new i16[cnt];
+    for (u16 j = 0; j < cnt; j++) {
+      args[j] = reader.read<i16>();
+    }
+    cmds[i] = new PathCmd(cmd, args);
+  }
+  return new Path(++id, len, cmds);
+}
+
+#else
+
+void CLMReader::skipGlyphPath(BinaryReader& reader) {
+  const auto len = reader.read<u16>();
+  if (len == 0) return;
+  for (u16 i = 0; i < len; i++) {
+    const auto cmd = reader.read<char>();
+    const auto cnt = microtex::pathCmdArgsCount(cmd);
+    for (u16 j = 0; j < cnt; j++) {
+      reader.read<i16>();
+    }
+  }
+}
+
+#endif  // HAVE_GLYPH_RENDER_PATH
+
+Glyph* CLMReader::readGlyph(bool isMathFont, bool hasGlyphPath, BinaryReader& reader) {
+  auto* glyph = new Glyph();
+  // Metrics is required
+  glyph->_metrics._width = reader.read<i16>();
+  glyph->_metrics._height = reader.read<i16>();
+  glyph->_metrics._depth = reader.read<i16>();
+  // read kern record, optional
+  auto kern = readKerns(reader);
+  glyph->_kernRecord = kern == nullptr ? &KernRecord::empty : kern;
+  // read math, optional
+  glyph->_math = isMathFont ? readMath(reader) : &Math::empty;
+#ifdef HAVE_GLYPH_RENDER_PATH
+  // read path
+  if (hasGlyphPath) {
+    auto path = readPath(reader);
+    glyph->_path = path == nullptr ? &Path::empty : path;
+  } else {
+    // The font does not have glyph paths, although we have the path render
+    // capability
+    glyph->_path = &Path::empty;
+  }
+#else
+  // Need to skip the glyph paths, because we don't have the path render
+  // capability
+  if (hasGlyphPath) skipGlyphPath(reader);
+#endif
+  return glyph;
+}
+
+void CLMReader::readGlyphs(Otf& font, bool hasGlyphPath, BinaryReader& reader) {
+  const u16 count = reader.read<u16>();
+  auto** glyphs = new Glyph*[count];
+  for (u16 i = 0; i < count; i++) {
+    glyphs[i] = readGlyph(font._isMathFont, hasGlyphPath, reader);
+  }
+  font._glyphCount = count;
+  font._glyphs = glyphs;
+}
+
+Otf* CLMReader::read(BinaryReader& reader) {
+  // read format
+  const auto c = reader.read<u8>();
+  const auto l = reader.read<u8>();
+  const auto m = reader.read<u8>();
+  if (c != 'c' || l != 'l' || m != 'm') {
+    throw ex_invalid_param("invalid clm data format");
+  }
+  const auto ver = reader.read<u16>();
+  if (ver != CLM_VER_MAJOR) {
+    throw ex_invalid_param(
+      "clm data (with version: " + toString(ver) + ") does not match the required version ("
+      + toString(CLM_VER_MAJOR) + ")!"
+    );
+  }
+  const auto minor = reader.read<u8>();
+  const bool hasGlyphPath = CLM_SUPPORT_GLYPH_PATH(minor);
+#if GLYPH_RENDER_TYPE == GLYPH_RENDER_TYPE_PATH
+  if (!hasGlyphPath) {
+    throw ex_invalid_param("The given clm data does not have glyph paths.");
+  }
+#endif
+  // read otf-spec
+  Otf* font = new Otf();
+  font->_hasGlyphPath = hasGlyphPath;
+#ifdef HAVE_GLYPH_RENDER_PATH
+  font->_hasGlyphPath = hasGlyphPath;
+#else
+  // We don't have the path render capability
+  font->_hasGlyphPath = false;
+#endif
+  readMeta(*font, reader);
+  readClassKernings(*font, reader);
+  font->_ligatures = readLigatures(reader);
+  font->_mathConsts = font->_isMathFont ? readMathConsts(reader) : nullptr;
+  readGlyphs(*font, hasGlyphPath, reader);
+  return font;
+}
+
+Otf* CLMReader::read(const char* clmFilePath) const {
+  BinaryFileReader reader(clmFilePath);
+  return read(reader);
+}
+
+Otf* CLMReader::read(size_t len, const u8* bytes) const {
+  BinaryDataReader reader(len, bytes);
+  return read(reader);
+}
+
+}  // namespace microtex

package/native/vendor/microtex/lib/otf/clm.h

@@ -0,0 +1,61 @@
+#ifndef MICROTEX_CLM_H
+#define MICROTEX_CLM_H
+
+#include "otf/otf.h"
+
+namespace microtex {
+
+class BinaryReader;
+
+/** Read an Otf from `.clm` file. A class wrapper to read/write private fields of glyph. */
+class CLMReader final {
+private:
+  static void readMeta(Otf& font, BinaryReader& reader);
+
+  static void readClassKernings(Otf& font, BinaryReader& reader);
+
+  static ClassKerning* readClassKerning(BinaryReader& reader);
+
+  static std::pair<u16, u16*> readClassKerningGlyphs(BinaryReader& reader);
+
+  static LigaTable* readLigatures(BinaryReader& reader);
+
+  static MathConsts* readMathConsts(BinaryReader& reader);
+
+  static KernRecord* readKerns(BinaryReader& reader);
+
+  static Variants* readVariants(BinaryReader& reader);
+
+  static GlyphAssembly* readGlyphAssembly(BinaryReader& reader);
+
+  static Math* readMath(BinaryReader& reader);
+
+#ifdef HAVE_GLYPH_RENDER_PATH
+
+  static Path* readPath(BinaryReader& reader);
+
+#else
+
+  static void skipGlyphPath(BinaryReader& reader);
+
+#endif
+
+  static Glyph* readGlyph(bool isMathFont, bool hasGlyphPath, BinaryReader& reader);
+
+  static void readGlyphs(Otf& font, bool hasGlyphPath, BinaryReader& reader);
+
+  static Otf* read(BinaryReader& reader);
+
+public:
+  no_copy_assign(CLMReader);
+
+  CLMReader() = default;
+
+  Otf* read(const char* clmFilePath) const;
+
+  Otf* read(size_t len, const u8* bytes) const;
+};
+
+}  // namespace microtex
+
+#endif

package/native/vendor/microtex/lib/otf/fontsense.cpp

@@ -0,0 +1,191 @@
+#include "fontsense.h"
+
+#ifdef HAVE_AUTO_FONT_FIND
+
+#include <cstdlib>
+#include <cstring>
+#include <queue>
+#include <sstream>
+
+#include "microtex.h"
+#include "unimath/uni_font.h"
+
+#ifdef USE_BOOST_FILESYSTEM
+#include <boost/filesystem.hpp>
+namespace fs = boost::filesystem;
+#elif USE_EXPERIMENTAL_FILESYSTEM
+#include <experimental/filesystem>
+namespace fs = std::experimental::filesystem;
+#else
+#include <filesystem>
+namespace fs = std::filesystem;
+#endif
+
+#define FONTDIR "microtex"
+
+namespace microtex {
+
+class FontSrcSense : public FontSrc {
+public:
+  Otf* otf;
+
+  explicit FontSrcSense(Otf* otf, std::string fontFile = "")
+      : FontSrc(std::move(fontFile)), otf(otf) {}
+
+  sptr<Otf> loadOtf() const override { return sptr<Otf>(otf); }
+};
+
+// Map<FileStem, <OTF File, CLM File>>
+typedef std::map<std::string, std::pair<char*, char*>> font_paths_t;
+
+font_paths_t getFontPaths();
+
+std::string clmExt() {
+#ifdef HAVE_GLYPH_RENDER_PATH
+  return ".clm2";
+#else
+  return ".clm1";
+#endif
+}
+
+void fontPathsFree(const font_paths_t& font_paths);
+
+#ifdef _WIN32
+#include <windows.h>
+// Get dir of executable
+// For example, the full path is c:\x\y\z\a.exe
+// return c:\x\y\z\
+//
+std::string getDirOfExecutable() {
+  char szBuff[MAX_PATH] = {0};
+  // WIN API: GetModuleFileNameA
+  // retrieves the path of the executable file of the current process
+  // see
+  // https://docs.microsoft.com/en-us/windows/win32/api/libloaderapi/nf-libloaderapi-getmodulefilenamea
+  GetModuleFileNameA(nullptr, szBuff, MAX_PATH);
+  std::string exePath(szBuff);
+  auto pos = exePath.find_last_of('\\');
+  // pos + 1 for adding last \ to path
+  return exePath.substr(0, pos + 1);
+}
+#endif
+
+font_paths_t getFontPaths() {
+  std::queue<std::string> paths;
+  // checks if MICROTEX_FONTDIR exists. If it does, it pushes it to potential paths.
+  char* devdir = getenv("MICROTEX_FONTDIR");
+  if (devdir && *devdir) paths.push(std::string(devdir));
+
+  // checks if XDG_DATA_HOME exists. If it does, it pushes it to potential paths.
+  char* userdata = getenv("XDG_DATA_HOME");
+  if (userdata && *userdata) paths.push(std::string(userdata) + "/" + FONTDIR);
+
+  // checks if XDG_DATA_DIRS is set. If it is, it splits XDG_DATA_DIRS at : and
+  // pushes each part of it to potential paths.
+  char* data_dirs = getenv("XDG_DATA_DIRS");
+  if (data_dirs && *data_dirs) {
+    std::stringstream data_dir_paths(data_dirs);
+    std::string data_dir_path;
+    while (getline(data_dir_paths, data_dir_path, ':')) paths.push(data_dir_path + "/" + FONTDIR);
+  }
+
+#ifndef _WIN32
+  char* home = getenv("HOME");
+  if (home != nullptr && *home != '\0') {
+    char* userdata_fallback;
+    auto n = asprintf(&userdata_fallback, "%s/.local/share/%s/", home, FONTDIR);
+    if (n > 0) {
+      paths.push(std::string(userdata_fallback));
+      free(userdata_fallback);
+    }
+  }
+
+  paths.push("/usr/local/share/" FONTDIR);
+  paths.push("/usr/share/" FONTDIR);
+#else
+  auto exeDir = getDirOfExecutable();
+  paths.push(exeDir + std::string("share/" FONTDIR));
+#endif
+
+  font_paths_t font_paths;
+
+  /*
+   * Iterate over all found data dirs. For each dir iterate over
+   * all files in it. For each font there should be a stem.otf and
+   * stem.clm file available. This function checks if the filestem
+   * is already in the font map and if it is, looks at the current
+   * file extension and sets the current path to it it if is unset.
+   * If the stem is not currently in the map it adds it together
+   * with the current file as clm or otf.
+   */
+  while (!paths.empty()) {
+    fs::path p = paths.front();
+    if (fs::exists(p))
+      for (const auto& entry : fs::directory_iterator(p)) {
+        const fs::path& path = entry.path();
+        std::string stem = path.stem().string();
+        std::string ext = path.extension().string();
+        auto it = font_paths.find(stem);
+        if (it != font_paths.end()) {
+          if (ext == ".otf" && !it->second.first) {
+            it->second.first = strdup(path.string().c_str());
+          }
+          if (ext == clmExt() && !it->second.second) {
+            it->second.second = strdup(path.string().c_str());
+          }
+        } else {
+          font_paths.emplace(
+            stem,
+            std::pair(
+              ext == ".otf" ? strdup(path.string().c_str()) : nullptr,
+              ext == clmExt() ? strdup(path.string().c_str()) : nullptr
+            )
+          );
+        }
+      }
+    paths.pop();
+  }
+
+  /*
+   * Iterate over all font paths in map and remove all of them
+   * where either the oth or clm path is NULL.
+   */
+  for (auto it = font_paths.begin(); it != font_paths.end();) {
+    if (!it->second.first || !it->second.second) {
+      font_paths.erase(it++);
+    } else {
+      it++;
+    }
+  }
+
+  return font_paths;
+}
+
+void fontPathsFree(const font_paths_t& font_paths) {
+  for (auto [_stem, files] : font_paths) {
+    free(files.first);
+    free(files.second);
+  }
+}
+
+std::optional<FontMeta> fontsenseLookup() {
+  std::optional<FontMeta> mathfont;
+
+  font_paths_t font_paths = getFontPaths();
+
+  for (const auto& [_stem, files] : font_paths) {
+    Otf* font = Otf::fromFile(files.second);
+    auto meta = MicroTeX::addFont(FontSrcSense(font, files.first));
+    if (font->isMathFont()) {
+      if (!mathfont) mathfont = meta;
+    }
+  }
+
+  fontPathsFree(font_paths);
+
+  return mathfont;
+}
+
+}  // namespace microtex
+
+#endif  // HAVE_AUTO_FONT_FIND

package/native/vendor/microtex/lib/otf/fontsense.h

@@ -0,0 +1,20 @@
+#include "microtexconfig.h"
+
+#ifdef HAVE_AUTO_FONT_FIND
+#ifndef MICROTEX_FONTSENSE_H
+#define MICROTEX_FONTSENSE_H
+
+#include <optional>
+#include <string>
+
+#include "unimath/font_meta.h"
+
+namespace microtex {
+
+/** Find font resources auto. Return the first found math font name. */
+std::optional<FontMeta> fontsenseLookup();
+
+}  // namespace microtex
+
+#endif  // MICROTEX_FONTSENSE_H
+#endif  // HAVE_AUTO_FONT_FIND