convert TG constants to scoped enum

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

6 files changed, 379 insertions, 373 deletions

diff --git a/starmath/inc/parse.hxx b/starmath/inc/parse.hxx
index 34194de3b55e..3ebeb2c1e2ee 100644
--- a/starmath/inc/parse.hxx
+++ b/starmath/inc/parse.hxx
@@ -56,7 +56,7 @@ class SmParser
     sal_Int32       GetTokenIndex() const   { return m_nTokenIndex; }
     void            Replace( sal_Int32 nPos, sal_Int32 nLen, const OUString &rText );
 
-    inline bool     TokenInGroup( sal_uLong nGroup );
+    inline bool     TokenInGroup( TG nGroup );
 
     // grammar
     void    DoTable();
@@ -65,7 +65,7 @@ class SmParser
     void    DoRelation();
     void    DoSum();
     void    DoProduct();
-    void    DoSubSup(sal_uLong nActiveGroup);
+    void    DoSubSup(TG nActiveGroup);
     void    DoOpSubSup();
     void    DoPower();
     void    DoBlank();
@@ -119,9 +119,9 @@ public:
 };
 
 
-inline bool SmParser::TokenInGroup( sal_uLong nGroup)
+inline bool SmParser::TokenInGroup( TG nGroup)
 {
-    return (m_aCurToken.nGroup & nGroup) != 0;
+    return bool(m_aCurToken.nGroup & nGroup);
 }
 
 
diff --git a/starmath/inc/token.hxx b/starmath/inc/token.hxx
index dbc24d5c35e0..acb944a98afd 100644
--- a/starmath/inc/token.hxx
+++ b/starmath/inc/token.hxx
@@ -22,27 +22,33 @@
 #include <sal/types.h>
 #include <rtl/ustring.hxx>
 #include <tools/solar.h>
+#include <o3tl/typed_flags_set.hxx>
 
 // TokenGroups
-#define TGOPER          0x00000001
-#define TGRELATION      0x00000002
-#define TGSUM           0x00000004
-#define TGPRODUCT       0x00000008
-#define TGUNOPER        0x00000010
-#define TGPOWER         0x00000020
-#define TGATTRIBUT      0x00000040
-#define TGALIGN         0x00000080
-#define TGFUNCTION      0x00000100
-#define TGBLANK         0x00000200
-#define TGLBRACES       0x00000400
-#define TGRBRACES       0x00000800
-#define TGCOLOR         0x00001000
-#define TGFONT          0x00002000
-#define TGSTANDALONE    0x00004000
-#define TGDISCARDED     0x00008000
-#define TGLIMIT         0x00010000
-#define TGFONTATTR      0x00020000
-
+enum class TG {
+    NONE          = 0x000000,
+    Oper          = 0x000001,
+    Relation      = 0x000002,
+    Sum           = 0x000004,
+    Product       = 0x000008,
+    UnOper        = 0x000010,
+    Power         = 0x000020,
+    Attribute     = 0x000040,
+    Align         = 0x000080,
+    Function      = 0x000100,
+    Blank         = 0x000200,
+    LBrace        = 0x000400,
+    RBrace        = 0x000800,
+    Color         = 0x001000,
+    Font          = 0x002000,
+    Standalone    = 0x004000,
+    Discarded     = 0x008000,
+    Limit         = 0x010000,
+    FontAttr      = 0x020000
+};
+namespace o3tl {
+    template<> struct typed_flags<TG> : is_typed_flags<TG, 0x03ffff> {};
+}
 
 enum SmTokenType
 {
@@ -105,7 +111,7 @@ struct SmToken
     sal_Unicode cMathChar;
 
     // parse-help info
-    sal_uLong       nGroup;
+    TG              nGroup;
     sal_uInt16      nLevel;
 
     // token position
@@ -116,7 +122,7 @@ struct SmToken
     SmToken(SmTokenType eTokenType,
             sal_Unicode cMath,
             const sal_Char* pText,
-            sal_uLong nTokenGroup = 0,
+            TG nTokenGroup = TG::NONE,
             sal_uInt16 nTokenLevel = 0);
 };
 
@@ -125,7 +131,7 @@ struct SmTokenTableEntry
     const sal_Char* pIdent;
     SmTokenType     eType;
     sal_Unicode     cMathChar;
-    sal_uLong       nGroup;
+    TG              nGroup;
     sal_uInt16      nLevel;
 };
 
diff --git a/starmath/source/cursor.cxx b/starmath/source/cursor.cxx
index 5146600fbbcd..58a2a63fc66e 100644
--- a/starmath/source/cursor.cxx
+++ b/starmath/source/cursor.cxx
@@ -537,7 +537,7 @@ void SmCursor::InsertSubSup(SmSubSup eSubSup) {
     SmSubSupNode* pSubSup;
     if(pSubject->GetType() != NSUBSUP){
         SmToken token;
-        token.nGroup = TGPOWER;
+        token.nGroup = TG::Power;
         pSubSup = new SmSubSupNode(token);
         pSubSup->SetBody(pSubject);
         *(--it) = pSubSup;
@@ -612,7 +612,7 @@ bool SmCursor::InsertLimit(SmSubSup eSubSup) {
         pSubSup = static_cast<SmSubSupNode*>(pSubject->GetSubNode(0));
     else { //if not create a new SmSubSupNode
         SmToken token;
-        token.nGroup = TGLIMIT;
+        token.nGroup = TG::Limit;
         pSubSup = new SmSubSupNode(token);
         //Set it's body
         pSubSup->SetBody(pSubject->GetSubNode(0));
@@ -693,7 +693,7 @@ void SmCursor::InsertBrackets(SmBracketType eBracketType) {
     delete pSelectedNodesList;
 
     //Create SmBraceNode
-    SmToken aTok(TLEFT, '\0', "left", 0, 5);
+    SmToken aTok(TLEFT, '\0', "left", TG::NONE, 5);
     SmBraceNode *pBrace = new SmBraceNode(aTok);
     pBrace->SetScaleMode(SCALE_HEIGHT);
     SmNode *pLeft = CreateBracket(eBracketType, true),
@@ -719,67 +719,67 @@ SmNode *SmCursor::CreateBracket(SmBracketType eBracketType, bool bIsLeft) {
     if(bIsLeft){
         switch(eBracketType){
             case NoneBrackets:
-                aTok = SmToken(TNONE, '\0', "none", TGLBRACES | TGRBRACES, 0);
+                aTok = SmToken(TNONE, '\0', "none", TG::LBrace | TG::RBrace, 0);
                 break;
             case RoundBrackets:
-                aTok = SmToken(TLPARENT, MS_LPARENT, "(", TGLBRACES, 5);
+                aTok = SmToken(TLPARENT, MS_LPARENT, "(", TG::LBrace, 5);
                 break;
             case SquareBrackets:
-                aTok = SmToken(TLBRACKET, MS_LBRACKET, "[", TGLBRACES, 5);
+                aTok = SmToken(TLBRACKET, MS_LBRACKET, "[", TG::LBrace, 5);
                 break;
             case DoubleSquareBrackets:
-                aTok = SmToken(TLDBRACKET, MS_LDBRACKET, "ldbracket", TGLBRACES, 5);
+                aTok = SmToken(TLDBRACKET, MS_LDBRACKET, "ldbracket", TG::LBrace, 5);
                 break;
             case LineBrackets:
-                aTok = SmToken(TLLINE, MS_VERTLINE, "lline", TGLBRACES, 5);
+                aTok = SmToken(TLLINE, MS_VERTLINE, "lline", TG::LBrace, 5);
                 break;
             case DoubleLineBrackets:
-                aTok = SmToken(TLDLINE, MS_DVERTLINE, "ldline", TGLBRACES, 5);
+                aTok = SmToken(TLDLINE, MS_DVERTLINE, "ldline", TG::LBrace, 5);
                 break;
             case CurlyBrackets:
-                aTok = SmToken(TLBRACE, MS_LBRACE, "lbrace", TGLBRACES, 5);
+                aTok = SmToken(TLBRACE, MS_LBRACE, "lbrace", TG::LBrace, 5);
                 break;
             case AngleBrackets:
-                aTok = SmToken(TLANGLE, MS_LMATHANGLE, "langle", TGLBRACES, 5);
+                aTok = SmToken(TLANGLE, MS_LMATHANGLE, "langle", TG::LBrace, 5);
                 break;
             case CeilBrackets:
-                aTok = SmToken(TLCEIL, MS_LCEIL, "lceil", TGLBRACES, 5);
+                aTok = SmToken(TLCEIL, MS_LCEIL, "lceil", TG::LBrace, 5);
                 break;
             case FloorBrackets:
-                aTok = SmToken(TLFLOOR, MS_LFLOOR, "lfloor", TGLBRACES, 5);
+                aTok = SmToken(TLFLOOR, MS_LFLOOR, "lfloor", TG::LBrace, 5);
                 break;
         }
     } else {
         switch(eBracketType) {
             case NoneBrackets:
-                aTok = SmToken(TNONE, '\0', "none", TGLBRACES | TGRBRACES, 0);
+                aTok = SmToken(TNONE, '\0', "none", TG::LBrace | TG::RBrace, 0);
                 break;
             case RoundBrackets:
-                aTok = SmToken(TRPARENT, MS_RPARENT, ")", TGRBRACES, 5);
+                aTok = SmToken(TRPARENT, MS_RPARENT, ")", TG::RBrace, 5);
                 break;
             case SquareBrackets:
-                aTok = SmToken(TRBRACKET, MS_RBRACKET, "]", TGRBRACES, 5);
+                aTok = SmToken(TRBRACKET, MS_RBRACKET, "]", TG::RBrace, 5);
                 break;
             case DoubleSquareBrackets:
-                aTok = SmToken(TRDBRACKET, MS_RDBRACKET, "rdbracket", TGRBRACES, 5);
+                aTok = SmToken(TRDBRACKET, MS_RDBRACKET, "rdbracket", TG::RBrace, 5);
                 break;
             case LineBrackets:
-                aTok = SmToken(TRLINE, MS_VERTLINE, "rline", TGRBRACES, 5);
+                aTok = SmToken(TRLINE, MS_VERTLINE, "rline", TG::RBrace, 5);
                 break;
             case DoubleLineBrackets:
-                aTok = SmToken(TRDLINE, MS_DVERTLINE, "rdline", TGRBRACES, 5);
+                aTok = SmToken(TRDLINE, MS_DVERTLINE, "rdline", TG::RBrace, 5);
                 break;
             case CurlyBrackets:
-                aTok = SmToken(TRBRACE, MS_RBRACE, "rbrace", TGRBRACES, 5);
+                aTok = SmToken(TRBRACE, MS_RBRACE, "rbrace", TG::RBrace, 5);
                 break;
             case AngleBrackets:
-                aTok = SmToken(TRANGLE, MS_RMATHANGLE, "rangle", TGRBRACES, 5);
+                aTok = SmToken(TRANGLE, MS_RMATHANGLE, "rangle", TG::RBrace, 5);
                 break;
             case CeilBrackets:
-                aTok = SmToken(TRCEIL, MS_RCEIL, "rceil", TGRBRACES, 5);
+                aTok = SmToken(TRCEIL, MS_RCEIL, "rceil", TG::RBrace, 5);
                 break;
             case FloorBrackets:
-                aTok = SmToken(TRFLOOR, MS_RFLOOR, "rfloor", TGRBRACES, 5);
+                aTok = SmToken(TRFLOOR, MS_RFLOOR, "rfloor", TG::RBrace, 5);
                 break;
         }
     }
@@ -948,7 +948,7 @@ void SmCursor::InsertFraction() {
     pSelectedNodesList = nullptr;
 
     //Create new fraction
-    SmBinVerNode *pFrac = new SmBinVerNode(SmToken(TOVER, '\0', "over", TGPRODUCT, 0));
+    SmBinVerNode *pFrac = new SmBinVerNode(SmToken(TOVER, '\0', "over", TG::Product, 0));
     SmNode *pRect = new SmRectangleNode(SmToken());
     pFrac->SetSubNodes(pNum, pRect, pDenom);
 
@@ -971,7 +971,7 @@ void SmCursor::InsertText(const OUString& aString)
     SmToken token;
     token.eType = TIDENT;
     token.cMathChar = '\0';
-    token.nGroup = 0;
+    token.nGroup = TG::NONE;
     token.nLevel = 5;
     token.aText = aString;
 
@@ -999,13 +999,13 @@ void SmCursor::InsertElement(SmFormulaElement element){
         case BlankElement:
         {
             SmToken token;
-            token.nGroup = TGBLANK;
+            token.nGroup = TG::Blank;
             token.aText = "~";
             pNewNode = new SmBlankNode(token);
         }break;
         case FactorialElement:
         {
-            SmToken token(TFACT, MS_FACT, "fact", TGUNOPER, 5);
+            SmToken token(TFACT, MS_FACT, "fact", TG::UnOper, 5);
             pNewNode = new SmMathSymbolNode(token);
         }break;
         case PlusElement:
@@ -1013,7 +1013,7 @@ void SmCursor::InsertElement(SmFormulaElement element){
             SmToken token;
             token.eType = TPLUS;
             token.cMathChar = MS_PLUS;
-            token.nGroup = TGUNOPER | TGSUM;
+            token.nGroup = TG::UnOper | TG::Sum;
             token.nLevel = 5;
             token.aText = "+";
             pNewNode = new SmMathSymbolNode(token);
@@ -1023,7 +1023,7 @@ void SmCursor::InsertElement(SmFormulaElement element){
             SmToken token;
             token.eType = TMINUS;
             token.cMathChar = MS_MINUS;
-            token.nGroup = TGUNOPER | TGSUM;
+            token.nGroup = TG::UnOper | TG::Sum;
             token.nLevel = 5;
             token.aText = "-";
             pNewNode = new SmMathSymbolNode(token);
@@ -1033,7 +1033,7 @@ void SmCursor::InsertElement(SmFormulaElement element){
             SmToken token;
             token.eType = TCDOT;
             token.cMathChar = MS_CDOT;
-            token.nGroup = TGPRODUCT;
+            token.nGroup = TG::Product;
             token.aText = "cdot";
             pNewNode = new SmMathSymbolNode(token);
         }break;
@@ -1042,7 +1042,7 @@ void SmCursor::InsertElement(SmFormulaElement element){
             SmToken token;
             token.eType = TASSIGN;
             token.cMathChar = MS_ASSIGN;
-            token.nGroup = TGRELATION;
+            token.nGroup = TG::Relation;
             token.aText = "=";
             pNewNode = new SmMathSymbolNode(token);
         }break;
@@ -1051,7 +1051,7 @@ void SmCursor::InsertElement(SmFormulaElement element){
             SmToken token;
             token.eType = TLT;
             token.cMathChar = MS_LT;
-            token.nGroup = TGRELATION;
+            token.nGroup = TG::Relation;
             token.aText = "<";
             pNewNode = new SmMathSymbolNode(token);
         }break;
@@ -1060,7 +1060,7 @@ void SmCursor::InsertElement(SmFormulaElement element){
             SmToken token;
             token.eType = TGT;
             token.cMathChar = MS_GT;
-            token.nGroup = TGRELATION;
+            token.nGroup = TG::Relation;
             token.aText = ">";
             pNewNode = new SmMathSymbolNode(token);
         }break;
@@ -1069,7 +1069,7 @@ void SmCursor::InsertElement(SmFormulaElement element){
             SmToken token;
             token.eType = TTEXT;
             token.cMathChar = MS_PERCENT;
-            token.nGroup = 0;
+            token.nGroup = TG::NONE;
             token.aText = "\"%\"";
             pNewNode = new SmMathSymbolNode(token);
         }break;
@@ -1102,7 +1102,7 @@ void SmCursor::InsertSpecial(const OUString& _aString)
     SmToken token;
     token.eType = TSPECIAL;
     token.cMathChar = '\0';
-    token.nGroup = 0;
+    token.nGroup = TG::NONE;
     token.nLevel = 5;
     token.aText = aString;
     SmSpecialNode* pSpecial = new SmSpecialNode(token);
@@ -1364,7 +1364,7 @@ void SmCursor::FinishEdit(SmNodeList* pLineList,
        nParentIndex == 0 &&
        entries > 1) {
         //Wrap pLine in scalable round brackets
-        SmToken aTok(TLEFT, '\0', "left", 0, 5);
+        SmToken aTok(TLEFT, '\0', "left", TG::NONE, 5);
         SmBraceNode *pBrace = new SmBraceNode(aTok);
         pBrace->SetScaleMode(SCALE_HEIGHT);
         SmNode *pLeft  = CreateBracket(RoundBrackets, true),
@@ -1684,15 +1684,15 @@ bool SmNodeListParser::IsOperator(const SmToken &token) {
 }
 
 bool SmNodeListParser::IsRelationOperator(const SmToken &token) {
-    return token.nGroup & TGRELATION;
+    return bool(token.nGroup & TG::Relation);
 }
 
 bool SmNodeListParser::IsSumOperator(const SmToken &token) {
-    return token.nGroup & TGSUM;
+    return bool(token.nGroup & TG::Sum);
 }
 
 bool SmNodeListParser::IsProductOperator(const SmToken &token) {
-    return token.nGroup & TGPRODUCT &&
+    return token.nGroup & TG::Product &&
            token.eType != TWIDESLASH &&
            token.eType != TWIDEBACKSLASH &&
            token.eType != TUNDERBRACE &&
@@ -1701,7 +1701,7 @@ bool SmNodeListParser::IsProductOperator(const SmToken &token) {
 }
 
 bool SmNodeListParser::IsUnaryOperator(const SmToken &token) {
-    return  token.nGroup & TGUNOPER &&
+    return  token.nGroup & TG::UnOper &&
             (token.eType == TPLUS ||
              token.eType == TMINUS ||
              token.eType == TPLUSMINUS ||
diff --git a/starmath/source/mathmlexport.cxx b/starmath/source/mathmlexport.cxx
index b14dd1fa6939..b17523675ec1 100644
--- a/starmath/source/mathmlexport.cxx
+++ b/starmath/source/mathmlexport.cxx
@@ -604,7 +604,7 @@ void SmXMLExport::ExportLine(const SmNode *pNode, int nLevel)
 
 void SmXMLExport::ExportBinaryHorizontal(const SmNode *pNode, int nLevel)
 {
-    sal_uLong nGroup = pNode->GetToken().nGroup;
+    TG nGroup = pNode->GetToken().nGroup;
 
     SvXMLElementExport* pRow = new SvXMLElementExport(*this,
         XML_NAMESPACE_MATH, XML_MROW, true, true);
diff --git a/starmath/source/node.cxx b/starmath/source/node.cxx
index c5ae4135357f..58f4df3769ee 100644
--- a/starmath/source/node.cxx
+++ b/starmath/source/node.cxx
@@ -1260,7 +1260,7 @@ void SmSubSupNode::Arrange(OutputDevice &rDev, const SmFormat &rFormat)
             continue;
 
         // switch position of limits if we are in textmode
-        if (rFormat.IsTextmode()  &&  (GetToken().nGroup & TGLIMIT))
+        if (rFormat.IsTextmode()  &&  (GetToken().nGroup & TG::Limit))
             switch (eSubSup)
             {   case CSUB:  eSubSup = RSUB;     break;
                 case CSUP:  eSubSup = RSUP;     break;
@@ -2250,7 +2250,7 @@ void SmTextNode::AdjustFontDesc()
     else {
         SmTokenType nTok;
         const SmTokenTableEntry *pEntry = SmParser::GetTokenTableEntry( aText );
-        if (pEntry && pEntry->nGroup == TGFUNCTION) {
+        if (pEntry && pEntry->nGroup == TG::Function) {
             nTok = pEntry->eType;
             nFontDesc = FNT_FUNCTION;
         } else {
diff --git a/starmath/source/parse.cxx b/starmath/source/parse.cxx
index 7ccf4424167d..b3bef505099f 100644
--- a/starmath/source/parse.cxx
+++ b/starmath/source/parse.cxx
@@ -38,7 +38,7 @@ using namespace ::com::sun::star::i18n;
 SmToken::SmToken()
     : eType(TUNKNOWN)
     , cMathChar('\0')
-    , nGroup(0)
+    , nGroup(TG::NONE)
     , nLevel(0)
     , nRow(0)
     , nCol(0)
@@ -48,7 +48,7 @@ SmToken::SmToken()
 SmToken::SmToken(SmTokenType eTokenType,
                  sal_Unicode cMath,
                  const sal_Char* pText,
-                 sal_uLong nTokenGroup,
+                 TG nTokenGroup,
                  sal_uInt16 nTokenLevel)
     : aText(OUString::createFromAscii(pText))
     , eType(eTokenType)
@@ -63,232 +63,232 @@ SmToken::SmToken(SmTokenType eTokenType,
 
 static const SmTokenTableEntry aTokenTable[] =
 {
-    { "Im" , TIM, MS_IM, TGSTANDALONE, 5 },
-    { "Re" , TRE, MS_RE, TGSTANDALONE, 5 },
-    { "abs", TABS, '\0', TGUNOPER, 13 },
-    { "arcosh", TACOSH, '\0', TGFUNCTION, 5 },
-    { "arcoth", TACOTH, '\0', TGFUNCTION, 5 },
-    { "acute", TACUTE, MS_ACUTE, TGATTRIBUT, 5 },
-    { "aleph" , TALEPH, MS_ALEPH, TGSTANDALONE, 5 },
-    { "alignb", TALIGNC, '\0', TGALIGN | TGDISCARDED, 0},
-    { "alignc", TALIGNC, '\0', TGALIGN, 0},
-    { "alignl", TALIGNL, '\0', TGALIGN, 0},
-    { "alignm", TALIGNC, '\0', TGALIGN | TGDISCARDED, 0},
-    { "alignr", TALIGNR, '\0', TGALIGN, 0},
-    { "alignt", TALIGNC, '\0', TGALIGN | TGDISCARDED, 0},
-    { "and", TAND, MS_AND, TGPRODUCT, 0},
-    { "approx", TAPPROX, MS_APPROX, TGRELATION, 0},
-    { "aqua", TAQUA, '\0', TGCOLOR, 0},
-    { "arccos", TACOS, '\0', TGFUNCTION, 5},
-    { "arccot", TACOT, '\0', TGFUNCTION, 5},
-    { "arcsin", TASIN, '\0', TGFUNCTION, 5},
-    { "arctan", TATAN, '\0', TGFUNCTION, 5},
-    { "arsinh", TASINH, '\0', TGFUNCTION, 5},
-    { "artanh", TATANH, '\0', TGFUNCTION, 5},
-    { "backepsilon" , TBACKEPSILON, MS_BACKEPSILON, TGSTANDALONE, 5},
-    { "bar", TBAR, MS_BAR, TGATTRIBUT, 5},
-    { "binom", TBINOM, '\0', 0, 5 },
-    { "black", TBLACK, '\0', TGCOLOR, 0},
-    { "blue", TBLUE, '\0', TGCOLOR, 0},
-    { "bold", TBOLD, '\0', TGFONTATTR, 5},
-    { "boper", TBOPER, '\0', TGPRODUCT, 0},
-    { "breve", TBREVE, MS_BREVE, TGATTRIBUT, 5},
-    { "bslash", TBACKSLASH, MS_BACKSLASH, TGPRODUCT, 0 },
-    { "cdot", TCDOT, MS_CDOT, TGPRODUCT, 0},
-    { "check", TCHECK, MS_CHECK, TGATTRIBUT, 5},
-    { "circ" , TCIRC, MS_CIRC, TGSTANDALONE, 5},
-    { "circle", TCIRCLE, MS_CIRCLE, TGATTRIBUT, 5},
-    { "color", TCOLOR, '\0', TGFONTATTR, 5},
-    { "coprod", TCOPROD, MS_COPROD, TGOPER, 5},
-    { "cos", TCOS, '\0', TGFUNCTION, 5},
-    { "cosh", TCOSH, '\0', TGFUNCTION, 5},
-    { "cot", TCOT, '\0', TGFUNCTION, 5},
-    { "coth", TCOTH, '\0', TGFUNCTION, 5},
-    { "csub", TCSUB, '\0', TGPOWER, 0},
-    { "csup", TCSUP, '\0', TGPOWER, 0},
-    { "cyan", TCYAN, '\0', TGCOLOR, 0},
-    { "dddot", TDDDOT, MS_DDDOT, TGATTRIBUT, 5},
-    { "ddot", TDDOT, MS_DDOT, TGATTRIBUT, 5},
-    { "def", TDEF, MS_DEF, TGRELATION, 0},
-    { "div", TDIV, MS_DIV, TGPRODUCT, 0},
-    { "divides", TDIVIDES, MS_LINE, TGRELATION, 0},
-    { "dlarrow" , TDLARROW, MS_DLARROW, TGSTANDALONE, 5},
-    { "dlrarrow" , TDLRARROW, MS_DLRARROW, TGSTANDALONE, 5},
-    { "dot", TDOT, MS_DOT, TGATTRIBUT, 5},
-    { "dotsaxis", TDOTSAXIS, MS_DOTSAXIS, TGSTANDALONE, 5}, // 5 to continue expression
-    { "dotsdiag", TDOTSDIAG, MS_DOTSUP, TGSTANDALONE, 5},
-    { "dotsdown", TDOTSDOWN, MS_DOTSDOWN, TGSTANDALONE, 5},
-    { "dotslow", TDOTSLOW, MS_DOTSLOW, TGSTANDALONE, 5},
-    { "dotsup", TDOTSUP, MS_DOTSUP, TGSTANDALONE, 5},
-    { "dotsvert", TDOTSVERT, MS_DOTSVERT, TGSTANDALONE, 5},
-    { "downarrow" , TDOWNARROW, MS_DOWNARROW, TGSTANDALONE, 5},
-    { "drarrow" , TDRARROW, MS_DRARROW, TGSTANDALONE, 5},
-    { "emptyset" , TEMPTYSET, MS_EMPTYSET, TGSTANDALONE, 5},
-    { "equiv", TEQUIV, MS_EQUIV, TGRELATION, 0},
-    { "exists", TEXISTS, MS_EXISTS, TGSTANDALONE, 5},
-    { "notexists", TNOTEXISTS, MS_NOTEXISTS, TGSTANDALONE, 5},
-    { "exp", TEXP, '\0', TGFUNCTION, 5},
-    { "fact", TFACT, MS_FACT, TGUNOPER, 5},
-    { "fixed", TFIXED, '\0', TGFONT, 0},
-    { "font", TFONT, '\0', TGFONTATTR, 5},
-    { "forall", TFORALL, MS_FORALL, TGSTANDALONE, 5},
-    { "from", TFROM, '\0', TGLIMIT, 0},
-    { "fuchsia", TFUCHSIA, '\0', TGCOLOR, 0},
-    { "func", TFUNC, '\0', TGFUNCTION, 5},
-    { "ge", TGE, MS_GE, TGRELATION, 0},
-    { "geslant", TGESLANT, MS_GESLANT, TGRELATION, 0 },
-    { "gg", TGG, MS_GG, TGRELATION, 0},
-    { "grave", TGRAVE, MS_GRAVE, TGATTRIBUT, 5},
-    { "gray", TGRAY, '\0', TGCOLOR, 0},
-    { "green", TGREEN, '\0', TGCOLOR, 0},
-    { "gt", TGT, MS_GT, TGRELATION, 0},
-    { "hat", THAT, MS_HAT, TGATTRIBUT, 5},
-    { "hbar" , THBAR, MS_HBAR, TGSTANDALONE, 5},
-    { "iiint", TIIINT, MS_IIINT, TGOPER, 5},
-    { "iint", TIINT, MS_IINT, TGOPER, 5},
-    { "in", TIN, MS_IN, TGRELATION, 0},
-    { "infinity" , TINFINITY, MS_INFINITY, TGSTANDALONE, 5},
-    { "infty" , TINFINITY, MS_INFINITY, TGSTANDALONE, 5},
-    { "int", TINT, MS_INT, TGOPER, 5},
-    { "intd", TINTD, MS_INT, TGUNOPER, 5},
-    { "intersection", TINTERSECT, MS_INTERSECT, TGPRODUCT, 0},
-    { "ital", TITALIC, '\0', TGFONTATTR, 5},
-    { "italic", TITALIC, '\0', TGFONTATTR, 5},
-    { "lambdabar" , TLAMBDABAR, MS_LAMBDABAR, TGSTANDALONE, 5},
-    { "langle", TLANGLE, MS_LMATHANGLE, TGLBRACES, 5},
-    { "lbrace", TLBRACE, MS_LBRACE, TGLBRACES, 5},
-    { "lceil", TLCEIL, MS_LCEIL, TGLBRACES, 5},
-    { "ldbracket", TLDBRACKET, MS_LDBRACKET, TGLBRACES, 5},
-    { "ldline", TLDLINE, MS_DVERTLINE, TGLBRACES, 5},
-    { "le", TLE, MS_LE, TGRELATION, 0},
-    { "left", TLEFT, '\0', 0, 5},
-    { "leftarrow" , TLEFTARROW, MS_LEFTARROW, TGSTANDALONE, 5},
-    { "leslant", TLESLANT, MS_LESLANT, TGRELATION, 0 },
-    { "lfloor", TLFLOOR, MS_LFLOOR, TGLBRACES, 5},
-    { "lim", TLIM, '\0', TGOPER, 5},
-    { "lime", TLIME, '\0', TGCOLOR, 0},
-    { "liminf", TLIMINF, '\0', TGOPER, 5},
-    { "limsup", TLIMSUP, '\0', TGOPER, 5},
-    { "lint", TLINT, MS_LINT, TGOPER, 5},
-    { "ll", TLL, MS_LL, TGRELATION, 0},
-    { "lline", TLLINE, MS_VERTLINE, TGLBRACES, 5},
-    { "llint", TLLINT, MS_LLINT, TGOPER, 5},
-    { "lllint", TLLLINT, MS_LLLINT, TGOPER, 5},
-    { "ln", TLN, '\0', TGFUNCTION, 5},
-    { "log", TLOG, '\0', TGFUNCTION, 5},
-    { "lsub", TLSUB, '\0', TGPOWER, 0},
-    { "lsup", TLSUP, '\0', TGPOWER, 0},
-    { "lt", TLT, MS_LT, TGRELATION, 0},
-    { "magenta", TMAGENTA, '\0', TGCOLOR, 0},
-    { "maroon", TMAROON, '\0', TGCOLOR, 0},
-    { "matrix", TMATRIX, '\0', 0, 5},
-    { "minusplus", TMINUSPLUS, MS_MINUSPLUS, TGUNOPER | TGSUM, 5},
-    { "mline", TMLINE, MS_VERTLINE, 0, 0},      //! not in TGRBRACES, Level 0
-    { "nabla", TNABLA, MS_NABLA, TGSTANDALONE, 5},
-    { "navy", TNAVY, '\0', TGCOLOR, 0},
-    { "nbold", TNBOLD, '\0', TGFONTATTR, 5},
-    { "ndivides", TNDIVIDES, MS_NDIVIDES, TGRELATION, 0},
-    { "neg", TNEG, MS_NEG, TGUNOPER, 5 },
-    { "neq", TNEQ, MS_NEQ, TGRELATION, 0},
-    { "newline", TNEWLINE, '\0', 0, 0},
-    { "ni", TNI, MS_NI, TGRELATION, 0},
-    { "nitalic", TNITALIC, '\0', TGFONTATTR, 5},
-    { "none", TNONE, '\0', TGLBRACES | TGRBRACES, 0},
-    { "nospace", TNOSPACE, '\0', TGSTANDALONE, 5},
-    { "notin", TNOTIN, MS_NOTIN, TGRELATION, 0},
-    { "nroot", TNROOT, MS_SQRT, TGUNOPER, 5},
-    { "nsubset", TNSUBSET, MS_NSUBSET, TGRELATION, 0 },
-    { "nsupset", TNSUPSET, MS_NSUPSET, TGRELATION, 0 },
-    { "nsubseteq", TNSUBSETEQ, MS_NSUBSETEQ, TGRELATION, 0 },
-    { "nsupseteq", TNSUPSETEQ, MS_NSUPSETEQ, TGRELATION, 0 },
-    { "odivide", TODIVIDE, MS_ODIVIDE, TGPRODUCT, 0},
-    { "odot", TODOT, MS_ODOT, TGPRODUCT, 0},
-    { "olive", TOLIVE, '\0', TGCOLOR, 0},
-    { "ominus", TOMINUS, MS_OMINUS, TGSUM, 0},
-    { "oper", TOPER, '\0', TGOPER, 5},
-    { "oplus", TOPLUS, MS_OPLUS, TGSUM, 0},
-    { "or", TOR, MS_OR, TGSUM, 0},
-    { "ortho", TORTHO, MS_ORTHO, TGRELATION, 0},
-    { "otimes", TOTIMES, MS_OTIMES, TGPRODUCT, 0},
-    { "over", TOVER, '\0', TGPRODUCT, 0},
-    { "overbrace", TOVERBRACE, MS_OVERBRACE, TGPRODUCT, 5},
-    { "overline", TOVERLINE, '\0', TGATTRIBUT, 5},
-    { "overstrike", TOVERSTRIKE, '\0', TGATTRIBUT, 5},
-    { "owns", TNI, MS_NI, TGRELATION, 0},
-    { "parallel", TPARALLEL, MS_DLINE, TGRELATION, 0},
-    { "partial", TPARTIAL, MS_PARTIAL, TGSTANDALONE, 5 },
-    { "phantom", TPHANTOM, '\0', TGFONTATTR, 5},
-    { "plusminus", TPLUSMINUS, MS_PLUSMINUS, TGUNOPER | TGSUM, 5},
-    { "prec", TPRECEDES, MS_PRECEDES, TGRELATION, 0 },
-    { "preccurlyeq", TPRECEDESEQUAL, MS_PRECEDESEQUAL, TGRELATION, 0 },
-    { "precsim", TPRECEDESEQUIV, MS_PRECEDESEQUIV, TGRELATION, 0 },
-    { "nprec", TNOTPRECEDES, MS_NOTPRECEDES, TGRELATION, 0 },
-    { "prod", TPROD, MS_PROD, TGOPER, 5},
-    { "prop", TPROP, MS_PROP, TGRELATION, 0},
-    { "purple", TPURPLE, '\0', TGCOLOR, 0},
-    { "rangle", TRANGLE, MS_RMATHANGLE, TGRBRACES, 0},  //! 0 to terminate expression
-    { "rbrace", TRBRACE, MS_RBRACE, TGRBRACES, 0},
-    { "rceil", TRCEIL, MS_RCEIL, TGRBRACES, 0},
-    { "rdbracket", TRDBRACKET, MS_RDBRACKET, TGRBRACES, 0},
-    { "rdline", TRDLINE, MS_DVERTLINE, TGRBRACES, 0},
-    { "red", TRED, '\0', TGCOLOR, 0},
-    { "rfloor", TRFLOOR, MS_RFLOOR, TGRBRACES, 0},  //! 0 to terminate expression
-    { "right", TRIGHT, '\0', 0, 0},
-    { "rightarrow" , TRIGHTARROW, MS_RIGHTARROW, TGSTANDALONE, 5},
-    { "rline", TRLINE, MS_VERTLINE, TGRBRACES, 0},  //! 0 to terminate expression
-    { "rsub", TRSUB, '\0', TGPOWER, 0},
-    { "rsup", TRSUP, '\0', TGPOWER, 0},
-    { "sans", TSANS, '\0', TGFONT, 0},
-    { "serif", TSERIF, '\0', TGFONT, 0},
-    { "setC" , TSETC, MS_SETC, TGSTANDALONE, 5},
-    { "setN" , TSETN, MS_SETN, TGSTANDALONE, 5},
-    { "setQ" , TSETQ, MS_SETQ, TGSTANDALONE, 5},
-    { "setR" , TSETR, MS_SETR, TGSTANDALONE, 5},
-    { "setZ" , TSETZ, MS_SETZ, TGSTANDALONE, 5},
-    { "setminus", TBACKSLASH, MS_BACKSLASH, TGPRODUCT, 0 },
-    { "silver", TSILVER, '\0', TGCOLOR, 0},
-    { "sim", TSIM, MS_SIM, TGRELATION, 0},
-    { "simeq", TSIMEQ, MS_SIMEQ, TGRELATION, 0},
-    { "sin", TSIN, '\0', TGFUNCTION, 5},
-    { "sinh", TSINH, '\0', TGFUNCTION, 5},
-    { "size", TSIZE, '\0', TGFONTATTR, 5},
-    { "slash", TSLASH, MS_SLASH, TGPRODUCT, 0 },
-    { "sqrt", TSQRT, MS_SQRT, TGUNOPER, 5},
-    { "stack", TSTACK, '\0', 0, 5},
-    { "sub", TRSUB, '\0', TGPOWER, 0},
-    { "subset", TSUBSET, MS_SUBSET, TGRELATION, 0},
-    { "succ", TSUCCEEDS, MS_SUCCEEDS, TGRELATION, 0 },
-    { "succcurlyeq", TSUCCEEDSEQUAL, MS_SUCCEEDSEQUAL, TGRELATION, 0 },
-    { "succsim", TSUCCEEDSEQUIV, MS_SUCCEEDSEQUIV, TGRELATION, 0 },
-    { "nsucc", TNOTSUCCEEDS, MS_NOTSUCCEEDS, TGRELATION, 0 },
-    { "subseteq", TSUBSETEQ, MS_SUBSETEQ, TGRELATION, 0},
-    { "sum", TSUM, MS_SUM, TGOPER, 5},
-    { "sup", TRSUP, '\0', TGPOWER, 0},
-    { "supset", TSUPSET, MS_SUPSET, TGRELATION, 0},
-    { "supseteq", TSUPSETEQ, MS_SUPSETEQ, TGRELATION, 0},
-    { "tan", TTAN, '\0', TGFUNCTION, 5},
-    { "tanh", TTANH, '\0', TGFUNCTION, 5},
-    { "teal", TTEAL, '\0', TGCOLOR, 0},
-    { "tilde", TTILDE, MS_TILDE, TGATTRIBUT, 5},
-    { "times", TTIMES, MS_TIMES, TGPRODUCT, 0},
-    { "to", TTO, '\0', TGLIMIT, 0},
-    { "toward", TTOWARD, MS_RIGHTARROW, TGRELATION, 0},
-    { "transl", TTRANSL, MS_TRANSL, TGRELATION, 0},
-    { "transr", TTRANSR, MS_TRANSR, TGRELATION, 0},
-    { "underbrace", TUNDERBRACE, MS_UNDERBRACE, TGPRODUCT, 5},
-    { "underline", TUNDERLINE, '\0', TGATTRIBUT, 5},
-    { "union", TUNION, MS_UNION, TGSUM, 0},
-    { "uoper", TUOPER, '\0', TGUNOPER, 5},
-    { "uparrow" , TUPARROW, MS_UPARROW, TGSTANDALONE, 5},
-    { "vec", TVEC, MS_VEC, TGATTRIBUT, 5},
-    { "white", TWHITE, '\0', TGCOLOR, 0},
-    { "widebslash", TWIDEBACKSLASH, MS_BACKSLASH, TGPRODUCT, 0 },
-    { "widehat", TWIDEHAT, MS_HAT, TGATTRIBUT, 5},
-    { "widetilde", TWIDETILDE, MS_TILDE, TGATTRIBUT, 5},
-    { "wideslash", TWIDESLASH, MS_SLASH, TGPRODUCT, 0 },
-    { "widevec", TWIDEVEC, MS_VEC, TGATTRIBUT, 5},
-    { "wp" , TWP, MS_WP, TGSTANDALONE, 5},
-    { "yellow", TYELLOW, '\0', TGCOLOR, 0}
+    { "Im" , TIM, MS_IM, TG::Standalone, 5 },
+    { "Re" , TRE, MS_RE, TG::Standalone, 5 },
+    { "abs", TABS, '\0', TG::UnOper, 13 },
+    { "arcosh", TACOSH, '\0', TG::Function, 5 },
+    { "arcoth", TACOTH, '\0', TG::Function, 5 },
+    { "acute", TACUTE, MS_ACUTE, TG::Attribute, 5 },
+    { "aleph" , TALEPH, MS_ALEPH, TG::Standalone, 5 },
+    { "alignb", TALIGNC, '\0', TG::Align | TG::Discarded, 0},
+    { "alignc", TALIGNC, '\0', TG::Align, 0},
+    { "alignl", TALIGNL, '\0', TG::Align, 0},
+    { "alignm", TALIGNC, '\0', TG::Align | TG::Discarded, 0},
+    { "alignr", TALIGNR, '\0', TG::Align, 0},
+    { "alignt", TALIGNC, '\0', TG::Align | TG::Discarded, 0},
+    { "and", TAND, MS_AND, TG::Product, 0},
+    { "approx", TAPPROX, MS_APPROX, TG::Relation, 0},
+    { "aqua", TAQUA, '\0', TG::Color, 0},
+    { "arccos", TACOS, '\0', TG::Function, 5},
+    { "arccot", TACOT, '\0', TG::Function, 5},
+    { "arcsin", TASIN, '\0', TG::Function, 5},
+    { "arctan", TATAN, '\0', TG::Function, 5},
+    { "arsinh", TASINH, '\0', TG::Function, 5},
+    { "artanh", TATANH, '\0', TG::Function, 5},
+    { "backepsilon" , TBACKEPSILON, MS_BACKEPSILON, TG::Standalone, 5},
+    { "bar", TBAR, MS_BAR, TG::Attribute, 5},
+    { "binom", TBINOM, '\0', TG::NONE, 5 },
+    { "black", TBLACK, '\0', TG::Color, 0},
+    { "blue", TBLUE, '\0', TG::Color, 0},
+    { "bold", TBOLD, '\0', TG::FontAttr, 5},
+    { "boper", TBOPER, '\0', TG::Product, 0},
+    { "breve", TBREVE, MS_BREVE, TG::Attribute, 5},
+    { "bslash", TBACKSLASH, MS_BACKSLASH, TG::Product, 0 },
+    { "cdot", TCDOT, MS_CDOT, TG::Product, 0},
+    { "check", TCHECK, MS_CHECK, TG::Attribute, 5},
+    { "circ" , TCIRC, MS_CIRC, TG::Standalone, 5},
+    { "circle", TCIRCLE, MS_CIRCLE, TG::Attribute, 5},
+    { "color", TCOLOR, '\0', TG::FontAttr, 5},
+    { "coprod", TCOPROD, MS_COPROD, TG::Oper, 5},
+    { "cos", TCOS, '\0', TG::Function, 5},
+    { "cosh", TCOSH, '\0', TG::Function, 5},
+    { "cot", TCOT, '\0', TG::Function, 5},
+    { "coth", TCOTH, '\0', TG::Function, 5},
+    { "csub", TCSUB, '\0', TG::Power, 0},
+    { "csup", TCSUP, '\0', TG::Power, 0},
+    { "cyan", TCYAN, '\0', TG::Color, 0},
+    { "dddot", TDDDOT, MS_DDDOT, TG::Attribute, 5},
+    { "ddot", TDDOT, MS_DDOT, TG::Attribute, 5},
+    { "def", TDEF, MS_DEF, TG::Relation, 0},
+    { "div", TDIV, MS_DIV, TG::Product, 0},
+    { "divides", TDIVIDES, MS_LINE, TG::Relation, 0},
+    { "dlarrow" , TDLARROW, MS_DLARROW, TG::Standalone, 5},
+    { "dlrarrow" , TDLRARROW, MS_DLRARROW, TG::Standalone, 5},
+    { "dot", TDOT, MS_DOT, TG::Attribute, 5},
+    { "dotsaxis", TDOTSAXIS, MS_DOTSAXIS, TG::Standalone, 5}, // 5 to continue expression
+    { "dotsdiag", TDOTSDIAG, MS_DOTSUP, TG::Standalone, 5},
+    { "dotsdown", TDOTSDOWN, MS_DOTSDOWN, TG::Standalone, 5},
+    { "dotslow", TDOTSLOW, MS_DOTSLOW, TG::Standalone, 5},
+    { "dotsup", TDOTSUP, MS_DOTSUP, TG::Standalone, 5},
+    { "dotsvert", TDOTSVERT, MS_DOTSVERT, TG::Standalone, 5},
+    { "downarrow" , TDOWNARROW, MS_DOWNARROW, TG::Standalone, 5},
+    { "drarrow" , TDRARROW, MS_DRARROW, TG::Standalone, 5},
+    { "emptyset" , TEMPTYSET, MS_EMPTYSET, TG::Standalone, 5},
+    { "equiv", TEQUIV, MS_EQUIV, TG::Relation, 0},
+    { "exists", TEXISTS, MS_EXISTS, TG::Standalone, 5},
+    { "notexists", TNOTEXISTS, MS_NOTEXISTS, TG::Standalone, 5},
+    { "exp", TEXP, '\0', TG::Function, 5},
+    { "fact", TFACT, MS_FACT, TG::UnOper, 5},
+    { "fixed", TFIXED, '\0', TG::Font, 0},
+    { "font", TFONT, '\0', TG::FontAttr, 5},
+    { "forall", TFORALL, MS_FORALL, TG::Standalone, 5},
+    { "from", TFROM, '\0', TG::Limit, 0},
+    { "fuchsia", TFUCHSIA, '\0', TG::Color, 0},
+    { "func", TFUNC, '\0', TG::Function, 5},
+    { "ge", TGE, MS_GE, TG::Relation, 0},
+    { "geslant", TGESLANT, MS_GESLANT, TG::Relation, 0 },
+    { "gg", TGG, MS_GG, TG::Relation, 0},
+    { "grave", TGRAVE, MS_GRAVE, TG::Attribute, 5},
+    { "gray", TGRAY, '\0', TG::Color, 0},
+    { "green", TGREEN, '\0', TG::Color, 0},
+    { "gt", TGT, MS_GT, TG::Relation, 0},
+    { "hat", THAT, MS_HAT, TG::Attribute, 5},
+    { "hbar" , THBAR, MS_HBAR, TG::Standalone, 5},
+    { "iiint", TIIINT, MS_IIINT, TG::Oper, 5},
+    { "iint", TIINT, MS_IINT, TG::Oper, 5},
+    { "in", TIN, MS_IN, TG::Relation, 0},
+    { "infinity" , TINFINITY, MS_INFINITY, TG::Standalone, 5},
+    { "infty" , TINFINITY, MS_INFINITY, TG::Standalone, 5},
+    { "int", TINT, MS_INT, TG::Oper, 5},
+    { "intd", TINTD, MS_INT, TG::UnOper, 5},
+    { "intersection", TINTERSECT, MS_INTERSECT, TG::Product, 0},
+    { "ital", TITALIC, '\0', TG::FontAttr, 5},
+    { "italic", TITALIC, '\0', TG::FontAttr, 5},
+    { "lambdabar" , TLAMBDABAR, MS_LAMBDABAR, TG::Standalone, 5},
+    { "langle", TLANGLE, MS_LMATHANGLE, TG::LBrace, 5},
+    { "lbrace", TLBRACE, MS_LBRACE, TG::LBrace, 5},
+    { "lceil", TLCEIL, MS_LCEIL, TG::LBrace, 5},
+    { "ldbracket", TLDBRACKET, MS_LDBRACKET, TG::LBrace, 5},
+    { "ldline", TLDLINE, MS_DVERTLINE, TG::LBrace, 5},
+    { "le", TLE, MS_LE, TG::Relation, 0},
+    { "left", TLEFT, '\0', TG::NONE, 5},
+    { "leftarrow" , TLEFTARROW, MS_LEFTARROW, TG::Standalone, 5},
+    { "leslant", TLESLANT, MS_LESLANT, TG::Relation, 0 },
+    { "lfloor", TLFLOOR, MS_LFLOOR, TG::LBrace, 5},
+    { "lim", TLIM, '\0', TG::Oper, 5},
+    { "lime", TLIME, '\0', TG::Color, 0},
+    { "liminf", TLIMINF, '\0', TG::Oper, 5},
+    { "limsup", TLIMSUP, '\0', TG::Oper, 5},
+    { "lint", TLINT, MS_LINT, TG::Oper, 5},
+    { "ll", TLL, MS_LL, TG::Relation, 0},
+    { "lline", TLLINE, MS_VERTLINE, TG::LBrace, 5},
+    { "llint", TLLINT, MS_LLINT, TG::Oper, 5},
+    { "lllint", TLLLINT, MS_LLLINT, TG::Oper, 5},
+    { "ln", TLN, '\0', TG::Function, 5},
+    { "log", TLOG, '\0', TG::Function, 5},
+    { "lsub", TLSUB, '\0', TG::Power, 0},
+    { "lsup", TLSUP, '\0', TG::Power, 0},
+    { "lt", TLT, MS_LT, TG::Relation, 0},
+    { "magenta", TMAGENTA, '\0', TG::Color, 0},
+    { "maroon", TMAROON, '\0', TG::Color, 0},
+    { "matrix", TMATRIX, '\0', TG::NONE, 5},
+    { "minusplus", TMINUSPLUS, MS_MINUSPLUS, TG::UnOper | TG::Sum, 5},
+    { "mline", TMLINE, MS_VERTLINE, TG::NONE, 0},      //! not in TG::RBrace, Level 0
+    { "nabla", TNABLA, MS_NABLA, TG::Standalone, 5},
+    { "navy", TNAVY, '\0', TG::Color, 0},
+    { "nbold", TNBOLD, '\0', TG::FontAttr, 5},
+    { "ndivides", TNDIVIDES, MS_NDIVIDES, TG::Relation, 0},
+    { "neg", TNEG, MS_NEG, TG::UnOper, 5 },
+    { "neq", TNEQ, MS_NEQ, TG::Relation, 0},
+    { "newline", TNEWLINE, '\0', TG::NONE, 0},
+    { "ni", TNI, MS_NI, TG::Relation, 0},
+    { "nitalic", TNITALIC, '\0', TG::FontAttr, 5},
+    { "none", TNONE, '\0', TG::LBrace | TG::RBrace, 0},
+    { "nospace", TNOSPACE, '\0', TG::Standalone, 5},
+    { "notin", TNOTIN, MS_NOTIN, TG::Relation, 0},
+    { "nroot", TNROOT, MS_SQRT, TG::UnOper, 5},
+    { "nsubset", TNSUBSET, MS_NSUBSET, TG::Relation, 0 },
+    { "nsupset", TNSUPSET, MS_NSUPSET, TG::Relation, 0 },
+    { "nsubseteq", TNSUBSETEQ, MS_NSUBSETEQ, TG::Relation, 0 },
+    { "nsupseteq", TNSUPSETEQ, MS_NSUPSETEQ, TG::Relation, 0 },
+    { "odivide", TODIVIDE, MS_ODIVIDE, TG::Product, 0},
+    { "odot", TODOT, MS_ODOT, TG::Product, 0},
+    { "olive", TOLIVE, '\0', TG::Color, 0},
+    { "ominus", TOMINUS, MS_OMINUS, TG::Sum, 0},
+    { "oper", TOPER, '\0', TG::Oper, 5},
+    { "oplus", TOPLUS, MS_OPLUS, TG::Sum, 0},
+    { "or", TOR, MS_OR, TG::Sum, 0},
+    { "ortho", TORTHO, MS_ORTHO, TG::Relation, 0},
+    { "otimes", TOTIMES, MS_OTIMES, TG::Product, 0},
+    { "over", TOVER, '\0', TG::Product, 0},
+    { "overbrace", TOVERBRACE, MS_OVERBRACE, TG::Product, 5},
+    { "overline", TOVERLINE, '\0', TG::Attribute, 5},
+    { "overstrike", TOVERSTRIKE, '\0', TG::Attribute, 5},
+    { "owns", TNI, MS_NI, TG::Relation, 0},
+    { "parallel", TPARALLEL, MS_DLINE, TG::Relation, 0},
+    { "partial", TPARTIAL, MS_PARTIAL, TG::Standalone, 5 },
+    { "phantom", TPHANTOM, '\0', TG::FontAttr, 5},
+    { "plusminus", TPLUSMINUS, MS_PLUSMINUS, TG::UnOper | TG::Sum, 5},
+    { "prec", TPRECEDES, MS_PRECEDES, TG::Relation, 0 },
+    { "preccurlyeq", TPRECEDESEQUAL, MS_PRECEDESEQUAL, TG::Relation, 0 },
+    { "precsim", TPRECEDESEQUIV, MS_PRECEDESEQUIV, TG::Relation, 0 },
+    { "nprec", TNOTPRECEDES, MS_NOTPRECEDES, TG::Relation, 0 },
+    { "prod", TPROD, MS_PROD, TG::Oper, 5},
+    { "prop", TPROP, MS_PROP, TG::Relation, 0},
+    { "purple", TPURPLE, '\0', TG::Color, 0},
+    { "rangle", TRANGLE, MS_RMATHANGLE, TG::RBrace, 0},  //! 0 to terminate expression
+    { "rbrace", TRBRACE, MS_RBRACE, TG::RBrace, 0},
+    { "rceil", TRCEIL, MS_RCEIL, TG::RBrace, 0},
+    { "rdbracket", TRDBRACKET, MS_RDBRACKET, TG::RBrace, 0},
+    { "rdline", TRDLINE, MS_DVERTLINE, TG::RBrace, 0},
+    { "red", TRED, '\0', TG::Color, 0},
+    { "rfloor", TRFLOOR, MS_RFLOOR, TG::RBrace, 0},  //! 0 to terminate expression
+    { "right", TRIGHT, '\0', TG::NONE, 0},
+    { "rightarrow" , TRIGHTARROW, MS_RIGHTARROW, TG::Standalone, 5},
+    { "rline", TRLINE, MS_VERTLINE, TG::RBrace, 0},  //! 0 to terminate expression
+    { "rsub", TRSUB, '\0', TG::Power, 0},
+    { "rsup", TRSUP, '\0', TG::Power, 0},
+    { "sans", TSANS, '\0', TG::Font, 0},
+    { "serif", TSERIF, '\0', TG::Font, 0},
+    { "setC" , TSETC, MS_SETC, TG::Standalone, 5},
+    { "setN" , TSETN, MS_SETN, TG::Standalone, 5},
+    { "setQ" , TSETQ, MS_SETQ, TG::Standalone, 5},
+    { "setR" , TSETR, MS_SETR, TG::Standalone, 5},
+    { "setZ" , TSETZ, MS_SETZ, TG::Standalone, 5},
+    { "setminus", TBACKSLASH, MS_BACKSLASH, TG::Product, 0 },
+    { "silver", TSILVER, '\0', TG::Color, 0},
+    { "sim", TSIM, MS_SIM, TG::Relation, 0},
+    { "simeq", TSIMEQ, MS_SIMEQ, TG::Relation, 0},
+    { "sin", TSIN, '\0', TG::Function, 5},
+    { "sinh", TSINH, '\0', TG::Function, 5},
+    { "size", TSIZE, '\0', TG::FontAttr, 5},
+    { "slash", TSLASH, MS_SLASH, TG::Product, 0 },
+    { "sqrt", TSQRT, MS_SQRT, TG::UnOper, 5},
+    { "stack", TSTACK, '\0', TG::NONE, 5},
+    { "sub", TRSUB, '\0', TG::Power, 0},
+    { "subset", TSUBSET, MS_SUBSET, TG::Relation, 0},
+    { "succ", TSUCCEEDS, MS_SUCCEEDS, TG::Relation, 0 },
+    { "succcurlyeq", TSUCCEEDSEQUAL, MS_SUCCEEDSEQUAL, TG::Relation, 0 },
+    { "succsim", TSUCCEEDSEQUIV, MS_SUCCEEDSEQUIV, TG::Relation, 0 },
+    { "nsucc", TNOTSUCCEEDS, MS_NOTSUCCEEDS, TG::Relation, 0 },
+    { "subseteq", TSUBSETEQ, MS_SUBSETEQ, TG::Relation, 0},
+    { "sum", TSUM, MS_SUM, TG::Oper, 5},
+    { "sup", TRSUP, '\0', TG::Power, 0},
+    { "supset", TSUPSET, MS_SUPSET, TG::Relation, 0},
+    { "supseteq", TSUPSETEQ, MS_SUPSETEQ, TG::Relation, 0},
+    { "tan", TTAN, '\0', TG::Function, 5},
+    { "tanh", TTANH, '\0', TG::Function, 5},
+    { "teal", TTEAL, '\0', TG::Color, 0},
+    { "tilde", TTILDE, MS_TILDE, TG::Attribute, 5},
+    { "times", TTIMES, MS_TIMES, TG::Product, 0},
+    { "to", TTO, '\0', TG::Limit, 0},
+    { "toward", TTOWARD, MS_RIGHTARROW, TG::Relation, 0},
+    { "transl", TTRANSL, MS_TRANSL, TG::Relation, 0},
+    { "transr", TTRANSR, MS_TRANSR, TG::Relation, 0},
+    { "underbrace", TUNDERBRACE, MS_UNDERBRACE, TG::Product, 5},
+    { "underline", TUNDERLINE, '\0', TG::Attribute, 5},
+    { "union", TUNION, MS_UNION, TG::Sum, 0},
+    { "uoper", TUOPER, '\0', TG::UnOper, 5},
+    { "uparrow" , TUPARROW, MS_UPARROW, TG::Standalone, 5},
+    { "vec", TVEC, MS_VEC, TG::Attribute, 5},
+    { "white", TWHITE, '\0', TG::Color, 0},
+    { "widebslash", TWIDEBACKSLASH, MS_BACKSLASH, TG::Product, 0 },
+    { "widehat", TWIDEHAT, MS_HAT, TG::Attribute, 5},
+    { "widetilde", TWIDETILDE, MS_TILDE, TG::Attribute, 5},
+    { "wideslash", TWIDESLASH, MS_SLASH, TG::Product, 0 },
+    { "widevec", TWIDEVEC, MS_VEC, TG::Attribute, 5},
+    { "wp" , TWP, MS_WP, TG::Standalone, 5},
+    { "yellow", TYELLOW, '\0', TG::Color, 0}
 };
 
 const SmTokenTableEntry * SmParser::GetTokenTableEntry( const OUString &rName )
@@ -444,7 +444,7 @@ void SmParser::NextToken()
     {
         m_aCurToken.eType    = TEND;
         m_aCurToken.cMathChar = '\0';
-        m_aCurToken.nGroup       = 0;
+        m_aCurToken.nGroup       = TG::NONE;
         m_aCurToken.nLevel       = 0;
         m_aCurToken.aText.clear();
     }
@@ -462,7 +462,7 @@ void SmParser::NextToken()
         OSL_ENSURE( n >= 0, "length < 0" );
         m_aCurToken.eType      = TNUMBER;
         m_aCurToken.cMathChar  = '\0';
-        m_aCurToken.nGroup     = 0;
+        m_aCurToken.nGroup     = TG::NONE;
         m_aCurToken.nLevel     = 5;
         m_aCurToken.aText      = m_aBufferString.copy( nRealStart, n );
 
@@ -472,7 +472,7 @@ void SmParser::NextToken()
     {
         m_aCurToken.eType      = TTEXT;
         m_aCurToken.cMathChar  = '\0';
-        m_aCurToken.nGroup     = 0;
+        m_aCurToken.nGroup     = TG::NONE;
         m_aCurToken.nLevel     = 5;
         m_aCurToken.aText     = aRes.DequotedNameOrString;
         m_aCurToken.nRow       = m_Row;
@@ -497,7 +497,7 @@ void SmParser::NextToken()
         {
             m_aCurToken.eType      = TIDENT;
             m_aCurToken.cMathChar  = '\0';
-            m_aCurToken.nGroup     = 0;
+            m_aCurToken.nGroup     = TG::NONE;
             m_aCurToken.nLevel     = 5;
             m_aCurToken.aText      = aName;
 
@@ -508,7 +508,7 @@ void SmParser::NextToken()
     {
         m_aCurToken.eType    = TRSUB;
         m_aCurToken.cMathChar = '\0';
-        m_aCurToken.nGroup       = TGPOWER;
+        m_aCurToken.nGroup       = TG::Power;
         m_aCurToken.nLevel       = 0;
         m_aCurToken.aText = "_";
 
@@ -528,7 +528,7 @@ void SmParser::NextToken()
                         {
                             m_aCurToken.eType    = TLL;
                             m_aCurToken.cMathChar = MS_LL;
-                            m_aCurToken.nGroup       = TGRELATION;
+                            m_aCurToken.nGroup       = TG::Relation;
                             m_aCurToken.nLevel       = 0;
                             m_aCurToken.aText = "<<";
 
@@ -538,7 +538,7 @@ void SmParser::NextToken()
                         {
                             m_aCurToken.eType    = TLE;
                             m_aCurToken.cMathChar = MS_LE;
-                            m_aCurToken.nGroup       = TGRELATION;
+                            m_aCurToken.nGroup       = TG::Relation;
                             m_aCurToken.nLevel       = 0;
                             m_aCurToken.aText = "<=";
 
@@ -548,7 +548,7 @@ void SmParser::NextToken()
                         {
                             m_aCurToken.eType    = TLEFTARROW;
                             m_aCurToken.cMathChar = MS_LEFTARROW;
-                            m_aCurToken.nGroup       = TGSTANDALONE;
+                            m_aCurToken.nGroup       = TG::Standalone;
                             m_aCurToken.nLevel       = 5;
                             m_aCurToken.aText = "<-";
 
@@ -558,7 +558,7 @@ void SmParser::NextToken()
                         {
                             m_aCurToken.eType    = TNEQ;
                             m_aCurToken.cMathChar = MS_NEQ;
-                            m_aCurToken.nGroup       = TGRELATION;
+                            m_aCurToken.nGroup       = TG::Relation;
                             m_aCurToken.nLevel       = 0;
                             m_aCurToken.aText = "<>";
 
@@ -568,7 +568,7 @@ void SmParser::NextToken()
                         {
                             m_aCurToken.eType    = TPLACE;
                             m_aCurToken.cMathChar = MS_PLACE;
-                            m_aCurToken.nGroup       = 0;
+                            m_aCurToken.nGroup       = TG::NONE;
                             m_aCurToken.nLevel       = 5;
                             m_aCurToken.aText = "<?>";
 
@@ -578,7 +578,7 @@ void SmParser::NextToken()
                         {
                             m_aCurToken.eType    = TLT;
                             m_aCurToken.cMathChar = MS_LT;
-                            m_aCurToken.nGroup       = TGRELATION;
+                            m_aCurToken.nGroup       = TG::Relation;
                             m_aCurToken.nLevel       = 0;
                             m_aCurToken.aText = "<";
                         }
@@ -590,7 +590,7 @@ void SmParser::NextToken()
                         {
                             m_aCurToken.eType    = TGE;
                             m_aCurToken.cMathChar = MS_GE;
-                            m_aCurToken.nGroup       = TGRELATION;
+                            m_aCurToken.nGroup       = TG::Relation;
                             m_aCurToken.nLevel       = 0;
                             m_aCurToken.aText = ">=";
 
@@ -600,7 +600,7 @@ void SmParser::NextToken()
                         {
                             m_aCurToken.eType    = TGG;
                             m_aCurToken.cMathChar = MS_GG;
-                            m_aCurToken.nGroup       = TGRELATION;
+                            m_aCurToken.nGroup       = TG::Relation;
                             m_aCurToken.nLevel       = 0;
                             m_aCurToken.aText = ">>";
 
@@ -610,7 +610,7 @@ void SmParser::NextToken()
                         {
                             m_aCurToken.eType    = TGT;
                             m_aCurToken.cMathChar = MS_GT;
-                            m_aCurToken.nGroup       = TGRELATION;
+                            m_aCurToken.nGroup       = TG::Relation;
                             m_aCurToken.nLevel       = 0;
                             m_aCurToken.aText = ">";
                         }
@@ -652,7 +652,7 @@ void SmParser::NextToken()
                         // character
                         m_aCurToken.eType      = TTEXT;
                         m_aCurToken.cMathChar  = '\0';
-                        m_aCurToken.nGroup     = 0;
+                        m_aCurToken.nGroup     = TG::NONE;
                         m_aCurToken.nLevel     = 5;
                         m_aCurToken.aText.clear();
                         m_aCurToken.nRow       = m_Row;
@@ -682,7 +682,7 @@ void SmParser::NextToken()
                     {
                         m_aCurToken.eType    = TLBRACKET;
                         m_aCurToken.cMathChar = MS_LBRACKET;
-                        m_aCurToken.nGroup       = TGLBRACES;
+                        m_aCurToken.nGroup       = TG::LBrace;
                         m_aCurToken.nLevel       = 5;
                         m_aCurToken.aText = "[";
                     }
@@ -691,7 +691,7 @@ void SmParser::NextToken()
                     {
                         m_aCurToken.eType    = TESCAPE;
                         m_aCurToken.cMathChar = '\0';
-                        m_aCurToken.nGroup       = 0;
+                        m_aCurToken.nGroup       = TG::NONE;
                         m_aCurToken.nLevel       = 5;
                         m_aCurToken.aText = "\\";
                     }
@@ -700,7 +700,7 @@ void SmParser::NextToken()
                     {
                         m_aCurToken.eType    = TRBRACKET;
                         m_aCurToken.cMathChar = MS_RBRACKET;
-                        m_aCurToken.nGroup       = TGRBRACES;
+                        m_aCurToken.nGroup       = TG::RBrace;
                         m_aCurToken.nLevel       = 0;
                         m_aCurToken.aText = "]";
                     }
@@ -709,7 +709,7 @@ void SmParser::NextToken()
                     {
                         m_aCurToken.eType    = TRSUP;
                         m_aCurToken.cMathChar = '\0';
-                        m_aCurToken.nGroup       = TGPOWER;
+                        m_aCurToken.nGroup       = TG::Power;
                         m_aCurToken.nLevel       = 0;
                         m_aCurToken.aText = "^";
                     }
@@ -718,7 +718,7 @@ void SmParser::NextToken()
                     {
                         m_aCurToken.eType    = TSBLANK;
                         m_aCurToken.cMathChar = '\0';
-                        m_aCurToken.nGroup       = TGBLANK;
+                        m_aCurToken.nGroup       = TG::Blank;
                         m_aCurToken.nLevel       = 5;
                         m_aCurToken.aText = "`";
                     }
@@ -727,7 +727,7 @@ void SmParser::NextToken()
                     {
                         m_aCurToken.eType    = TLGROUP;
                         m_aCurToken.cMathChar = MS_LBRACE;
-                        m_aCurToken.nGroup       = 0;
+                        m_aCurToken.nGroup       = TG::NONE;
                         m_aCurToken.nLevel       = 5;
                         m_aCurToken.aText = "{";
                     }
@@ -736,7 +736,7 @@ void SmParser::NextToken()
                     {
                         m_aCurToken.eType    = TOR;
                         m_aCurToken.cMathChar = MS_OR;
-                        m_aCurToken.nGroup       = TGSUM;
+                        m_aCurToken.nGroup       = TG::Sum;
                         m_aCurToken.nLevel       = 0;
                         m_aCurToken.aText = "|";
                     }
@@ -745,7 +745,7 @@ void SmParser::NextToken()
                     {
                         m_aCurToken.eType    = TRGROUP;
                         m_aCurToken.cMathChar = MS_RBRACE;
-                        m_aCurToken.nGroup       = 0;
+                        m_aCurToken.nGroup       = TG::NONE;
                         m_aCurToken.nLevel       = 0;
                         m_aCurToken.aText = "}";
                     }
@@ -754,7 +754,7 @@ void SmParser::NextToken()
                     {
                         m_aCurToken.eType    = TBLANK;
                         m_aCurToken.cMathChar = '\0';
-                        m_aCurToken.nGroup       = TGBLANK;
+                        m_aCurToken.nGroup       = TG::Blank;
                         m_aCurToken.nLevel       = 5;
                         m_aCurToken.aText = "~";
                     }
@@ -765,7 +765,7 @@ void SmParser::NextToken()
                         {
                             m_aCurToken.eType    = TDPOUND;
                             m_aCurToken.cMathChar = '\0';
-                            m_aCurToken.nGroup       = 0;
+                            m_aCurToken.nGroup       = TG::NONE;
                             m_aCurToken.nLevel       = 0;
                             m_aCurToken.aText = "##";
 
@@ -775,7 +775,7 @@ void SmParser::NextToken()
                         {
                             m_aCurToken.eType    = TPOUND;
                             m_aCurToken.cMathChar = '\0';
-                            m_aCurToken.nGroup       = 0;
+                            m_aCurToken.nGroup       = TG::NONE;
                             m_aCurToken.nLevel       = 0;
                             m_aCurToken.aText = "#";
                         }
@@ -785,7 +785,7 @@ void SmParser::NextToken()
                     {
                         m_aCurToken.eType    = TAND;
                         m_aCurToken.cMathChar = MS_AND;
-                        m_aCurToken.nGroup       = TGPRODUCT;
+                        m_aCurToken.nGroup       = TG::Product;
                         m_aCurToken.nLevel       = 0;
                         m_aCurToken.aText = "&";
                     }
@@ -794,7 +794,7 @@ void SmParser::NextToken()
                     {
                         m_aCurToken.eType    = TLPARENT;
                         m_aCurToken.cMathChar = MS_LPARENT;
-                        m_aCurToken.nGroup       = TGLBRACES;
+                        m_aCurToken.nGroup       = TG::LBrace;
                         m_aCurToken.nLevel       = 5;     //! 0 to continue expression
                         m_aCurToken.aText = "(";
                     }
@@ -803,7 +803,7 @@ void SmParser::NextToken()
                     {
                         m_aCurToken.eType    = TRPARENT;
                         m_aCurToken.cMathChar = MS_RPARENT;
-                        m_aCurToken.nGroup       = TGRBRACES;
+                        m_aCurToken.nGroup       = TG::RBrace;
                         m_aCurToken.nLevel       = 0;     //! 0 to terminate expression
                         m_aCurToken.aText = ")";
                     }
@@ -812,7 +812,7 @@ void SmParser::NextToken()
                     {
                         m_aCurToken.eType    = TMULTIPLY;
                         m_aCurToken.cMathChar = MS_MULTIPLY;
-                        m_aCurToken.nGroup       = TGPRODUCT;
+                        m_aCurToken.nGroup       = TG::Product;
                         m_aCurToken.nLevel       = 0;
                         m_aCurToken.aText = "*";
                     }
@@ -823,7 +823,7 @@ void SmParser::NextToken()
                         {
                             m_aCurToken.eType    = TPLUSMINUS;
                             m_aCurToken.cMathChar = MS_PLUSMINUS;
-                            m_aCurToken.nGroup       = TGUNOPER | TGSUM;
+                            m_aCurToken.nGroup       = TG::UnOper | TG::Sum;
                             m_aCurToken.nLevel       = 5;
                             m_aCurToken.aText = "+-";
 
@@ -833,7 +833,7 @@ void SmParser::NextToken()
                         {
                             m_aCurToken.eType    = TPLUS;
                             m_aCurToken.cMathChar = MS_PLUS;
-                            m_aCurToken.nGroup       = TGUNOPER | TGSUM;
+                            m_aCurToken.nGroup       = TG::UnOper | TG::Sum;
                             m_aCurToken.nLevel       = 5;
                             m_aCurToken.aText = "+";
                         }
@@ -845,7 +845,7 @@ void SmParser::NextToken()
                         {
                             m_aCurToken.eType    = TMINUSPLUS;
                             m_aCurToken.cMathChar = MS_MINUSPLUS;
-                            m_aCurToken.nGroup       = TGUNOPER | TGSUM;
+                            m_aCurToken.nGroup       = TG::UnOper | TG::Sum;
                             m_aCurToken.nLevel       = 5;
                             m_aCurToken.aText = "-+";
 
@@ -855,7 +855,7 @@ void SmParser::NextToken()
                         {
                             m_aCurToken.eType    = TRIGHTARROW;
                             m_aCurToken.cMathChar = MS_RIGHTARROW;
-                            m_aCurToken.nGroup       = TGSTANDALONE;
+                            m_aCurToken.nGroup       = TG::Standalone;
                             m_aCurToken.nLevel       = 5;
                             m_aCurToken.aText = "->";
 
@@ -865,7 +865,7 @@ void SmParser::NextToken()
                         {
                             m_aCurToken.eType    = TMINUS;
                             m_aCurToken.cMathChar = MS_MINUS;
-                            m_aCurToken.nGroup       = TGUNOPER | TGSUM;
+                            m_aCurToken.nGroup       = TG::UnOper | TG::Sum;
                             m_aCurToken.nLevel       = 5;
                             m_aCurToken.aText = "-";
                         }
@@ -881,7 +881,7 @@ void SmParser::NextToken()
                             // will be treated as numbers
                             m_aCurToken.eType     = TNUMBER;
                             m_aCurToken.cMathChar = '\0';
-                            m_aCurToken.nGroup       = 0;
+                            m_aCurToken.nGroup    = TG::NONE;
                             m_aCurToken.nLevel    = 5;
 
                             sal_Int32 nTxtStart = m_nBufferIndex;
@@ -905,7 +905,7 @@ void SmParser::NextToken()
                     {
                         m_aCurToken.eType    = TDIVIDEBY;
                         m_aCurToken.cMathChar = MS_SLASH;
-                        m_aCurToken.nGroup       = TGPRODUCT;
+                        m_aCurToken.nGroup       = TG::Product;
                         m_aCurToken.nLevel       = 0;
                         m_aCurToken.aText = "/";
                     }
@@ -914,7 +914,7 @@ void SmParser::NextToken()
                     {
                         m_aCurToken.eType    = TASSIGN;
                         m_aCurToken.cMathChar = MS_ASSIGN;
-                        m_aCurToken.nGroup       = TGRELATION;
+                        m_aCurToken.nGroup       = TG::Relation;
                         m_aCurToken.nLevel       = 0;
                         m_aCurToken.aText = "=";
                     }
@@ -931,7 +931,7 @@ void SmParser::NextToken()
     {
         m_aCurToken.eType      = TCHARACTER;
         m_aCurToken.cMathChar  = '\0';
-        m_aCurToken.nGroup     = 0;
+        m_aCurToken.nGroup     = TG::NONE;
         m_aCurToken.nLevel     = 5;
         m_aCurToken.aText      = m_aBufferString.copy( nRealStart, 1 );
 
@@ -972,14 +972,14 @@ void SmParser::DoAlign()
 {
     std::unique_ptr<SmStructureNode> pSNode;
 
-    if (TokenInGroup(TGALIGN))
+    if (TokenInGroup(TG::Align))
     {
         pSNode.reset(new SmAlignNode(m_aCurToken));
 
         NextToken();
 
         // allow for just one align statement in 5.0
-        if (TokenInGroup(TGALIGN))
+        if (TokenInGroup(TG::Align))
         {
             Error(PE_DOUBLE_ALIGN);
             return;
@@ -1074,7 +1074,7 @@ void SmParser::DoExpression()
 void SmParser::DoRelation()
 {
     DoSum();
-    while (TokenInGroup(TGRELATION))
+    while (TokenInGroup(TG::Relation))
     {
         std::unique_ptr<SmStructureNode> pSNode(new SmBinHorNode(m_aCurToken));
         SmNode *pFirst = popOrZero(m_aNodeStack);
@@ -1092,7 +1092,7 @@ void SmParser::DoRelation()
 void SmParser::DoSum()
 {
     DoProduct();
-    while (TokenInGroup(TGSUM))
+    while (TokenInGroup(TG::Sum))
     {
         std::unique_ptr<SmStructureNode> pSNode(new SmBinHorNode(m_aCurToken));
         SmNode *pFirst = popOrZero(m_aNodeStack);
@@ -1111,7 +1111,7 @@ void SmParser::DoProduct()
 {
     DoPower();
 
-    while (TokenInGroup(TGPRODUCT))
+    while (TokenInGroup(TG::Product))
     {   SmStructureNode *pSNode;
         SmNode *pFirst = popOrZero(m_aNodeStack),
                *pOper;
@@ -1133,7 +1133,7 @@ void SmParser::DoProduct()
 
                 //Let the glyph node know it's a binary operation
                 m_aCurToken.eType = TBOPER;
-                m_aCurToken.nGroup = TGPRODUCT;
+                m_aCurToken.nGroup = TG::Product;
 
                 DoGlyphSpecial();
                 pOper = popOrZero(m_aNodeStack);
@@ -1183,9 +1183,9 @@ void SmParser::DoProduct()
     }
 }
 
-void SmParser::DoSubSup(sal_uLong nActiveGroup)
+void SmParser::DoSubSup(TG nActiveGroup)
 {
-    OSL_ENSURE(nActiveGroup == TGPOWER  ||  nActiveGroup == TGLIMIT,
+    OSL_ENSURE(nActiveGroup == TG::Power  ||  nActiveGroup == TG::Limit,
                "Sm: wrong token group");
 
     if (!TokenInGroup(nActiveGroup))
@@ -1198,7 +1198,7 @@ void SmParser::DoSubSup(sal_uLong nActiveGroup)
     //! sub-/supscripts will be identified by the corresponding subnodes
     //! index in the 'aSubNodes' array (enum value from 'SmSubSup').
 
-    pNode->SetUseLimits(nActiveGroup == TGLIMIT);
+    pNode->SetUseLimits(nActiveGroup == TG::Limit);
 
     // initialize subnodes array
     SmNodeArray aSubNodes(1 + SUBSUP_NUM_ENTRIES, nullptr);
@@ -1254,8 +1254,8 @@ void SmParser::DoOpSubSup()
     // skip operator token
     NextToken();
     // get sub- supscripts if any
-    if (TokenInGroup(TGPOWER))
-        DoSubSup(TGPOWER);
+    if (TokenInGroup(TG::Power))
+        DoSubSup(TG::Power);
 }
 
 void SmParser::DoPower()
@@ -1263,15 +1263,15 @@ void SmParser::DoPower()
     // get body for sub- supscripts on top of stack
     DoTerm(false);
 
-    DoSubSup(TGPOWER);
+    DoSubSup(TG::Power);
 }
 
 void SmParser::DoBlank()
 {
-    OSL_ENSURE(TokenInGroup(TGBLANK), "Sm : wrong token");
+    OSL_ENSURE(TokenInGroup(TG::Blank), "Sm : wrong token");
     std::unique_ptr<SmBlankNode> pBlankNode(new SmBlankNode(m_aCurToken));
 
-    while (TokenInGroup(TGBLANK))
+    while (TokenInGroup(TG::Blank))
     {
         pBlankNode->IncreaseBy(m_aCurToken);
         NextToken();
@@ -1481,25 +1481,25 @@ void SmParser::DoTerm(bool bGroupNumberIdent)
             break;
 
         default:
-            if (TokenInGroup(TGLBRACES))
+            if (TokenInGroup(TG::LBrace))
             {
                 DoBrace();
             }
-            else if (TokenInGroup(TGOPER))
+            else if (TokenInGroup(TG::Oper))
             {
                 DoOperator();
             }
-            else if (TokenInGroup(TGUNOPER))
+            else if (TokenInGroup(TG::UnOper))
             {
                 DoUnOper();
             }
-            else if (    TokenInGroup(TGATTRIBUT)
-                     ||  TokenInGroup(TGFONTATTR))
+            else if (    TokenInGroup(TG::Attribute)
+                     ||  TokenInGroup(TG::FontAttr))
             {
                 std::stack<SmStructureNode *> aStack;
                 bool    bIsAttr;
-                while ( (bIsAttr = TokenInGroup(TGATTRIBUT))
-                       ||  TokenInGroup(TGFONTATTR))
+                while ( (bIsAttr = TokenInGroup(TG::Attribute))
+                       ||  TokenInGroup(TG::FontAttr))
                 {
                     if (bIsAttr)
                         DoAttribut();
@@ -1526,7 +1526,7 @@ void SmParser::DoTerm(bool bGroupNumberIdent)
                 }
                 m_aNodeStack.push_front(std::unique_ptr<SmNode>(pFirstNode));
             }
-            else if (TokenInGroup(TGFUNCTION))
+            else if (TokenInGroup(TG::Function))
             {
                 DoFunction();
             }
@@ -1574,14 +1574,14 @@ void SmParser::DoEscape()
 
 void SmParser::DoOperator()
 {
-    if (TokenInGroup(TGOPER))
+    if (TokenInGroup(TG::Oper))
     {
         std::unique_ptr<SmStructureNode> pSNode(new SmOperNode(m_aCurToken));
 
         // put operator on top of stack
         DoOper();
 
-        if (TokenInGroup(TGLIMIT) || TokenInGroup(TGPOWER))
+        if (TokenInGroup(TG::Limit) || TokenInGroup(TG::Power))
             DoSubSup(m_aCurToken.nGroup);
         SmNode *pOperator = popOrZero(m_aNodeStack);
 
@@ -1648,7 +1648,7 @@ void SmParser::DoOper()
 
 void SmParser::DoUnOper()
 {
-    OSL_ENSURE(TokenInGroup(TGUNOPER), "Sm: wrong token");
+    OSL_ENSURE(TokenInGroup(TG::UnOper), "Sm: wrong token");
 
     SmToken      aNodeToken = m_aCurToken;
     SmTokenType  eType      = m_aCurToken.eType;
@@ -1680,7 +1680,7 @@ void SmParser::DoUnOper()
             NextToken();
             //Let the glyph know what it is...
             m_aCurToken.eType = TUOPER;
-            m_aCurToken.nGroup = TGUNOPER;
+            m_aCurToken.nGroup = TG::UnOper;
             DoGlyphSpecial();
             pOper = popOrZero(m_aNodeStack);
             break;
@@ -1748,7 +1748,7 @@ void SmParser::DoUnOper()
 
 void SmParser::DoAttribut()
 {
-    OSL_ENSURE(TokenInGroup(TGATTRIBUT), "Sm: wrong token group");
+    OSL_ENSURE(TokenInGroup(TG::Attribute), "Sm: wrong token group");
 
     std::unique_ptr<SmStructureNode> pSNode(new SmAttributNode(m_aCurToken));
     SmNode      *pAttr;
@@ -1784,7 +1784,7 @@ void SmParser::DoAttribut()
 
 void SmParser::DoFontAttribut()
 {
-    OSL_ENSURE(TokenInGroup(TGFONTATTR), "Sm: wrong token group");
+    OSL_ENSURE(TokenInGroup(TG::FontAttr), "Sm: wrong token group");
 
     switch (m_aCurToken.eType)
     {
@@ -1823,7 +1823,7 @@ void SmParser::DoColor()
     do
     {   NextToken();
 
-        if (TokenInGroup(TGCOLOR))
+        if (TokenInGroup(TG::Color))
         {   aToken = m_aCurToken;
             NextToken();
         }
@@ -1843,7 +1843,7 @@ void SmParser::DoFont()
     do
     {   NextToken();
 
-        if (TokenInGroup(TGFONT))
+        if (TokenInGroup(TG::Font))
         {   aToken = m_aCurToken;
             NextToken();
         }
@@ -1945,7 +1945,7 @@ void SmParser::DoFontSize()
 
 void SmParser::DoBrace()
 {
-    OSL_ENSURE(m_aCurToken.eType == TLEFT  ||  TokenInGroup(TGLBRACES),
+    OSL_ENSURE(m_aCurToken.eType == TLEFT  ||  TokenInGroup(TG::LBrace),
         "Sm: kein Klammer Ausdruck");
 
     std::unique_ptr<SmStructureNode> pSNode(new SmBraceNode(m_aCurToken));
@@ -1961,7 +1961,7 @@ void SmParser::DoBrace()
         eScaleMode = SCALE_HEIGHT;
 
         // check for left bracket
-        if (TokenInGroup(TGLBRACES) || TokenInGroup(TGRBRACES))
+        if (TokenInGroup(TG::LBrace) || TokenInGroup(TG::RBrace))
         {
             pLeft = new SmMathSymbolNode(m_aCurToken);
 
@@ -1973,7 +1973,7 @@ void SmParser::DoBrace()
             {   NextToken();
 
                 // check for right bracket
-                if (TokenInGroup(TGLBRACES) || TokenInGroup(TGRBRACES))
+                if (TokenInGroup(TG::LBrace) || TokenInGroup(TG::RBrace))
                 {
                     pRight = new SmMathSymbolNode(m_aCurToken);
                     NextToken();
@@ -1989,7 +1989,7 @@ void SmParser::DoBrace()
     }
     else
     {
-        if (TokenInGroup(TGLBRACES))
+        if (TokenInGroup(TG::LBrace))
         {
             pLeft = new SmMathSymbolNode(m_aCurToken);
 
@@ -2078,15 +2078,15 @@ void SmParser::DoBracebody(bool bIsLeftRight)
                 NextToken();
                 nNum++;
             }
-            else if (!TokenInGroup(TGRBRACES))
+            else if (!TokenInGroup(TG::RBrace))
             {
                 DoAlign();
                 nNum++;
 
-                if (m_aCurToken.eType != TMLINE  &&  !TokenInGroup(TGRBRACES))
+                if (m_aCurToken.eType != TMLINE  &&  !TokenInGroup(TG::RBrace))
                     Error(PE_RBRACE_EXPECTED);
             }
-        } while (m_aCurToken.eType != TEND  &&  !TokenInGroup(TGRBRACES));
+        } while (m_aCurToken.eType != TEND  &&  !TokenInGroup(TG::RBrace));
     }
 
     // build argument vector in parsing order