@simonklee/opentui-tex-native-source 0.2.0 → 0.3.1

package/native/vendor/{.bootstrap-v5 → .bootstrap-v8}

@@ -1 +1 @@
-zigtex=fda2819e45f57ca2071810c47249a46bfc782cdf microtex=74e8fee9e47edc3a777e64fb2eff9a85a01defac nanosvg=239e102ec2c691f2902e20ace2ed36ee4a35cfe6 zig=0.16-v5
+zigtex=fda2819e45f57ca2071810c47249a46bfc782cdf microtex=74e8fee9e47edc3a777e64fb2eff9a85a01defac nanosvg=239e102ec2c691f2902e20ace2ed36ee4a35cfe6 zig=0.16-v8

package/native/vendor/microtex/lib/atom/atom_matrix.cpp

@@ -1,11 +1,13 @@
 #include "atom/atom_matrix.h"
 
+#include <charconv>
 #include <memory>
 
 #include "atom/atom_basic.h"
 #include "atom/atom_row.h"
 #include "core/formula.h"
 #include "core/glue.h"
+#include "core/parse_limits.h"
 #include "env/env.h"
 #include "utils/exceptions.h"
 #include "utils/string_utils.h"
@@ -31,6 +33,8 @@ void MatrixAtom::defineColumnSpecifier(const string& rep, const string& spe) {
 }
 
 void MatrixAtom::parsePositions(string opt, vector<Alignment>& lpos) {
+  ParseDepth depth;
+  parse_limits.input(opt.size());
   int len = opt.length();
   int pos = 0;
   char ch;
@@ -39,6 +43,7 @@ void MatrixAtom::parsePositions(string opt, vector<Alignment>& lpos) {
   // clear first
   lpos.clear();
   while (pos < len) {
+    parse_limits.spend();
     ch = opt[pos];
     switch (ch) {
       case 'l': lpos.push_back(Alignment::left); break;
@@ -79,11 +84,22 @@ void MatrixAtom::parsePositions(string opt, vector<Alignment>& lpos) {
         vector<string> args;
         tp->getOptsArgs(2, 0, args);
         pos += tp->getPos();
-        int nrep = 0;
-        valueOf(args[1], nrep);
+        size_t nrep = 0;
+        const auto& count = trim(args[1]);
+        auto first = count.data();
+        if (!count.empty() && count.front() == '+') ++first;
+        const auto parsed = from_chars(first, count.data() + count.size(), nrep);
+        if (parsed.ec != errc{} || parsed.ptr != count.data() + count.size() ||
+            nrep > ParseLimits::bytes_max ||
+            (!args[2].empty() && nrep > (ParseLimits::bytes_max - opt.size()) / args[2].size())) {
+          throw ParseLimitExceeded{};
+        }
+        const auto bytes = nrep * args[2].size();
+        parse_limits.spend(nrep + bytes);
         string str;
-        for (int j = 0; j < nrep; j++) str += args[2];
-        opt.insert(pos, str);
+        str.reserve(bytes);
+        for (size_t j = 0; j < nrep; j++) str += args[2];
+        parse_limits.replace(opt, pos, 0, str);
         len = opt.length();
         pos--;
       } break;
@@ -102,10 +118,11 @@ void MatrixAtom::parsePositions(string opt, vector<Alignment>& lpos) {
         int spos = len + 1;
         bool hasrep = false;
         while (--spos > pos) {
+          parse_limits.spend(spos - pos);
           auto it = _colspeReplacement.find(opt.substr(pos, spos - pos));
           if (it != _colspeReplacement.end()) {
             hasrep = true;
-            opt.insert(spos, it->second);
+            parse_limits.replace(opt, spos, 0, it->second);
             len = opt.length();
             pos = spos - 1;
             break;
@@ -127,9 +144,9 @@ void MatrixAtom::parsePositions(string opt, vector<Alignment>& lpos) {
   if (lpos.empty()) lpos.push_back(Alignment::center);
 }
 
-float* MatrixAtom::getColumnSep(Env& env, float width) {
+vector<float> MatrixAtom::getColumnSep(Env& env, float width) {
   const int cols = _matrix->cols();
-  auto* arr = new float[cols + 1]();
+  vector<float> arr(cols + 1);
   sptr<Box> Align, AlignSep, Hsep;
   float h, w = env.textWidth();
   int i = 0;
@@ -234,7 +251,7 @@ float* MatrixAtom::getColumnSep(Env& env, float width) {
 
 void MatrixAtom::recalculateLine(
   const int rows,
-  sptr<Box>** boxarr,
+  vector<vector<sptr<Box>>>& boxarr,
   vector<sptr<Atom>>& multiRows,
   float* height,
   float* depth,
@@ -406,11 +423,11 @@ sptr<Box> MatrixAtom::createBoxInner(Env& env) {
   const int rows = _matrix->rows();
   const int cols = _matrix->cols();
 
-  auto lineDepth = new float[rows]();
-  auto lineHeight = new float[rows]();
-  auto colWidth = new float[cols]();
-  auto boxarr = new sptr<Box>*[rows]();
-  for (int i = 0; i < rows; i++) boxarr[i] = new sptr<Box>[cols]();
+  vector<float> lineDepth(rows);
+  vector<float> lineHeight(rows);
+  vector<float> colWidth(cols);
+  vector<vector<sptr<Box>>> boxarr(rows);
+  for (auto& row : boxarr) row.resize(cols);
 
   float matW = 0;
   const auto drt = env.ruleThickness();
@@ -459,7 +476,7 @@ sptr<Box> MatrixAtom::createBoxInner(Env& env) {
   for (int j = 0; j < cols; j++) matW += colWidth[j];
 
   // The horizontal separator's width
-  float* Hsep = getColumnSep(env, matW);
+  auto Hsep = getColumnSep(env, matW);
 
   for (auto& i : multiCols) {
     auto* multi = (MulticolumnAtom*)i.get();
@@ -486,9 +503,9 @@ sptr<Box> MatrixAtom::createBoxInner(Env& env) {
 
   auto Vsep = _vsep_in.createBox(env);
   // Recalculate the height of the row
-  recalculateLine(rows, boxarr, multiRows, lineHeight, lineDepth, drt, Vsep->_height);
+  recalculateLine(rows, boxarr, multiRows, lineHeight.data(), lineDepth.data(), drt, Vsep->_height);
 
-  auto* vb = new VBox();
+  auto vb = sptrOf<VBox>();
   float totalHeight = 0;
   float Vspace = Vsep->_height / 2;
 
@@ -511,11 +528,11 @@ sptr<Box> MatrixAtom::createBoxInner(Env& env) {
 
           bool isLastVline = true;
 
-          WrapperBox* wb = nullptr;
+          sptr<WrapperBox> wb;
           int tj = j;
           float l = j == 0 ? Hsep[j] : Hsep[j] / 2;
           if (boxarr[i][j]->_type == AtomType::none) {
-            wb = new WrapperBox(
+            wb = sptrOf<WrapperBox>(
               boxarr[i][j],
               colWidth[j],
               lineHeight[i],
@@ -523,18 +540,17 @@ sptr<Box> MatrixAtom::createBoxInner(Env& env) {
               _position[j]  //
             );
           } else {
-            auto b = generateMulticolumn(env, boxarr[i][j], Hsep, colWidth, i, j);
+            auto b = generateMulticolumn(env, boxarr[i][j], Hsep.data(), colWidth.data(), i, j);
             auto* matom = (MulticolumnAtom*)_matrix->_array[i][j].get();
             j += matom->skipped() - 1;
-            wb = new WrapperBox(b, b->_width, lineHeight[i], lineDepth[i], Alignment::left);
+            wb = sptrOf<WrapperBox>(b, b->_width, lineHeight[i], lineDepth[i], Alignment::left);
             isLastVline = matom->hasRightVline();
           }
           float r = j == cols - 1 ? Hsep[j + 1] : Hsep[j + 1] / 2;
           wb->addInsets(l, Vspace, r, Vspace);
           applyCell(*wb, i, j);
-          sptr<Box> swb(wb);
-          boxarr[i][tj] = swb;
-          hb->add(swb);
+          boxarr[i][tj] = wb;
+          hb->add(wb);
 
           auto it = _vlines.find(j + 1);
           if (isLastVline && it != _vlines.end()) {
@@ -582,14 +598,7 @@ sptr<Box> MatrixAtom::createBoxInner(Env& env) {
   vb->_height = totalHeight / 2 + axis;
   vb->_depth = totalHeight / 2 - axis;
 
-  delete[] Hsep;
-  delete[] lineDepth;
-  delete[] lineHeight;
-  delete[] colWidth;
-  for (int i = 0; i < rows; i++) delete[] boxarr[i];
-  delete[] boxarr;
-
-  return sptr<Box>(vb);
+  return vb;
 }
 
 sptr<Box> MatrixAtom::createBox(Env& env) {
@@ -709,13 +718,13 @@ sptr<Box> VlineAtom::createBox(Env& env) {
   const auto drt = env.ruleThickness();
   auto rb = sptrOf<RuleBox>(_height, drt, _shift, MatrixAtom::LINE_COLOR, true);
   auto sep = sptrOf<StrutBox>(2 * drt, 0.f, 0.f, 0.f);
-  auto hb = new HBox();
+  auto hb = sptrOf<HBox>();
   for (int i = 0; i < _n - 1; i++) {
     hb->add(rb);
     hb->add(sep);
   }
   if (_n > 0) hb->add(rb);
-  return sptr<Box>(hb);
+  return hb;
 }
 
 SpaceAtom MultlineAtom::_vsep_in(UnitType::ex, 0.f, 1.f, 0.f);
@@ -725,7 +734,7 @@ sptr<Box> MultlineAtom::createBox(Env& env) {
   if (tw == POS_INF || _lineType == MultiLineType::gathered)
     return MatrixAtom(_isPartial, _column, "").createBox(env);
 
-  auto* vb = new VBox();
+  auto vb = sptrOf<VBox>();
   auto atom = _column->_array[0][0];
   Alignment alignment = _lineType == MultiLineType::gather ? Alignment::center : Alignment::left;
   if (atom->_alignment != Alignment::none) alignment = atom->_alignment;
@@ -752,5 +761,5 @@ sptr<Box> MultlineAtom::createBox(Env& env) {
   vb->_height = h / 2;
   vb->_depth = h / 2;
 
-  return sptr<Box>(vb);
+  return vb;
 }

package/native/vendor/microtex/lib/atom/atom_matrix.h

@@ -87,7 +87,7 @@ private:
 
   static void recalculateLine(
     int rows,
-    sptr<Box>** boxarr,
+    std::vector<std::vector<sptr<Box>>>& boxarr,
     std::vector<sptr<Atom>>& multiRows,
     float* height,
     float* depth,
@@ -95,7 +95,7 @@ private:
     float vspace
   );
 
-  float* getColumnSep(Env& env, float width);
+  std::vector<float> getColumnSep(Env& env, float width);
 
   void applyCell(WrapperBox& box, int i, int j);
 

package/native/vendor/microtex/lib/atom/atom_row.cpp

@@ -172,7 +172,7 @@ sptr<TextAtom> RowAtom::processContinues(int& i, bool isMathMode) {
 }
 
 sptr<Box> RowAtom::createBox(Env& env) {
-  auto hbox = new HBox();
+  auto hbox = sptrOf<HBox>();
   // convert atoms to boxes and add to the horizontal box
   const int end = _elements.size() - 1;
   for (int i = -1; i < end;) {
@@ -326,7 +326,7 @@ sptr<Box> RowAtom::createBox(Env& env) {
   }
   // reset previous atom
   _previousAtom = nullptr;
-  return sptr<Box>(hbox);
+  return hbox;
 }
 
 void RowAtom::setPreviousAtom(const sptr<AtomDecor>& prev) {

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

@@ -0,0 +1,54 @@
+#ifndef MICROTEX_PARSE_LIMITS_H
+#define MICROTEX_PARSE_LIMITS_H
+
+#include <cstddef>
+#include <string>
+
+namespace microtex {
+
+// Deliberately not std::exception: partial parsing must not swallow limit failures.
+struct ParseLimitExceeded {};
+
+struct ParseLimits {
+  // Allow expansion beyond the 4 KiB public input limit, but bound synchronous work.
+  static constexpr size_t bytes_max = 64 * 1024;
+  size_t work_left = 1024 * 1024;
+  size_t replacements_left = 1024;
+  size_t depth = 0;
+
+  void spend(size_t work = 1) {
+    if (work > work_left) throw ParseLimitExceeded{};
+    work_left -= work;
+  }
+
+  void input(size_t bytes) {
+    if (bytes > bytes_max) throw ParseLimitExceeded{};
+    spend(bytes);
+  }
+
+  void replace(std::string& source, size_t pos, size_t count, const std::string& text) {
+    if (replacements_left == 0 || text.size() > bytes_max ||
+        source.size() > bytes_max - text.size()) throw ParseLimitExceeded{};
+    --replacements_left;
+    spend(source.size() + text.size());
+    source.replace(pos, count, text);
+  }
+};
+
+// Nested parsers and macro argument substitutions share the caller's budget.
+inline thread_local ParseLimits parse_limits;
+
+struct ParseDepth {
+  ParseDepth() {
+    parse_limits.spend();
+    if (parse_limits.depth >= 64) throw ParseLimitExceeded{};
+    ++parse_limits.depth;
+  }
+  ~ParseDepth() { --parse_limits.depth; }
+  ParseDepth(const ParseDepth&) = delete;
+  ParseDepth& operator=(const ParseDepth&) = delete;
+};
+
+} // namespace microtex
+
+#endif

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

@@ -1,4 +1,5 @@
 #include "core/parser.h"
+#include "core/parse_limits.h"
 
 #include "atom/atom.h"
 #include "atom/atom_basic.h"
@@ -39,6 +40,7 @@ static constexpr char BACKPRIME = '`';
 }  // namespace
 
 void Parser::init(bool isPartial, const string& latex, Formula* formula, bool firstPass) {
+  parse_limits.input(latex.size());
   _pos = _spos = _len = 0;
   _group = 0;
   _atIsLetter = 0;
@@ -62,6 +64,7 @@ void Parser::init(bool isPartial, const string& latex, Formula* formula, bool fi
 }
 
 void Parser::reset(const string& latex) {
+  parse_limits.input(latex.size());
   _latex = latex;
   _len = latex.length();
   _formula->_root = nullptr;
@@ -284,7 +287,7 @@ string Parser::getCmd() {
 }
 
 void Parser::insert(int beg, int end, const string& formula) {
-  _latex.replace(beg, end - beg, formula);
+  parse_limits.replace(_latex, beg, end - beg, formula);
   _len = _latex.length();
   _pos = beg;
   _insertion = true;
@@ -363,6 +366,8 @@ string Parser::forward(std::function<bool(char)>&& f) {
 }
 
 void Parser::getOptsArgs(int argc, int opts, Args& args) {
+  ParseDepth depth;
+  if (argc < 0 || argc > 10) throw ParseLimitExceeded{};
   // A maximum of 10 options can be passed to a command,
   // the value will be added at the tail of the args if found any,
   // the last (maximum to 12th) value is reserved for returned value
@@ -536,6 +541,7 @@ sptr<Atom> Parser::getScripts(char first) {
 }
 
 sptr<Atom> Parser::getArgument() {
+  ParseDepth depth;
   skipWhiteSpace();
   char ch;
   if (_pos < _len)
@@ -619,7 +625,7 @@ void Parser::preprocessNewCmd(string& cmd, Args& args, int& pos) {
   auto mac = MacroInfo::get(cmd);
   getOptsArgs(mac->argc, mac->opt, args);
   mac->invoke(*this, args);
-  _latex.erase(pos, _pos - pos);
+  parse_limits.replace(_latex, pos, _pos - pos, "");
   _len = _latex.length();
   _pos = pos;
 }
@@ -632,7 +638,7 @@ void Parser::inflateNewCmd(string& cmd, Args& args, int& pos) {
   try {
     mac->invoke(*this, args);
     // The last element is the returned value (after inflated macro)
-    _latex.replace(pos, _pos - pos, args.back());
+    parse_limits.replace(_latex, pos, _pos - pos, args.back());
   } catch (ex_parse& e) {
     if (!_isPartial) throw e;
     pos += cmd.length() + 1;
@@ -654,7 +660,7 @@ void Parser::inflateEnv(string& cmd, Args& args, int& pos) {
   string expr = "{\\makeatletter \\" + args[1] + "@env";
   for (int i = 1; i <= mac->argc - 1; i++) expr += "{" + optargs[i] + "}";
   expr += "{" + grp + "}\\makeatother}";
-  _latex.replace(pos, _pos - pos, expr);
+  parse_limits.replace(_latex, pos, _pos - pos, expr);
   _len = _latex.length();
   _pos = pos;
 }
@@ -666,6 +672,7 @@ void Parser::preprocess() {
   int spos;
   vector<string> args;
   while (_pos < _len) {
+    parse_limits.spend();
     ch = _latex[_pos];
     switch (ch) {
       case ESCAPE: {
@@ -687,7 +694,7 @@ void Parser::preprocess() {
           if (chr == '\r' || chr == '\n') break;
         }
         if (_pos < _len) _pos--;
-        _latex.replace(spos, _pos - spos, "");
+        parse_limits.replace(_latex, spos, _pos - spos, "");
         _len = _latex.length();
         _pos = spos;
         break;
@@ -700,6 +707,7 @@ void Parser::preprocess() {
 }
 
 void Parser::parse() {
+  ParseDepth depth;
   if (_len == 0) {
     if (_formula->_root == nullptr && !_arrayMode) _formula->add(sptrOf<EmptyAtom>());
     return;
@@ -707,6 +715,7 @@ void Parser::parse() {
 
   char ch;
   while (_pos < _len) {
+    parse_limits.spend();
     ch = _latex[_pos];
 
     switch (ch) {

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

@@ -13,18 +13,18 @@ macro(xarrow) {
     StackArgs::autoSpace(Formula(tp, args[1], false, tp.isMathMode())._root, false);
   const auto& under =
     StackArgs::autoSpace(Formula(tp, args[2], false, tp.isMathMode())._root, false);
-  const auto stack = new StackAtom(nullptr, over, under);
+  const auto stack = sptrOf<StackAtom>(nullptr, over, under);
   const auto& arrow = sptrOf<ExtensibleAtom>(
     name,
     // capture raw pointer to avoid cycle reference
-    [stack](const Env& env) -> float {
+    [stack = stack.get()](const Env& env) -> float {
       return stack->getMaxWidth() + Units::fsize(UnitType::ex, 1.f, env);
     },
     false
   );
   arrow->_type = AtomType::relation;
   stack->setBaseAtom(arrow);
-  return sptr<StackAtom>(stack);
+  return stack;
 }
 
 macro(left) {
@@ -45,12 +45,12 @@ macro(left) {
     return sptrOf<FencedAtom>(tf._root, sl->name(), sr->name(), tf.middle());
   }
 
-  auto* ra = new RowAtom();
+  auto ra = sptrOf<RowAtom>();
   ra->add(left);
   ra->add(Formula(tp, grep, false)._root);
   ra->add(right);
 
-  return sptr<Atom>(ra);
+  return ra;
 }
 
 }  // namespace microtex

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

@@ -11,68 +11,68 @@
 namespace microtex {
 
 inline macro(smallmatrixATATenv) {
-  auto* arr = new ArrayFormula();
-  Parser parser(tp.isPartial(), args[1], arr, false);
+  auto arr = sptrOf<ArrayFormula>();
+  Parser parser(tp.isPartial(), args[1], arr.get(), false);
   parser.parse();
   arr->checkDimensions();
-  return sptrOf<MatrixAtom>(tp.isPartial(), sptr<ArrayFormula>(arr), MatrixType::smallMatrix);
+  return sptrOf<MatrixAtom>(tp.isPartial(), arr, MatrixType::smallMatrix);
 }
 
 inline macro(matrixATATenv) {
-  auto* arr = new ArrayFormula();
-  Parser parser(tp.isPartial(), args[1], arr, false);
+  auto arr = sptrOf<ArrayFormula>();
+  Parser parser(tp.isPartial(), args[1], arr.get(), false);
   parser.parse();
   arr->checkDimensions();
-  return sptrOf<MatrixAtom>(tp.isPartial(), sptr<ArrayFormula>(arr), MatrixType::matrix);
+  return sptrOf<MatrixAtom>(tp.isPartial(), arr, MatrixType::matrix);
 }
 
 inline macro(arrayATATenv) {
-  auto* arr = new ArrayFormula();
-  Parser parser(tp.isPartial(), args[2], arr, false);
+  auto arr = sptrOf<ArrayFormula>();
+  Parser parser(tp.isPartial(), args[2], arr.get(), false);
   parser.parse();
   arr->checkDimensions();
-  return sptrOf<MatrixAtom>(tp.isPartial(), sptr<ArrayFormula>(arr), args[1], true);
+  return sptrOf<MatrixAtom>(tp.isPartial(), arr, args[1], true);
 }
 
 inline macro(alignATATenv) {
-  auto* arr = new ArrayFormula();
-  Parser parser(tp.isPartial(), args[1], arr, false);
+  auto arr = sptrOf<ArrayFormula>();
+  Parser parser(tp.isPartial(), args[1], arr.get(), false);
   parser.parse();
   arr->checkDimensions();
-  return sptrOf<MatrixAtom>(tp.isPartial(), sptr<ArrayFormula>(arr), MatrixType::align);
+  return sptrOf<MatrixAtom>(tp.isPartial(), arr, MatrixType::align);
 }
 
 inline macro(flalignATATenv) {
-  auto* arr = new ArrayFormula();
-  Parser parser(tp.isPartial(), args[1], arr, false);
+  auto arr = sptrOf<ArrayFormula>();
+  Parser parser(tp.isPartial(), args[1], arr.get(), false);
   parser.parse();
   arr->checkDimensions();
-  return sptrOf<MatrixAtom>(tp.isPartial(), sptr<ArrayFormula>(arr), MatrixType::flAlign);
+  return sptrOf<MatrixAtom>(tp.isPartial(), arr, MatrixType::flAlign);
 }
 
 inline macro(alignatATATenv) {
-  auto* arr = new ArrayFormula();
-  Parser par(tp.isPartial(), args[2], arr, false);
+  auto arr = sptrOf<ArrayFormula>();
+  Parser par(tp.isPartial(), args[2], arr.get(), false);
   par.parse();
   arr->checkDimensions();
   size_t n = 0;
   valueOf(args[1], n);
   if (arr->cols() != 2 * n) throw ex_parse("Bad number of equations in alignat environment!");
 
-  return sptrOf<MatrixAtom>(tp.isPartial(), sptr<ArrayFormula>(arr), MatrixType::alignAt);
+  return sptrOf<MatrixAtom>(tp.isPartial(), arr, MatrixType::alignAt);
 }
 
 inline macro(alignedATATenv) {
-  auto* arr = new ArrayFormula();
-  Parser p(tp.isPartial(), args[1], arr, false);
+  auto arr = sptrOf<ArrayFormula>();
+  Parser p(tp.isPartial(), args[1], arr.get(), false);
   p.parse();
   arr->checkDimensions();
-  return sptrOf<MatrixAtom>(tp.isPartial(), sptr<ArrayFormula>(arr), MatrixType::aligned);
+  return sptrOf<MatrixAtom>(tp.isPartial(), arr, MatrixType::aligned);
 }
 
 inline macro(alignedatATATenv) {
-  auto* arr = new ArrayFormula();
-  Parser p(tp.isPartial(), args[2], arr, false);
+  auto arr = sptrOf<ArrayFormula>();
+  Parser p(tp.isPartial(), args[2], arr.get(), false);
   p.parse();
   arr->checkDimensions();
   size_t n = 0;
@@ -81,12 +81,12 @@ inline macro(alignedatATATenv) {
     throw ex_parse("Bad number of equations in alignedat environment!");
   }
 
-  return sptrOf<MatrixAtom>(tp.isPartial(), sptr<ArrayFormula>(arr), MatrixType::alignedAt);
+  return sptrOf<MatrixAtom>(tp.isPartial(), arr, MatrixType::alignedAt);
 }
 
 inline macro(multlineATATenv) {
-  auto* arr = new ArrayFormula();
-  Parser p(tp.isPartial(), args[1], arr, false);
+  auto arr = sptrOf<ArrayFormula>();
+  Parser p(tp.isPartial(), args[1], arr.get(), false);
   p.parse();
   arr->checkDimensions();
   if (arr->cols() > 1) {
@@ -94,29 +94,29 @@ inline macro(multlineATATenv) {
   }
   if (arr->cols() == 0) return nullptr;
 
-  return sptrOf<MultlineAtom>(tp.isPartial(), sptr<ArrayFormula>(arr), MultiLineType::multiline);
+  return sptrOf<MultlineAtom>(tp.isPartial(), arr, MultiLineType::multiline);
 }
 
 inline macro(gatherATATenv) {
-  auto* arr = new ArrayFormula();
-  Parser p(tp.isPartial(), args[1], arr, false);
+  auto arr = sptrOf<ArrayFormula>();
+  Parser p(tp.isPartial(), args[1], arr.get(), false);
   p.parse();
   arr->checkDimensions();
   if (arr->cols() > 1) throw ex_parse("Requires exact one column in gather environment!");
   if (arr->cols() == 0) return nullptr;
 
-  return sptrOf<MultlineAtom>(tp.isPartial(), sptr<ArrayFormula>(arr), MultiLineType::gather);
+  return sptrOf<MultlineAtom>(tp.isPartial(), arr, MultiLineType::gather);
 }
 
 inline macro(gatheredATATenv) {
-  auto* arr = new ArrayFormula();
-  Parser p(tp.isPartial(), args[1], arr, false);
+  auto arr = sptrOf<ArrayFormula>();
+  Parser p(tp.isPartial(), args[1], arr.get(), false);
   p.parse();
   arr->checkDimensions();
   if (arr->cols() > 1) throw ex_parse("Requires exact one column in gathered environment!");
   if (arr->cols() == 0) return nullptr;
 
-  return sptrOf<MultlineAtom>(tp.isPartial(), sptr<ArrayFormula>(arr), MultiLineType::gathered);
+  return sptrOf<MultlineAtom>(tp.isPartial(), arr, MultiLineType::gathered);
 }
 
 inline macro(multicolumn) {

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

@@ -8,6 +8,7 @@
 #include <map>
 #include <string>
 #include <vector>
+#include "core/parse_limits.h"
 
 namespace microtex {
 
@@ -119,7 +120,7 @@ inline std::string& replaceAll(std::string& src, const std::string& from, const
   if (from.empty()) return src;
   size_t start = 0;
   while ((start = src.find(from, start)) != std::string::npos) {
-    src.replace(start, from.length(), to);
+    parse_limits.replace(src, start, from.length(), to);
     start += to.length();
   }
   return src;

package/native/vendor/microtex/lib/wrapper/byte_seq.cpp

@@ -3,6 +3,7 @@
 #include "wrapper/byte_seq.h"
 
 #include <cstdlib>
+#include <new>
 
 #include "utils/log.h"
 
@@ -10,11 +11,16 @@ namespace microtex {
 
 ByteSeq::ByteSeq() {
   _data = malloc(CHUNK_SIZE);
+  if (_data == nullptr) throw std::bad_alloc();
   // the first 4 bytes is the bytes size used
   _index = 4;
   _capacity = CHUNK_SIZE;
 }
 
+ByteSeq::~ByteSeq() {
+  free(_data);
+}
+
 void ByteSeq::_put(const char* str) {
   auto l = sizeOf(str);
   strcpy((char*)_data + _index, str);
@@ -28,8 +34,11 @@ void ByteSeq::ensureCapacity(len_t required) {
 #ifdef HAVE_LOG
   logv("grow buffer, _capacity: %u, to be add: %u\n", _capacity, required);
 #endif
-  _data = realloc(_data, _capacity + CHUNK_SIZE);
-  _capacity += CHUNK_SIZE;
+  const auto capacity = _index + required + CHUNK_SIZE;
+  auto data = realloc(_data, capacity);
+  if (data == nullptr) throw std::bad_alloc();
+  _data = data;
+  _capacity = capacity;
 }
 
 void* ByteSeq::finish() {
@@ -38,7 +47,8 @@ void* ByteSeq::finish() {
 #endif
   auto ptr = (unsigned int*)_data;
   *ptr = _index;
-  return _data;
+  _data = nullptr;
+  return ptr;
 }
 
 }  // namespace microtex

package/native/vendor/microtex/lib/wrapper/byte_seq.h

@@ -52,6 +52,7 @@ public:
   no_copy_assign(ByteSeq);
 
   ByteSeq();
+  ~ByteSeq();
 
   template <typename T, typename... Ts>
   void put(T t, Ts... ts) {