@simonklee/opentui-tex-native-source 0.2.0

package/native/vendor/microtex/lib/unimath/uni_symbol.h

@@ -0,0 +1,31 @@
+#ifndef MICROTEX_UNI_SYMBOL_H
+#define MICROTEX_UNI_SYMBOL_H
+
+#include "utils/types.h"
+#include "utils/utils.h"
+
+namespace microtex {
+
+struct Symbol {
+  const c32 unicode;
+  const u32 flag;
+  const char* name;
+
+  AtomType type() const;
+
+  LimitsType limitsType() const;
+
+  bool isVariable() const;
+
+  /**
+   * Get the symbol from the given name.
+   *
+   * @param name the name of the symbol
+   * @return the symbol of the given name or null if not found
+   */
+  static const Symbol* get(const char* name);
+};
+
+}  // namespace microtex
+
+#endif  // MICROTEX_UNI_SYMBOL_H

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

@@ -0,0 +1,68 @@
+#ifndef DICT_TREE_INCLUDED
+#define DICT_TREE_INCLUDED
+
+#include "utils/utils.h"
+
+namespace microtex {
+
+template <typename K, typename V>
+struct SortedDictTree {
+private:
+  K _key;
+  V _value;
+  u16 _childCount;
+  /** Children sorted by #_key */
+  SortedDictTree<K, V>** _children;
+
+public:
+  no_copy_assign(SortedDictTree);
+
+  SortedDictTree() = delete;
+
+  SortedDictTree(const K& key, const V& value, u16 childCount)
+      : _key(key),
+        _value(value),
+        _childCount(childCount),
+        _children(childCount == 0 ? nullptr : new SortedDictTree<K, V>*[childCount]) {}
+
+  inline K key() const { return _key; }
+
+  inline V value() const { return _value; }
+
+  inline u16 childCount() const { return _childCount; }
+
+  /** Get child at the given index. */
+  inline SortedDictTree<K, V>*& child(u16 i) const { return _children[i]; }
+
+  /**
+   * Get the child match the given key, or null if not found.
+   *
+   * @param key the key to match
+   */
+  const SortedDictTree<K, V>* operator[](const K& key) const {
+    const int index = binIndexOf(_childCount, [&](int i) { return key - _children[i]->_key; });
+    return index < 0 ? nullptr : _children[index];
+  }
+
+  bool operator==(const SortedDictTree<K, V>& b) const {
+    if (&b == this) return true;
+    bool same = _key == b._key && _value == b._value && _childCount == b._childCount;
+    if (!same) return false;
+    for (u16 i = 0; i < _childCount; i++) {
+      same &= *child(i) == *(b.child(i));
+      if (!same) return false;
+    }
+    return true;
+  }
+
+  bool operator!=(const SortedDictTree<K, V>& b) const { return !(*this == b); }
+
+  ~SortedDictTree() {
+    for (u16 i = 0; i < _childCount; i++) delete _children[i];
+    delete[] _children;
+  }
+};
+
+}  // namespace microtex
+
+#endif

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

@@ -0,0 +1,61 @@
+#ifndef EXCEPTIONS_H_INCLUDED
+#define EXCEPTIONS_H_INCLUDED
+
+#include <exception>
+#include <string>
+#include <utility>
+
+namespace microtex {
+
+/** Superclass of all the possible exceptions that can be thrown */
+class ex_tex : public std::exception {
+private:
+  const std::string _msg;
+
+public:
+  explicit ex_tex(std::string msg) : _msg(std::move(msg)) {}
+
+  explicit ex_tex(const std::string& msg, const exception& cause)
+      : _msg(msg + "\n caused by: " + cause.what()) {}
+
+  const char* what() const noexcept override { return _msg.c_str(); }
+};
+
+/** Error occurred while parsing a string to a formula */
+class ex_parse : public ex_tex {
+public:
+  explicit ex_parse(const std::string& msg, const exception& cause) : ex_tex(msg, cause) {}
+
+  explicit ex_parse(const std::string& msg) : ex_tex(msg) {}
+};
+
+/** Error occurred while conditions not satisfied */
+class ex_invalid_state : public ex_tex {
+public:
+  explicit ex_invalid_state(const std::string& e) : ex_tex(e) {}
+};
+
+/** Error occurred while an invalid param was given */
+class ex_invalid_param : public ex_tex {
+public:
+  explicit ex_invalid_param(const std::string& e) : ex_tex(e) {}
+};
+
+class ex_file_not_found : public ex_tex {
+public:
+  explicit ex_file_not_found(const std::string& e) : ex_tex(e) {}
+};
+
+class ex_eof : public ex_tex {
+public:
+  explicit ex_eof(const std::string& msg) : ex_tex(msg) {}
+};
+
+class ex_unprivileged : public ex_tex {
+public:
+  explicit ex_unprivileged(const std::string& msg) : ex_tex(msg) {}
+};
+
+}  // namespace microtex
+
+#endif

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

@@ -0,0 +1,34 @@
+#ifndef LOG_H_INCLUDED
+#define LOG_H_INCLUDED
+
+#ifdef HAVE_LOG
+
+#include <cstdio>
+
+// clang-format off
+#define ANSI_BOLD        "\x1b[1m"
+#define ANSI_COLOR_CYAN  "\x1b[36m"
+#define ANSI_COLOR_RED   "\x1b[31m"
+#define ANSI_COLOR_GREEN "\x1b[32m"
+#define ANSI_UNDERLINE   "\x1b[4m"
+#define ANSI_RESET       "\x1b[0m"
+// clang-format on
+
+#define dbg(format, ...)                                                              \
+  fprintf(                                                                            \
+    stdout,                                                                           \
+    "FILE: " ANSI_UNDERLINE "%s" ANSI_RESET ", LINE: " ANSI_COLOR_RED "%d" ANSI_RESET \
+    ", FUNCTION: " ANSI_COLOR_CYAN "%s" ANSI_RESET ", MSG: " format,                  \
+    __FILE__,                                                                         \
+    __LINE__,                                                                         \
+    __FUNCTION__,                                                                     \
+    ##__VA_ARGS__                                                                     \
+  );
+
+#define logv(format, ...) fprintf(stdout, format, ##__VA_ARGS__);
+
+#define loge(format, ...) fprintf(stderr, format, ##__VA_ARGS__);
+
+#endif  // HAVE_LOG
+
+#endif

package/native/vendor/microtex/lib/utils/meson.build

@@ -0,0 +1,18 @@
+utils_src = [
+	'utils/string_utils.cpp',
+	'utils/utf.cpp',
+	'utils/utils.cpp'
+]
+
+if install_headerfiles
+	install_headers([
+		'dict_tree.h',
+        'exceptions.h',
+        'log.h',
+        'nums.h',
+        'string_utils.h',
+        'utf.h',
+        'utils.h',
+        'types.h'
+	], subdir: 'microtex/utils')
+endif

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

@@ -0,0 +1,24 @@
+#ifndef NUMS_H_INCLUDED
+#define NUMS_H_INCLUDED
+
+#include <cmath>
+#include <limits>
+
+namespace microtex {
+
+/** Positive infinity */
+static constexpr float POS_INF = std::numeric_limits<float>::infinity();
+/** Negative infinity */
+static constexpr float NEG_INF = -POS_INF;
+/** Max float value */
+static constexpr float F_MAX = std::numeric_limits<float>::max();
+/** Min float value */
+static constexpr float F_MIN = -F_MAX;
+/** Pi */
+static constexpr double PI = 3.1415926535;
+/** Precision, for compare with 0.0f, if a value < PREC, we trade it as 0.0f */
+static constexpr float PREC = 0.01;
+
+}  // namespace microtex
+
+#endif

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

@@ -0,0 +1,85 @@
+#include "utils/string_utils.h"
+
+#include <utility>
+
+using namespace std;
+using namespace microtex;
+
+StrTokenizer::StrTokenizer(string str) : _str(std::move(str)) {
+  _del = " \t\n\r\f";
+  _ret = false;
+  _pos = 0;
+}
+
+StrTokenizer::StrTokenizer(string str, string del, bool ret)
+    : _str(std::move(str)), _del(std::move(del)), _ret(ret) {
+  _pos = 0;
+}
+
+int StrTokenizer::count() {
+  int c = 0;
+  bool in = false;
+  for (int i = _pos, len = _str.length(); i < len; i++) {
+    if (_del.find(_str[i]) != std::string::npos) {
+      if (_ret) c++;
+      if (in) {
+        c++;
+        in = false;
+      }
+    } else {
+      in = true;
+    }
+  }
+  if (in) c++;
+  return c;
+}
+
+std::string StrTokenizer::next() {
+  int i = _pos;
+  int len = _str.length();
+
+  if (i < len) {
+    if (_ret) {
+      if (_del.find(_str[_pos]) != std::string::npos) return std::string({_str[_pos++]});
+      for (_pos++; _pos < len; _pos++)
+        if (_del.find(_str[_pos]) != std::string::npos) return _str.substr(i, _pos - i);
+      return _str.substr(i);
+    }
+
+    while (i < len && _del.find(_str[i]) != std::string::npos) i++;
+
+    _pos = i;
+    if (i < len) {
+      for (_pos++; _pos < len; _pos++)
+        if (_del.find(_str[_pos]) != std::string::npos) return _str.substr(i, _pos - i);
+      return _str.substr(i);
+    }
+  }
+  return "";
+}
+
+map<string, string> microtex::parseOption(const string& options) {
+  if (options.empty()) return {};
+
+  map<string, string> res;
+  StrTokenizer tokens(options, ";,");
+  const int c = tokens.count();
+  for (int i = 0; i < c; i++) {
+    std::string tok = tokens.next();
+    trim(tok);
+    StrTokenizer opt(tok, "=");
+    const int n = opt.count();
+    std::vector<std::string> optarg(n);
+    for (int j = 0; j < n; j++) {
+      optarg[j] = opt.next();
+    }
+    if (!optarg.empty()) {
+      if (optarg.size() == 2) {
+        res[trim(optarg[0])] = trim(optarg[1]);
+      } else if (optarg.size() == 1) {
+        res[trim(optarg[0])] = "";
+      }
+    }
+  }
+  return res;
+}

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

@@ -0,0 +1,130 @@
+#ifndef STRING_UTILS_H_INCLUDED
+#define STRING_UTILS_H_INCLUDED
+
+#include <algorithm>
+#include <cerrno>
+#include <climits>
+#include <functional>
+#include <map>
+#include <string>
+#include <vector>
+
+namespace microtex {
+
+/**
+ * Parse options from given string. The options are given in the form of
+ * [key=value,key=value...].
+ */
+std::map<std::string, std::string> parseOption(const std::string& options);
+
+/** Convert a value to string */
+template <class T>
+inline std::string toString(T val) {
+  return std::to_string(val);
+}
+
+inline std::string toString(char val) {
+  return {val};
+}
+
+template <class T>
+inline void valueOf(const std::string& s, T& val) {
+  char* endptr = nullptr;
+  val = strtod(s.c_str(), &endptr);
+}
+
+inline bool str2int(const char* str, size_t len, int& res, int radix) {
+  char* endptr = nullptr;
+  errno = 0;
+
+  const long val = strtol(str, &endptr, radix);
+
+  if ((val == LONG_MAX || val == LONG_MIN) && errno == ERANGE) return false;
+
+  res = static_cast<int>(val);
+  return endptr == str + len;
+}
+
+/** Transform a string to lowercase */
+inline std::string& toLower(std::string& src) {
+  std::transform(src.begin(), src.end(), src.begin(), ::tolower);
+  return src;
+}
+
+/** Ignore left side whitespace in a string */
+inline std::string& ltrim(std::string& s) {
+  s.erase(s.begin(), std::find_if(s.begin(), s.end(), [](char c) { return !isspace(c); }));
+  return s;
+}
+
+/** Ignore right side whitespace in a string */
+inline std::string& rtrim(std::string& s) {
+  s.erase(std::find_if(s.rbegin(), s.rend(), [](char c) { return !isspace(c); }).base(), s.end());
+  return s;
+}
+
+/** Ignore left and right side whitespace in a string */
+inline std::string& trim(std::string& s) {
+  return ltrim(rtrim(s));
+}
+
+inline bool startsWith(const std::string& str, const std::string& cmp) {
+  return str.find(cmp) == 0;
+}
+
+inline bool endsWith(const std::string& str, const std::string& cmp) {
+  return str.rfind(cmp) == (str.length() - cmp.length());
+}
+
+/** Split string with delimiter */
+class StrTokenizer {
+private:
+  std::string _str;
+  std::string _del;
+  bool _ret;
+  int _pos;
+
+public:
+  StrTokenizer(std::string str);
+
+  StrTokenizer(std::string str, std::string del, bool ret = false);
+
+  int count();
+
+  std::string next();
+};
+
+/**
+ * Returns a replacement string for the given one that has all backslashes
+ * and dollar signs escaped
+ */
+inline std::string& quoteReplace(const std::string& src, std::string& out) {
+  for (size_t i = 0; i < src.length(); i++) {
+    char c = src[i];
+    if (c == '\\' || c == '$') out.append(1, '\\');
+    out.append(1, c);
+  }
+  return out;
+}
+
+/** Replace string with specified string in the first */
+inline std::string& replaceFirst(std::string& src, const std::string& from, const std::string& to) {
+  size_t start = src.find(from);
+  if (start == std::string::npos) return src;
+  src.replace(start, from.length(), to);
+  return src;
+}
+
+inline std::string& replaceAll(std::string& src, const std::string& from, const std::string& to) {
+  if (from.empty()) return src;
+  size_t start = 0;
+  while ((start = src.find(from, start)) != std::string::npos) {
+    src.replace(start, from.length(), to);
+    start += to.length();
+  }
+  return src;
+}
+
+}  // namespace microtex
+
+#endif

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

@@ -0,0 +1,152 @@
+#ifndef MICROTEX_TYPES_H
+#define MICROTEX_TYPES_H
+
+#include <cinttypes>
+#include <memory>
+
+namespace microtex {
+
+using i8 = std::int8_t;
+using u8 = std::uint8_t;
+using i16 = std::int16_t;
+using u16 = std::uint16_t;
+using i32 = std::int32_t;
+using u32 = std::uint32_t;
+using c32 = char32_t;
+
+/** Type alias shared_ptr<T> to sptr<T> */
+template <typename T>
+using sptr = std::shared_ptr<T>;
+
+/** Type alias unique_ptr<T> to uptr<T> */
+template <typename T>
+using uptr = std::unique_ptr<T>;
+
+/** Formula alignment. */
+enum class Alignment : i8 {
+  /** Extra space will be added to the right of the formula. */
+  left,
+  /** Extra space will be added to the left of the formula. */
+  right,
+  /**
+   * The formula will be centered in the middle. This can
+   * be used for both horizontal and vertical alignment.
+   */
+  center,
+  /** Extra space will be added under the formula. */
+  top,
+  /** Extra space will be added above the formula. */
+  bottom,
+  none = -1
+};
+
+/** Space amount between formulas. */
+enum class SpaceType : i8 {
+  thinMuSkip = 1,
+  medMuSkip = 2,
+  thickMuSkip = 3,
+  negThinMuSkip = -1,
+  negMedMuSkip = -2,
+  negThickMuSkip = -3,
+  quad = 3,
+  none = 0
+};
+
+/** Script display type */
+enum class LimitsType : i8 {
+  /** depending on TeX style */
+  normal,
+  /** scripts display on right of the base */
+  noLimits,
+  /** scripts display above/under the base */
+  limits
+};
+
+enum class AtomType : i8 {
+  /** Ordinary symbol, e.g. "slash" */
+  ordinary,
+  /** Big operator, e.g. "sum" */
+  bigOperator,
+  /** Binary operator, e.g. "plus" */
+  binaryOperator,
+  /** Relation, e.g. "equals" */
+  relation,
+  /** Opening symbol, e.g. "lbrace" */
+  opening,
+  /** Closing symbol, e.g. "rbrace" */
+  closing,
+  /** Punctuation, e.g. "comma" */
+  punctuation,
+  /** Inner atom (NOT FOR SYMBOLS) */
+  inner,
+  /** Accent, e.g. "hat" */
+  accent = 10,
+  /** Inter-text in matrix environment */
+  interText,
+  /** Multi-column in matrix environment */
+  multiColumn,
+  /** Horizontal line in matrix environment */
+  hline,
+  /** Multi-row in matrix environment */
+  multiRow,
+  /** No type specified */
+  none = -1
+};
+
+enum class TexStyle : i8 {
+  /**
+   * The larger versions of big operators are used and limits are placed under
+   * and over these operators (default). Symbols are rendered in the largest
+   * size.
+   */
+  display,
+  display1,
+  /**
+   * The small versions of big operator are used and limits are attached to
+   * these operators as scripts (default). The same size as in the display
+   * style is used to render symbols.
+   */
+  text,
+  text1,
+  /** The same as the the text style, but symbols are rendered in a smaller size. */
+  script,
+  script1,
+  /** The same as the script style, but symbols are rendered in a smaller size. */
+  scriptScript,
+  scriptScript1
+};
+
+enum class UnitType : i8 {
+  /** 1 em = the width of the capital 'M' in the current font */
+  em,
+  /** 1 ex = the height of the character 'x' in the current font */
+  ex,
+  pixel,
+  /** postscript point (also known as big-point (bp) in TeX) */
+  point,
+  /** 1 pica = 12 point */
+  pica,
+  /** 1 mu = 1/18 em */
+  mu,
+  /** 1 cm = 28.346456693 point */
+  cm,
+  /** 1 mm = 1/10 cm */
+  mm,
+  /** 1 in = 72 point */
+  in,
+  /** 1 sp = 65536 point, shortcut for `scaled-point` */
+  sp,
+  /** 1 pt = 0.99626401 point (pt means point in printer's) */
+  pt,
+  /** 1157 dd = 1238 pt, shortcut for `didot` */
+  dd,
+  /** 1 cc = 12 dd, shortcut for `cicero` */
+  cc,
+  /** 1 tt = the rule thickness */
+  tt,
+  none = -1
+};
+
+}  // namespace microtex
+
+#endif  // MICROTEX_TYPES_H