Let depthGuard handle everything

Change-Id: I3887273aa0b4e88dd454099052db8ce3811b5d66
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/110524
Tested-by: Jenkins
Reviewed-by: Noel Grandin <noel.grandin@collabora.co.uk>

2 files changed, 8 insertions, 67 deletions

diff --git a/starmath/inc/parse.hxx b/starmath/inc/parse.hxx
index 6eb83500b3d3..88024572db82 100644
--- a/starmath/inc/parse.hxx
+++ b/starmath/inc/parse.hxx
@@ -112,8 +112,9 @@ class SmParser
             : m_rParseDepth(rParseDepth)
         {
             ++m_rParseDepth;
+            if(m_rParseDepth > DEPTH_LIMIT)
+                throw std::range_error("parser depth limit");
         }
-        bool TooDeep() const { return m_rParseDepth > DEPTH_LIMIT; }
         ~DepthProtect()
         {
             --m_rParseDepth;
diff --git a/starmath/source/parse.cxx b/starmath/source/parse.cxx
index 68aab9e8dc77..7584c712b96e 100644
--- a/starmath/source/parse.cxx
+++ b/starmath/source/parse.cxx
@@ -1182,8 +1182,6 @@ namespace
 std::unique_ptr<SmTableNode> SmParser::DoTable()
 {
     DepthProtect aDepthGuard(m_nParseDepth);
-    if (aDepthGuard.TooDeep())
-        throw std::range_error("parser depth limit");
 
     std::vector<std::unique_ptr<SmNode>> aLineArray;
     aLineArray.push_back(DoLine());
@@ -1202,8 +1200,6 @@ std::unique_ptr<SmNode> SmParser::DoAlign(bool bUseExtraSpaces)
     // parse alignment info (if any), then go on with rest of expression
 {
     DepthProtect aDepthGuard(m_nParseDepth);
-    if (aDepthGuard.TooDeep())
-        throw std::range_error("parser depth limit");
 
     std::unique_ptr<SmStructureNode> xSNode;
 
@@ -1232,8 +1228,6 @@ std::unique_ptr<SmNode> SmParser::DoAlign(bool bUseExtraSpaces)
 std::unique_ptr<SmNode> SmParser::DoLine()
 {
     DepthProtect aDepthGuard(m_nParseDepth);
-    if (aDepthGuard.TooDeep())
-        throw std::range_error("parser depth limit");
 
     std::vector<std::unique_ptr<SmNode>> ExpressionArray;
 
@@ -1264,8 +1258,6 @@ std::unique_ptr<SmNode> SmParser::DoLine()
 std::unique_ptr<SmNode> SmParser::DoExpression(bool bUseExtraSpaces)
 {
     DepthProtect aDepthGuard(m_nParseDepth);
-    if (aDepthGuard.TooDeep())
-        throw std::range_error("parser depth limit");
 
     std::vector<std::unique_ptr<SmNode>> RelationArray;
     RelationArray.push_back(DoRelation());
@@ -1289,8 +1281,6 @@ std::unique_ptr<SmNode> SmParser::DoExpression(bool bUseExtraSpaces)
 std::unique_ptr<SmNode> SmParser::DoRelation()
 {
     DepthProtect aDepthGuard(m_nParseDepth);
-    if (aDepthGuard.TooDeep())
-        throw std::range_error("parser depth limit");
 
     int nDepthLimit = m_nParseDepth;
 
@@ -1304,8 +1294,7 @@ std::unique_ptr<SmNode> SmParser::DoRelation()
         xFirst = std::move(xSNode);
 
         ++m_nParseDepth;
-        if (aDepthGuard.TooDeep())
-            throw std::range_error("parser depth limit");
+        DepthProtect bDepthGuard(m_nParseDepth);
     }
 
     m_nParseDepth = nDepthLimit;
@@ -1316,8 +1305,6 @@ std::unique_ptr<SmNode> SmParser::DoRelation()
 std::unique_ptr<SmNode> SmParser::DoSum()
 {
     DepthProtect aDepthGuard(m_nParseDepth);
-    if (aDepthGuard.TooDeep())
-        throw std::range_error("parser depth limit");
 
     auto xFirst = DoProduct();
     while (TokenInGroup(TG::Sum))
@@ -1334,8 +1321,6 @@ std::unique_ptr<SmNode> SmParser::DoSum()
 std::unique_ptr<SmNode> SmParser::DoProduct()
 {
     DepthProtect aDepthGuard(m_nParseDepth);
-    if (aDepthGuard.TooDeep())
-        throw std::range_error("parser depth limit");
 
     auto xFirst = DoPower();
 
@@ -1409,10 +1394,8 @@ std::unique_ptr<SmNode> SmParser::DoProduct()
 
 std::unique_ptr<SmNode> SmParser::DoSubSup(TG nActiveGroup, SmNode *pGivenNode)
 {
-    std::unique_ptr<SmNode> xGivenNode(pGivenNode);
     DepthProtect aDepthGuard(m_nParseDepth);
-    if (aDepthGuard.TooDeep())
-        throw std::range_error("parser depth limit");
+    std::unique_ptr<SmNode> xGivenNode(pGivenNode);
 
     assert(nActiveGroup == TG::Power || nActiveGroup == TG::Limit);
     assert(m_aCurToken.nGroup == nActiveGroup);
@@ -1485,9 +1468,8 @@ std::unique_ptr<SmNode> SmParser::DoSubSup(TG nActiveGroup, SmNode *pGivenNode)
 
 std::unique_ptr<SmNode> SmParser::DoSubSupEvaluate(SmNode *pGivenNode)
 {
-    std::unique_ptr<SmNode> xGivenNode(pGivenNode);
     DepthProtect aDepthGuard(m_nParseDepth);
-    if (aDepthGuard.TooDeep()) throw std::range_error("parser depth limit");
+    std::unique_ptr<SmNode> xGivenNode(pGivenNode);
 
     std::unique_ptr<SmSubSupNode> pNode(new SmSubSupNode(m_aCurToken));
     pNode->SetUseLimits(true);
@@ -1535,8 +1517,6 @@ std::unique_ptr<SmNode> SmParser::DoSubSupEvaluate(SmNode *pGivenNode)
 std::unique_ptr<SmNode> SmParser::DoOpSubSup()
 {
     DepthProtect aDepthGuard(m_nParseDepth);
-    if (aDepthGuard.TooDeep())
-        throw std::range_error("parser depth limit");
 
     // get operator symbol
     auto pNode = std::make_unique<SmMathSymbolNode>(m_aCurToken);
@@ -1551,8 +1531,6 @@ std::unique_ptr<SmNode> SmParser::DoOpSubSup()
 std::unique_ptr<SmNode> SmParser::DoPower()
 {
     DepthProtect aDepthGuard(m_nParseDepth);
-    if (aDepthGuard.TooDeep())
-        throw std::range_error("parser depth limit");
 
     // get body for sub- supscripts on top of stack
     std::unique_ptr<SmNode> xNode(DoTerm(false));
@@ -1565,8 +1543,6 @@ std::unique_ptr<SmNode> SmParser::DoPower()
 std::unique_ptr<SmBlankNode> SmParser::DoBlank()
 {
     DepthProtect aDepthGuard(m_nParseDepth);
-    if (aDepthGuard.TooDeep())
-        throw std::range_error("parser depth limit");
 
     assert(TokenInGroup(TG::Blank));
     std::unique_ptr<SmBlankNode> pBlankNode(new SmBlankNode(m_aCurToken));
@@ -1590,8 +1566,6 @@ std::unique_ptr<SmBlankNode> SmParser::DoBlank()
 std::unique_ptr<SmNode> SmParser::DoTerm(bool bGroupNumberIdent)
 {
     DepthProtect aDepthGuard(m_nParseDepth);
-    if (aDepthGuard.TooDeep())
-        throw std::range_error("parser depth limit");
 
     switch (m_aCurToken.eType)
     {
@@ -1820,8 +1794,6 @@ std::unique_ptr<SmNode> SmParser::DoTerm(bool bGroupNumberIdent)
 std::unique_ptr<SmNode> SmParser::DoEscape()
 {
     DepthProtect aDepthGuard(m_nParseDepth);
-    if (aDepthGuard.TooDeep())
-        throw std::range_error("parser depth limit");
 
     NextToken();
 
@@ -1860,8 +1832,6 @@ std::unique_ptr<SmNode> SmParser::DoEscape()
 std::unique_ptr<SmOperNode> SmParser::DoOperator()
 {
     DepthProtect aDepthGuard(m_nParseDepth);
-    if (aDepthGuard.TooDeep())
-        throw std::range_error("parser depth limit");
 
     assert(TokenInGroup(TG::Oper));
 
@@ -1883,8 +1853,6 @@ std::unique_ptr<SmOperNode> SmParser::DoOperator()
 std::unique_ptr<SmNode> SmParser::DoOper()
 {
     DepthProtect aDepthGuard(m_nParseDepth);
-    if (aDepthGuard.TooDeep())
-        throw std::range_error("parser depth limit");
 
     SmTokenType  eType (m_aCurToken.eType);
     std::unique_ptr<SmNode> pNode;
@@ -1941,8 +1909,6 @@ std::unique_ptr<SmNode> SmParser::DoOper()
 std::unique_ptr<SmStructureNode> SmParser::DoUnOper()
 {
     DepthProtect aDepthGuard(m_nParseDepth);
-    if (aDepthGuard.TooDeep())
-        throw std::range_error("parser depth limit");
 
     assert(TokenInGroup(TG::UnOper));
 
@@ -2030,8 +1996,6 @@ std::unique_ptr<SmStructureNode> SmParser::DoUnOper()
 std::unique_ptr<SmStructureNode> SmParser::DoAttribute()
 {
     DepthProtect aDepthGuard(m_nParseDepth);
-    if (aDepthGuard.TooDeep())
-        throw std::range_error("parser depth limit");
 
     assert(TokenInGroup(TG::Attribute));
 
@@ -2070,8 +2034,6 @@ std::unique_ptr<SmStructureNode> SmParser::DoAttribute()
 std::unique_ptr<SmStructureNode> SmParser::DoFontAttribute()
 {
     DepthProtect aDepthGuard(m_nParseDepth);
-    if (aDepthGuard.TooDeep())
-        throw std::range_error("parser depth limit");
 
     assert(TokenInGroup(TG::FontAttr));
 
@@ -2106,7 +2068,6 @@ std::unique_ptr<SmStructureNode> SmParser::DoFontAttribute()
 std::unique_ptr<SmStructureNode> SmParser::DoColor()
 {
     DepthProtect aDepthGuard(m_nParseDepth);
-    if (aDepthGuard.TooDeep()) throw std::range_error("parser depth limit");
 
     assert(m_aCurToken.eType == TCOLOR);
     NextTokenColor(false);
@@ -2185,8 +2146,6 @@ std::unique_ptr<SmStructureNode> SmParser::DoColor()
 std::unique_ptr<SmStructureNode> SmParser::DoFont()
 {
     DepthProtect aDepthGuard(m_nParseDepth);
-    if (aDepthGuard.TooDeep())
-        throw std::range_error("parser depth limit");
 
     assert(m_aCurToken.eType == TFONT);
 
@@ -2213,7 +2172,6 @@ std::unique_ptr<SmStructureNode> SmParser::DoFont()
 std::unique_ptr<SmStructureNode> SmParser::DoFontSize()
 {
     DepthProtect aDepthGuard(m_nParseDepth);
-    if (aDepthGuard.TooDeep()) throw std::range_error("parser depth limit");
     std::unique_ptr<SmFontNode> pFontNode(new SmFontNode(m_aCurToken));
     NextTokenFontSize();
     FontSizeType Type;
@@ -2264,8 +2222,6 @@ std::unique_ptr<SmStructureNode> SmParser::DoFontSize()
 std::unique_ptr<SmStructureNode> SmParser::DoBrace()
 {
     DepthProtect aDepthGuard(m_nParseDepth);
-    if (aDepthGuard.TooDeep())
-        throw std::range_error("parser depth limit");
 
     assert(m_aCurToken.eType == TLEFT  ||  TokenInGroup(TG::LBrace));
 
@@ -2354,8 +2310,6 @@ std::unique_ptr<SmStructureNode> SmParser::DoBrace()
 std::unique_ptr<SmBracebodyNode> SmParser::DoBracebody(bool bIsLeftRight)
 {
     DepthProtect aDepthGuard(m_nParseDepth);
-    if (aDepthGuard.TooDeep())
-        throw std::range_error("parser depth limit");
 
     auto pBody = std::make_unique<SmBracebodyNode>(m_aCurToken);
 
@@ -2403,10 +2357,9 @@ std::unique_ptr<SmBracebodyNode> SmParser::DoBracebody(bool bIsLeftRight)
 
 std::unique_ptr<SmNode> SmParser::DoEvaluate()
 {
-
-    // Checkout depth and create node
     DepthProtect aDepthGuard(m_nParseDepth);
-    if (aDepthGuard.TooDeep()) throw std::range_error("parser depth limit");
+
+    // Create node
     std::unique_ptr<SmStructureNode> xSNode(new SmBraceNode(m_aCurToken));
     SmToken aToken( TRLINE, MS_VERTLINE, "evaluate", TG::RBrace, 5);
     aToken.nRow = m_aCurToken.nRow;
@@ -2441,7 +2394,7 @@ std::unique_ptr<SmNode> SmParser::DoEvaluate()
 std::unique_ptr<SmTextNode> SmParser::DoFunction()
 {
     DepthProtect aDepthGuard(m_nParseDepth);
-    if (aDepthGuard.TooDeep()) throw std::range_error("parser depth limit");
+
     if( m_aCurToken.eType == TFUNC )
     {
         NextToken();    // skip "FUNC"-statement
@@ -2456,8 +2409,6 @@ std::unique_ptr<SmTextNode> SmParser::DoFunction()
 std::unique_ptr<SmTableNode> SmParser::DoBinom()
 {
     DepthProtect aDepthGuard(m_nParseDepth);
-    if (aDepthGuard.TooDeep())
-        throw std::range_error("parser depth limit");
 
     auto xSNode = std::make_unique<SmTableNode>(m_aCurToken);
 
@@ -2472,7 +2423,6 @@ std::unique_ptr<SmTableNode> SmParser::DoBinom()
 std::unique_ptr<SmBinVerNode> SmParser::DoFrac()
 {
     DepthProtect aDepthGuard(m_nParseDepth);
-    if (aDepthGuard.TooDeep()) throw std::range_error("parser depth limit");
 
     std::unique_ptr<SmBinVerNode> xSNode = std::make_unique<SmBinVerNode>(m_aCurToken);
     std::unique_ptr<SmNode> xOper = std::make_unique<SmRectangleNode>(m_aCurToken);
@@ -2488,8 +2438,6 @@ std::unique_ptr<SmBinVerNode> SmParser::DoFrac()
 std::unique_ptr<SmStructureNode> SmParser::DoStack()
 {
     DepthProtect aDepthGuard(m_nParseDepth);
-    if (aDepthGuard.TooDeep())
-        throw std::range_error("parser depth limit");
 
     std::unique_ptr<SmStructureNode> xSNode(new SmTableNode(m_aCurToken));
     NextToken();
@@ -2515,8 +2463,6 @@ std::unique_ptr<SmStructureNode> SmParser::DoStack()
 std::unique_ptr<SmStructureNode> SmParser::DoMatrix()
 {
     DepthProtect aDepthGuard(m_nParseDepth);
-    if (aDepthGuard.TooDeep())
-        throw std::range_error("parser depth limit");
 
     std::unique_ptr<SmMatrixNode> xMNode(new SmMatrixNode(m_aCurToken));
     NextToken();
@@ -2572,8 +2518,6 @@ std::unique_ptr<SmStructureNode> SmParser::DoMatrix()
 std::unique_ptr<SmSpecialNode> SmParser::DoSpecial()
 {
     DepthProtect aDepthGuard(m_nParseDepth);
-    if (aDepthGuard.TooDeep())
-        throw std::range_error("parser depth limit");
 
     bool bReplace = false;
     OUString &rName = m_aCurToken.aText;
@@ -2618,8 +2562,6 @@ std::unique_ptr<SmSpecialNode> SmParser::DoSpecial()
 std::unique_ptr<SmGlyphSpecialNode> SmParser::DoGlyphSpecial()
 {
     DepthProtect aDepthGuard(m_nParseDepth);
-    if (aDepthGuard.TooDeep())
-        throw std::range_error("parser depth limit");
 
     auto pNode = std::make_unique<SmGlyphSpecialNode>(m_aCurToken);
     NextToken();
@@ -2629,8 +2571,6 @@ std::unique_ptr<SmGlyphSpecialNode> SmParser::DoGlyphSpecial()
 std::unique_ptr<SmExpressionNode> SmParser::DoError(SmParseError eError)
 {
     DepthProtect aDepthGuard(m_nParseDepth);
-    if (aDepthGuard.TooDeep())
-        throw std::range_error("parser depth limit");
 
     // Identify error message
     OUStringBuffer sStrBuf(128);