commit bdf41d8aeb53a298780f3633a76d71598a695bab
author Takeshi Abe <tabe@fixedpoint.jp> Tue Mar 21 17:31:14 2017 +0900
committer Takeshi Abe <tabe@fixedpoint.jp> Wed Mar 22 01:34:45 2017 +0000
tree 1ddce5285b8e4eedd3f1fbf75691f77f8291e361
parent d0740605fcd6f2f65f78f1ac8a05bd641edc6a76

starmath: Make DoSubSup() return SmNode by taking another node

as an argument, not from the top of the stack.
Because no token belongs to groups TG::Limit and TG::Power at
the same time, we can replace TokenInGroup() with direct comparison
with each group.

Change-Id: I44882ab40f59c4de1c0e2cbbdc354e43de926ab1
Reviewed-on: https://gerrit.libreoffice.org/35500
Tested-by: Jenkins <ci@libreoffice.org>
Reviewed-by: Takeshi Abe <tabe@fixedpoint.jp>

starmath/inc/parse.hxx

diff --git a/starmath/inc/parse.hxx b/starmath/inc/parse.hxx
index b4dc0a1..1b96c15 100644
--- a/starmath/inc/parse.hxx
+++ b/starmath/inc/parse.hxx
@@ -67,14 +67,14 @@ class SmParser
    void    DoRelation();
    void    DoSum();
    void    DoProduct();
    void    DoSubSup(TG nActiveGroup);
    SmNode *DoSubSup(TG nActiveGroup, SmNode *pGivenNode);
    void    DoOpSubSup();
    void    DoPower();
    SmBlankNode *DoBlank();
    SmNode *DoTerm(bool bGroupNumberIdent);
    SmNode *DoEscape();
    SmOperNode *DoOperator();
    void    DoOper();
    SmNode *DoOper();
    SmStructureNode *DoUnOper();
    void    DoAlign();
    SmStructureNode *DoFontAttribut();

starmath/source/parse.cxx

diff --git a/starmath/source/parse.cxx b/starmath/source/parse.cxx
index a4c390d..b9f7fde 100644
--- a/starmath/source/parse.cxx
+++ b/starmath/source/parse.cxx
@@ -1171,14 +1171,10 @@ void SmParser::DoProduct()
    }
}

void SmParser::DoSubSup(TG nActiveGroup)
SmNode *SmParser::DoSubSup(TG nActiveGroup, SmNode *pGivenNode)
{
    OSL_ENSURE(nActiveGroup == TG::Power  ||  nActiveGroup == TG::Limit,
               "Sm: wrong token group");

    if (!TokenInGroup(nActiveGroup))
        // already finish
        return;
    assert(nActiveGroup == TG::Power || nActiveGroup == TG::Limit);
    assert(m_aCurToken.nGroup == nActiveGroup);

    std::unique_ptr<SmSubSupNode> pNode(new SmSubSupNode(m_aCurToken));
    //! Of course 'm_aCurToken' is just the first sub-/supscript token.
@@ -1190,7 +1186,7 @@ void SmParser::DoSubSup(TG nActiveGroup)

    // initialize subnodes array
    SmNodeArray aSubNodes(1 + SUBSUP_NUM_ENTRIES, nullptr);
    aSubNodes[0] = popOrZero(m_aNodeStack);
    aSubNodes[0] = pGivenNode;

    // process all sub-/supscripts
    int  nIndex = 0;
@@ -1232,26 +1228,31 @@ void SmParser::DoSubSup(TG nActiveGroup)
    }

    pNode->SetSubNodes(aSubNodes);
    m_aNodeStack.push_front(std::move(pNode));
    return pNode.release();
}

void SmParser::DoOpSubSup()
{
    // push operator symbol
    m_aNodeStack.push_front(o3tl::make_unique<SmMathSymbolNode>(m_aCurToken));
    // get operator symbol
    auto pNode = o3tl::make_unique<SmMathSymbolNode>(m_aCurToken);
    // skip operator token
    NextToken();
    // get sub- supscripts if any
    if (TokenInGroup(TG::Power))
        DoSubSup(TG::Power);
    if (m_aCurToken.nGroup == TG::Power)
        m_aNodeStack.emplace_front(DoSubSup(TG::Power, pNode.release()));
    else
        m_aNodeStack.push_front(std::move(pNode));
}

void SmParser::DoPower()
{
    // get body for sub- supscripts on top of stack
    m_aNodeStack.emplace_front(DoTerm(false));
    SmNode *pNode = DoTerm(false);

    DoSubSup(TG::Power);
    if (m_aCurToken.nGroup == TG::Power)
        m_aNodeStack.emplace_front(DoSubSup(TG::Power, pNode));
    else
        m_aNodeStack.emplace_front(pNode);
}

SmBlankNode *SmParser::DoBlank()
@@ -1544,12 +1545,12 @@ SmOperNode *SmParser::DoOperator()

    auto pSNode = o3tl::make_unique<SmOperNode>(m_aCurToken);

    // put operator on top of stack
    DoOper();
    // get operator
    SmNode *pOperator = DoOper();

    if (TokenInGroup(TG::Limit) || TokenInGroup(TG::Power))
        DoSubSup(m_aCurToken.nGroup);
    SmNode *pOperator = popOrZero(m_aNodeStack);
    if ( m_aCurToken.nGroup == TG::Limit ||
         m_aCurToken.nGroup == TG::Power )
        pOperator = DoSubSup(m_aCurToken.nGroup, pOperator);

    // get argument
    DoPower();
@@ -1558,7 +1559,7 @@ SmOperNode *SmParser::DoOperator()
    return pSNode.release();
}

void SmParser::DoOper()
SmNode *SmParser::DoOper()
{
    SmTokenType  eType (m_aCurToken.eType);
    std::unique_ptr<SmNode> pNode;
@@ -1607,9 +1608,9 @@ void SmParser::DoOper()
        default :
            assert(false && "unknown case");
    }
    m_aNodeStack.push_front(std::move(pNode));

    NextToken();
    return pNode.release();
}

SmStructureNode *SmParser::DoUnOper()