2553 lines
80 KiB
C++
2553 lines
80 KiB
C++
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
|
|
/*
|
|
* This file is part of the LibreOffice project.
|
|
*
|
|
* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
|
|
*
|
|
* This file incorporates work covered by the following license notice:
|
|
*
|
|
* Licensed to the Apache Software Foundation (ASF) under one or more
|
|
* contributor license agreements. See the NOTICE file distributed
|
|
* with this work for additional information regarding copyright
|
|
* ownership. The ASF licenses this file to you under the Apache
|
|
* License, Version 2.0 (the "License"); you may not use this file
|
|
* except in compliance with the License. You may obtain a copy of
|
|
* the License at http://www.apache.org/licenses/LICENSE-2.0 .
|
|
*/
|
|
|
|
#include <stdio.h>
|
|
|
|
#define SMDLL 1
|
|
|
|
#include <com/sun/star/i18n/UnicodeType.hpp>
|
|
#include <i18npool/lang.h>
|
|
#include <unotools/charclass.hxx>
|
|
#include <editeng/unolingu.hxx>
|
|
#include <unotools/syslocale.hxx>
|
|
#include <sal/macros.h>
|
|
#include "parse.hxx"
|
|
#include "starmath.hrc"
|
|
#include "smdll.hxx"
|
|
#include "smmod.hxx"
|
|
#include "config.hxx"
|
|
|
|
#include "node.hxx"
|
|
|
|
using namespace ::com::sun::star;
|
|
using namespace ::com::sun::star::i18n;
|
|
|
|
///////////////////////////////////////////////////////////////////////////
|
|
|
|
namespace {
|
|
template < typename T >
|
|
T* lcl_popOrZero( ::std::stack<T*> & rStack )
|
|
{
|
|
if (rStack.empty())
|
|
return 0;
|
|
T* pTmp = rStack.top();
|
|
rStack.pop();
|
|
return pTmp;
|
|
}
|
|
}
|
|
|
|
static inline bool strnccmp(const String &u1, xub_StrLen nIdx,
|
|
const sal_Char *s2, xub_StrLen nLen)
|
|
{
|
|
return u1.EqualsIgnoreCaseAscii( s2, nIdx, nLen );
|
|
}
|
|
|
|
static const sal_Unicode aDelimiterTable[] =
|
|
{
|
|
' ', '\t', '\n', '\r', '+', '-', '*', '/', '=', '#',
|
|
'%', '\\', '"', '~', '`', '>', '<', '&', '|', '(',
|
|
')', '{', '}', '[', ']', '^', '_',
|
|
'\0' // end of list symbol
|
|
};
|
|
|
|
|
|
static inline bool IsDigit( sal_Unicode cChar )
|
|
{
|
|
return '0' <= cChar && cChar <= '9';
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////
|
|
|
|
SmToken::SmToken() :
|
|
eType (TUNKNOWN),
|
|
cMathChar ('\0')
|
|
{
|
|
nGroup = nCol = nRow = nLevel = 0;
|
|
}
|
|
|
|
SmToken::SmToken(SmTokenType eTokenType,
|
|
sal_Unicode cMath,
|
|
const sal_Char* pText,
|
|
sal_uLong nTokenGroup,
|
|
sal_uInt16 nTokenLevel) {
|
|
eType = eTokenType;
|
|
cMathChar = cMath;
|
|
aText.AssignAscii(pText);
|
|
nGroup = nTokenGroup;
|
|
nLevel = nTokenLevel;
|
|
nCol = nRow = 0;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
static const SmTokenTableEntry aTokenTable[] =
|
|
{
|
|
{ "Im" , TIM, MS_IM, TGSTANDALONE, 5 },
|
|
{ "MZ23", TDEBUG, '\0', TGATTRIBUT, 0 },
|
|
{ "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},
|
|
{ "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},
|
|
{ "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},
|
|
{ "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},
|
|
{ "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_LANGLE, TGLBRACES, 5},
|
|
{ "lbrace", TLBRACE, MS_LBRACE, TGLBRACES, 5},
|
|
{ "lceil", TLCEIL, MS_LCEIL, TGLBRACES, 5},
|
|
{ "ldbracket", TLDBRACKET, MS_LDBRACKET, TGLBRACES, 5},
|
|
{ "ldline", TLDLINE, MS_DLINE, 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},
|
|
{ "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_LINE, 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},
|
|
{ "matrix", TMATRIX, '\0', 0, 5},
|
|
{ "minusplus", TMINUSPLUS, MS_MINUSPLUS, TGUNOPER | TGSUM, 5},
|
|
{ "mline", TMLINE, MS_LINE, 0, 0}, //! nicht in TGRBRACES, Level 0
|
|
{ "nabla", TNABLA, MS_NABLA, TGSTANDALONE, 5},
|
|
{ "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},
|
|
{ "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},
|
|
{ "rangle", TRANGLE, MS_RANGLE, 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_DLINE, 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_LINE, 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 },
|
|
{ "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},
|
|
{ "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},
|
|
{ "", TEND, '\0', 0, 0}
|
|
};
|
|
|
|
const SmTokenTableEntry * SmParser::GetTokenTableEntry( const String &rName )
|
|
{
|
|
const SmTokenTableEntry * pRes = 0;
|
|
if (rName.Len())
|
|
{
|
|
for (size_t i = 0; i < SAL_N_ELEMENTS(aTokenTable); ++i)
|
|
{
|
|
if (rName.EqualsIgnoreCaseAscii( aTokenTable[i].pIdent ))
|
|
{
|
|
pRes = &aTokenTable[i];
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
return pRes;
|
|
}
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////
|
|
|
|
#if OSL_DEBUG_LEVEL > 1
|
|
|
|
bool SmParser::IsDelimiter( const String &rTxt, xub_StrLen nPos )
|
|
// returns 'true' iff cChar is '\0' or a delimeter
|
|
{
|
|
OSL_ENSURE( nPos <= rTxt.Len(), "index out of range" );
|
|
|
|
sal_Unicode cChar = rTxt.GetChar( nPos );
|
|
if(!cChar)
|
|
return true;
|
|
|
|
// check if 'cChar' is in the delimeter table
|
|
const sal_Unicode *pDelim = &aDelimiterTable[0];
|
|
for ( ; *pDelim != 0; pDelim++)
|
|
if (*pDelim == cChar)
|
|
break;
|
|
|
|
|
|
sal_Int16 nTypJp = SM_MOD()->GetSysLocale().GetCharClass().getType( rTxt, nPos );
|
|
bool bIsDelim = (*pDelim != 0 ||
|
|
nTypJp == com::sun::star::i18n::UnicodeType::SPACE_SEPARATOR ||
|
|
nTypJp == com::sun::star::i18n::UnicodeType::CONTROL);
|
|
|
|
return bIsDelim;
|
|
}
|
|
|
|
#endif
|
|
|
|
void SmParser::Insert(const String &rText, sal_uInt16 nPos)
|
|
{
|
|
m_aBufferString.Insert(rText, nPos);
|
|
|
|
xub_StrLen nLen = rText.Len();
|
|
m_nBufferIndex = m_nBufferIndex + nLen;
|
|
m_nTokenIndex = m_nTokenIndex + nLen;
|
|
}
|
|
|
|
|
|
void SmParser::Replace( sal_uInt16 nPos, sal_uInt16 nLen, const String &rText )
|
|
{
|
|
OSL_ENSURE( nPos + nLen <= m_aBufferString.Len(), "argument mismatch" );
|
|
|
|
m_aBufferString.Replace( nPos, nLen, rText );
|
|
sal_Int16 nChg = rText.Len() - nLen;
|
|
m_nBufferIndex = m_nBufferIndex + nChg;
|
|
m_nTokenIndex = m_nTokenIndex + nChg;
|
|
}
|
|
|
|
|
|
// First character may be any alphabetic
|
|
const sal_Int32 coStartFlags =
|
|
KParseTokens::ANY_LETTER_OR_NUMBER |
|
|
KParseTokens::IGNORE_LEADING_WS;
|
|
|
|
// Continuing characters may be any alphanumeric or dot.
|
|
const sal_Int32 coContFlags =
|
|
((coStartFlags | KParseTokens::ASC_DOT) & ~KParseTokens::IGNORE_LEADING_WS)
|
|
| KParseTokens::TWO_DOUBLE_QUOTES_BREAK_STRING;
|
|
|
|
// First character for numbers, may be any numeric or dot
|
|
const sal_Int32 coNumStartFlags =
|
|
KParseTokens::ASC_DIGIT |
|
|
KParseTokens::ASC_DOT |
|
|
KParseTokens::IGNORE_LEADING_WS;
|
|
// Continuing characters for numbers, may be any numeric or dot.
|
|
const sal_Int32 coNumContFlags =
|
|
(coNumStartFlags | KParseTokens::ASC_DOT) & ~KParseTokens::IGNORE_LEADING_WS;
|
|
|
|
void SmParser::NextToken()
|
|
{
|
|
static const String aEmptyStr;
|
|
|
|
xub_StrLen nBufLen = m_aBufferString.Len();
|
|
ParseResult aRes;
|
|
xub_StrLen nRealStart;
|
|
bool bCont;
|
|
bool bNumStart = false;
|
|
CharClass aCC(SM_MOD()->GetSysLocale().GetCharClass().getLocale());
|
|
do
|
|
{
|
|
// skip white spaces
|
|
while (UnicodeType::SPACE_SEPARATOR ==
|
|
aCC.getType( m_aBufferString, m_nBufferIndex ))
|
|
++m_nBufferIndex;
|
|
|
|
sal_Int32 nStartFlags = coStartFlags;
|
|
sal_Int32 nContFlags = coContFlags;
|
|
sal_Unicode cFirstChar = m_aBufferString.GetChar( m_nBufferIndex );
|
|
aRes = aCC.parseAnyToken( m_aBufferString, m_nBufferIndex,
|
|
nStartFlags, aEmptyStr,
|
|
nContFlags, aEmptyStr );
|
|
|
|
// #i45779# parse numbers correctly
|
|
// i.e. independent from the locale setting.
|
|
// (note that #i11752# remains fixed)
|
|
if ((aRes.TokenType & KParseType::IDENTNAME) && IsDigit( cFirstChar ))
|
|
{
|
|
ParseResult aTmpRes;
|
|
lang::Locale aOldLoc( aCC.getLocale() );
|
|
aCC.setLocale( m_aDotLoc );
|
|
aTmpRes = aCC.parsePredefinedToken(
|
|
KParseType::ASC_NUMBER,
|
|
m_aBufferString, m_nBufferIndex,
|
|
KParseTokens::ASC_DIGIT, aEmptyStr,
|
|
KParseTokens::ASC_DIGIT | KParseTokens::ASC_DOT, aEmptyStr );
|
|
aCC.setLocale( aOldLoc );
|
|
if (aTmpRes.TokenType & KParseType::ASC_NUMBER)
|
|
aRes.TokenType = aTmpRes.TokenType;
|
|
}
|
|
|
|
nRealStart = m_nBufferIndex + sal::static_int_cast< xub_StrLen >(aRes.LeadingWhiteSpace);
|
|
m_nBufferIndex = nRealStart;
|
|
|
|
bCont = false;
|
|
if ( aRes.TokenType == 0 &&
|
|
nRealStart < nBufLen &&
|
|
'\n' == m_aBufferString.GetChar( nRealStart ) )
|
|
{
|
|
// keep data needed for tokens row and col entry up to date
|
|
++m_Row;
|
|
m_nBufferIndex = m_nColOff = nRealStart + 1;
|
|
bCont = true;
|
|
}
|
|
else if (aRes.TokenType & KParseType::ONE_SINGLE_CHAR)
|
|
{
|
|
String aName( m_aBufferString.Copy( nRealStart, 2 ));
|
|
if ( aName.EqualsAscii( "%%" ))
|
|
{
|
|
//SkipComment
|
|
m_nBufferIndex = nRealStart + 2;
|
|
while (m_nBufferIndex < nBufLen &&
|
|
'\n' != m_aBufferString.GetChar( m_nBufferIndex ))
|
|
++m_nBufferIndex;
|
|
bCont = true;
|
|
}
|
|
}
|
|
|
|
} while (bCont);
|
|
|
|
// set index of current token
|
|
m_nTokenIndex = m_nBufferIndex;
|
|
|
|
m_aCurToken.nRow = m_Row;
|
|
m_aCurToken.nCol = nRealStart - m_nColOff + 1;
|
|
|
|
bool bHandled = true;
|
|
if (nRealStart >= nBufLen)
|
|
{
|
|
m_aCurToken.eType = TEND;
|
|
m_aCurToken.cMathChar = '\0';
|
|
m_aCurToken.nGroup = 0;
|
|
m_aCurToken.nLevel = 0;
|
|
m_aCurToken.aText.Erase();
|
|
}
|
|
else if ((aRes.TokenType & (KParseType::ASC_NUMBER | KParseType::UNI_NUMBER))
|
|
|| (bNumStart && (aRes.TokenType & KParseType::IDENTNAME)))
|
|
{
|
|
sal_Int32 n = aRes.EndPos - nRealStart;
|
|
OSL_ENSURE( n >= 0, "length < 0" );
|
|
m_aCurToken.eType = TNUMBER;
|
|
m_aCurToken.cMathChar = '\0';
|
|
m_aCurToken.nGroup = 0;
|
|
m_aCurToken.nLevel = 5;
|
|
m_aCurToken.aText = m_aBufferString.Copy( nRealStart, sal::static_int_cast< xub_StrLen >(n) );
|
|
|
|
#if OSL_DEBUG_LEVEL > 1
|
|
if (!IsDelimiter( m_aBufferString, static_cast< xub_StrLen >(aRes.EndPos) ))
|
|
{
|
|
OSL_FAIL( "identifier really finished? (compatibility!)" );
|
|
}
|
|
#endif
|
|
}
|
|
else if (aRes.TokenType & KParseType::DOUBLE_QUOTE_STRING)
|
|
{
|
|
m_aCurToken.eType = TTEXT;
|
|
m_aCurToken.cMathChar = '\0';
|
|
m_aCurToken.nGroup = 0;
|
|
m_aCurToken.nLevel = 5;
|
|
m_aCurToken.aText = aRes.DequotedNameOrString;
|
|
m_aCurToken.nRow = m_Row;
|
|
m_aCurToken.nCol = nRealStart - m_nColOff + 2;
|
|
}
|
|
else if (aRes.TokenType & KParseType::IDENTNAME)
|
|
{
|
|
sal_Int32 n = aRes.EndPos - nRealStart;
|
|
OSL_ENSURE( n >= 0, "length < 0" );
|
|
String aName( m_aBufferString.Copy( nRealStart, sal::static_int_cast< xub_StrLen >(n) ) );
|
|
const SmTokenTableEntry *pEntry = GetTokenTableEntry( aName );
|
|
|
|
if (pEntry)
|
|
{
|
|
m_aCurToken.eType = pEntry->eType;
|
|
m_aCurToken.cMathChar = pEntry->cMathChar;
|
|
m_aCurToken.nGroup = pEntry->nGroup;
|
|
m_aCurToken.nLevel = pEntry->nLevel;
|
|
m_aCurToken.aText.AssignAscii( pEntry->pIdent );
|
|
}
|
|
else
|
|
{
|
|
m_aCurToken.eType = TIDENT;
|
|
m_aCurToken.cMathChar = '\0';
|
|
m_aCurToken.nGroup = 0;
|
|
m_aCurToken.nLevel = 5;
|
|
m_aCurToken.aText = aName;
|
|
|
|
#if OSL_DEBUG_LEVEL > 1
|
|
if (!IsDelimiter( m_aBufferString, static_cast< xub_StrLen >(aRes.EndPos) ))
|
|
{
|
|
OSL_FAIL( "identifier really finished? (compatibility!)" );
|
|
}
|
|
#endif
|
|
}
|
|
}
|
|
else if (aRes.TokenType == 0 && '_' == m_aBufferString.GetChar( nRealStart ))
|
|
{
|
|
m_aCurToken.eType = TRSUB;
|
|
m_aCurToken.cMathChar = '\0';
|
|
m_aCurToken.nGroup = TGPOWER;
|
|
m_aCurToken.nLevel = 0;
|
|
m_aCurToken.aText.AssignAscii( "_" );
|
|
|
|
aRes.EndPos = nRealStart + 1;
|
|
}
|
|
else if (aRes.TokenType & KParseType::BOOLEAN)
|
|
{
|
|
sal_Int32 &rnEndPos = aRes.EndPos;
|
|
String aName( m_aBufferString.Copy( nRealStart,
|
|
sal::static_int_cast< xub_StrLen >(rnEndPos - nRealStart) ));
|
|
if (2 >= aName.Len())
|
|
{
|
|
sal_Unicode ch = aName.GetChar( 0 );
|
|
switch (ch)
|
|
{
|
|
case '<':
|
|
{
|
|
if (m_aBufferString.Copy( nRealStart, 2 ).
|
|
EqualsAscii( "<<" ))
|
|
{
|
|
m_aCurToken.eType = TLL;
|
|
m_aCurToken.cMathChar = MS_LL;
|
|
m_aCurToken.nGroup = TGRELATION;
|
|
m_aCurToken.nLevel = 0;
|
|
m_aCurToken.aText.AssignAscii( "<<" );
|
|
|
|
rnEndPos = nRealStart + 2;
|
|
}
|
|
else if (m_aBufferString.Copy( nRealStart, 2 ).
|
|
EqualsAscii( "<=" ))
|
|
{
|
|
m_aCurToken.eType = TLE;
|
|
m_aCurToken.cMathChar = MS_LE;
|
|
m_aCurToken.nGroup = TGRELATION;
|
|
m_aCurToken.nLevel = 0;
|
|
m_aCurToken.aText.AssignAscii( "<=" );
|
|
|
|
rnEndPos = nRealStart + 2;
|
|
}
|
|
else if (m_aBufferString.Copy( nRealStart, 2 ).
|
|
EqualsAscii( "<>" ))
|
|
{
|
|
m_aCurToken.eType = TNEQ;
|
|
m_aCurToken.cMathChar = MS_NEQ;
|
|
m_aCurToken.nGroup = TGRELATION;
|
|
m_aCurToken.nLevel = 0;
|
|
m_aCurToken.aText.AssignAscii( "<>" );
|
|
|
|
rnEndPos = nRealStart + 2;
|
|
}
|
|
else if (m_aBufferString.Copy( nRealStart, 3 ).
|
|
EqualsAscii( "<?>" ))
|
|
{
|
|
m_aCurToken.eType = TPLACE;
|
|
m_aCurToken.cMathChar = MS_PLACE;
|
|
m_aCurToken.nGroup = 0;
|
|
m_aCurToken.nLevel = 5;
|
|
m_aCurToken.aText.AssignAscii( "<?>" );
|
|
|
|
rnEndPos = nRealStart + 3;
|
|
}
|
|
else
|
|
{
|
|
m_aCurToken.eType = TLT;
|
|
m_aCurToken.cMathChar = MS_LT;
|
|
m_aCurToken.nGroup = TGRELATION;
|
|
m_aCurToken.nLevel = 0;
|
|
m_aCurToken.aText.AssignAscii( "<" );
|
|
}
|
|
}
|
|
break;
|
|
case '>':
|
|
{
|
|
if (m_aBufferString.Copy( nRealStart, 2 ).
|
|
EqualsAscii( ">=" ))
|
|
{
|
|
m_aCurToken.eType = TGE;
|
|
m_aCurToken.cMathChar = MS_GE;
|
|
m_aCurToken.nGroup = TGRELATION;
|
|
m_aCurToken.nLevel = 0;
|
|
m_aCurToken.aText.AssignAscii( ">=" );
|
|
|
|
rnEndPos = nRealStart + 2;
|
|
}
|
|
else if (m_aBufferString.Copy( nRealStart, 2 ).
|
|
EqualsAscii( ">>" ))
|
|
{
|
|
m_aCurToken.eType = TGG;
|
|
m_aCurToken.cMathChar = MS_GG;
|
|
m_aCurToken.nGroup = TGRELATION;
|
|
m_aCurToken.nLevel = 0;
|
|
m_aCurToken.aText.AssignAscii( ">>" );
|
|
|
|
rnEndPos = nRealStart + 2;
|
|
}
|
|
else
|
|
{
|
|
m_aCurToken.eType = TGT;
|
|
m_aCurToken.cMathChar = MS_GT;
|
|
m_aCurToken.nGroup = TGRELATION;
|
|
m_aCurToken.nLevel = 0;
|
|
m_aCurToken.aText.AssignAscii( ">" );
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
bHandled = false;
|
|
}
|
|
}
|
|
}
|
|
else if (aRes.TokenType & KParseType::ONE_SINGLE_CHAR)
|
|
{
|
|
sal_Int32 &rnEndPos = aRes.EndPos;
|
|
String aName( m_aBufferString.Copy( nRealStart,
|
|
sal::static_int_cast< xub_StrLen >(rnEndPos - nRealStart) ) );
|
|
|
|
if (1 == aName.Len())
|
|
{
|
|
sal_Unicode ch = aName.GetChar( 0 );
|
|
switch (ch)
|
|
{
|
|
case '%':
|
|
{
|
|
//! modifies aRes.EndPos
|
|
|
|
OSL_ENSURE( rnEndPos >= nBufLen ||
|
|
'%' != m_aBufferString.GetChar( sal::static_int_cast< xub_StrLen >(rnEndPos) ),
|
|
"unexpected comment start" );
|
|
|
|
// get identifier of user-defined character
|
|
ParseResult aTmpRes = aCC.parseAnyToken(
|
|
m_aBufferString, rnEndPos,
|
|
KParseTokens::ANY_LETTER,
|
|
aEmptyStr,
|
|
coContFlags,
|
|
aEmptyStr );
|
|
|
|
xub_StrLen nTmpStart = sal::static_int_cast< xub_StrLen >(rnEndPos +
|
|
aTmpRes.LeadingWhiteSpace);
|
|
|
|
// default setting for the case that no identifier
|
|
// i.e. a valid symbol-name is following the '%'
|
|
// character
|
|
m_aCurToken.eType = TTEXT;
|
|
m_aCurToken.cMathChar = '\0';
|
|
m_aCurToken.nGroup = 0;
|
|
m_aCurToken.nLevel = 5;
|
|
m_aCurToken.aText = String();
|
|
m_aCurToken.nRow = sal::static_int_cast< xub_StrLen >(m_Row);
|
|
m_aCurToken.nCol = nTmpStart - m_nColOff;
|
|
|
|
if (aTmpRes.TokenType & KParseType::IDENTNAME)
|
|
{
|
|
|
|
xub_StrLen n = sal::static_int_cast< xub_StrLen >(aTmpRes.EndPos - nTmpStart);
|
|
m_aCurToken.eType = TSPECIAL;
|
|
m_aCurToken.aText = m_aBufferString.Copy( sal::static_int_cast< xub_StrLen >(nTmpStart-1), n+1 );
|
|
|
|
OSL_ENSURE( aTmpRes.EndPos > rnEndPos,
|
|
"empty identifier" );
|
|
if (aTmpRes.EndPos > rnEndPos)
|
|
rnEndPos = aTmpRes.EndPos;
|
|
else
|
|
++rnEndPos;
|
|
}
|
|
|
|
// if no symbol-name was found we start-over with
|
|
// finding the next token right afer the '%' sign.
|
|
// I.e. we leave rnEndPos unmodified.
|
|
}
|
|
break;
|
|
case '[':
|
|
{
|
|
m_aCurToken.eType = TLBRACKET;
|
|
m_aCurToken.cMathChar = MS_LBRACKET;
|
|
m_aCurToken.nGroup = TGLBRACES;
|
|
m_aCurToken.nLevel = 5;
|
|
m_aCurToken.aText.AssignAscii( "[" );
|
|
}
|
|
break;
|
|
case '\\':
|
|
{
|
|
m_aCurToken.eType = TESCAPE;
|
|
m_aCurToken.cMathChar = '\0';
|
|
m_aCurToken.nGroup = 0;
|
|
m_aCurToken.nLevel = 5;
|
|
m_aCurToken.aText.AssignAscii( "\\" );
|
|
}
|
|
break;
|
|
case ']':
|
|
{
|
|
m_aCurToken.eType = TRBRACKET;
|
|
m_aCurToken.cMathChar = MS_RBRACKET;
|
|
m_aCurToken.nGroup = TGRBRACES;
|
|
m_aCurToken.nLevel = 0;
|
|
m_aCurToken.aText.AssignAscii( "]" );
|
|
}
|
|
break;
|
|
case '^':
|
|
{
|
|
m_aCurToken.eType = TRSUP;
|
|
m_aCurToken.cMathChar = '\0';
|
|
m_aCurToken.nGroup = TGPOWER;
|
|
m_aCurToken.nLevel = 0;
|
|
m_aCurToken.aText.AssignAscii( "^" );
|
|
}
|
|
break;
|
|
case '`':
|
|
{
|
|
m_aCurToken.eType = TSBLANK;
|
|
m_aCurToken.cMathChar = '\0';
|
|
m_aCurToken.nGroup = TGBLANK;
|
|
m_aCurToken.nLevel = 5;
|
|
m_aCurToken.aText.AssignAscii( "`" );
|
|
}
|
|
break;
|
|
case '{':
|
|
{
|
|
m_aCurToken.eType = TLGROUP;
|
|
m_aCurToken.cMathChar = MS_LBRACE;
|
|
m_aCurToken.nGroup = 0;
|
|
m_aCurToken.nLevel = 5;
|
|
m_aCurToken.aText.AssignAscii( "{" );
|
|
}
|
|
break;
|
|
case '|':
|
|
{
|
|
m_aCurToken.eType = TOR;
|
|
m_aCurToken.cMathChar = MS_OR;
|
|
m_aCurToken.nGroup = TGSUM;
|
|
m_aCurToken.nLevel = 0;
|
|
m_aCurToken.aText.AssignAscii( "|" );
|
|
}
|
|
break;
|
|
case '}':
|
|
{
|
|
m_aCurToken.eType = TRGROUP;
|
|
m_aCurToken.cMathChar = MS_RBRACE;
|
|
m_aCurToken.nGroup = 0;
|
|
m_aCurToken.nLevel = 0;
|
|
m_aCurToken.aText.AssignAscii( "}" );
|
|
}
|
|
break;
|
|
case '~':
|
|
{
|
|
m_aCurToken.eType = TBLANK;
|
|
m_aCurToken.cMathChar = '\0';
|
|
m_aCurToken.nGroup = TGBLANK;
|
|
m_aCurToken.nLevel = 5;
|
|
m_aCurToken.aText.AssignAscii( "~" );
|
|
}
|
|
break;
|
|
case '#':
|
|
{
|
|
if (m_aBufferString.Copy( nRealStart, 2 ).
|
|
EqualsAscii( "##" ))
|
|
{
|
|
m_aCurToken.eType = TDPOUND;
|
|
m_aCurToken.cMathChar = '\0';
|
|
m_aCurToken.nGroup = 0;
|
|
m_aCurToken.nLevel = 0;
|
|
m_aCurToken.aText.AssignAscii( "##" );
|
|
|
|
rnEndPos = nRealStart + 2;
|
|
}
|
|
else
|
|
{
|
|
m_aCurToken.eType = TPOUND;
|
|
m_aCurToken.cMathChar = '\0';
|
|
m_aCurToken.nGroup = 0;
|
|
m_aCurToken.nLevel = 0;
|
|
m_aCurToken.aText.AssignAscii( "#" );
|
|
}
|
|
}
|
|
break;
|
|
case '&':
|
|
{
|
|
m_aCurToken.eType = TAND;
|
|
m_aCurToken.cMathChar = MS_AND;
|
|
m_aCurToken.nGroup = TGPRODUCT;
|
|
m_aCurToken.nLevel = 0;
|
|
m_aCurToken.aText.AssignAscii( "&" );
|
|
}
|
|
break;
|
|
case '(':
|
|
{
|
|
m_aCurToken.eType = TLPARENT;
|
|
m_aCurToken.cMathChar = MS_LPARENT;
|
|
m_aCurToken.nGroup = TGLBRACES;
|
|
m_aCurToken.nLevel = 5; //! 0 to continue expression
|
|
m_aCurToken.aText.AssignAscii( "(" );
|
|
}
|
|
break;
|
|
case ')':
|
|
{
|
|
m_aCurToken.eType = TRPARENT;
|
|
m_aCurToken.cMathChar = MS_RPARENT;
|
|
m_aCurToken.nGroup = TGRBRACES;
|
|
m_aCurToken.nLevel = 0; //! 0 to terminate expression
|
|
m_aCurToken.aText.AssignAscii( ")" );
|
|
}
|
|
break;
|
|
case '*':
|
|
{
|
|
m_aCurToken.eType = TMULTIPLY;
|
|
m_aCurToken.cMathChar = MS_MULTIPLY;
|
|
m_aCurToken.nGroup = TGPRODUCT;
|
|
m_aCurToken.nLevel = 0;
|
|
m_aCurToken.aText.AssignAscii( "*" );
|
|
}
|
|
break;
|
|
case '+':
|
|
{
|
|
if (m_aBufferString.Copy( nRealStart, 2 ).
|
|
EqualsAscii( "+-" ))
|
|
{
|
|
m_aCurToken.eType = TPLUSMINUS;
|
|
m_aCurToken.cMathChar = MS_PLUSMINUS;
|
|
m_aCurToken.nGroup = TGUNOPER | TGSUM;
|
|
m_aCurToken.nLevel = 5;
|
|
m_aCurToken.aText.AssignAscii( "+-" );
|
|
|
|
rnEndPos = nRealStart + 2;
|
|
}
|
|
else
|
|
{
|
|
m_aCurToken.eType = TPLUS;
|
|
m_aCurToken.cMathChar = MS_PLUS;
|
|
m_aCurToken.nGroup = TGUNOPER | TGSUM;
|
|
m_aCurToken.nLevel = 5;
|
|
m_aCurToken.aText.AssignAscii( "+" );
|
|
}
|
|
}
|
|
break;
|
|
case '-':
|
|
{
|
|
if (m_aBufferString.Copy( nRealStart, 2 ).
|
|
EqualsAscii( "-+" ))
|
|
{
|
|
m_aCurToken.eType = TMINUSPLUS;
|
|
m_aCurToken.cMathChar = MS_MINUSPLUS;
|
|
m_aCurToken.nGroup = TGUNOPER | TGSUM;
|
|
m_aCurToken.nLevel = 5;
|
|
m_aCurToken.aText.AssignAscii( "-+" );
|
|
|
|
rnEndPos = nRealStart + 2;
|
|
}
|
|
else
|
|
{
|
|
m_aCurToken.eType = TMINUS;
|
|
m_aCurToken.cMathChar = MS_MINUS;
|
|
m_aCurToken.nGroup = TGUNOPER | TGSUM;
|
|
m_aCurToken.nLevel = 5;
|
|
m_aCurToken.aText.AssignAscii( "-" );
|
|
}
|
|
}
|
|
break;
|
|
case '.':
|
|
{
|
|
// for compatibility with SO5.2
|
|
// texts like .34 ...56 ... h ...78..90
|
|
// will be treated as numbers
|
|
m_aCurToken.eType = TNUMBER;
|
|
m_aCurToken.cMathChar = '\0';
|
|
m_aCurToken.nGroup = 0;
|
|
m_aCurToken.nLevel = 5;
|
|
|
|
xub_StrLen nTxtStart = m_nBufferIndex;
|
|
sal_Unicode cChar;
|
|
do
|
|
{
|
|
cChar = m_aBufferString.GetChar( ++m_nBufferIndex );
|
|
}
|
|
while ( cChar == '.' || IsDigit( cChar ) );
|
|
|
|
m_aCurToken.aText = m_aBufferString.Copy( sal::static_int_cast< xub_StrLen >(nTxtStart),
|
|
sal::static_int_cast< xub_StrLen >(m_nBufferIndex - nTxtStart) );
|
|
aRes.EndPos = m_nBufferIndex;
|
|
}
|
|
break;
|
|
case '/':
|
|
{
|
|
m_aCurToken.eType = TDIVIDEBY;
|
|
m_aCurToken.cMathChar = MS_SLASH;
|
|
m_aCurToken.nGroup = TGPRODUCT;
|
|
m_aCurToken.nLevel = 0;
|
|
m_aCurToken.aText.AssignAscii( "/" );
|
|
}
|
|
break;
|
|
case '=':
|
|
{
|
|
m_aCurToken.eType = TASSIGN;
|
|
m_aCurToken.cMathChar = MS_ASSIGN;
|
|
m_aCurToken.nGroup = TGRELATION;
|
|
m_aCurToken.nLevel = 0;
|
|
m_aCurToken.aText.AssignAscii( "=" );
|
|
}
|
|
break;
|
|
default:
|
|
bHandled = false;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
bHandled = false;
|
|
|
|
if (!bHandled)
|
|
{
|
|
m_aCurToken.eType = TCHARACTER;
|
|
m_aCurToken.cMathChar = '\0';
|
|
m_aCurToken.nGroup = 0;
|
|
m_aCurToken.nLevel = 5;
|
|
m_aCurToken.aText = m_aBufferString.Copy( nRealStart, 1 );
|
|
|
|
aRes.EndPos = nRealStart + 1;
|
|
}
|
|
|
|
if (TEND != m_aCurToken.eType)
|
|
m_nBufferIndex = sal::static_int_cast< xub_StrLen >(aRes.EndPos);
|
|
}
|
|
|
|
|
|
////////////////////////////////////////
|
|
// grammar
|
|
//
|
|
|
|
|
|
void SmParser::Table()
|
|
{
|
|
SmNodeArray LineArray;
|
|
|
|
Line();
|
|
while (m_aCurToken.eType == TNEWLINE)
|
|
{
|
|
NextToken();
|
|
Line();
|
|
}
|
|
|
|
if (m_aCurToken.eType != TEND)
|
|
Error(PE_UNEXPECTED_CHAR);
|
|
|
|
sal_uLong n = m_aNodeStack.size();
|
|
|
|
LineArray.resize(n);
|
|
|
|
for (sal_uLong i = 0; i < n; i++)
|
|
{
|
|
LineArray[n - (i + 1)] = m_aNodeStack.top();
|
|
m_aNodeStack.pop();
|
|
}
|
|
|
|
SmStructureNode *pSNode = new SmTableNode(m_aCurToken);
|
|
pSNode->SetSubNodes(LineArray);
|
|
m_aNodeStack.push(pSNode);
|
|
}
|
|
|
|
|
|
void SmParser::Align()
|
|
// parse alignment info (if any), then go on with rest of expression
|
|
{
|
|
SmStructureNode *pSNode = 0;
|
|
bool bNeedGroupClose = false;
|
|
|
|
if (TokenInGroup(TGALIGN))
|
|
{
|
|
if (CONVERT_40_TO_50 == GetConversion())
|
|
// encapsulate expression to be aligned in group braces
|
|
// (here group-open brace)
|
|
{ Insert(rtl::OUString('{'), GetTokenIndex());
|
|
bNeedGroupClose = true;
|
|
|
|
// get first valid align statement in sequence
|
|
// (the dominant one in 4.0) and erase all others (especially old
|
|
// discarded tokens) from command string.
|
|
while (TokenInGroup(TGALIGN))
|
|
{
|
|
if (TokenInGroup(TGDISCARDED) || pSNode)
|
|
{
|
|
m_nBufferIndex = GetTokenIndex();
|
|
m_aBufferString.Erase(m_nBufferIndex, m_aCurToken.aText.Len());
|
|
}
|
|
else
|
|
pSNode = new SmAlignNode(m_aCurToken);
|
|
|
|
NextToken();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pSNode = new SmAlignNode(m_aCurToken);
|
|
|
|
NextToken();
|
|
|
|
// allow for just one align statement in 5.0
|
|
if (CONVERT_40_TO_50 != GetConversion() && TokenInGroup(TGALIGN))
|
|
{ Error(PE_DOUBLE_ALIGN);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
Expression();
|
|
|
|
if (bNeedGroupClose)
|
|
Insert(rtl::OUString('}'), GetTokenIndex());
|
|
|
|
if (pSNode)
|
|
{
|
|
pSNode->SetSubNodes(lcl_popOrZero(m_aNodeStack), 0);
|
|
m_aNodeStack.push(pSNode);
|
|
}
|
|
}
|
|
|
|
|
|
void SmParser::Line()
|
|
{
|
|
sal_uInt16 n = 0;
|
|
SmNodeArray ExpressionArray;
|
|
|
|
ExpressionArray.resize(n);
|
|
|
|
// start with single expression that may have an alignment statement
|
|
// (and go on with expressions that must not have alignment
|
|
// statements in 'while' loop below. See also 'Expression()'.)
|
|
if (m_aCurToken.eType != TEND && m_aCurToken.eType != TNEWLINE)
|
|
{ Align();
|
|
ExpressionArray.resize(++n);
|
|
ExpressionArray[n - 1] = lcl_popOrZero(m_aNodeStack);
|
|
}
|
|
|
|
while (m_aCurToken.eType != TEND && m_aCurToken.eType != TNEWLINE)
|
|
{ if (CONVERT_40_TO_50 != GetConversion())
|
|
Expression();
|
|
else
|
|
Align();
|
|
ExpressionArray.resize(++n);
|
|
ExpressionArray[n - 1] = lcl_popOrZero(m_aNodeStack);
|
|
}
|
|
|
|
//If there's no expression, add an empty one.
|
|
//this is to avoid a formula tree without any caret
|
|
//positions, in visual formula editor.
|
|
if(ExpressionArray.empty())
|
|
ExpressionArray.push_back(new SmExpressionNode(SmToken()));
|
|
|
|
SmStructureNode *pSNode = new SmLineNode(m_aCurToken);
|
|
pSNode->SetSubNodes(ExpressionArray);
|
|
m_aNodeStack.push(pSNode);
|
|
}
|
|
|
|
|
|
void SmParser::Expression()
|
|
{
|
|
bool bUseExtraSpaces = true;
|
|
if (!m_aNodeStack.empty())
|
|
{
|
|
SmNode *pNode = m_aNodeStack.top();
|
|
m_aNodeStack.pop();
|
|
if (pNode->GetToken().eType == TNOSPACE)
|
|
bUseExtraSpaces = false;
|
|
else
|
|
m_aNodeStack.push(pNode); // push the node from above again (now to be used as argument to this current 'nospace' node)
|
|
}
|
|
|
|
sal_uInt16 n = 0;
|
|
SmNodeArray RelationArray;
|
|
|
|
RelationArray.resize(n);
|
|
|
|
Relation();
|
|
RelationArray.resize(++n);
|
|
RelationArray[n - 1] = lcl_popOrZero(m_aNodeStack);
|
|
|
|
while (m_aCurToken.nLevel >= 4)
|
|
{ Relation();
|
|
RelationArray.resize(++n);
|
|
RelationArray[n - 1] = lcl_popOrZero(m_aNodeStack);
|
|
}
|
|
|
|
SmExpressionNode *pSNode = new SmExpressionNode(m_aCurToken);
|
|
pSNode->SetSubNodes(RelationArray);
|
|
pSNode->SetUseExtraSpaces(bUseExtraSpaces);
|
|
m_aNodeStack.push(pSNode);
|
|
}
|
|
|
|
|
|
void SmParser::Relation()
|
|
{
|
|
Sum();
|
|
while (TokenInGroup(TGRELATION))
|
|
{
|
|
SmStructureNode *pSNode = new SmBinHorNode(m_aCurToken);
|
|
SmNode *pFirst = lcl_popOrZero(m_aNodeStack);
|
|
|
|
OpSubSup();
|
|
SmNode *pSecond = lcl_popOrZero(m_aNodeStack);
|
|
|
|
Sum();
|
|
|
|
pSNode->SetSubNodes(pFirst, pSecond, lcl_popOrZero(m_aNodeStack));
|
|
m_aNodeStack.push(pSNode);
|
|
}
|
|
}
|
|
|
|
|
|
void SmParser::Sum()
|
|
{
|
|
Product();
|
|
while (TokenInGroup(TGSUM))
|
|
{
|
|
SmStructureNode *pSNode = new SmBinHorNode(m_aCurToken);
|
|
SmNode *pFirst = lcl_popOrZero(m_aNodeStack);
|
|
|
|
OpSubSup();
|
|
SmNode *pSecond = lcl_popOrZero(m_aNodeStack);
|
|
|
|
Product();
|
|
|
|
pSNode->SetSubNodes(pFirst, pSecond, lcl_popOrZero(m_aNodeStack));
|
|
m_aNodeStack.push(pSNode);
|
|
}
|
|
}
|
|
|
|
|
|
void SmParser::Product()
|
|
{
|
|
Power();
|
|
|
|
while (TokenInGroup(TGPRODUCT))
|
|
{ SmStructureNode *pSNode;
|
|
SmNode *pFirst = lcl_popOrZero(m_aNodeStack),
|
|
*pOper;
|
|
bool bSwitchArgs = false;
|
|
|
|
SmTokenType eType = m_aCurToken.eType;
|
|
switch (eType)
|
|
{
|
|
case TOVER:
|
|
pSNode = new SmBinVerNode(m_aCurToken);
|
|
pOper = new SmRectangleNode(m_aCurToken);
|
|
NextToken();
|
|
break;
|
|
|
|
case TBOPER:
|
|
pSNode = new SmBinHorNode(m_aCurToken);
|
|
|
|
NextToken();
|
|
|
|
//Let the glyph node know it's a binary operation
|
|
m_aCurToken.eType = TBOPER;
|
|
m_aCurToken.nGroup = TGPRODUCT;
|
|
|
|
GlyphSpecial();
|
|
pOper = lcl_popOrZero(m_aNodeStack);
|
|
break;
|
|
|
|
case TOVERBRACE :
|
|
case TUNDERBRACE :
|
|
pSNode = new SmVerticalBraceNode(m_aCurToken);
|
|
pOper = new SmMathSymbolNode(m_aCurToken);
|
|
|
|
NextToken();
|
|
break;
|
|
|
|
case TWIDEBACKSLASH:
|
|
case TWIDESLASH:
|
|
{
|
|
SmBinDiagonalNode *pSTmp = new SmBinDiagonalNode(m_aCurToken);
|
|
pSTmp->SetAscending(eType == TWIDESLASH);
|
|
pSNode = pSTmp;
|
|
|
|
pOper = new SmPolyLineNode(m_aCurToken);
|
|
NextToken();
|
|
|
|
bSwitchArgs = true;
|
|
break;
|
|
}
|
|
|
|
default:
|
|
pSNode = new SmBinHorNode(m_aCurToken);
|
|
|
|
OpSubSup();
|
|
pOper = lcl_popOrZero(m_aNodeStack);
|
|
}
|
|
|
|
Power();
|
|
|
|
if (bSwitchArgs)
|
|
{
|
|
//! vgl siehe SmBinDiagonalNode::Arrange
|
|
pSNode->SetSubNodes(pFirst, lcl_popOrZero(m_aNodeStack), pOper);
|
|
}
|
|
else
|
|
{
|
|
pSNode->SetSubNodes(pFirst, pOper, lcl_popOrZero(m_aNodeStack));
|
|
}
|
|
m_aNodeStack.push(pSNode);
|
|
}
|
|
}
|
|
|
|
|
|
void SmParser::SubSup(sal_uLong nActiveGroup)
|
|
{
|
|
OSL_ENSURE(nActiveGroup == TGPOWER || nActiveGroup == TGLIMIT,
|
|
"Sm: wrong token group");
|
|
|
|
if (!TokenInGroup(nActiveGroup))
|
|
// already finish
|
|
return;
|
|
|
|
SmSubSupNode *pNode = new SmSubSupNode(m_aCurToken);
|
|
//! Of course 'm_aCurToken' is just the first sub-/supscript token.
|
|
//! It should be of no further interest. The positions of the
|
|
//! sub-/supscripts will be identified by the corresponding subnodes
|
|
//! index in the 'aSubNodes' array (enum value from 'SmSubSup').
|
|
|
|
pNode->SetUseLimits(nActiveGroup == TGLIMIT);
|
|
|
|
// initialize subnodes array
|
|
SmNodeArray aSubNodes;
|
|
aSubNodes.resize(1 + SUBSUP_NUM_ENTRIES);
|
|
aSubNodes[0] = lcl_popOrZero(m_aNodeStack);
|
|
for (sal_uInt16 i = 1; i < aSubNodes.size(); i++)
|
|
aSubNodes[i] = NULL;
|
|
|
|
// process all sub-/supscripts
|
|
int nIndex = 0;
|
|
while (TokenInGroup(nActiveGroup))
|
|
{ SmTokenType eType (m_aCurToken.eType);
|
|
|
|
// skip sub-/supscript token
|
|
NextToken();
|
|
|
|
// get sub-/supscript node on top of stack
|
|
if (eType == TFROM || eType == TTO)
|
|
{
|
|
// parse limits in old 4.0 and 5.0 style
|
|
Relation();
|
|
}
|
|
else
|
|
Term();
|
|
|
|
switch (eType)
|
|
{ case TRSUB : nIndex = (int) RSUB; break;
|
|
case TRSUP : nIndex = (int) RSUP; break;
|
|
case TFROM :
|
|
case TCSUB : nIndex = (int) CSUB; break;
|
|
case TTO :
|
|
case TCSUP : nIndex = (int) CSUP; break;
|
|
case TLSUB : nIndex = (int) LSUB; break;
|
|
case TLSUP : nIndex = (int) LSUP; break;
|
|
default :
|
|
OSL_FAIL("Sm: unknown case");
|
|
}
|
|
nIndex++;
|
|
OSL_ENSURE(1 <= nIndex && nIndex <= 1 + SUBSUP_NUM_ENTRIES,
|
|
"SmParser::Power() : sub-/supscript index falsch");
|
|
|
|
// set sub-/supscript if not already done
|
|
if (aSubNodes[nIndex] != NULL)
|
|
Error(PE_DOUBLE_SUBSUPSCRIPT);
|
|
aSubNodes[nIndex] = lcl_popOrZero(m_aNodeStack);
|
|
}
|
|
|
|
pNode->SetSubNodes(aSubNodes);
|
|
m_aNodeStack.push(pNode);
|
|
}
|
|
|
|
|
|
void SmParser::OpSubSup()
|
|
{
|
|
// push operator symbol
|
|
m_aNodeStack.push(new SmMathSymbolNode(m_aCurToken));
|
|
// skip operator token
|
|
NextToken();
|
|
// get sub- supscripts if any
|
|
if (TokenInGroup(TGPOWER))
|
|
SubSup(TGPOWER);
|
|
}
|
|
|
|
|
|
void SmParser::Power()
|
|
{
|
|
// get body for sub- supscripts on top of stack
|
|
Term();
|
|
|
|
SubSup(TGPOWER);
|
|
}
|
|
|
|
|
|
void SmParser::Blank()
|
|
{
|
|
OSL_ENSURE(TokenInGroup(TGBLANK), "Sm : wrong token");
|
|
SmBlankNode *pBlankNode = new SmBlankNode(m_aCurToken);
|
|
|
|
while (TokenInGroup(TGBLANK))
|
|
{
|
|
pBlankNode->IncreaseBy(m_aCurToken);
|
|
NextToken();
|
|
}
|
|
|
|
// Blanks am Zeilenende ignorieren wenn die entsprechende Option gesetzt ist
|
|
if ( m_aCurToken.eType == TNEWLINE ||
|
|
(m_aCurToken.eType == TEND && SM_MOD()->GetConfig()->IsIgnoreSpacesRight()) )
|
|
{
|
|
pBlankNode->Clear();
|
|
}
|
|
|
|
m_aNodeStack.push(pBlankNode);
|
|
}
|
|
|
|
|
|
void SmParser::Term()
|
|
{
|
|
switch (m_aCurToken.eType)
|
|
{
|
|
case TESCAPE :
|
|
Escape();
|
|
break;
|
|
|
|
case TNOSPACE :
|
|
case TLGROUP :
|
|
{
|
|
bool bNoSpace = m_aCurToken.eType == TNOSPACE;
|
|
if (bNoSpace) // push 'no space' node and continue to parse expression
|
|
{
|
|
m_aNodeStack.push(new SmExpressionNode(m_aCurToken));
|
|
NextToken();
|
|
}
|
|
if (m_aCurToken.eType != TLGROUP)
|
|
{
|
|
m_aNodeStack.pop(); // get rid of the 'no space' node pushed above
|
|
Term();
|
|
}
|
|
else
|
|
{
|
|
NextToken();
|
|
|
|
// allow for empty group
|
|
if (m_aCurToken.eType == TRGROUP)
|
|
{
|
|
if (bNoSpace) // get rid of the 'no space' node pushed above
|
|
m_aNodeStack.pop();
|
|
SmStructureNode *pSNode = new SmExpressionNode(m_aCurToken);
|
|
pSNode->SetSubNodes(NULL, NULL);
|
|
m_aNodeStack.push(pSNode);
|
|
|
|
NextToken();
|
|
}
|
|
else // go as usual
|
|
{
|
|
Align();
|
|
if (m_aCurToken.eType != TRGROUP)
|
|
Error(PE_RGROUP_EXPECTED);
|
|
else
|
|
NextToken();
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
case TLEFT :
|
|
Brace();
|
|
break;
|
|
|
|
case TBLANK :
|
|
case TSBLANK :
|
|
Blank();
|
|
break;
|
|
|
|
case TTEXT :
|
|
m_aNodeStack.push(new SmTextNode(m_aCurToken, FNT_TEXT));
|
|
NextToken();
|
|
break;
|
|
case TIDENT :
|
|
case TCHARACTER :
|
|
m_aNodeStack.push(new SmTextNode(m_aCurToken, FNT_VARIABLE));
|
|
NextToken();
|
|
break;
|
|
case TNUMBER :
|
|
m_aNodeStack.push(new SmTextNode(m_aCurToken, FNT_NUMBER));
|
|
NextToken();
|
|
break;
|
|
|
|
case TLEFTARROW :
|
|
case TRIGHTARROW :
|
|
case TUPARROW :
|
|
case TDOWNARROW :
|
|
case TSETN :
|
|
case TSETZ :
|
|
case TSETQ :
|
|
case TSETR :
|
|
case TSETC :
|
|
case THBAR :
|
|
case TLAMBDABAR :
|
|
case TCIRC :
|
|
case TDRARROW :
|
|
case TDLARROW :
|
|
case TDLRARROW :
|
|
case TBACKEPSILON :
|
|
case TALEPH :
|
|
case TIM :
|
|
case TRE :
|
|
case TWP :
|
|
case TEMPTYSET :
|
|
case TINFINITY :
|
|
case TEXISTS :
|
|
case TNOTEXISTS :
|
|
case TFORALL :
|
|
case TPARTIAL :
|
|
case TNABLA :
|
|
case TTOWARD :
|
|
case TDOTSAXIS :
|
|
case TDOTSDIAG :
|
|
case TDOTSDOWN :
|
|
case TDOTSLOW :
|
|
case TDOTSUP :
|
|
case TDOTSVERT :
|
|
m_aNodeStack.push(new SmMathSymbolNode(m_aCurToken));
|
|
NextToken();
|
|
break;
|
|
|
|
case TPLACE:
|
|
m_aNodeStack.push(new SmPlaceNode(m_aCurToken));
|
|
NextToken();
|
|
break;
|
|
|
|
case TSPECIAL:
|
|
Special();
|
|
break;
|
|
|
|
case TBINOM:
|
|
Binom();
|
|
break;
|
|
|
|
case TSTACK:
|
|
Stack();
|
|
break;
|
|
|
|
case TMATRIX:
|
|
Matrix();
|
|
break;
|
|
|
|
default:
|
|
if (TokenInGroup(TGLBRACES))
|
|
{ Brace();
|
|
}
|
|
else if (TokenInGroup(TGOPER))
|
|
{ Operator();
|
|
}
|
|
else if (TokenInGroup(TGUNOPER))
|
|
{ UnOper();
|
|
}
|
|
else if ( TokenInGroup(TGATTRIBUT)
|
|
|| TokenInGroup(TGFONTATTR))
|
|
{ SmStructureNodeArray aArray;
|
|
|
|
bool bIsAttr;
|
|
sal_uInt16 n = 0;
|
|
while (true == (bIsAttr = TokenInGroup(TGATTRIBUT))
|
|
|| TokenInGroup(TGFONTATTR))
|
|
{ aArray.resize(n + 1);
|
|
|
|
if (bIsAttr)
|
|
Attribut();
|
|
else
|
|
FontAttribut();
|
|
|
|
SmNode* pTmp = lcl_popOrZero(m_aNodeStack);
|
|
|
|
// check if casting in following line is ok
|
|
OSL_ENSURE(pTmp && !pTmp->IsVisible(), "Sm : Ooops...");
|
|
|
|
aArray[n] = (SmStructureNode *) pTmp;
|
|
n++;
|
|
}
|
|
|
|
Power();
|
|
|
|
SmNode *pFirstNode = lcl_popOrZero(m_aNodeStack);
|
|
while (n > 0)
|
|
{ aArray[n - 1]->SetSubNodes(0, pFirstNode);
|
|
pFirstNode = aArray[n - 1];
|
|
n--;
|
|
}
|
|
m_aNodeStack.push(pFirstNode);
|
|
}
|
|
else if (TokenInGroup(TGFUNCTION))
|
|
{ if (CONVERT_40_TO_50 != GetConversion())
|
|
{ Function();
|
|
}
|
|
else // encapsulate old 4.0 style parsing in braces
|
|
{
|
|
// insert opening brace
|
|
Insert(rtl::OUString('{'), GetTokenIndex());
|
|
|
|
//
|
|
// parse in 4.0 style
|
|
//
|
|
Function();
|
|
|
|
SmNode *pFunc = lcl_popOrZero(m_aNodeStack);
|
|
|
|
if (m_aCurToken.eType == TLPARENT)
|
|
{ Term();
|
|
}
|
|
else
|
|
{ Align();
|
|
}
|
|
|
|
// insert closing brace
|
|
Insert(rtl::OUString('}'), GetTokenIndex());
|
|
|
|
SmStructureNode *pSNode = new SmExpressionNode(pFunc->GetToken());
|
|
pSNode->SetSubNodes(pFunc, lcl_popOrZero(m_aNodeStack));
|
|
m_aNodeStack.push(pSNode);
|
|
}
|
|
}
|
|
else
|
|
Error(PE_UNEXPECTED_CHAR);
|
|
}
|
|
}
|
|
|
|
|
|
void SmParser::Escape()
|
|
{
|
|
NextToken();
|
|
|
|
switch (m_aCurToken.eType)
|
|
{
|
|
case TLPARENT :
|
|
case TRPARENT :
|
|
case TLBRACKET :
|
|
case TRBRACKET :
|
|
case TLDBRACKET :
|
|
case TRDBRACKET :
|
|
case TLBRACE :
|
|
case TLGROUP :
|
|
case TRBRACE :
|
|
case TRGROUP :
|
|
case TLANGLE :
|
|
case TRANGLE :
|
|
case TLCEIL :
|
|
case TRCEIL :
|
|
case TLFLOOR :
|
|
case TRFLOOR :
|
|
case TLLINE :
|
|
case TRLINE :
|
|
case TLDLINE :
|
|
case TRDLINE :
|
|
break;
|
|
default:
|
|
Error(PE_UNEXPECTED_TOKEN);
|
|
}
|
|
|
|
SmNode *pNode = new SmMathSymbolNode(m_aCurToken);
|
|
m_aNodeStack.push(pNode);
|
|
|
|
NextToken();
|
|
}
|
|
|
|
|
|
void SmParser::Operator()
|
|
{
|
|
if (TokenInGroup(TGOPER))
|
|
{ SmStructureNode *pSNode = new SmOperNode(m_aCurToken);
|
|
|
|
// put operator on top of stack
|
|
Oper();
|
|
|
|
if (TokenInGroup(TGLIMIT) || TokenInGroup(TGPOWER))
|
|
SubSup(m_aCurToken.nGroup);
|
|
SmNode *pOperator = lcl_popOrZero(m_aNodeStack);
|
|
|
|
// get argument
|
|
Power();
|
|
|
|
pSNode->SetSubNodes(pOperator, lcl_popOrZero(m_aNodeStack));
|
|
m_aNodeStack.push(pSNode);
|
|
}
|
|
}
|
|
|
|
|
|
void SmParser::Oper()
|
|
{
|
|
SmTokenType eType (m_aCurToken.eType);
|
|
SmNode *pNode = NULL;
|
|
|
|
switch (eType)
|
|
{
|
|
case TSUM :
|
|
case TPROD :
|
|
case TCOPROD :
|
|
case TINT :
|
|
case TIINT :
|
|
case TIIINT :
|
|
case TLINT :
|
|
case TLLINT :
|
|
case TLLLINT :
|
|
pNode = new SmMathSymbolNode(m_aCurToken);
|
|
break;
|
|
|
|
case TLIM :
|
|
case TLIMSUP :
|
|
case TLIMINF :
|
|
{
|
|
const sal_Char* pLim = 0;
|
|
switch (eType)
|
|
{
|
|
case TLIM : pLim = "lim"; break;
|
|
case TLIMSUP : pLim = "lim sup"; break;
|
|
case TLIMINF : pLim = "lim inf"; break;
|
|
default:
|
|
break;
|
|
}
|
|
if( pLim )
|
|
m_aCurToken.aText.AssignAscii( pLim );
|
|
pNode = new SmTextNode(m_aCurToken, FNT_TEXT);
|
|
}
|
|
break;
|
|
|
|
case TOVERBRACE :
|
|
case TUNDERBRACE :
|
|
pNode = new SmMathSymbolNode(m_aCurToken);
|
|
break;
|
|
|
|
case TOPER :
|
|
NextToken();
|
|
|
|
OSL_ENSURE(m_aCurToken.eType == TSPECIAL, "Sm: wrong token");
|
|
pNode = new SmGlyphSpecialNode(m_aCurToken);
|
|
break;
|
|
|
|
default :
|
|
OSL_FAIL("Sm: unknown case");
|
|
}
|
|
m_aNodeStack.push(pNode);
|
|
|
|
NextToken();
|
|
}
|
|
|
|
|
|
void SmParser::UnOper()
|
|
{
|
|
OSL_ENSURE(TokenInGroup(TGUNOPER), "Sm: wrong token");
|
|
|
|
SmToken aNodeToken = m_aCurToken;
|
|
SmTokenType eType = m_aCurToken.eType;
|
|
bool bIsPostfix = eType == TFACT;
|
|
|
|
SmStructureNode *pSNode;
|
|
SmNode *pOper = 0,
|
|
*pExtra = 0,
|
|
*pArg;
|
|
|
|
switch (eType)
|
|
{
|
|
case TABS :
|
|
case TSQRT :
|
|
NextToken();
|
|
break;
|
|
|
|
case TNROOT :
|
|
NextToken();
|
|
Power();
|
|
pExtra = lcl_popOrZero(m_aNodeStack);
|
|
break;
|
|
|
|
case TUOPER :
|
|
NextToken();
|
|
//Let the glyph know what it is...
|
|
m_aCurToken.eType = TUOPER;
|
|
m_aCurToken.nGroup = TGUNOPER;
|
|
GlyphSpecial();
|
|
pOper = lcl_popOrZero(m_aNodeStack);
|
|
break;
|
|
|
|
case TPLUS :
|
|
case TMINUS :
|
|
case TPLUSMINUS :
|
|
case TMINUSPLUS :
|
|
case TNEG :
|
|
case TFACT :
|
|
OpSubSup();
|
|
pOper = lcl_popOrZero(m_aNodeStack);
|
|
break;
|
|
|
|
default :
|
|
Error(PE_UNOPER_EXPECTED);
|
|
}
|
|
|
|
// get argument
|
|
Power();
|
|
pArg = lcl_popOrZero(m_aNodeStack);
|
|
|
|
if (eType == TABS)
|
|
{ pSNode = new SmBraceNode(aNodeToken);
|
|
pSNode->SetScaleMode(SCALE_HEIGHT);
|
|
|
|
// build nodes for left & right lines
|
|
// (text, group, level of the used token are of no interrest here)
|
|
// we'll use row & column of the keyword for abs
|
|
aNodeToken.eType = TABS;
|
|
//
|
|
aNodeToken.cMathChar = MS_LINE;
|
|
SmNode* pLeft = new SmMathSymbolNode(aNodeToken);
|
|
//
|
|
aNodeToken.cMathChar = MS_LINE;
|
|
SmNode* pRight = new SmMathSymbolNode(aNodeToken);
|
|
|
|
pSNode->SetSubNodes(pLeft, pArg, pRight);
|
|
}
|
|
else if (eType == TSQRT || eType == TNROOT)
|
|
{ pSNode = new SmRootNode(aNodeToken);
|
|
pOper = new SmRootSymbolNode(aNodeToken);
|
|
pSNode->SetSubNodes(pExtra, pOper, pArg);
|
|
}
|
|
else
|
|
{ pSNode = new SmUnHorNode(aNodeToken);
|
|
|
|
if (bIsPostfix)
|
|
pSNode->SetSubNodes(pArg, pOper);
|
|
else
|
|
// prefix operator
|
|
pSNode->SetSubNodes(pOper, pArg);
|
|
}
|
|
|
|
m_aNodeStack.push(pSNode);
|
|
}
|
|
|
|
|
|
void SmParser::Attribut()
|
|
{
|
|
OSL_ENSURE(TokenInGroup(TGATTRIBUT), "Sm: wrong token group");
|
|
|
|
SmStructureNode *pSNode = new SmAttributNode(m_aCurToken);
|
|
SmNode *pAttr;
|
|
SmScaleMode eScaleMode = SCALE_NONE;
|
|
|
|
// get appropriate node for the attribut itself
|
|
switch (m_aCurToken.eType)
|
|
{ case TUNDERLINE :
|
|
case TOVERLINE :
|
|
case TOVERSTRIKE :
|
|
pAttr = new SmRectangleNode(m_aCurToken);
|
|
eScaleMode = SCALE_WIDTH;
|
|
break;
|
|
|
|
case TWIDEVEC :
|
|
case TWIDEHAT :
|
|
case TWIDETILDE :
|
|
pAttr = new SmMathSymbolNode(m_aCurToken);
|
|
eScaleMode = SCALE_WIDTH;
|
|
break;
|
|
|
|
default :
|
|
pAttr = new SmMathSymbolNode(m_aCurToken);
|
|
}
|
|
|
|
NextToken();
|
|
|
|
pSNode->SetSubNodes(pAttr, 0);
|
|
pSNode->SetScaleMode(eScaleMode);
|
|
m_aNodeStack.push(pSNode);
|
|
}
|
|
|
|
|
|
void SmParser::FontAttribut()
|
|
{
|
|
OSL_ENSURE(TokenInGroup(TGFONTATTR), "Sm: wrong token group");
|
|
|
|
switch (m_aCurToken.eType)
|
|
{
|
|
case TITALIC :
|
|
case TNITALIC :
|
|
case TBOLD :
|
|
case TNBOLD :
|
|
case TPHANTOM :
|
|
m_aNodeStack.push(new SmFontNode(m_aCurToken));
|
|
NextToken();
|
|
break;
|
|
|
|
case TSIZE :
|
|
FontSize();
|
|
break;
|
|
|
|
case TFONT :
|
|
Font();
|
|
break;
|
|
|
|
case TCOLOR :
|
|
Color();
|
|
break;
|
|
|
|
default :
|
|
OSL_FAIL("Sm: unknown case");
|
|
}
|
|
}
|
|
|
|
|
|
void SmParser::Color()
|
|
{
|
|
OSL_ENSURE(m_aCurToken.eType == TCOLOR, "Sm : Ooops...");
|
|
|
|
// last color rules, get that one
|
|
SmToken aToken;
|
|
do
|
|
{ NextToken();
|
|
|
|
if (TokenInGroup(TGCOLOR))
|
|
{ aToken = m_aCurToken;
|
|
NextToken();
|
|
}
|
|
else
|
|
Error(PE_COLOR_EXPECTED);
|
|
} while (m_aCurToken.eType == TCOLOR);
|
|
|
|
m_aNodeStack.push(new SmFontNode(aToken));
|
|
}
|
|
|
|
|
|
void SmParser::Font()
|
|
{
|
|
OSL_ENSURE(m_aCurToken.eType == TFONT, "Sm : Ooops...");
|
|
|
|
// last font rules, get that one
|
|
SmToken aToken;
|
|
do
|
|
{ NextToken();
|
|
|
|
if (TokenInGroup(TGFONT))
|
|
{ aToken = m_aCurToken;
|
|
NextToken();
|
|
}
|
|
else
|
|
Error(PE_FONT_EXPECTED);
|
|
} while (m_aCurToken.eType == TFONT);
|
|
|
|
m_aNodeStack.push(new SmFontNode(aToken));
|
|
}
|
|
|
|
|
|
// gets number used as arguments in Math formulas (e.g. 'size' command)
|
|
// Format: no negative numbers, must start with a digit, no exponent notation, ...
|
|
bool lcl_IsNumber(const rtl::OUString& rText)
|
|
{
|
|
bool bPoint = false;
|
|
const sal_Unicode* pBuffer = rText.getStr();
|
|
for(sal_Int32 nPos = 0; nPos < rText.getLength(); nPos++, pBuffer++)
|
|
{
|
|
const sal_Unicode cChar = *pBuffer;
|
|
if(cChar == '.')
|
|
{
|
|
if(bPoint)
|
|
return false;
|
|
else
|
|
bPoint = true;
|
|
}
|
|
else if ( !IsDigit( cChar ) )
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void SmParser::FontSize()
|
|
{
|
|
OSL_ENSURE(m_aCurToken.eType == TSIZE, "Sm : Ooops...");
|
|
|
|
sal_uInt16 Type;
|
|
SmFontNode *pFontNode = new SmFontNode(m_aCurToken);
|
|
|
|
NextToken();
|
|
|
|
switch (m_aCurToken.eType)
|
|
{
|
|
case TNUMBER: Type = FNTSIZ_ABSOLUT; break;
|
|
case TPLUS: Type = FNTSIZ_PLUS; break;
|
|
case TMINUS: Type = FNTSIZ_MINUS; break;
|
|
case TMULTIPLY: Type = FNTSIZ_MULTIPLY; break;
|
|
case TDIVIDEBY: Type = FNTSIZ_DIVIDE; break;
|
|
|
|
default:
|
|
delete pFontNode;
|
|
Error(PE_SIZE_EXPECTED);
|
|
return;
|
|
}
|
|
|
|
if (Type != FNTSIZ_ABSOLUT)
|
|
{
|
|
NextToken();
|
|
if (m_aCurToken.eType != TNUMBER)
|
|
{
|
|
delete pFontNode;
|
|
Error(PE_SIZE_EXPECTED);
|
|
return;
|
|
}
|
|
}
|
|
|
|
// get number argument
|
|
Fraction aValue( 1L );
|
|
if (lcl_IsNumber( m_aCurToken.aText ))
|
|
{
|
|
double fTmp = rtl::OUString(m_aCurToken.aText).toDouble();
|
|
if (fTmp != 0.0)
|
|
{
|
|
aValue = fTmp;
|
|
|
|
//!! keep the numerator and denominator from being to large
|
|
//!! otherwise ongoing multiplications may result in overflows
|
|
//!! (for example in SmNode::SetFontSize the font size calculated
|
|
//!! may become 0 because of this!!! Happens e.g. for ftmp = 2.9 with Linux
|
|
//!! or ftmp = 1.11111111111111111... (11/9) on every platform.)
|
|
if (aValue.GetDenominator() > 1000)
|
|
{
|
|
long nNum = aValue.GetNumerator();
|
|
long nDenom = aValue.GetDenominator();
|
|
while (nDenom > 1000)
|
|
{
|
|
nNum /= 10;
|
|
nDenom /= 10;
|
|
}
|
|
aValue = Fraction( nNum, nDenom );
|
|
}
|
|
}
|
|
}
|
|
|
|
NextToken();
|
|
|
|
pFontNode->SetSizeParameter(aValue, Type);
|
|
m_aNodeStack.push(pFontNode);
|
|
}
|
|
|
|
|
|
void SmParser::Brace()
|
|
{
|
|
OSL_ENSURE(m_aCurToken.eType == TLEFT || TokenInGroup(TGLBRACES),
|
|
"Sm: kein Klammer Ausdruck");
|
|
|
|
SmStructureNode *pSNode = new SmBraceNode(m_aCurToken);
|
|
SmNode *pBody = 0,
|
|
*pLeft = 0,
|
|
*pRight = 0;
|
|
SmScaleMode eScaleMode = SCALE_NONE;
|
|
SmParseError eError = PE_NONE;
|
|
|
|
if (m_aCurToken.eType == TLEFT)
|
|
{ NextToken();
|
|
|
|
eScaleMode = SCALE_HEIGHT;
|
|
|
|
// check for left bracket
|
|
if (TokenInGroup(TGLBRACES) || TokenInGroup(TGRBRACES))
|
|
{
|
|
pLeft = new SmMathSymbolNode(m_aCurToken);
|
|
|
|
NextToken();
|
|
Bracebody(true);
|
|
pBody = lcl_popOrZero(m_aNodeStack);
|
|
|
|
if (m_aCurToken.eType == TRIGHT)
|
|
{ NextToken();
|
|
|
|
// check for right bracket
|
|
if (TokenInGroup(TGLBRACES) || TokenInGroup(TGRBRACES))
|
|
{
|
|
pRight = new SmMathSymbolNode(m_aCurToken);
|
|
NextToken();
|
|
}
|
|
else
|
|
eError = PE_RBRACE_EXPECTED;
|
|
}
|
|
else
|
|
eError = PE_RIGHT_EXPECTED;
|
|
}
|
|
else
|
|
eError = PE_LBRACE_EXPECTED;
|
|
}
|
|
else
|
|
{
|
|
if (TokenInGroup(TGLBRACES))
|
|
{
|
|
pLeft = new SmMathSymbolNode(m_aCurToken);
|
|
|
|
NextToken();
|
|
Bracebody(false);
|
|
pBody = lcl_popOrZero(m_aNodeStack);
|
|
|
|
SmTokenType eExpectedType = TUNKNOWN;
|
|
switch (pLeft->GetToken().eType)
|
|
{ case TLPARENT : eExpectedType = TRPARENT; break;
|
|
case TLBRACKET : eExpectedType = TRBRACKET; break;
|
|
case TLBRACE : eExpectedType = TRBRACE; break;
|
|
case TLDBRACKET : eExpectedType = TRDBRACKET; break;
|
|
case TLLINE : eExpectedType = TRLINE; break;
|
|
case TLDLINE : eExpectedType = TRDLINE; break;
|
|
case TLANGLE : eExpectedType = TRANGLE; break;
|
|
case TLFLOOR : eExpectedType = TRFLOOR; break;
|
|
case TLCEIL : eExpectedType = TRCEIL; break;
|
|
default :
|
|
OSL_FAIL("Sm: unknown case");
|
|
}
|
|
|
|
if (m_aCurToken.eType == eExpectedType)
|
|
{
|
|
pRight = new SmMathSymbolNode(m_aCurToken);
|
|
NextToken();
|
|
}
|
|
else
|
|
eError = PE_PARENT_MISMATCH;
|
|
}
|
|
else
|
|
eError = PE_LBRACE_EXPECTED;
|
|
}
|
|
|
|
if (eError == PE_NONE)
|
|
{ OSL_ENSURE(pLeft, "Sm: NULL pointer");
|
|
OSL_ENSURE(pRight, "Sm: NULL pointer");
|
|
pSNode->SetSubNodes(pLeft, pBody, pRight);
|
|
pSNode->SetScaleMode(eScaleMode);
|
|
m_aNodeStack.push(pSNode);
|
|
}
|
|
else
|
|
{ delete pSNode;
|
|
delete pBody;
|
|
delete pLeft;
|
|
delete pRight;
|
|
|
|
Error(eError);
|
|
}
|
|
}
|
|
|
|
|
|
void SmParser::Bracebody(bool bIsLeftRight)
|
|
{
|
|
SmStructureNode *pBody = new SmBracebodyNode(m_aCurToken);
|
|
SmNodeArray aNodes;
|
|
sal_uInt16 nNum = 0;
|
|
|
|
// get body if any
|
|
if (bIsLeftRight)
|
|
{
|
|
do
|
|
{
|
|
if (m_aCurToken.eType == TMLINE)
|
|
{
|
|
m_aNodeStack.push(new SmMathSymbolNode(m_aCurToken));
|
|
NextToken();
|
|
nNum++;
|
|
}
|
|
else if (m_aCurToken.eType != TRIGHT)
|
|
{ Align();
|
|
nNum++;
|
|
|
|
if (m_aCurToken.eType != TMLINE && m_aCurToken.eType != TRIGHT)
|
|
Error(PE_RIGHT_EXPECTED);
|
|
}
|
|
} while (m_aCurToken.eType != TEND && m_aCurToken.eType != TRIGHT);
|
|
}
|
|
else
|
|
{
|
|
do
|
|
{
|
|
if (m_aCurToken.eType == TMLINE)
|
|
{
|
|
m_aNodeStack.push(new SmMathSymbolNode(m_aCurToken));
|
|
NextToken();
|
|
nNum++;
|
|
}
|
|
else if (!TokenInGroup(TGRBRACES))
|
|
{ Align();
|
|
nNum++;
|
|
|
|
if (m_aCurToken.eType != TMLINE && !TokenInGroup(TGRBRACES))
|
|
Error(PE_RBRACE_EXPECTED);
|
|
}
|
|
} while (m_aCurToken.eType != TEND && !TokenInGroup(TGRBRACES));
|
|
}
|
|
|
|
// build argument vector in parsing order
|
|
aNodes.resize(nNum);
|
|
for (sal_uInt16 i = 0; i < nNum; i++)
|
|
{
|
|
aNodes[nNum - 1 - i] = lcl_popOrZero(m_aNodeStack);
|
|
}
|
|
|
|
pBody->SetSubNodes(aNodes);
|
|
pBody->SetScaleMode(bIsLeftRight ? SCALE_HEIGHT : SCALE_NONE);
|
|
m_aNodeStack.push(pBody);
|
|
}
|
|
|
|
|
|
void SmParser::Function()
|
|
{
|
|
switch (m_aCurToken.eType)
|
|
{
|
|
case TFUNC:
|
|
NextToken(); // skip "FUNC"-statement
|
|
// fall through
|
|
|
|
case TSIN :
|
|
case TCOS :
|
|
case TTAN :
|
|
case TCOT :
|
|
case TASIN :
|
|
case TACOS :
|
|
case TATAN :
|
|
case TACOT :
|
|
case TSINH :
|
|
case TCOSH :
|
|
case TTANH :
|
|
case TCOTH :
|
|
case TASINH :
|
|
case TACOSH :
|
|
case TATANH :
|
|
case TACOTH :
|
|
case TLN :
|
|
case TLOG :
|
|
case TEXP :
|
|
m_aNodeStack.push(new SmTextNode(m_aCurToken, FNT_FUNCTION));
|
|
NextToken();
|
|
break;
|
|
|
|
default:
|
|
Error(PE_FUNC_EXPECTED);
|
|
}
|
|
}
|
|
|
|
|
|
void SmParser::Binom()
|
|
{
|
|
SmNodeArray ExpressionArray;
|
|
SmStructureNode *pSNode = new SmTableNode(m_aCurToken);
|
|
|
|
NextToken();
|
|
|
|
Sum();
|
|
Sum();
|
|
|
|
ExpressionArray.resize(2);
|
|
|
|
for (int i = 0; i < 2; i++)
|
|
{
|
|
ExpressionArray[2 - (i + 1)] = lcl_popOrZero(m_aNodeStack);
|
|
}
|
|
|
|
pSNode->SetSubNodes(ExpressionArray);
|
|
m_aNodeStack.push(pSNode);
|
|
}
|
|
|
|
|
|
void SmParser::Stack()
|
|
{
|
|
SmNodeArray ExpressionArray;
|
|
NextToken();
|
|
if (m_aCurToken.eType == TLGROUP)
|
|
{
|
|
sal_uInt16 n = 0;
|
|
|
|
do
|
|
{
|
|
NextToken();
|
|
Align();
|
|
n++;
|
|
}
|
|
while (m_aCurToken.eType == TPOUND);
|
|
|
|
ExpressionArray.resize(n);
|
|
|
|
for (sal_uInt16 i = 0; i < n; i++)
|
|
{
|
|
ExpressionArray[n - (i + 1)] = lcl_popOrZero(m_aNodeStack);
|
|
}
|
|
|
|
if (m_aCurToken.eType != TRGROUP)
|
|
Error(PE_RGROUP_EXPECTED);
|
|
|
|
NextToken();
|
|
|
|
//We need to let the table node know it context
|
|
//it's used in SmNodeToTextVisitor
|
|
SmToken aTok = m_aCurToken;
|
|
aTok.eType = TSTACK;
|
|
SmStructureNode *pSNode = new SmTableNode(aTok);
|
|
pSNode->SetSubNodes(ExpressionArray);
|
|
m_aNodeStack.push(pSNode);
|
|
}
|
|
else
|
|
Error(PE_LGROUP_EXPECTED);
|
|
}
|
|
|
|
|
|
void SmParser::Matrix()
|
|
{
|
|
SmNodeArray ExpressionArray;
|
|
|
|
NextToken();
|
|
if (m_aCurToken.eType == TLGROUP)
|
|
{
|
|
sal_uInt16 c = 0;
|
|
|
|
do
|
|
{
|
|
NextToken();
|
|
Align();
|
|
c++;
|
|
}
|
|
while (m_aCurToken.eType == TPOUND);
|
|
|
|
sal_uInt16 r = 1;
|
|
|
|
while (m_aCurToken.eType == TDPOUND)
|
|
{
|
|
NextToken();
|
|
for (sal_uInt16 i = 0; i < c; i++)
|
|
{
|
|
Align();
|
|
if (i < (c - 1))
|
|
{
|
|
if (m_aCurToken.eType == TPOUND)
|
|
{
|
|
NextToken();
|
|
}
|
|
else
|
|
Error(PE_POUND_EXPECTED);
|
|
}
|
|
}
|
|
|
|
r++;
|
|
}
|
|
|
|
long nRC = r * c;
|
|
|
|
ExpressionArray.resize(nRC);
|
|
|
|
for (sal_uInt16 i = 0; i < (nRC); i++)
|
|
{
|
|
ExpressionArray[(nRC) - (i + 1)] = lcl_popOrZero(m_aNodeStack);
|
|
}
|
|
|
|
if (m_aCurToken.eType != TRGROUP)
|
|
Error(PE_RGROUP_EXPECTED);
|
|
|
|
NextToken();
|
|
|
|
SmMatrixNode *pMNode = new SmMatrixNode(m_aCurToken);
|
|
pMNode->SetSubNodes(ExpressionArray);
|
|
pMNode->SetRowCol(r, c);
|
|
m_aNodeStack.push(pMNode);
|
|
}
|
|
else
|
|
Error(PE_LGROUP_EXPECTED);
|
|
}
|
|
|
|
|
|
void SmParser::Special()
|
|
{
|
|
bool bReplace = false;
|
|
String &rName = m_aCurToken.aText;
|
|
String aNewName;
|
|
|
|
if (CONVERT_NONE == GetConversion())
|
|
{
|
|
// conversion of symbol names for 6.0 (XML) file format
|
|
// (name change on import / export.
|
|
// UI uses localized names XML file format does not.)
|
|
if( rName.Len() && rName.GetChar( 0 ) == sal_Unicode( '%' ) )
|
|
{
|
|
if (IsImportSymbolNames())
|
|
{
|
|
const SmLocalizedSymbolData &rLSD = SM_MOD()->GetLocSymbolData();
|
|
aNewName = rLSD.GetUiSymbolName( rName.Copy( 1 ) );
|
|
bReplace = true;
|
|
}
|
|
else if (IsExportSymbolNames())
|
|
{
|
|
const SmLocalizedSymbolData &rLSD = SM_MOD()->GetLocSymbolData();
|
|
aNewName = rLSD.GetExportSymbolName( rName.Copy( 1 ) );
|
|
bReplace = true;
|
|
}
|
|
}
|
|
if( aNewName.Len() )
|
|
aNewName.Insert( '%', 0 );
|
|
}
|
|
else // 5.0 <-> 6.0 formula text (symbol name) conversion
|
|
{
|
|
LanguageType nLanguage = GetLanguage();
|
|
SmLocalizedSymbolData &rData = SM_MOD()->GetLocSymbolData();
|
|
const ResStringArray *pFrom = 0;
|
|
const ResStringArray *pTo = 0;
|
|
if (CONVERT_50_TO_60 == GetConversion())
|
|
{
|
|
pFrom = rData.Get50NamesArray( nLanguage );
|
|
pTo = rData.Get60NamesArray( nLanguage );
|
|
}
|
|
else if (CONVERT_60_TO_50 == GetConversion())
|
|
{
|
|
pFrom = rData.Get60NamesArray( nLanguage );
|
|
pTo = rData.Get50NamesArray( nLanguage );
|
|
}
|
|
if (pFrom && pTo)
|
|
{
|
|
OSL_ENSURE( pFrom->Count() == pTo->Count(),
|
|
"array length mismatch" );
|
|
sal_uInt16 nCount = sal::static_int_cast< sal_uInt16 >(pFrom->Count());
|
|
for (sal_uInt16 i = 0; i < nCount; ++i)
|
|
{
|
|
if (pFrom->GetString(i).equals(rName))
|
|
{
|
|
aNewName = pTo->GetString(i);
|
|
bReplace = true;
|
|
}
|
|
}
|
|
}
|
|
// else:
|
|
// conversion arrays not found or (usually)
|
|
// conversion not necessary
|
|
}
|
|
|
|
if (bReplace && aNewName.Len() && rName != aNewName)
|
|
{
|
|
Replace( GetTokenIndex(), rName.Len(), aNewName );
|
|
rName = aNewName;
|
|
}
|
|
|
|
// add symbol name to list of used symbols
|
|
const String aSymbolName( m_aCurToken.aText.Copy( 1 ) );
|
|
if (aSymbolName.Len() > 0 )
|
|
AddToUsedSymbols( aSymbolName );
|
|
|
|
m_aNodeStack.push(new SmSpecialNode(m_aCurToken));
|
|
NextToken();
|
|
}
|
|
|
|
|
|
void SmParser::GlyphSpecial()
|
|
{
|
|
m_aNodeStack.push(new SmGlyphSpecialNode(m_aCurToken));
|
|
NextToken();
|
|
}
|
|
|
|
|
|
void SmParser::Error(SmParseError eError)
|
|
{
|
|
SmStructureNode *pSNode = new SmExpressionNode(m_aCurToken);
|
|
SmErrorNode *pErr = new SmErrorNode(eError, m_aCurToken);
|
|
pSNode->SetSubNodes(pErr, 0);
|
|
|
|
//! put a structure node on the stack (instead of the error node itself)
|
|
//! because sometimes such a node is expected in order to attach some
|
|
//! subnodes
|
|
m_aNodeStack.push(pSNode);
|
|
|
|
AddError(eError, pSNode);
|
|
|
|
NextToken();
|
|
}
|
|
|
|
|
|
// end gramar
|
|
|
|
|
|
SmParser::SmParser()
|
|
: m_aDotLoc( SvxCreateLocale( LANGUAGE_ENGLISH_US ) )
|
|
{
|
|
m_eConversion = CONVERT_NONE;
|
|
bImportSymNames = m_bExportSymNames = false;
|
|
m_nLang = Application::GetSettings().GetUILanguage();
|
|
}
|
|
|
|
SmNode *SmParser::Parse(const String &rBuffer)
|
|
{
|
|
ClearUsedSymbols();
|
|
|
|
m_aBufferString = convertLineEnd(rBuffer, LINEEND_LF);
|
|
m_nBufferIndex = 0;
|
|
m_nTokenIndex = 0;
|
|
m_Row = 1;
|
|
m_nColOff = 0;
|
|
m_nCurError = -1;
|
|
|
|
for ( size_t i = 0, n = m_aErrDescList.size(); i < n; ++i )
|
|
delete m_aErrDescList[ i ];
|
|
m_aErrDescList.clear();
|
|
|
|
while ( !m_aNodeStack.empty() )
|
|
m_aNodeStack.pop();
|
|
|
|
SetLanguage( Application::GetSettings().GetUILanguage() );
|
|
NextToken();
|
|
Table();
|
|
|
|
SmNode* result = lcl_popOrZero(m_aNodeStack);
|
|
return result;
|
|
}
|
|
|
|
SmNode *SmParser::ParseExpression(const String &rBuffer)
|
|
{
|
|
m_aBufferString = convertLineEnd(rBuffer, LINEEND_LF);
|
|
m_nBufferIndex = 0;
|
|
m_nTokenIndex = 0;
|
|
m_Row = 1;
|
|
m_nColOff = 0;
|
|
m_nCurError = -1;
|
|
|
|
for ( size_t i = 0, n = m_aErrDescList.size(); i < n; ++i )
|
|
delete m_aErrDescList[ i ];
|
|
m_aErrDescList.clear();
|
|
|
|
while ( !m_aNodeStack.empty() )
|
|
m_aNodeStack.pop();
|
|
|
|
SetLanguage( Application::GetSettings().GetUILanguage() );
|
|
NextToken();
|
|
Expression();
|
|
|
|
SmNode* result = lcl_popOrZero(m_aNodeStack);
|
|
return result;
|
|
}
|
|
|
|
|
|
size_t SmParser::AddError(SmParseError Type, SmNode *pNode)
|
|
{
|
|
SmErrorDesc *pErrDesc = new SmErrorDesc;
|
|
|
|
pErrDesc->Type = Type;
|
|
pErrDesc->pNode = pNode;
|
|
pErrDesc->Text = String(SmResId(RID_ERR_IDENT));
|
|
|
|
sal_uInt16 nRID;
|
|
switch (Type)
|
|
{
|
|
case PE_UNEXPECTED_CHAR: nRID = RID_ERR_UNEXPECTEDCHARACTER; break;
|
|
case PE_LGROUP_EXPECTED: nRID = RID_ERR_LGROUPEXPECTED; break;
|
|
case PE_RGROUP_EXPECTED: nRID = RID_ERR_RGROUPEXPECTED; break;
|
|
case PE_LBRACE_EXPECTED: nRID = RID_ERR_LBRACEEXPECTED; break;
|
|
case PE_RBRACE_EXPECTED: nRID = RID_ERR_RBRACEEXPECTED; break;
|
|
case PE_FUNC_EXPECTED: nRID = RID_ERR_FUNCEXPECTED; break;
|
|
case PE_UNOPER_EXPECTED: nRID = RID_ERR_UNOPEREXPECTED; break;
|
|
case PE_BINOPER_EXPECTED: nRID = RID_ERR_BINOPEREXPECTED; break;
|
|
case PE_SYMBOL_EXPECTED: nRID = RID_ERR_SYMBOLEXPECTED; break;
|
|
case PE_IDENTIFIER_EXPECTED: nRID = RID_ERR_IDENTEXPECTED; break;
|
|
case PE_POUND_EXPECTED: nRID = RID_ERR_POUNDEXPECTED; break;
|
|
case PE_COLOR_EXPECTED: nRID = RID_ERR_COLOREXPECTED; break;
|
|
case PE_RIGHT_EXPECTED: nRID = RID_ERR_RIGHTEXPECTED; break;
|
|
|
|
default:
|
|
nRID = RID_ERR_UNKOWN;
|
|
}
|
|
pErrDesc->Text += SM_RESSTR(nRID);
|
|
|
|
m_aErrDescList.push_back( pErrDesc );
|
|
|
|
return m_aErrDescList.size()-1;
|
|
}
|
|
|
|
|
|
const SmErrorDesc *SmParser::NextError()
|
|
{
|
|
if ( !m_aErrDescList.empty() )
|
|
if (m_nCurError > 0) return m_aErrDescList[ --m_nCurError ];
|
|
else
|
|
{
|
|
m_nCurError = 0;
|
|
return m_aErrDescList[ m_nCurError ];
|
|
}
|
|
else return NULL;
|
|
}
|
|
|
|
|
|
const SmErrorDesc *SmParser::PrevError()
|
|
{
|
|
if ( !m_aErrDescList.empty() )
|
|
if (m_nCurError < (int) (m_aErrDescList.size() - 1)) return m_aErrDescList[ ++m_nCurError ];
|
|
else
|
|
{
|
|
m_nCurError = (int) (m_aErrDescList.size() - 1);
|
|
return m_aErrDescList[ m_nCurError ];
|
|
}
|
|
else return NULL;
|
|
}
|
|
|
|
|
|
const SmErrorDesc *SmParser::GetError(size_t i)
|
|
{
|
|
if ( i < m_aErrDescList.size() )
|
|
return m_aErrDescList[ i ];
|
|
|
|
if ( (size_t)m_nCurError < m_aErrDescList.size() )
|
|
return m_aErrDescList[ m_nCurError ];
|
|
|
|
return NULL;
|
|
}
|
|
|
|
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|