@simonklee/opentui-tex-native-source 0.2.0

package/native/vendor/microtex/lib/core/parser.h

@@ -0,0 +1,306 @@
+#ifndef PARSER_H_INCLUDED
+#define PARSER_H_INCLUDED
+
+#include "atom/atom.h"
+#include "env/units.h"
+
+namespace microtex {
+
+using Args = std::vector<std::string>;
+
+/**
+ * Convert a character to roman-number if it is a digit localized
+ * @param c character to be converted
+ */
+c32 convertToRomanNumber(c32 c);
+
+class Formula;
+
+class MacroInfo;
+
+/** This class implements a parser for latex formulas */
+class Parser {
+private:
+  std::string _latex;
+  int _pos, _spos, _len;
+  int _group;
+  int _atIsLetter;
+  bool _insertion;
+  bool _arrayMode;
+  bool _isMathMode;
+  bool _isPartial;
+
+  /** Preprocess parse string */
+  void preprocess();
+
+  sptr<Atom> getScripts(char first);
+
+  std::string getCmd();
+
+  sptr<Atom> processEscape();
+
+  void insert(int beg, int end, const std::string& formula);
+
+  /**
+   * Return a string with command, options and arguments.
+   *
+   * @param cmd name of command
+   * @return command with arguments string with format: \cmd[opt][...]{arg}{...}
+   */
+  std::string getCmdWithArgs(const std::string& cmd);
+
+  /**
+   * Process the given TeX command (by parsing following command
+   * arguments in the parse string).
+   */
+  sptr<Atom> processCmd(const std::string& cmd, MacroInfo* mac);
+
+  void preprocess(std::string& cmd, Args& args, int& pos);
+
+  void preprocessNewCmd(std::string& cmd, Args& args, int& pos);
+
+  void inflateNewCmd(std::string& cmd, Args& args, int& pos);
+
+  void inflateEnv(std::string& cmd, Args& args, int& pos);
+
+  void init(bool isPartial, const std::string& latex, Formula* formula, bool firstPass);
+
+  sptr<Atom> getCharAtom();
+
+public:
+  Formula* _formula;
+
+  /**
+   * Create a new TeXParser
+   * @param latex the string to be parsed
+   * @param formula the formula where to put the atoms
+   * @throw ex_parse if the string could not be parsed correctly
+   */
+  Parser(const std::string& latex, Formula* formula) { init(true, latex, formula, true); }
+
+  /**
+   * Create a new TeXParser
+   * @param isPartial if true certain exceptions are not thrown
+   * @param latex the string to be parsed
+   * @param formula the formula where to put the atoms
+   * @throw ex_parse if the string could not be parsed correctly
+   */
+  Parser(bool isPartial, const std::string& latex, Formula* formula) {
+    init(isPartial, latex, formula, true);
+  }
+
+  /**
+   * Create a new TeXParser with or without a first pass
+   * @param isPartial if true certain exceptions are not thrown
+   * @param latex the string to be parsed
+   * @param formula the formula where to put the atoms
+   * @param preprocess indicate if the parser must replace the user-defined macros by their content
+   *
+   * @throw ex_parse if the string could not be parsed correctly
+   */
+  Parser(bool isPartial, const std::string& latex, Formula* formula, bool preprocess) {
+    init(isPartial, latex, formula, preprocess);
+  }
+
+  /**
+   * Create a new TeXParser with or without a first pass
+   * @param latex the string to be parsed
+   * @param formula the formula where to put the atoms
+   * @param preprocess indicate if the parser must replace the user-defined macros by their content
+   *
+   * @throw ex_parse if the string could not be parsed correctly
+   */
+  Parser(const std::string& latex, Formula* formula, bool preprocess) {
+    init(true, latex, formula, preprocess);
+  }
+
+  /**
+   * Create a new TeXParser which ignores or not the white spaces, it's useful
+   * for mbox command
+   *
+   * @param isPartial if true certain exceptions are not thrown
+   * @param latex the string to be parsed
+   * @param formula the formula to hold the atoms
+   * @param preprocess indicate if the parser must replace the user-defined macros by their content
+   * @param isMathMode a boolean to indicate if the parser must ignore or not the white space
+   *
+   * @throw ex_parse if the string could not be parsed correctly
+   */
+  Parser(
+    bool isPartial,
+    const std::string& latex,
+    Formula* formula,
+    bool preprocess,
+    bool isMathMode
+  ) {
+    init(isPartial, latex, formula, preprocess);
+    _isMathMode = isMathMode;
+  }
+
+  void skipWhiteSpace(int count = -1);
+
+  /** Reset the parser with a new latex expression */
+  void reset(const std::string& latex);
+
+  /** Return true if we get a partial formula */
+  inline bool isPartial() const { return _isPartial; }
+
+  /** Get and remove the last atom of the current formula */
+  sptr<Atom> popBack() const;
+
+  /** Get and remove the atom represented by the current formula */
+  sptr<Atom> popFormulaAtom() const;
+
+  /** Put an atom in the current formula */
+  void addAtom(const sptr<Atom>& atom) const;
+
+  /** Make the character @ as letter that can be used in the command's name */
+  inline void makeAtLetter() { _atIsLetter++; }
+
+  /** Make the character @ that can not be used in the command's name */
+  inline void makeAtOther() { _atIsLetter--; }
+
+  /** Test if the character @ is considered as a letter or not */
+  inline bool isAtLetter() const { return (_atIsLetter != 0); }
+
+  /** Test if the parser is used to parse an array or not */
+  inline bool isArrayMode() const { return _arrayMode; }
+
+  /** Test if the parser is in math mode  */
+  inline bool isMathMode() const { return _isMathMode; }
+
+  /** Return the current position in the parsed string */
+  inline int getPos() const { return _pos; }
+
+  /**
+   * Rewind the current parsed string
+   *
+   * @param n the number of character to be rewind
+   * @return the new position in the parsed string
+   */
+  inline int rewind(int n) {
+    _pos -= n;
+    return _pos;
+  }
+
+  /** Finish the parse process */
+  inline void finish() { _pos = _latex.size(); }
+
+  /**
+   * Forward from current position to get a balanced group.
+   * <li> Forward to the end of the parse string if no group was in process
+   * <li> Otherwise get the balanced group embraced by '{' and '}' and forward
+   */
+  std::string forwardBalancedGroup();
+
+  /** Forward parse while the given function #f returns true. */
+  std::string forward(std::function<bool(char)>&& f);
+
+  /**
+   * Add a new row when the parser is in array mode
+   *
+   * @throw ex_parse if the parser is not in array mode
+   */
+  void addRow() const;
+
+  /**
+   * Parse the input string
+   *
+   * @throw ex_parse if an error is encountered during parse
+   */
+  void parse();
+
+  /**
+   * Get the contents between two delimiters
+   *
+   * @param openClose the opening and closing character (such as $)
+   * @return the enclosed contents
+   *
+   * @throw ex_parse if the contents are badly enclosed
+   */
+  std::string getGroup(char openClose);
+
+  /**
+   * Get the contents between two delimiters
+   *
+   * @param open the opening character
+   * @param close the closing character
+   * @return the enclosed contents
+   *
+   * @throw ex_parse if the contents are badly enclosed
+   */
+  std::string getGroup(char open, char close);
+
+  /**
+   * Get the contents between two strings as in \\begin{foo}... \\end{foo}
+   *
+   * @param open the opening string
+   * @param close the closing string
+   * @return the enclosed contents
+   *
+   * @throw ex_parse if the contents are badly enclosed
+   */
+  std::string getGroup(const std::string& open, const std::string& close);
+
+  /**
+   * Get the argument of a command in his atomic format
+   *
+   * @return the corresponding atom
+   *
+   * @throw ex_parse if the argument is incorrect
+   */
+  sptr<Atom> getArgument();
+
+  /** Get the supscript argument */
+  std::string getOverArgument();
+
+  /**
+   * Get the unit and length from given string. The string must be in the format: a digital
+   * following with the unit (e.g. 10px, 1cm, 8.2em, ...) or a pair (UnitType::none, 0) will be
+   * returned.
+   */
+  Dimen getDimen();
+
+  /**
+   * Convert a character in the corresponding atom
+   *
+   * @param chr the character to be converted
+   * @return the corresponding atom
+   */
+  sptr<Atom> getCharAtom(c32 chr);
+
+  /** Get the simple scripts from given character */
+  sptr<Atom> getSimpleScripts(bool isPrime);
+
+  /**
+   * Get the arguments and the options of a command
+   *
+   * @param argc the number of arguments of the command
+   * @param opts
+   *   must be 1 if the options are found before the first argument,
+   *   and must be 2 if they must be found before the second argument,
+   *   otherwise there're no options for the command.
+   *
+   * @param args a vector to put with argument strings
+   */
+  void getOptsArgs(int argc, int opts, Args& args);
+
+  /**
+   * Test the validity of the name of a command. It must contains only alpha
+   * characters and eventually a @ if makeAtletter activated
+   *
+   * @param cmd the command's name
+   * @return the validity of the name
+   */
+  bool isValidCmd(const std::string& cmd) const;
+
+  /**
+   * Test the validity of a character in a command. It must contains only
+   * alpha characters and eventually a @ if makeAtletter activated
+   */
+  bool isValidCharInCmd(char ch) const;
+};
+
+}  // namespace microtex
+
+#endif  // PARSER_H_INCLUDED

package/native/vendor/microtex/lib/core/split.cpp

@@ -0,0 +1,185 @@
+#include "core/split.h"
+
+#include "box/box_group.h"
+#include "utils/log.h"
+
+using namespace std;
+using namespace microtex;
+
+#ifdef HAVE_LOG
+
+static void printBox(const sptr<Box>& b, int dep, vector<bool>& lines, int max = 0) {
+  logv("%-4d", dep);
+  if (lines.size() < dep + 1) lines.resize(dep + 1, false);
+
+  for (int i = 0; i < dep - 1; i++) {
+    logv(lines[i] ? "    " : " │  ");
+  }
+
+  if (dep > 0) {
+    logv(lines[dep - 1] ? " └──" : " ├──");
+  }
+
+  if (b == nullptr) {
+    logv(ANSI_COLOR_RED " NULL\n" ANSI_RESET);
+    return;
+  }
+
+  const vector<sptr<Box>>& children = b->descendants();
+  const auto size = children.size();
+  const auto& name = b->name();
+  const char* fmt = (size > 0 ? ANSI_COLOR_CYAN " %-*s " ANSI_RESET : " %-*s ");
+  logv(fmt, size > 0 ? name.size() : max, name.c_str());
+  // show metrics and additional info
+  logv(
+    "[%g, (%g + %g) = %g, %g] %s\n",
+    b->_width,
+    b->_height,
+    b->_depth,
+    b->vlen(),
+    b->_shift,
+    b->toString().c_str()
+  );
+  if (size == 0) return;
+
+  size_t limit = 0;
+  for (const auto& x : children) {
+    limit = std::max(limit, x->name().size());
+  }
+
+  for (size_t i = 0; i < size; i++) {
+    lines[dep] = i == size - 1;
+    printBox(children[i], dep + 1, lines, limit);
+  }
+}
+
+void microtex::printBox(const sptr<Box>& box) {
+  vector<bool> lines;
+  ::printBox(box, 0, lines, box->name().size());
+  logv("\n");
+}
+
+#endif  // HAVE_LOG
+
+std::pair<bool, sptr<Box>> BoxSplitter::split(const sptr<Box>& b, float width, float lineSpace) {
+  auto h = dynamic_pointer_cast<HBox>(b);
+  sptr<Box> box;
+  if (h != nullptr) {
+    auto [splitted, box] = split(h, width, lineSpace);
+#ifdef HAVE_LOG
+    if (box != b) {
+      logv("[BEFORE SPLIT]:\n");
+      printBox(b);
+      logv("[AFTER SPLIT]:\n");
+      printBox(box);
+    } else {
+      logv("[BOX TREE]:\n");
+      printBox(box);
+    }
+#endif
+    return {splitted, box};
+  }
+#ifdef HAVE_LOG
+  logv("[BOX TREE]:\n");
+  printBox(b);
+#endif
+  return {false, b};
+}
+
+std::pair<bool, sptr<Box>> BoxSplitter::split(const sptr<HBox>& hb, float width, float lineSpace) {
+  if (width == 0 || hb->_width <= width) return {false, hb};
+
+  auto* vbox = new VBox();
+  sptr<HBox> first, second;
+  stack<Position> positions;
+  sptr<HBox> hbox = hb;
+  bool splitted = false;
+
+  while (hbox->_width > width && canBreak(positions, hbox, width) != hbox->_width) {
+    Position pos = positions.top();
+    positions.pop();
+    auto hboxes = pos._box->split(pos._index - 1);
+    first = hboxes.first;
+    second = hboxes.second;
+    while (!positions.empty()) {
+      pos = positions.top();
+      positions.pop();
+      hboxes = pos._box->splitRemove(pos._index);
+      hboxes.first->add(first);
+      hboxes.second->add(0, second);
+      first = hboxes.first;
+      second = hboxes.second;
+    }
+    vbox->add(first, lineSpace);
+    splitted = true;
+    hbox = second;
+  }
+
+  if (second != nullptr) {
+    vbox->add(second, lineSpace);
+    return {splitted, sptr<Box>(vbox)};
+  }
+
+  return {splitted, hbox};
+}
+
+float BoxSplitter::canBreak(stack<Position>& s, const sptr<HBox>& hbox, const float width) {
+  const vector<sptr<Box>>& children = hbox->_children;
+  const int count = children.size();
+  // Cumulative width
+  auto* cumWidth = new float[count + 1]();
+  cumWidth[0] = 0;
+  for (int i = 0; i < count; i++) {
+    auto box = children[i];
+    cumWidth[i + 1] = cumWidth[i] + box->_width;
+    if (cumWidth[i + 1] <= width) continue;
+    int pos = getBreakPosition(hbox, i);
+    auto h = dynamic_pointer_cast<HBox>(box);
+    if (h != nullptr) {
+      stack<Position> sub;
+      float w = canBreak(sub, h, width - cumWidth[i]);
+      if (w != box->_width && (cumWidth[i] + w <= width || pos == -1)) {
+        s.push(Position(i - 1, hbox));
+        // add to stack
+        vector<Position> p;
+        while (!sub.empty()) {
+          p.push_back(sub.top());
+          sub.pop();
+        }
+        for (auto it = p.rbegin(); it != p.rend(); it++) s.push(*it);
+        // release cum-width
+        float x = cumWidth[i] + w;
+        delete[] cumWidth;
+        return x;
+      }
+    }
+
+    if (pos != -1) {
+      s.push(Position(pos, hbox));
+      float x = cumWidth[pos];
+      delete[] cumWidth;
+      return x;
+    }
+  }
+
+  delete[] cumWidth;
+  return hbox->_width;
+}
+
+int BoxSplitter::getBreakPosition(const sptr<HBox>& hb, int i) {
+  if (hb->_breakPositions.empty()) return -1;
+
+  if (hb->_breakPositions.size() == 1 && hb->_breakPositions[0] <= i) {
+    return hb->_breakPositions[0];
+  }
+
+  size_t pos = 0;
+  for (; pos < hb->_breakPositions.size(); pos++) {
+    if (hb->_breakPositions[pos] > i) {
+      if (pos == 0) return -1;
+      return hb->_breakPositions[pos - 1];
+    }
+  }
+
+  return hb->_breakPositions[pos - 1];
+}

package/native/vendor/microtex/lib/core/split.h

@@ -0,0 +1,40 @@
+#ifndef MICROTEX_SPLIT_H
+#define MICROTEX_SPLIT_H
+
+#include <stack>
+
+#include "box/box.h"
+#include "box/box_group.h"
+#include "core/glue.h"
+
+namespace microtex {
+
+#ifdef HAVE_LOG
+
+void printBox(const sptr<Box>& box);
+
+#endif  // HAVE_LOG
+
+class BoxSplitter {
+public:
+  struct Position {
+    int _index;
+    sptr<HBox> _box;
+
+    Position(int index, const sptr<HBox>& box) : _index(index), _box(box) {}
+  };
+
+private:
+  static float canBreak(std::stack<Position>& stack, const sptr<HBox>& hbox, float width);
+
+  static int getBreakPosition(const sptr<HBox>& hb, int index);
+
+  static std::pair<bool, sptr<Box>> split(const sptr<HBox>& hb, float width, float lineSpace);
+
+public:
+  static std::pair<bool, sptr<Box>> split(const sptr<Box>& box, float width, float lineSpace);
+};
+
+}  // namespace microtex
+
+#endif  // MICROTEX_SPLIT_H

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

@@ -0,0 +1,141 @@
+#include "env/env.h"
+
+#include "env/units.h"
+
+using namespace std;
+using namespace microtex;
+
+float Env::PIXELS_PER_POINT = 1.f;
+
+float Env::scale(TexStyle style) const {
+  if (style < TexStyle::script) return 1;
+  auto math = _fctx->mathFont().otf().mathConsts();
+  i16 percent = style < TexStyle::scriptScript ? math->scriptPercentScaleDown()
+                                               : math->scriptScriptPercentScaleDown();
+  return percent / 100.f;
+}
+
+float Env::scale() const {
+  return scale(_style);
+}
+
+Env& Env::setTextWidth(const Dimen& dimen) {
+  _textWidth = Units::fsize(dimen, *this);
+  return *this;
+}
+
+Env& Env::setLineSpace(const Dimen& dimen) {
+  _lineSpace = Units::fsize(dimen, *this);
+  return *this;
+}
+
+const MathConsts& Env::mathConsts() const {
+  return *_fctx->mathFont().otf().mathConsts();
+}
+
+float Env::upem() const {
+  return _fctx->mathFont().otf().em();
+}
+
+float Env::em() const {
+  return upem() * scale();
+}
+
+float Env::ppem() const {
+  return PIXELS_PER_POINT * textSize();
+}
+
+float Env::xHeight() const {
+  return _fctx->getFont(lastFontId())->otf().xHeight() * scale();
+}
+
+float Env::space(bool isMathMode) const {
+  if (isMathMode) {
+    return _fctx->mathFont().otf().space() * scale();
+  }
+  return _fctx->mainSpace() * scale();
+}
+
+float Env::ruleThickness() const {
+  return mathConsts().fractionRuleThickness() * scale();
+}
+
+float Env::axisHeight() const {
+  return mathConsts().axisHeight() * scale();
+}
+
+void Env::addFontStyle(FontStyle style, FontStyle& target) {
+  auto dummy = static_cast<u16>(target) | static_cast<u16>(style);
+  target = static_cast<FontStyle>(dummy);
+}
+
+void Env::removeFontStyle(FontStyle style, FontStyle& target) {
+  auto dummy = static_cast<u16>(target) & (~static_cast<u16>(style));
+  target = static_cast<FontStyle>(dummy);
+}
+
+void Env::addMathFontStyle(FontStyle style) {
+  addFontStyle(style, _mathFontStyle);
+}
+
+void Env::removeMathFontStyle(FontStyle style) {
+  removeFontStyle(style, _mathFontStyle);
+}
+
+void Env::addTextFontStyle(FontStyle style) {
+  addFontStyle(style, _textFontStyle);
+}
+
+void Env::removeTextFontStyle(FontStyle style) {
+  removeFontStyle(style, _textFontStyle);
+}
+
+void Env::selectMathFont(const std::string& name, MathStyle style) {
+  _fctx->selectMathFont(name);
+  MathVersion::setMathStyle(style);
+}
+
+TexStyle Env::crampStyle() const {
+  const i8 style = static_cast<i8>(_style);
+  return static_cast<TexStyle>(style % 2 == 1 ? style : style + 1);
+}
+
+TexStyle Env::dnomStyle() const {
+  const i8 style = static_cast<i8>(_style);
+  return static_cast<TexStyle>(2 * (style / 2) + 1 + 2 - 2 * (style / 6));
+}
+
+TexStyle Env::numStyle() const {
+  const i8 style = static_cast<i8>(_style);
+  return static_cast<TexStyle>(style + 2 - 2 * (style / 6));
+}
+
+TexStyle Env::rootStyle() const {
+  return TexStyle::scriptScript;
+}
+
+TexStyle Env::subStyle() const {
+  const i8 style = static_cast<i8>(_style);
+  return static_cast<TexStyle>(2 * (style / 4) + 4 + 1);
+}
+
+TexStyle Env::supStyle() const {
+  const i8 style = static_cast<i8>(_style);
+  return static_cast<TexStyle>(2 * (style / 4) + 4 + (style % 2));
+}
+
+Char Env::getChar(c32 code, bool isMathMode, FontStyle style) const {
+  auto targetStyle = style;
+  if (style == FontStyle::invalid) {
+    targetStyle = isMathMode ? _mathFontStyle : _textFontStyle;
+  }
+  auto chr = _fctx->getChar(code, targetStyle, isMathMode);
+  chr.scale = scale();
+  return chr;
+}
+
+Char Env::getChar(const Symbol& sym) const {
+  auto chr = _fctx->getChar(sym, _mathFontStyle);
+  chr.scale = scale();
+  return chr;
+}