@simonklee/opentui-tex-native-source 0.2.0

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

@@ -0,0 +1,155 @@
+#ifndef MACRO_H_INCLUDED
+#define MACRO_H_INCLUDED
+
+#include <map>
+#include <string>
+
+#include "atom/atom.h"
+#include "utils/utils.h"
+
+namespace microtex {
+
+class Parser;
+
+class Macro {
+public:
+  virtual void execute(Parser& tp, std::vector<std::string>& args) = 0;
+
+  virtual ~Macro() = default;
+};
+
+class NewCommandMacro : public Macro {
+protected:
+  static std::map<std::string, std::string> _codes;
+  static std::map<std::string, std::string> _replacements;
+  static Macro* _instance;
+
+  static void checkNew(const std::string& name);
+
+  static void checkRenew(const std::string& name);
+
+public:
+  /**
+   * If notify a fatal error when defining a new command but it has been
+   * defined already or redefine a command but it has not been defined,
+   * default is true.
+   */
+  static bool _errIfConflict;
+
+  void execute(Parser& tp, std::vector<std::string>& args) override;
+
+  static void addNewCommand(const std::string& name, const std::string& code, int argc);
+
+  static void
+  addNewCommand(const std::string& name, const std::string& code, int argc, const std::string& def);
+
+  static void addRenewCommand(const std::string& name, const std::string& code, int argc);
+
+  static void addRenewCommand(
+    const std::string& name,
+    const std::string& code,
+    int argc,
+    const std::string& def
+  );
+
+  static bool isMacro(const std::string& name);
+
+  static void _init_();
+
+  static void _free_();
+
+  ~NewCommandMacro() override = default;
+};
+
+class NewEnvironmentMacro : public NewCommandMacro {
+public:
+  static void addNewEnvironment(
+    const std::string& name,
+    const std::string& begDef,
+    const std::string& endDef,
+    int argc
+  );
+
+  static void addRenewEnvironment(
+    const std::string& name,
+    const std::string& begDef,
+    const std::string& endDef,
+    int argc
+  );
+};
+
+class MacroInfo {
+private:
+  static std::map<std::string, MacroInfo*> _commands;
+
+public:
+  /** Add a macro, replace it if the macro is exists. */
+  static void add(const std::string& name, MacroInfo* mac);
+
+  /** Get the macro info from given name, return nullptr if not found. */
+  static MacroInfo* get(const std::string& name);
+
+  // Number of arguments
+  const int argc;
+  // Options' position, can be  0, 1 and 2
+  // 0 represents this macro has no options
+  // 1 represents the options appear after the command name, e.g.:
+  //      \sqrt[3]{2}
+  // 2 represents the options appear after the first argument, e.g.:
+  //      \scalebox{0.5}[2]{\LaTeX}
+  const int opt;
+
+  no_copy_assign(MacroInfo);
+
+  MacroInfo() : argc(0), opt(0) {}
+
+  MacroInfo(int argc, int opt) : argc(argc), opt(opt) {}
+
+  explicit MacroInfo(int argc) : argc(argc), opt(0) {}
+
+  virtual sptr<Atom> invoke(Parser& tp, std::vector<std::string>& args) { return nullptr; }
+
+  virtual ~MacroInfo() = default;
+
+  static void _free_();
+};
+
+class InflationMacroInfo : public MacroInfo {
+private:
+  // The actual macro to execute
+  Macro* const _macro;
+
+public:
+  no_copy_assign(InflationMacroInfo);
+
+  InflationMacroInfo(Macro* macro, int argc) : _macro(macro), MacroInfo(argc) {}
+
+  InflationMacroInfo(Macro* macro, int argc, int posOpts)
+      : _macro(macro), MacroInfo(argc, posOpts) {}
+
+  sptr<Atom> invoke(Parser& tp, std::vector<std::string>& args) override {
+    _macro->execute(tp, args);
+    return nullptr;
+  }
+};
+
+typedef sptr<Atom> (*MacroDelegate)(Parser& tp, std::vector<std::string>& args);
+
+class PreDefMacro : public MacroInfo {
+private:
+  MacroDelegate _delegate;
+
+public:
+  no_copy_assign(PreDefMacro);
+
+  PreDefMacro(int argc, int posOpts, MacroDelegate delegate)
+      : MacroInfo(argc, posOpts), _delegate(delegate) {}
+
+  PreDefMacro(int argc, MacroDelegate delegate) : MacroInfo(argc), _delegate(delegate) {}
+
+  sptr<Atom> invoke(Parser& tp, std::vector<std::string>& args) override;
+};
+
+}  // namespace microtex
+
+#endif  // MACRO_H_INCLUDED

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

@@ -0,0 +1,50 @@
+#include "macro/macro_accent.h"
+
+namespace microtex {
+
+macro(accentbiss) {
+  std::string acc;
+  switch (args[0][0]) {
+    case '~': acc = "tilde"; break;
+    case '\'': acc = "acute"; break;
+    case '^': acc = "hat"; break;
+    case '\"': acc = "ddot"; break;
+    case '`': acc = "grave"; break;
+    case '=': acc = "bar"; break;
+    case '.': acc = "dot"; break;
+    case 'u': acc = "breve"; break;
+    case 'v': acc = "check"; break;
+    case 't': acc = "tie"; break;
+    case 'r': acc = "mathring"; break;
+  }
+
+  return sptrOf<AccentedAtom>(Formula(tp, args[1], false)._root, acc);
+}
+
+macro(accents) {
+  const auto& name = args[0];
+  const auto& [acc, fit] = [&]() {
+    if (name == "widehat") return std::make_pair<std::string>("hat", true);
+    if (name == "widetilde") return std::make_pair<std::string>("tilde", true);
+    return std::make_pair(name, false);
+  }();
+  return sptrOf<AccentedAtom>(Formula(tp, args[1], false)._root, acc, fit);
+}
+
+macro(undertilde) {
+  auto stack = new StackAtom({StackElement::base, StackElement::under});
+  auto tilde = sptrOf<ExtensibleAtom>(
+    "tilde",
+    // capture raw pointer to avoid cycle reference
+    [stack](const Env& env) { return stack->getMaxWidth(); },
+    false
+  );
+  auto a = Formula(tp, args[1], false)._root;
+  const StackArgs under{tilde, UnitType::mu, 0.5f, true};
+  stack->setAdjustBottom(true);
+  stack->setBaseAtom(a);
+  stack->setUnder(under);
+  return sptr<StackAtom>(stack);
+}
+
+}  // namespace microtex

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

@@ -0,0 +1,61 @@
+#ifndef MICROTEX_MACRO_ACCENT_H
+#define MICROTEX_MACRO_ACCENT_H
+
+#include "atom/atom_accent.h"
+#include "atom/atom_basic.h"
+#include "atom/atom_stack.h"
+#include "macro/macro_decl.h"
+#include "utils/utf.h"
+
+namespace microtex {
+
+inline macro(accentset) {
+  if (args[1] == "")
+    return Formula(tp, args[2], false)._root;
+  return sptrOf<AccentedAtom>(Formula(tp, args[2], false)._root, args[1].substr(1), false, true);
+}
+
+inline macro(stack) {
+  const auto& over = StackArgs::autoSpace(Formula(tp, args[1], false)._root);
+  const auto& under = StackArgs::autoSpace(Formula(tp, args[3], false)._root);
+  return sptrOf<StackAtom>(Formula(tp, args[2], false)._root, over, under);
+}
+
+inline macro(stackrel) {
+  const auto& stack = macro_stack(tp, args);
+  return sptrOf<TypedAtom>(AtomType::relation, AtomType::relation, stack);
+}
+
+inline macro(stackbin) {
+  const auto& stack = macro_stack(tp, args);
+  return sptrOf<TypedAtom>(AtomType::binaryOperator, AtomType::binaryOperator, stack);
+}
+
+inline macro(overset) {
+  const auto& over = StackArgs::autoSpace(Formula(tp, args[1], false)._root);
+  sptr<Atom> a = sptrOf<StackAtom>(Formula(tp, args[2], false)._root, over, true);
+  return sptrOf<TypedAtom>(AtomType::relation, AtomType::relation, a);
+}
+
+inline macro(underset) {
+  const auto& under = StackArgs::autoSpace(Formula(tp, args[1], false)._root);
+  auto a = sptrOf<StackAtom>(Formula(tp, args[2], false)._root, under, false);
+  return sptrOf<TypedAtom>(AtomType::relation, AtomType::relation, a);
+}
+
+inline macro(underaccent) {
+  const StackArgs under{Formula(tp, args[1], false)._root, UnitType::mu, 1.f, true};
+  auto a = sptrOf<StackAtom>(Formula(tp, args[2], false)._root, under, false);
+  a->setAdjustBottom(true);
+  return a;
+}
+
+macro(accentbiss);
+
+macro(accents);
+
+macro(undertilde);
+
+}  // namespace microtex
+
+#endif  // MICROTEX_MACRO_ACCENT_H

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

@@ -0,0 +1,68 @@
+#ifndef MICROTEX_MACRO_BOXES_H
+#define MICROTEX_MACRO_BOXES_H
+
+#include "atom/atom_box.h"
+#include "atom/atom_misc.h"
+#include "macro/macro_decl.h"
+#include "utils/string_utils.h"
+
+namespace microtex {
+
+inline macro(rotatebox) {
+  float angle = 0;
+  if (!args[1].empty()) valueOf(args[1], angle);
+  return sptrOf<RotateAtom>(Formula(tp, args[2])._root, angle, args[3]);
+}
+
+inline macro(reflectbox) {
+  return sptrOf<ReflectAtom>(Formula(tp, args[1])._root);
+}
+
+inline macro(scalebox) {
+  float sx = 1, sy = 1;
+  valueOf(args[1], sx);
+
+  if (args[3].empty())
+    sy = sx;
+  else
+    valueOf(args[3], sy);
+
+  if (sx == 0) sx = 1;
+  if (sy == 0) sy = 1;
+  return sptrOf<ScaleAtom>(Formula(tp, args[2], false, tp.isMathMode())._root, sx, sy);
+}
+
+inline macro(resizebox) {
+  const std::string& ws = args[1];
+  const std::string& hs = args[2];
+  return sptrOf<ResizeAtom>(Formula(tp, args[3])._root, ws, hs, ws == "!" || hs == "!");
+}
+
+inline macro(shadowbox) {
+  return sptrOf<ShadowAtom>(Formula(tp, args[1])._root);
+}
+
+inline macro(ovalbox) {
+  return sptrOf<OvalAtom>(Formula(tp, args[1])._root);
+}
+
+inline macro(cornersize) {
+  float size = 0.5f;
+  valueOf(args[1], size);
+  if (size <= 0 || size > 0.5f) size = 0.5f;
+  OvalAtom::_multiplier = size;
+  OvalAtom::_diameter = 0;
+  return nullptr;
+}
+
+inline macro(doublebox) {
+  return sptrOf<DoubleFramedAtom>(Formula(tp, args[1])._root);
+}
+
+inline macro(fbox) {
+  return sptrOf<FBoxAtom>(Formula(tp, args[1], false)._root);
+}
+
+}  // namespace microtex
+
+#endif  // MICROTEX_MACRO_BOXES_H

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

@@ -0,0 +1,42 @@
+#include "macro/macro_colors.h"
+
+#include "utils/exceptions.h"
+#include "utils/string_utils.h"
+
+namespace microtex {
+
+macro(definecolor) {
+  color c = TRANSPARENT;
+  const auto& cs = args[3];
+  if (args[2] == "gray") {
+    float f = 0;
+    valueOf(args[3], f);
+    c = rgb(f, f, f);
+  } else if (args[2] == "rgb") {
+    StrTokenizer stok(cs, ":,");
+    if (stok.count() != 3) throw ex_parse("RGB color must have three components!");
+    float r, g, b;
+    std::string R = stok.next(), G = stok.next(), B = stok.next();
+    valueOf(trim(R), r);
+    valueOf(trim(G), g);
+    valueOf(trim(B), b);
+    c = rgb(r, g, b);
+  } else if (args[2] == "cmyk") {
+    StrTokenizer stok(cs, ":,");
+    if (stok.count() != 4) throw ex_parse("CMYK color must have four components!");
+    float cmyk[4];
+    for (float& i : cmyk) {
+      std::string X = stok.next();
+      valueOf(trim(X), i);
+    }
+    float k = 1 - cmyk[3];
+    c = rgb(k * (1 - cmyk[0]), k * (1 - cmyk[1]), k * (1 - cmyk[2]));
+  } else {
+    throw ex_parse("Invalid color model!");
+  }
+
+  ColorAtom::defineColor(args[1], c);
+  return nullptr;
+}
+
+}  // namespace microtex

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

@@ -0,0 +1,42 @@
+#ifndef MICROTEX_MACRO_COLORS_H
+#define MICROTEX_MACRO_COLORS_H
+
+#include "atom/atom_basic.h"
+#include "atom/atom_box.h"
+#include "atom/atom_misc.h"
+#include "macro/macro_decl.h"
+#include "utils/utf.h"
+
+namespace microtex {
+
+inline macro(fgcolor) {
+  auto a = Formula(tp, args[2])._root;
+  return sptrOf<ColorAtom>(a, TRANSPARENT, ColorAtom::getColor(args[1]));
+}
+
+inline macro(bgcolor) {
+  auto a = Formula(tp, args[2])._root;
+  return sptrOf<ColorAtom>(a, ColorAtom::getColor(args[1]), TRANSPARENT);
+}
+
+inline macro(textcolor) {
+  auto a = Formula(tp, args[2], false, false)._root;
+  return sptrOf<ColorAtom>(a, TRANSPARENT, ColorAtom::getColor(args[1]));
+}
+
+inline macro(colorbox) {
+  color c = ColorAtom::getColor(args[1]);
+  return sptrOf<FBoxAtom>(Formula(tp, args[2])._root, c, c);
+}
+
+inline macro(fcolorbox) {
+  color f = ColorAtom::getColor(args[2]);
+  color b = ColorAtom::getColor(args[1]);
+  return sptrOf<FBoxAtom>(Formula(tp, args[3])._root, f, b);
+}
+
+macro(definecolor);
+
+}  // namespace microtex
+
+#endif  // MICROTEX_MACRO_COLORS_H

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

@@ -0,0 +1,16 @@
+#ifndef MICROTEX_MACRO_DECL_H
+#define MICROTEX_MACRO_DECL_H
+
+#include "atom/atom.h"
+#include "core/formula.h"
+#include "core/parser.h"
+
+namespace microtex {
+
+#ifndef macro
+#define macro(name) sptr<Atom> macro_##name(Parser& tp, Args& args)
+#endif
+
+}  // namespace microtex
+
+#endif  // MICROTEX_MACRO_DECL_H