@simonklee/opentui-tex-native-source 0.2.0

package/native/vendor/microtex/lib/macro/macro_misc.cpp

@@ -0,0 +1,211 @@
+#include "macro/macro_misc.h"
+
+#include "atom/atom_font.h"
+#include "atom/atom_zstack.h"
+#include "core/debug_config.h"
+#include "env/env.h"
+#include "env/units.h"
+#include "graphic/graphic.h"
+
+using namespace microtex;
+using namespace std;
+
+namespace microtex {
+
+macro(longdiv) {
+  long dividend = 0;
+  valueOf(args[1], dividend);
+  long divisor = 0;
+  valueOf(args[2], divisor);
+  if (divisor == 0) throw ex_parse("Divisor must not be 0.");
+  return sptrOf<LongDivAtom>(divisor, dividend);
+}
+
+macro(char) {
+  // clang-format off
+  const auto& str = tp.forward([](char ch) {
+    return ch == '\'' || ch == '"'
+           || (ch >= '0' && ch <= '9')
+           || (ch >= 'a' && ch <= 'z')
+           || (ch >= 'A' && ch <= 'Z');
+  });
+  // clang-format on
+  int radix = 10;
+  int offset = 0;
+  if (startsWith(str, "'")) {
+    radix = 8;
+    offset = 1;
+  } else if (startsWith(str, "\"")) {
+    radix = 16;
+    offset = 1;
+  }
+  int n = 0;
+  str2int(str.c_str() + offset, str.length() - offset, n, radix);
+  return tp.getCharAtom(n);
+}
+
+macro(cr) {
+  if (tp.isArrayMode()) {
+    tp.addRow();
+  } else {
+    ArrayFormula arr;
+    arr.add(tp._formula->_root);
+    arr.addRow();
+    Parser parser(tp.isPartial(), tp.forwardBalancedGroup(), &arr, false, tp.isMathMode());
+    parser.parse();
+    arr.checkDimensions();
+    tp._formula->_root = arr.getAsVRow();
+  }
+
+  return nullptr;
+}
+
+macro(kern) {
+  auto [value, unit] = tp.getDimen();
+  return sptrOf<SpaceAtom>(unit, value, 0.f, 0.f);
+}
+
+macro(hvspace) {
+  auto [value, unit] = Units::getDimen(args[1]);
+  return args[0][0] == 'h' ? sptrOf<SpaceAtom>(unit, value, 0.f, 0.f)
+                           : sptrOf<SpaceAtom>(unit, 0.f, value, 0.f);
+}
+
+macro(rule) {
+  auto w = Units::getDimen(args[1]);
+  auto h = Units::getDimen(args[2]);
+  auto r = Units::getDimen(args[3]);
+
+  return sptrOf<RuleAtom>(w, h, -r);
+}
+
+template <typename F>
+sptr<Atom> _def_cmd(Parser& tp, Args& args, F&& f) {
+  string newcmd(args[1]);
+  int argc = 0;
+  if (!tp.isValidCmd(newcmd)) throw ex_parse("Invalid name for the command '" + newcmd);
+
+  if (!args[3].empty()) valueOf(args[3], argc);
+
+  const bool hasOption = !args[4].empty();
+  if (hasOption && argc > 0) --argc;
+
+  f(hasOption, newcmd.substr(1), args[2], argc, args[4]);
+
+  return nullptr;
+}
+
+macro(newcommand) {
+  return _def_cmd(
+    tp,
+    args,
+    [](bool hasOption, const string& cmd, const string& def, int argc, const string& opt) {
+      if (!hasOption) {
+        NewCommandMacro::addNewCommand(cmd, def, argc);
+      } else {
+        NewCommandMacro::addNewCommand(cmd, def, argc, opt);
+      }
+    }
+  );
+}
+
+macro(renewcommand) {
+  return _def_cmd(
+    tp,
+    args,
+    [](bool hasOption, const string& cmd, const string& def, int argc, const string& opt) {
+      if (!hasOption) {
+        NewCommandMacro::addRenewCommand(cmd, def, argc);
+      } else {
+        NewCommandMacro::addRenewCommand(cmd, def, argc, opt);
+      }
+    }
+  );
+}
+
+macro(raisebox) {
+  auto r = Units::getDimen(args[1]);
+  auto h = Units::getDimen(args[3]);
+  auto d = Units::getDimen(args[4]);
+  return sptrOf<RaiseAtom>(Formula(tp, args[2], false, tp.isMathMode())._root, -r, h, d);
+}
+
+macro(romannumeral) {
+  static const int numbers[] = {1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1};
+  static const string letters[] =
+    {"M", "CM", "D", "CD", "C", "XC", "", "XL", "X", "IX", "V", "IV", "I"};
+  string roman;
+
+  int num;
+  valueOf(trim(args[1]), num);
+  for (int i = 0; i < 13; i++) {
+    while (num >= numbers[i]) {
+      roman += letters[i];
+      num -= numbers[i];
+    }
+  }
+
+  if (args[0][0] == 'r') {
+    toLower(roman);
+  }
+
+  return sptrOf<FontStyleAtom>(
+    FontStyle::rm,
+    tp.isMathMode(),
+    Formula(tp, roman, false, tp.isMathMode())._root
+  );
+}
+
+macro(debug) {
+  auto& config = DebugConfig::INSTANCE;
+  const auto& options = parseOption(args[1]);
+  config.enable = true;
+  const auto& showOnlyChar = options.find("showonlychar");
+  if (showOnlyChar != options.end()) {
+    config.showOnlyChar = showOnlyChar->second == "true";
+  }
+  const auto& boundColor = options.find("boundcolor");
+  if (boundColor != options.end()) {
+    config.boundColor = ColorAtom::getColor(boundColor->second);
+  }
+  const auto& baselineColor = options.find("baselinecolor");
+  if (baselineColor != options.end()) {
+    config.baselineColor = ColorAtom::getColor(baselineColor->second);
+  }
+  return nullptr;
+}
+
+macro(undebug) {
+  auto& config = DebugConfig::INSTANCE;
+  config.enable = false;
+  return nullptr;
+}
+
+macro(zstack) {
+  auto halign = Alignment::left;
+  if (args[1] == "c") {
+    halign = Alignment::center;
+  } else if (args[1] == "r") {
+    halign = Alignment::right;
+  }
+  const auto& h = Units::getDimen(args[2]);
+  const ZStackArgs hargs{halign, h};
+
+  auto valign = Alignment::top;
+  if (args[3] == "c") {
+    valign = Alignment::center;
+  } else if (args[3] == "b") {
+    valign = Alignment::bottom;
+  } else if (args[3] == "B") {
+    valign = Alignment::none;
+  }
+  const auto& v = Units::getDimen(args[4]);
+  const ZStackArgs& vargs{valign, v};
+
+  const auto atom = Formula(tp, args[5], false)._root;
+  const auto anchor = Formula(tp, args[6], false)._root;
+
+  return sptrOf<ZStackAtom>(hargs, vargs, atom, anchor);
+}
+
+}  // namespace microtex

package/native/vendor/microtex/lib/macro/macro_misc.h

@@ -0,0 +1,217 @@
+#ifndef MICROTEX_MACRO_MISC_H
+#define MICROTEX_MACRO_MISC_H
+
+#include <memory>
+
+#include "atom/atom_basic.h"
+#include "atom/atom_misc.h"
+#include "atom/atom_sideset.h"
+#include "core/formula.h"
+#include "core/parser.h"
+#include "core/split.h"
+#include "graphic/graphic.h"
+#include "macro/macro.h"
+#include "macro/macro_decl.h"
+#include "utils/exceptions.h"
+#include "utils/string_utils.h"
+#include "utils/utf.h"
+
+namespace microtex {
+
+inline macro(fatalIfCmdConflict) {
+  NewCommandMacro::_errIfConflict = args[1] == "true";
+  return nullptr;
+}
+
+inline macro(breakEverywhere) {
+  RowAtom::_breakEverywhere = args[1] == "true";
+  return nullptr;
+}
+
+inline macro(st) {
+  auto base = Formula(tp, args[1], false, tp.isMathMode())._root;
+  return sptrOf<StrikeThroughAtom>(base);
+}
+
+inline macro(spATbreve) {
+  auto* vra = new VRowAtom(Formula("\\displaystyle\\!\\breve{}")._root);
+  vra->setRaise(UnitType::ex, 0.6f);
+  return sptrOf<SmashedAtom>(sptr<Atom>(vra), "");
+}
+
+inline macro(clrlap) {
+  return sptrOf<LapedAtom>(Formula(tp, args[1])._root, args[0][0]);
+}
+
+inline macro(mathclrlap) {
+  return sptrOf<LapedAtom>(Formula(tp, args[1])._root, args[0][4]);
+}
+
+inline sptr<Atom> _cancel(int cancelType, Parser& tp, std::vector<std::string>& args) {
+  auto base = Formula(tp, args[1], false)._root;
+  if (base == nullptr) throw ex_parse("Cancel content must not be empty!");
+  return sptrOf<CancelAtom>(base, cancelType);
+}
+
+inline macro(cancel) {
+  return _cancel(CancelAtom::SLASH, tp, args);
+}
+
+inline macro(bcancel) {
+  return _cancel(CancelAtom::BACKSLASH, tp, args);
+}
+
+inline macro(xcancel) {
+  return _cancel(CancelAtom::CROSS, tp, args);
+}
+
+inline macro(underscore) {
+  return SymbolAtom::get("_");
+}
+
+inline macro(nbsp) {
+  return sptrOf<SpaceAtom>();
+}
+
+inline macro(joinrel) {
+  return sptrOf<TypedAtom>(
+    AtomType::relation,
+    AtomType::relation,
+    sptrOf<SpaceAtom>(UnitType::mu, -2.6f, 0.f, 0.f)
+  );
+}
+
+inline macro(smash) {
+  return sptrOf<SmashedAtom>(Formula(tp, args[1], false)._root, args[2]);
+}
+
+inline macro(makeatletter) {
+  tp.makeAtLetter();
+  return nullptr;
+}
+
+inline macro(makeatother) {
+  tp.makeAtOther();
+  return nullptr;
+}
+
+inline macro(newenvironment) {
+  int opt = 0;
+  if (!args[4].empty()) valueOf(args[4], opt);
+
+  NewEnvironmentMacro::addNewEnvironment(args[1], args[2], args[3], opt);
+  return nullptr;
+}
+
+inline macro(renewenvironment) {
+  int opt = 0;
+  if (!args[4].empty()) valueOf(args[4], opt);
+
+  NewEnvironmentMacro::addRenewEnvironment(args[1], args[2], args[3], opt);
+  return nullptr;
+}
+
+inline macro(hphantom) {
+  return sptrOf<PhantomAtom>(Formula(tp, args[1], false)._root, true, false, false);
+}
+
+inline macro(vphantom) {
+  return sptrOf<PhantomAtom>(Formula(tp, args[1], false)._root, false, true, true);
+}
+
+inline macro(phantom) {
+  return sptr<Atom>(new PhantomAtom(Formula(tp, args[1], false)._root, true, true, true));
+}
+
+inline macro(surd) {
+  return sptrOf<VCenterAtom>(SymbolAtom::get("surdsign"));
+}
+
+inline macro(lmoustache) {
+  auto* s = new SymbolAtom(*(SymbolAtom::get("lmoustache")));
+  auto b = sptrOf<BigSymbolAtom>(sptr<SymbolAtom>(s), 1);
+  b->_type = AtomType::opening;
+  return b;
+}
+
+inline macro(rmoustache) {
+  auto* s = new SymbolAtom(*(SymbolAtom::get("rmoustache")));
+  auto b = sptrOf<BigSymbolAtom>(sptr<SymbolAtom>(s), 1);
+  b->_type = AtomType::closing;
+  return b;
+}
+
+inline macro(breakmark) {
+  return sptrOf<BreakMarkAtom>();
+}
+
+inline macro(nokern) {
+  return sptrOf<NokernAtom>();
+}
+
+/**************************************** limits macros *******************************************/
+
+inline sptr<Atom> _limits_type(Parser& tp, Args& args, LimitsType type) {
+  auto atom = tp.popBack();
+  if (atom != nullptr)
+    atom->_limitsType = type;
+  return atom;
+}
+
+inline macro(nolimits) {
+  return _limits_type(tp, args, LimitsType::noLimits);
+}
+
+inline macro(limits) {
+  return _limits_type(tp, args, LimitsType::limits);
+}
+
+inline macro(normal) {
+  return _limits_type(tp, args, LimitsType::normal);
+}
+
+/***************************************** implement at .cpp **************************************/
+
+macro(longdiv);
+
+macro(char);
+
+macro(cr);
+
+macro(kern);
+
+macro(hvspace);
+
+macro(rule);
+
+macro(newcommand);
+
+macro(renewcommand);
+
+macro(raisebox);
+
+macro(romannumeral);
+
+macro(zstack);
+
+#ifdef GRAPHICS_DEBUG
+
+macro(debug);
+
+macro(undebug);
+
+#endif  // GRAPHICS_DEBUG
+
+inline macro(backslashcr) {
+  return macro_cr(tp, args);
+}
+
+/**************************************** not implemented *****************************************/
+
+inline macro(includegraphics) {
+  return nullptr;
+}
+
+}  // namespace microtex
+
+#endif  // MICROTEX_MACRO_MISC_H

package/native/vendor/microtex/lib/macro/macro_scripts.cpp

@@ -0,0 +1,32 @@
+#include "macro/macro_scripts.h"
+
+#include "atom/atom_basic.h"
+#include "atom/atom_scripts.h"
+
+namespace microtex {
+
+using namespace std;
+
+macro(sideset) {
+  auto l = Formula(tp, args[1])._root;
+  auto r = Formula(tp, args[2])._root;
+  auto op = Formula(tp, args[3])._root;
+  if (op == nullptr) {
+    auto in = sptrOf<CharAtom>('M', FontStyle::rm, true);
+    op = sptrOf<PhantomAtom>(in, false, true, true);
+  }
+  op->_limitsType = LimitsType::limits;
+  op->_type = AtomType::bigOperator;
+  auto cl = dynamic_cast<CumulativeScriptsAtom*>(l.get());
+  auto cr = dynamic_cast<CumulativeScriptsAtom*>(r.get());
+  if (cl != nullptr) l = cl->getScriptsAtom();
+  if (cr != nullptr) r = cr->getScriptsAtom();
+  return sptrOf<SideSetsAtom>(op, l, r);
+}
+
+macro(prescript) {
+  auto base = Formula(tp, args[3])._root;
+  return sptrOf<ScriptsAtom>(base, Formula(tp, args[2])._root, Formula(tp, args[1])._root, false);
+}
+
+}  // namespace microtex

package/native/vendor/microtex/lib/macro/macro_scripts.h

@@ -0,0 +1,17 @@
+#ifndef MICROTEX_MACRO_SCRIPTS_H
+#define MICROTEX_MACRO_SCRIPTS_H
+
+#include "atom/atom_frac.h"
+#include "atom/atom_misc.h"
+#include "atom/atom_sideset.h"
+#include "macro/macro_decl.h"
+
+namespace microtex {
+
+macro(prescript);
+
+macro(sideset);
+
+}  // namespace microtex
+
+#endif  // MICROTEX_MACRO_SCRIPTS_H

package/native/vendor/microtex/lib/macro/macro_sizes.h

@@ -0,0 +1,110 @@
+#ifndef MICROTEX_MACRO_SIZES_H
+#define MICROTEX_MACRO_SIZES_H
+
+#include "macro/macro_decl.h"
+
+namespace microtex {
+
+inline macro(declaremathsizes) {
+  float a, b, c, d;
+  valueOf(args[1], a), valueOf(args[2], b), valueOf(args[3], c), valueOf(args[4], d);
+  // TODO setMathSizes(a, b, c, d);
+  return nullptr;
+}
+
+inline macro(magnification) {
+  float x;
+  valueOf(args[1], x);
+  // TODO setMagnification(x);
+  return nullptr;
+}
+
+inline macro(sizes) {
+  float f = 1;
+  if (args[0] == "tiny")
+    f = 0.5f;
+  else if (args[0] == "scriptsize")
+    f = 0.7f;
+  else if (args[0] == "footnotesize")
+    f = 0.8f;
+  else if (args[0] == "small")
+    f = 0.9f;
+  else if (args[0] == "normalsize")
+    f = 1.f;
+  else if (args[0] == "large")
+    f = 1.2f;
+  else if (args[0] == "Large")
+    f = 1.4f;
+  else if (args[0] == "LARGE")
+    f = 1.8f;
+  else if (args[0] == "huge")
+    f = 2.f;
+  else if (args[0] == "Huge")
+    f = 2.5f;
+
+  auto a = Formula(tp, tp.getOverArgument(), false, tp.isMathMode())._root;
+  a = a == nullptr ? sptrOf<EmptyAtom>() : a;
+  return sptrOf<ScaleAtom>(a, f);
+}
+
+inline sptr<Atom>
+_big(Parser& tp, std::vector<std::string>& args, int size, AtomType type = AtomType::none) {
+  auto a = Formula(tp, args[1], false)._root;
+  auto s = std::dynamic_pointer_cast<SymbolAtom>(a);
+  if (s == nullptr) return a;
+  auto t = sptrOf<BigSymbolAtom>(s, size);
+  if (type != AtomType::none) t->_type = type;
+  return t;
+}
+
+inline macro(big) {
+  return _big(tp, args, 1);
+}
+
+inline macro(Big) {
+  return _big(tp, args, 2);
+}
+
+inline macro(bigg) {
+  return _big(tp, args, 3);
+}
+
+inline macro(Bigg) {
+  return _big(tp, args, 4);
+}
+
+inline macro(bigl) {
+  return _big(tp, args, 1, AtomType::opening);
+}
+
+inline macro(Bigl) {
+  return _big(tp, args, 2, AtomType::opening);
+}
+
+inline macro(biggl) {
+  return _big(tp, args, 3, AtomType::opening);
+}
+
+inline macro(Biggl) {
+  return _big(tp, args, 4, AtomType::opening);
+}
+
+inline macro(bigr) {
+  return _big(tp, args, 1, AtomType::closing);
+}
+
+inline macro(Bigr) {
+  return _big(tp, args, 2, AtomType::closing);
+}
+
+inline macro(biggr) {
+  return _big(tp, args, 3, AtomType::closing);
+}
+
+inline macro(Biggr) {
+  return _big(tp, args, 4, AtomType::closing);
+}
+
+}  // namespace microtex
+
+#endif  // MICROTEX_MACRO_SIZES_H

package/native/vendor/microtex/lib/macro/macro_space.cpp

@@ -0,0 +1,31 @@
+#include "macro/macro_space.h"
+
+namespace microtex {
+
+macro(muskips) {
+  SpaceType type = SpaceType::none;
+  if (args[0] == ",")
+    type = SpaceType::thinMuSkip;
+  else if (args[0] == ":")
+    type = SpaceType::medMuSkip;
+  else if (args[0] == ";")
+    type = SpaceType::thickMuSkip;
+  else if (args[0] == "thinspace")
+    type = SpaceType::thinMuSkip;
+  else if (args[0] == "medspace")
+    type = SpaceType::medMuSkip;
+  else if (args[0] == "thickspace")
+    type = SpaceType::thickMuSkip;
+  else if (args[0] == "!")
+    type = SpaceType::negThinMuSkip;
+  else if (args[0] == "negthinspace")
+    type = SpaceType::negThinMuSkip;
+  else if (args[0] == "negmedspace")
+    type = SpaceType::negMedMuSkip;
+  else if (args[0] == "negthickspace")
+    type = SpaceType::negThickMuSkip;
+
+  return sptrOf<SpaceAtom>(type);
+}
+
+}  // namespace microtex

package/native/vendor/microtex/lib/macro/macro_space.h

@@ -0,0 +1,17 @@
+#ifndef MICROTEX_MACRO_SPACE_H
+#define MICROTEX_MACRO_SPACE_H
+
+#include "atom/atom_space.h"
+#include "macro/macro_decl.h"
+
+namespace microtex {
+
+inline macro(quad) {
+  return sptrOf<SpaceAtom>(UnitType::em, 1.f, 0.f, 0.f);
+}
+
+macro(muskips);
+
+}  // namespace microtex
+
+#endif  // MICROTEX_MACRO_SPACE_H

package/native/vendor/microtex/lib/macro/macro_styles.cpp

@@ -0,0 +1,45 @@
+#include "macro/macro_styles.h"
+
+#include "atom/atom_basic.h"
+#include "microtex.h"
+#include "utils/utf.h"
+
+namespace microtex {
+
+TexStyle texStyleOf(const std::string& str) {
+  TexStyle style = TexStyle::text;
+  if (str == "displaystyle") {
+    style = TexStyle::display;
+  } else if (str == "textstyle") {
+    style = TexStyle::text;
+  } else if (str == "scriptstyle") {
+    style = TexStyle::script;
+  } else if (str == "scriptscriptstyle") {
+    style = TexStyle::scriptScript;
+  }
+  return style;
+}
+
+macro(everymath) {
+  if (args[1].empty()) {
+    MicroTeX::overrideTexStyle(false);
+  } else {
+    TexStyle style = texStyleOf(args[1].substr(1));
+    MicroTeX::overrideTexStyle(true, style);
+  }
+  return nullptr;
+}
+
+macro(texstyle) {
+  auto g = Formula(tp, tp.getOverArgument(), false)._root;
+  g = g == nullptr ? sptrOf<EmptyAtom>() : g;
+  TexStyle style = texStyleOf(args[0]);
+  return sptrOf<StyleAtom>(style, g);
+}
+
+macro(atexstyle) {
+  auto g = Formula(tp, args[1], false)._root;
+  return sptrOf<AStyleAtom>(args[0], g);
+}
+
+}  // namespace microtex

package/native/vendor/microtex/lib/macro/macro_styles.h

@@ -0,0 +1,22 @@
+#ifndef MICROTEX_MACRO_STYLES_H
+#define MICROTEX_MACRO_STYLES_H
+
+#include "atom/atom_misc.h"
+#include "core/formula.h"
+#include "core/parser.h"
+#include "macro/macro.h"
+#include "macro/macro_decl.h"
+
+namespace microtex {
+
+TexStyle texStyleOf(const std::string& str);
+
+macro(everymath);
+
+macro(texstyle);
+
+macro(atexstyle);
+
+}  // namespace microtex
+
+#endif  // MICROTEX_MACRO_STYLES_H