[Libreoffice-commits] core.git: starmath/inc starmath/source
Noel Grandin
noel at peralex.com
Tue May 17 02:28:46 UTC 2016
starmath/inc/parse.hxx | 8
starmath/inc/token.hxx | 50 +--
starmath/source/cursor.cxx | 80 ++---
starmath/source/mathmlexport.cxx | 2
starmath/source/node.cxx | 4
starmath/source/parse.cxx | 608 +++++++++++++++++++--------------------
6 files changed, 379 insertions(+), 373 deletions(-)
New commits:
commit cc1a0ba927ad6f85103059aa8e6108017f436304
Author: Noel Grandin <noel at peralex.com>
Date: Fri May 13 15:50:42 2016 +0200
convert TG constants to scoped enum
Change-Id: Ide719e8bb0d5aacc8d5da18f385b6373c7e48184
Reviewed-on: https://gerrit.libreoffice.org/24973
Tested-by: Jenkins <ci at libreoffice.org>
Reviewed-by: Takeshi Abe <tabe at fixedpoint.jp>
diff --git a/starmath/inc/parse.hxx b/starmath/inc/parse.hxx
index 34194de..3ebeb2c 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 dbc24d5..acb944a 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 5146600..58a2a63 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 b14dd1f..b175236 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 c5ae413..58f4df3 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 7ccf442..b3bef50 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
More information about the Libreoffice-commits
mailing list