20#include <com/sun/star/i18n/UnicodeType.hpp>
21#include <com/sun/star/i18n/KParseTokens.hpp>
22#include <com/sun/star/i18n/KParseType.hpp>
27#include <osl/diagnose.h>
28#include <rtl/character.hxx>
262const sal_Int32
coStartFlags = KParseTokens::ANY_LETTER | KParseTokens::IGNORE_LEADING_WS;
266 | KParseTokens::TWO_DOUBLE_QUOTES_BREAK_STRING;
269 = KParseTokens::ASC_DIGIT | KParseTokens::ASC_DOT | KParseTokens::IGNORE_LEADING_WS;
276 | KParseTokens::GROUP_SEPARATOR_IN_NUMBER;
279 = KParseTokens::ASC_DIGIT | KParseTokens::ASC_UPALPHA | KParseTokens::IGNORE_LEADING_WS;
285 | KParseTokens::ASC_DOT
286 | KParseTokens::TWO_DOUBLE_QUOTES_BREAK_STRING;
291 return s.compareToIgnoreAsciiCase(lhs.
aIdent) > 0;
302 if (findIter != std::end(
aTokenTable) && rName.equalsIgnoreAsciiCase(findIter->aIdent))
310 assert(
nPos <= rTxt.getLength());
311 if (
nPos == rTxt.getLength())
317 ' ',
'{',
'}',
'(',
')',
'\t',
'\n',
'\r',
'+',
'-',
'*',
'/',
'=',
'[',
318 ']',
'^',
'_',
'#',
'%',
'>',
'<',
'&',
'|',
'\\',
'"',
'~',
'`'
322 for (
auto const&
cDelimiter : aDelimiterTable)
329 sal_Int16 nTypJp =
SM_MOD()->GetSysLocale().GetCharClass().getType(rTxt,
nPos);
330 return (nTypJp == css::i18n::UnicodeType::SPACE_SEPARATOR
331 || nTypJp == css::i18n::UnicodeType::CONTROL);
340 for (sal_Int32
nPos = 0;
nPos < rText.getLength();
nPos++, pBuffer++)
350 else if (!rtl::isAsciiDigit(cChar))
360 for (sal_Int32
nPos = 0;
nPos < rText.getLength();
nPos++, pBuffer++)
361 if (!rtl::isAsciiDigit(*pBuffer))
370 for (sal_Int32
nPos = 0;
nPos < rText.getLength();
nPos++, pBuffer++)
371 if (!rtl::isAsciiCanonicHexDigit(*pBuffer))
382 sal_Int32 nChg = aText.size() - nLen;
391 sal_Int32 nRealStart;
406 if (aRes.TokenType == 0)
417 if (aRes.TokenType == 0 && nRealStart < nBufLen &&
'\n' ==
m_aBufferString[nRealStart])
424 else if (aRes.TokenType & KParseType::ONE_SINGLE_CHAR)
426 if (nRealStart + 2 <= nBufLen &&
m_aBufferString.match(
"%%", nRealStart))
440 sal_uInt32 nCol = nRealStart -
m_nColOff;
442 bool bHandled =
true;
443 if (nRealStart >= nBufLen)
451 else if (aRes.TokenType & KParseType::ANY_NUMBER)
453 assert(aRes.EndPos > 0);
460 sal_Int32
n = aRes.EndPos - nRealStart;
469 "identifier really finished? (compatibility!)");
471 else if (aRes.TokenType & KParseType::DOUBLE_QUOTE_STRING)
480 else if (aRes.TokenType & KParseType::IDENTNAME)
482 sal_Int32
n = aRes.EndPos - nRealStart;
504 "identifier really finished? (compatibility!)");
515 aRes.EndPos = nRealStart + 1;
517 else if (aRes.TokenType & KParseType::BOOLEAN)
519 sal_Int32& rnEndPos = aRes.EndPos;
520 if (rnEndPos - nRealStart <= 2)
535 rnEndPos = nRealStart + 2;
545 rnEndPos = nRealStart + 2;
555 rnEndPos = nRealStart + 2;
565 rnEndPos = nRealStart + 2;
575 rnEndPos = nRealStart + 3;
597 rnEndPos = nRealStart + 2;
607 rnEndPos = nRealStart + 2;
624 else if (aRes.TokenType & KParseType::ONE_SINGLE_CHAR)
626 sal_Int32& rnEndPos = aRes.EndPos;
627 if (rnEndPos - nRealStart == 1)
637 "unexpected comment start");
641 KParseTokens::ANY_LETTER,
"",
644 sal_Int32 nTmpStart = rnEndPos + aTmpRes.LeadingWhiteSpace;
655 if (aTmpRes.TokenType & KParseType::IDENTNAME)
657 sal_Int32
n = aTmpRes.EndPos - nTmpStart;
661 OSL_ENSURE(aTmpRes.EndPos > rnEndPos,
"empty identifier");
662 if (aTmpRes.EndPos > rnEndPos)
663 rnEndPos = aTmpRes.EndPos;
764 rnEndPos = nRealStart + 2;
822 rnEndPos = nRealStart + 2;
844 rnEndPos = nRealStart + 2;
854 rnEndPos = nRealStart + 2;
885 }
while ((cChar ==
'.' || rtl::isAsciiDigit(cChar))
935 aRes.EndPos = nRealStart + nOffset;
947 sal_Int32 nRealStart;
961 if (aRes.TokenType == 0 && nRealStart < nBufLen &&
'\n' ==
m_aBufferString[nRealStart])
968 else if (aRes.TokenType & KParseType::ONE_SINGLE_CHAR)
970 if (nRealStart + 2 <= nBufLen &&
m_aBufferString.match(
"%%", nRealStart))
983 sal_uInt32 nCol = nRealStart -
m_nColOff;
985 if (nRealStart >= nBufLen)
987 else if (aRes.TokenType & KParseType::IDENTNAME)
989 sal_Int32
n = aRes.EndPos - nRealStart;
1005 else if (aRes.TokenType & KParseType::ONE_SINGLE_CHAR)
1028 sal_Int32 nRealStart;
1040 if (aRes.TokenType == 0)
1051 if (aRes.TokenType == 0 && nRealStart < nBufLen &&
'\n' ==
m_aBufferString[nRealStart])
1058 else if (aRes.TokenType & KParseType::ONE_SINGLE_CHAR)
1060 if (nRealStart + 2 <= nBufLen &&
m_aBufferString.match(
"%%", nRealStart))
1073 sal_uInt32 nCol = nRealStart -
m_nColOff;
1075 if (nRealStart >= nBufLen)
1077 else if (aRes.TokenType & KParseType::ONE_SINGLE_CHAR)
1079 if (aRes.EndPos - nRealStart == 1)
1121 assert(aRes.EndPos > 0);
1122 sal_Int32
n = aRes.EndPos - nRealStart;
1140SmNodeArray buildNodeArray(std::vector<std::unique_ptr<SmNode>>& rSubNodes)
1143 for (
size_t i = 0;
i < rSubNodes.size(); ++
i)
1144 aSubArray[i] = rSubNodes[i].release();
1156 std::vector<std::unique_ptr<SmNode>> aLineArray;
1157 aLineArray.push_back(
DoLine());
1161 aLineArray.push_back(
DoLine());
1166 xSNode->SetSubNodes(buildNodeArray(aLineArray));
1175 std::unique_ptr<SmStructureNode> xSNode;
1193 xSNode->SetSubNode(0, pNode.release());
1204 std::vector<std::unique_ptr<SmNode>> ExpressionArray;
1210 ExpressionArray.push_back(
DoAlign());
1218 if (ExpressionArray.empty())
1222 ExpressionArray.emplace_back(std::unique_ptr<SmNode>(
new SmExpressionNode(aTok)));
1225 auto xSNode = std::make_unique<SmLineNode>(
m_aCurToken);
1227 xSNode->SetSubNodes(buildNodeArray(ExpressionArray));
1235 std::vector<std::unique_ptr<SmNode>> RelationArray;
1240 if (RelationArray.size() > 1)
1243 xSNode->SetSubNodes(buildNodeArray(RelationArray));
1244 xSNode->SetUseExtraSpaces(bUseExtraSpaces);
1250 return std::move(RelationArray[0]);
1260 auto xFirst =
DoSum();
1266 auto xThird =
DoSum();
1267 xSNode->SetSubNodes(std::move(xFirst), std::move(xSecond), std::move(xThird));
1268 xFirst = std::move(xSNode);
1292 xSNode->SetSubNodes(std::move(xFirst), std::move(xSecond), std::move(xThird));
1293 xFirst = std::move(xSNode);
1310 int nDepthLimit = 0;
1318 throw std::range_error(
"parser depth limit");
1320 std::unique_ptr<SmStructureNode> xSNode;
1321 std::unique_ptr<SmNode> xOper;
1360 xSNode.reset(pSTmp);
1377 xSNode->SetSubNodesBinMo(std::move(xFirst), std::move(xOper), std::move(xArg));
1378 xFirst = std::move(xSNode);
1398 pNode->SetUseLimits(nActiveGroup ==
TG::Limit);
1402 aSubNodes[0] = std::move(xGivenNode);
1433 SAL_WARN(
"starmath",
"unknown case");
1438 std::unique_ptr<SmNode> xENode;
1442 aSubNodes[
nIndex].reset();
1454 std::unique_ptr<SmNode> xSNode;
1463 aSubNodes[
nIndex] = std::move(xENode ? xENode : xSNode);
1466 pNode->SetSubNodes(buildNodeArray(aSubNodes));
1476 pNode->SetUseLimits(
true);
1480 aSubNodes[0] = std::move(xGivenNode);
1497 SAL_WARN(
"starmath",
"unknown case");
1502 std::unique_ptr<SmNode> xENode;
1506 aSubNodes[
nIndex].reset();
1513 std::unique_ptr<SmNode> xSNode;
1516 aSubNodes[
nIndex] = std::move(xENode ? xENode : xSNode);
1519 pNode->SetSubNodes(buildNodeArray(aSubNodes));
1528 auto xNode = std::make_unique<SmMathSymbolNode>(
m_aCurToken);
1543 std::unique_ptr<SmNode> xNode(
DoTerm(
false));
1567 &&
SM_MOD()->GetConfig()->IsIgnoreSpacesRight()))
1569 pBlankNode->Clear();
1599 xSNode->SetSubNodes(
nullptr,
nullptr);
1602 return std::unique_ptr<SmNode>(xSNode.release());
1605 auto pNode =
DoAlign(!bNoSpace);
1611 auto xSNode = std::make_unique<SmExpressionNode>(
m_aCurToken);
1614 xSNode->SetSubNodes(std::move(pNode), std::move(xError));
1615 return std::unique_ptr<SmNode>(xSNode.release());
1632 return std::unique_ptr<SmNode>(pNode.release());
1639 return std::unique_ptr<SmNode>(pNode.release());
1644 auto pTextNode = std::make_unique<SmTextNode>(
1647 if (!bGroupNumberIdent)
1650 return std::unique_ptr<SmNode>(pTextNode.release());
1652 std::vector<std::unique_ptr<SmNode>> aNodes;
1664 bool moveToNextToken =
true;
1667 != UnicodeType::SPACE_SEPARATOR)
1674 moveToNextToken =
false;
1677 aNodes.emplace_back(std::unique_ptr<SmNode>(
new SmTextNode(
1680 if (moveToNextToken)
1683 return std::unique_ptr<SmNode>(pTextNode.release());
1686 aNodes.insert(aNodes.begin(), std::move(pTextNode));
1688 xNode->SetSubNodes(buildNodeArray(aNodes));
1689 return std::unique_ptr<SmNode>(xNode.release());
1714 auto pNode = std::make_unique<SmMathSymbolNode>(
m_aCurToken);
1717 return std::unique_ptr<SmNode>(pNode.release());
1735 auto pNode = std::make_unique<SmMathIdentifierNode>(
m_aCurToken);
1738 return std::unique_ptr<SmNode>(pNode.release());
1743 auto pNode = std::make_unique<SmPlaceNode>(
m_aCurToken);
1746 return std::unique_ptr<SmNode>(pNode.release());
1784 std::stack<std::unique_ptr<SmStructureNode>,
1785 std::vector<std::unique_ptr<SmStructureNode>>>
1797 while (!aStack.empty())
1799 std::unique_ptr<SmStructureNode> xNode = std::move(aStack.top());
1801 xNode->SetSubNodes(
nullptr, std::move(xFirstNode));
1802 xFirstNode = std::move(xNode);
1841 auto pNode = std::make_unique<SmMathSymbolNode>(
m_aCurToken);
1844 return std::unique_ptr<SmNode>(pNode.release());
1857 auto xSNode = std::make_unique<SmOperNode>(
m_aCurToken);
1861 auto xOperator =
DoOper();
1869 xSNode->SetSubNodes(std::move(xOperator), std::move(xArg));
1878 std::unique_ptr<SmNode> pNode;
1914 assert(
false &&
"unknown case");
1932 std::unique_ptr<SmStructureNode> xSNode;
1933 std::unique_ptr<SmNode> xOper;
1934 std::unique_ptr<SmNode> xExtra;
1935 std::unique_ptr<SmNode> xArg;
1976 xSNode->SetSelection(aESelection);
1986 xLeft->SetSelection(aESelection);
1988 xRight->SetSelection(aESelection);
1990 xSNode->SetSubNodes(std::move(xLeft), std::move(xArg), std::move(xRight));
1995 xSNode->SetSelection(aESelection);
1997 xOper->SetSelection(aESelection);
1998 xSNode->SetSubNodes(std::move(xExtra), std::move(xOper), std::move(xArg));
2003 xSNode->SetSelection(aESelection);
2005 xSNode->SetSubNodes(std::move(xArg), std::move(xOper));
2009 xSNode->SetSubNodes(std::move(xOper), std::move(xArg));
2021 auto xSNode = std::make_unique<SmAttributeNode>(
m_aCurToken);
2023 std::unique_ptr<SmNode> xAttr;
2053 xSNode->SetSubNodes(std::move(xAttr),
nullptr);
2054 xSNode->SetScaleMode(eScaleMode);
2072 auto pNode = std::make_unique<SmFontNode>(
m_aCurToken);
2113 sal_uInt32 nr, ng, nb, nc;
2132 nc = nb | ng << 8 | nr << 16 | sal_uInt32(0) << 24;
2133 aToken.
cMathChar = OUString::number(nc, 16);
2137 sal_uInt32 nr, na, ng, nb, nc;
2162 nc = nb | ng << 8 | nr << 16 | na << 24;
2163 aToken.
cMathChar = OUString::number(nc, 16);
2172 aToken.
cMathChar = OUString::number(nc, 16);
2180 std::unique_ptr<SmStructureNode> xNode;
2182 xNode->SetSelection(aESelection);
2192 std::unique_ptr<SmStructureNode> xNode;
2212 xNode->SetSelection(aESelection);
2263 while (nDenom > 1000)
2274 pFontNode->SetSizeParameter(aValue,
Type);
2287 std::unique_ptr<SmNode> pBody, pLeft, pRight;
2337 switch (pLeft->GetToken().eType)
2373 SAL_WARN(
"starmath",
"unknown case");
2390 xSNode->SetSubNodes(std::move(pLeft), std::move(pBody), std::move(pRight));
2391 xSNode->SetScaleMode(eScaleMode);
2401 auto pBody = std::make_unique<SmBracebodyNode>(
m_aCurToken);
2404 std::vector<std::unique_ptr<SmNode>> aNodes;
2414 aNodes.emplace_back(std::unique_ptr<SmMathSymbolNode>(pTempNode));
2433 aNodes.emplace_back(std::unique_ptr<SmMathSymbolNode>(pTempNode));
2445 pBody->SetSubNodes(buildNodeArray(aNodes));
2461 std::unique_ptr<SmNode> pBody =
DoPower();
2463 std::unique_ptr<SmNode> pLeft;
2467 std::unique_ptr<SmNode> pRight;
2469 xSNode->SetSubNodes(std::move(pLeft), std::move(pBody), std::move(pRight));
2475 std::unique_ptr<SmNode> rSNode;
2504 auto xSNode = std::make_unique<SmTableNode>(
m_aCurToken);
2509 auto xFirst =
DoSum();
2510 auto xSecond =
DoSum();
2511 xSNode->SetSubNodes(std::move(xFirst), std::move(xSecond));
2519 std::unique_ptr<SmBinVerNode> xSNode = std::make_unique<SmBinVerNode>(
m_aCurToken);
2521 std::unique_ptr<SmNode> xOper = std::make_unique<SmRectangleNode>(
m_aCurToken);
2526 auto xFirst =
DoSum();
2527 auto xSecond =
DoSum();
2528 xSNode->SetSubNodes(std::move(xFirst), std::move(xOper), std::move(xSecond));
2541 std::vector<std::unique_ptr<SmNode>> aExprArr;
2545 aExprArr.push_back(
DoAlign());
2553 xSNode->SetSubNodes(buildNodeArray(aExprArr));
2567 std::vector<std::unique_ptr<SmNode>> aExprArr;
2571 aExprArr.push_back(
DoAlign());
2574 size_t nCol = aExprArr.size();
2579 for (
size_t i = 0;
i < nCol;
i++)
2589 aExprArr.emplace_back(std::move(xNode));
2599 if (aExprArr.empty())
2602 aExprArr.pop_back();
2603 aExprArr.emplace_back(std::move(xENode));
2606 xMNode->SetSubNodes(buildNodeArray(aExprArr));
2607 xMNode->SetRowCol(
static_cast<sal_uInt16
>(nRow),
static_cast<sal_uInt16
>(nCol));
2608 return std::unique_ptr<SmStructureNode>(xMNode.release());
2615 bool bReplace =
false;
2622 if (rName.startsWith(
"%"))
2635 if (!aNewName.isEmpty())
2636 aNewName =
"%" + aNewName;
2638 if (bReplace && !aNewName.isEmpty() && rName != aNewName)
2646 if (!aSymbolName.isEmpty())
2649 auto pNode = std::make_unique<SmSpecialNode>(
m_aCurToken);
2659 auto pNode = std::make_unique<SmGlyphSpecialNode>(
m_aCurToken);
2674 auto xSNode = std::make_unique<SmExpressionNode>(
m_aCurToken);
2677 xSNode->SetSubNode(0, pErr);
2696 , m_bImportSymNames(false)
2697 , m_bExportSymNames(false)
2700 , m_pSysCC(&
SM_MOD()->GetSysLocale().GetCharClass())
css::i18n::ParseResult parseAnyToken(const OUString &rStr, sal_Int32 nPos, sal_Int32 nStartCharFlags, const OUString &userDefinedCharactersStart, sal_Int32 nContCharFlags, const OUString &userDefinedCharactersCont) const
css::i18n::ParseResult parsePredefinedToken(sal_Int32 nTokenType, const OUString &rStr, sal_Int32 nPos, sal_Int32 nStartCharFlags, const OUString &userDefinedCharactersStart, sal_Int32 nContCharFlags, const OUString &userDefinedCharactersCont) const
sal_Int16 getType(const OUString &rStr, sal_Int32 nPos) const
sal_Int32 GetNumerator() const
sal_Int32 GetDenominator() const
void SetAscending(bool bVal)
Sets if the wideslash is ascending to bVal.
Node for brace construction.
Error node, for parsing errors.
Glyph node for custom operators.
void SetSelection(ESelection aESelection)
Gets node position in input text.
std::unique_ptr< SmNode > DoOper()
std::unique_ptr< SmExpressionNode > DoError(SmParseError Error)
std::unique_ptr< SmStructureNode > DoFontAttribute()
std::unique_ptr< SmStructureNode > DoUnOper()
std::unique_ptr< SmStructureNode > DoStack()
std::unique_ptr< SmTextNode > DoFunction()
void NextTokenColor(SmTokenType dvipload)
const SmErrorDesc * GetError() const
std::unique_ptr< SmNode > DoSubSupEvaluate(std::unique_ptr< SmNode > xGivenNode)
bool TokenInGroup(TG nGroup)
std::unique_ptr< SmSpecialNode > DoSpecial()
std::set< OUString > m_aUsedSymbols
std::unique_ptr< SmStructureNode > DoAttribute()
std::unique_ptr< SmStructureNode > DoFontSize()
const SmErrorDesc * PrevError()
std::unique_ptr< SmNode > DoRelation()
std::unique_ptr< SmNode > DoTerm(bool bGroupNumberIdent)
std::unique_ptr< SmStructureNode > DoBrace()
std::unique_ptr< SmNode > DoEscape()
std::vector< SmErrorDesc > m_aErrDescList
std::unique_ptr< SmNode > DoEvaluate()
std::unique_ptr< SmNode > DoProduct()
std::unique_ptr< SmBinVerNode > DoFrac()
void Replace(sal_Int32 nPos, sal_Int32 nLen, std::u16string_view aText)
std::unique_ptr< SmNode > DoOpSubSup()
std::unique_ptr< SmTableNode > DoTable()
std::unique_ptr< SmBracebodyNode > DoBracebody(bool bIsLeftRight)
bool IsImportSymbolNames() const
std::unique_ptr< SmNode > DoSum()
std::unique_ptr< SmStructureNode > DoMatrix()
std::unique_ptr< SmBlankNode > DoBlank()
std::unique_ptr< SmStructureNode > DoColor()
std::unique_ptr< SmTableNode > DoBinom()
std::unique_ptr< SmNode > DoSubSup(TG nActiveGroup, std::unique_ptr< SmNode > xGivenNode)
std::unique_ptr< SmNode > DoAlign(bool bUseExtraSpaces=true)
std::unique_ptr< SmNode > DoLine()
std::unique_ptr< SmNode > DoPower()
bool IsExportSymbolNames() const
std::unique_ptr< SmNode > ParseExpression(const OUString &rBuffer)
Parse rBuffer to formula subtree that constitutes an expression.
std::unique_ptr< SmStructureNode > DoFont()
std::unique_ptr< SmNode > DoExpression(bool bUseExtraSpaces=true)
std::unique_ptr< SmOperNode > DoOperator()
const CharClass * m_pSysCC
const SmErrorDesc * NextError()
sal_Int32 GetTokenIndex() const
std::unique_ptr< SmGlyphSpecialNode > DoGlyphSpecial()
ESelection m_aCurESelection
std::unique_ptr< SmTableNode > Parse(const OUString &rBuffer)
Parse rBuffer to formula tree.
Super- and subscript node.
Node for vertical brace construction.
#define LANGUAGE_ENGLISH_US
TOOLS_DLLPUBLIC OString convertLineEnd(const OString &rIn, LineEnd eLineEnd)
#define SAL_WARN_IF(condition, area, stream)
#define SAL_WARN(area, stream)
OUString GetExportSymbolName(std::u16string_view rUiName)
OUString GetUiSymbolName(std::u16string_view rExportName)
const SmColorTokenTableEntry * Identify_ColorName_DVIPSNAMES(std::u16string_view colorname)
Identifies color from color name.
const SmColorTokenTableEntry * Identify_ColorName_Parser(std::u16string_view colorname)
Identifies color from color name.
OUString getParseErrorDesc(SmParseError err)
std::vector< SmNode * > SmNodeArray
#define SUBSUP_NUM_ENTRIES
numbers of entries in the above enum (that is: the number of possible sub-/supscripts)
static const SmTokenTableEntry * GetTokenTableEntry(const OUString &rName)
const sal_Int32 coStartFlags
static bool IsDelimiter(const OUString &rTxt, sal_Int32 nPos)
static bool lcl_IsNotWholeNumber16(const OUString &rText)
const sal_Int32 coNumContFlags
const sal_Int32 coNum16StartFlags
const sal_Int32 coNumStartFlags
const sal_Int32 coUserDefinedCharContFlags
static bool lcl_IsNotWholeNumber(const OUString &rText)
const sal_Int32 coNum16ContFlags
static bool findCompare(const SmTokenTableEntry &lhs, const OUString &s)
static bool lcl_IsNumber(const OUString &rText)
const SmTokenTableEntry aTokenTable[]
const sal_Int32 coContFlags
#define DEPTH_LIMIT
Parses the starmath code and creates the nodes.
OUString SmResId(TranslateId aId)
void setChar(sal_Unicode cChar)
TG
The tokens contain the information gathered by the parser.
const sal_Unicode cDelimiter
sal_Unicode const MS_UNDERBRACE
sal_Unicode const MS_DOTSDOWN
sal_Unicode const MS_DVERTLINE
sal_Unicode const MS_TILDE
sal_Unicode const MS_ODOT
sal_Unicode const MS_DOWNARROW
sal_Unicode const MS_INFINITY
sal_Unicode const MS_RIGHTARROW
sal_Unicode const MS_LEFTARROW
sal_Unicode const MS_FACT
sal_Unicode const MS_SUPSET
sal_Unicode const MS_UNION
sal_Unicode const MS_SETN
sal_Unicode const MS_TRANSR
sal_Unicode const MS_LAPLACE
sal_Unicode const MS_TRANSL
sal_Unicode const MS_NOTIN
sal_Unicode const MS_LCEIL
sal_Unicode const MS_IIINT
sal_Unicode const MS_LAMBDABAR
sal_Unicode const MS_LLINT
sal_Unicode const MS_PRECEDES
sal_Unicode const MS_GRAVE
sal_Unicode const MS_RMATHANGLE
sal_Unicode const MS_TIMES
sal_Unicode const MS_CIRC
sal_Unicode const MS_DDOT
sal_Unicode const MS_NSUPSETEQ
sal_Unicode const MS_NDIVIDES
sal_Unicode const MS_LBRACKET
sal_Unicode const MS_SETQ
sal_Unicode const MS_SETR
sal_Unicode const MS_DLINE
sal_Unicode const MS_ALEPH
sal_Unicode const MS_NOTSUCCEEDS
sal_Unicode const MS_SIMEQ
sal_Unicode const MS_LESLANT
sal_Unicode const MS_DDDOT
sal_Unicode const MS_FOURIER
sal_Unicode const MS_PLUS
sal_Unicode const MS_MINUS
sal_Unicode const MS_PROP
sal_Unicode const MS_RFLOOR
sal_Unicode const MS_MINUSPLUS
sal_Unicode const MS_RBRACKET
sal_Unicode const MS_CDOT
sal_Unicode const MS_DRARROW
sal_Unicode const MS_CHECK
sal_Unicode const MS_ASSIGN
sal_Unicode const MS_PLUSMINUS
sal_Unicode const MS_OVERBRACE
sal_Unicode const MS_DLARROW
sal_Unicode const MS_NABLA
sal_Unicode const MS_DOTSUP
sal_Unicode const MS_ACUTE
sal_Unicode const MS_SUCCEEDSEQUAL
sal_Unicode const MS_DOTSLOW
sal_Unicode const MS_OTIMES
sal_Unicode const MS_ODIVIDE
sal_Unicode const MS_INTERSECT
sal_Unicode const MS_RPARENT
sal_Unicode const MS_LFLOOR
sal_Unicode const MS_SETC
sal_Unicode const MS_LLLINT
sal_Unicode const MS_LDBRACKET
sal_Unicode const MS_SETZ
sal_Unicode const MS_CIRCLE
sal_Unicode const MS_RBRACE
sal_Unicode const MS_FORALL
sal_Unicode const MS_RCEIL
sal_Unicode const MS_NOTEXISTS
sal_Unicode const MS_PARTIAL
sal_Unicode const MS_SQRT
sal_Unicode const MS_EQUIV
sal_Unicode const MS_SUCCEEDSEQUIV
sal_Unicode const MS_SUBSETEQ
sal_Unicode const MS_UPARROW
sal_Unicode const MS_PRECEDESEQUAL
sal_Unicode const MS_GESLANT
sal_Unicode const MS_DOTSVERT
sal_Unicode const MS_DOTSAXIS
sal_Unicode const MS_NOTPRECEDES
sal_Unicode const MS_NSUPSET
sal_Unicode const MS_SUCCEEDS
sal_Unicode const MS_HBAR
sal_Unicode const MS_MULTIPLY
sal_Unicode const MS_LINE
sal_Unicode const MS_HARPOON
sal_Unicode const MS_COPROD
sal_Unicode const MS_BACKSLASH
sal_Unicode const MS_LBRACE
sal_Unicode const MS_LMATHANGLE
sal_Unicode const MS_EMPTYSET
sal_Unicode const MS_SUBSET
sal_Unicode const MS_NSUBSETEQ
sal_Unicode const MS_IINT
sal_Unicode const MS_PROD
sal_Unicode const MS_LPARENT
sal_Unicode const MS_BACKEPSILON
sal_Unicode const MS_DLRARROW
sal_Unicode const MS_SUPSETEQ
sal_Unicode const MS_PLACE
sal_Unicode const MS_EXISTS
sal_Unicode const MS_VERTLINE
sal_Unicode const MS_OPLUS
sal_Unicode const MS_RDBRACKET
sal_Unicode const MS_ORTHO
sal_Unicode const MS_PRECEDESEQUIV
sal_Unicode const MS_OMINUS
sal_Unicode const MS_NSUBSET
sal_Unicode const MS_LINT
sal_Unicode const MS_SLASH
sal_Unicode const MS_APPROX
sal_Unicode const MS_BREVE