| /************************************************************** |
| * |
| * 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 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| // MARKER(update_precomp.py): autogen include statement, do not remove |
| #include "precompiled_starmath.hxx" |
| |
| |
| #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 "parse.hxx" |
| #ifndef _STARMATH_HRC |
| #include "starmath.hrc" |
| #endif |
| #ifndef _SMDLL_HXX |
| #include "smdll.hxx" |
| #endif |
| #include "smmod.hxx" |
| #include "config.hxx" |
| |
| #include "node.hxx" |
| |
| using namespace ::com::sun::star; |
| using namespace ::com::sun::star::i18n; |
| |
| /////////////////////////////////////////////////////////////////////////// |
| |
| static inline sal_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 sal_Bool IsDigit( sal_Unicode cChar ) |
| { |
| return '0' <= cChar && cChar <= '9'; |
| } |
| |
| /////////////////////////////////////////////////////////////////////////// |
| |
| SmToken::SmToken() : |
| eType (TUNKNOWN), |
| cMathChar ('\0') |
| { |
| nGroup = nCol = nRow = nLevel = 0; |
| } |
| |
| /////////////////////////////////////////////////////////////////////////// |
| |
| struct SmTokenTableEntry |
| { |
| const sal_Char* pIdent; |
| SmTokenType eType; |
| sal_Unicode cMathChar; |
| sal_uLong nGroup; |
| sal_uInt16 nLevel; |
| }; |
| |
| static const SmTokenTableEntry aTokenTable[] = |
| { |
| // { "#", TPOUND, '\0', 0, 0 }, |
| // { "##", TDPOUND, '\0', 0, 0 }, |
| // { "&", TAND, MS_AND, TGPRODUCT, 0 }, |
| // { "(", TLPARENT, MS_LPARENT, TGLBRACES, 5 }, //! 5 to continue expression |
| // { ")", TRPARENT, MS_RPARENT, TGRBRACES, 0 }, //! 0 to terminate expression |
| // { "*", TMULTIPLY, MS_MULTIPLY, TGPRODUCT, 0 }, |
| // { "+", TPLUS, MS_PLUS, TGUNOPER | TGSUM, 5 }, |
| // { "+-", TPLUSMINUS, MS_PLUSMINUS, TGUNOPER | TGSUM, 5 }, |
| // { "-", TMINUS, MS_MINUS, TGUNOPER | TGSUM, 5 }, |
| // { "-+", TMINUSPLUS, MS_MINUSPLUS, TGUNOPER | TGSUM, 5 }, |
| // { ".", TPOINT, '\0', 0, 0 }, |
| // { "/", TDIVIDEBY, MS_SLASH, TGPRODUCT, 0 }, |
| // { "<", TLT, MS_LT, TGRELATION, 0 }, |
| // { "<<", TLL, MS_LL, TGRELATION, 0 }, |
| // { "<=", TLE, MS_LE, TGRELATION, 0 }, |
| // { "<>", TNEQ, MS_NEQ, TGRELATION, 0}, |
| // { "<?>", TPLACE, MS_PLACE, 0, 5 }, |
| // { "=", TASSIGN, MS_ASSIGN, TGRELATION, 0}, |
| // { ">", TGT, MS_GT, TGRELATION, 0 }, |
| // { ">=", TGE, MS_GE, TGRELATION, 0 }, |
| // { ">>", TGG, MS_GG, TGRELATION, 0 }, |
| { "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}, |
| { "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}, |
| { "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}, |
| { "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}, |
| // { "[", TLBRACKET, MS_LBRACKET, TGLBRACES, 5}, //! 5 to continue expression |
| // { "\\", TESCAPE, '\0', 0, 5}, |
| // { "]", TRBRACKET, MS_RBRACKET, TGRBRACES, 0}, //! 0 to terminate expression |
| // { "^", TRSUP, '\0', TGPOWER, 0}, |
| // { "_", TRSUB, '\0', TGPOWER, 0}, |
| // { "`", TSBLANK, '\0', TGBLANK, 5}, |
| // { "{", TLGROUP, MS_LBRACE, 0, 5}, //! 5 to continue expression |
| // { "|", TOR, MS_OR, TGSUM, 0}, |
| // { "}", TRGROUP, MS_RBRACE, 0, 0}, //! 0 to terminate expression |
| // { "~", TBLANK, '\0', TGBLANK, 5}, |
| { "", TEND, '\0', 0, 0} |
| }; |
| |
| |
| static const SmTokenTableEntry * GetTokenTableEntry( const String &rName ) |
| { |
| const SmTokenTableEntry * pRes = 0; |
| if (rName.Len()) |
| { |
| sal_Int32 nEntries = sizeof( aTokenTable ) / sizeof( aTokenTable[0] ); |
| for (sal_Int32 i = 0; i < nEntries; ++i) |
| { |
| if (rName.EqualsIgnoreCaseAscii( aTokenTable[i].pIdent )) |
| { |
| pRes = &aTokenTable[i]; |
| break; |
| } |
| } |
| |
| } |
| |
| return pRes; |
| } |
| |
| |
| /////////////////////////////////////////////////////////////////////////// |
| |
| #if OSL_DEBUG_LEVEL |
| |
| sal_Bool SmParser::IsDelimiter( const String &rTxt, xub_StrLen nPos ) |
| // returns 'sal_True' iff cChar is '\0' or a delimeter |
| { |
| DBG_ASSERT( nPos <= rTxt.Len(), "index out of range" ); |
| |
| sal_Unicode cChar = rTxt.GetChar( nPos ); |
| if(!cChar) |
| return sal_True; |
| |
| // check if 'cChar' is in the delimeter table |
| const sal_Unicode *pDelim = &aDelimiterTable[0]; |
| for ( ; *pDelim != 0; pDelim++) |
| if (*pDelim == cChar) |
| break; |
| |
| sal_Bool bIsDelim = *pDelim != 0; |
| |
| sal_Int16 nTypJp = SM_MOD()->GetSysLocale().GetCharClass().getType( rTxt, nPos ); |
| bIsDelim |= 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 ) |
| { |
| DBG_ASSERT( 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; |
| sal_Bool bCont; |
| sal_Bool bNumStart = sal_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 ); |
| /* |
| removed because of #i11752# |
| bNumStart = cFirstChar == '.' || ('0' <= cFirstChar && cFirstChar <= '9'); |
| if (bNumStart) |
| { |
| nStartFlags = coNumStartFlags; |
| nContFlags = coNumContFlags; |
| } |
| */ |
| 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 )) |
| { |
| //! locale where '.' is decimal seperator! |
| static lang::Locale aDotLoc( SvxCreateLocale( LANGUAGE_ENGLISH_US ) ); |
| |
| ParseResult aTmpRes; |
| lang::Locale aOldLoc( aCC.getLocale() ); |
| aCC.setLocale( 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 = sal_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 = sal_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 = sal_True; |
| } |
| } |
| |
| } while (bCont); |
| |
| // set index of current token |
| m_nTokenIndex = m_nBufferIndex; |
| |
| m_aCurToken.nRow = m_Row; |
| m_aCurToken.nCol = nRealStart - m_nColOff + 1; |
| |
| sal_Bool bHandled = sal_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; |
| DBG_ASSERT( 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) )) |
| { |
| DBG_WARNING( "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; |
| DBG_ASSERT( 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) )) |
| { |
| DBG_WARNING( "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 = sal_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 |
| |
| DBG_ASSERT( 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 ); |
| |
| DBG_ASSERT( 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 = sal_False; |
| } |
| } |
| } |
| else |
| bHandled = sal_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.Count(); |
| |
| LineArray.resize(n); |
| |
| for (sal_uLong i = 0; i < n; i++) |
| LineArray[n - (i + 1)] = 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; |
| sal_Bool bNeedGroupClose = sal_False; |
| |
| if (TokenInGroup(TGALIGN)) |
| { |
| if (CONVERT_40_TO_50 == GetConversion()) |
| // encapsulate expression to be aligned in group braces |
| // (here group-open brace) |
| { Insert('{', GetTokenIndex()); |
| bNeedGroupClose = sal_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('}', GetTokenIndex()); |
| |
| if (pSNode) |
| { pSNode->SetSubNodes(m_aNodeStack.Pop(), 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] = m_aNodeStack.Pop(); |
| } |
| |
| while (m_aCurToken.eType != TEND && m_aCurToken.eType != TNEWLINE) |
| { if (CONVERT_40_TO_50 != GetConversion()) |
| Expression(); |
| else |
| Align(); |
| ExpressionArray.resize(++n); |
| ExpressionArray[n - 1] = m_aNodeStack.Pop(); |
| } |
| |
| SmStructureNode *pSNode = new SmLineNode(m_aCurToken); |
| pSNode->SetSubNodes(ExpressionArray); |
| m_aNodeStack.Push(pSNode); |
| } |
| |
| |
| void SmParser::Expression() |
| { |
| sal_Bool bUseExtraSpaces = sal_True; |
| SmNode *pNode = m_aNodeStack.Pop(); |
| if (pNode) |
| { |
| if (pNode->GetToken().eType == TNOSPACE) |
| bUseExtraSpaces = sal_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] = m_aNodeStack.Pop(); |
| |
| while (m_aCurToken.nLevel >= 4) |
| { Relation(); |
| RelationArray.resize(++n); |
| RelationArray[n - 1] = m_aNodeStack.Pop(); |
| } |
| |
| 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 = m_aNodeStack.Pop(); |
| |
| OpSubSup(); |
| SmNode *pSecond = m_aNodeStack.Pop(); |
| |
| Sum(); |
| |
| pSNode->SetSubNodes(pFirst, pSecond, m_aNodeStack.Pop()); |
| m_aNodeStack.Push(pSNode); |
| } |
| } |
| |
| |
| void SmParser::Sum() |
| { |
| Product(); |
| while (TokenInGroup(TGSUM)) |
| { |
| SmStructureNode *pSNode = new SmBinHorNode(m_aCurToken); |
| SmNode *pFirst = m_aNodeStack.Pop(); |
| |
| OpSubSup(); |
| SmNode *pSecond = m_aNodeStack.Pop(); |
| |
| Product(); |
| |
| pSNode->SetSubNodes(pFirst, pSecond, m_aNodeStack.Pop()); |
| m_aNodeStack.Push(pSNode); |
| } |
| } |
| |
| |
| void SmParser::Product() |
| { |
| Power(); |
| |
| while (TokenInGroup(TGPRODUCT)) |
| { SmStructureNode *pSNode; |
| SmNode *pFirst = m_aNodeStack.Pop(), |
| *pOper; |
| sal_Bool bSwitchArgs = sal_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(); |
| |
| GlyphSpecial(); |
| pOper = m_aNodeStack.Pop(); |
| 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 =sal_True; |
| break; |
| } |
| |
| default: |
| pSNode = new SmBinHorNode(m_aCurToken); |
| |
| OpSubSup(); |
| pOper = m_aNodeStack.Pop(); |
| } |
| |
| Power(); |
| |
| if (bSwitchArgs) |
| //! vgl siehe SmBinDiagonalNode::Arrange |
| pSNode->SetSubNodes(pFirst, m_aNodeStack.Pop(), pOper); |
| else |
| pSNode->SetSubNodes(pFirst, pOper, m_aNodeStack.Pop()); |
| m_aNodeStack.Push(pSNode); |
| } |
| } |
| |
| |
| void SmParser::SubSup(sal_uLong nActiveGroup) |
| { |
| DBG_ASSERT(nActiveGroup == TGPOWER || nActiveGroup == TGLIMIT, |
| "Sm: falsche Tokengruppe"); |
| |
| 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] = m_aNodeStack.Pop(); |
| 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 : |
| DBG_ASSERT(sal_False, "Sm: unbekannter Fall"); |
| } |
| nIndex++; |
| DBG_ASSERT(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] = m_aNodeStack.Pop(); |
| } |
| |
| 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() |
| { |
| DBG_ASSERT(TokenInGroup(TGBLANK), "Sm : falsches 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 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; |
| |
| sal_Bool bIsAttr; |
| sal_uInt16 n = 0; |
| while (sal_True == (bIsAttr = TokenInGroup(TGATTRIBUT)) |
| || TokenInGroup(TGFONTATTR)) |
| { aArray.resize(n + 1); |
| |
| if (bIsAttr) |
| Attribut(); |
| else |
| FontAttribut(); |
| |
| // check if casting in following line is ok |
| DBG_ASSERT(!m_aNodeStack.Top()->IsVisible(), "Sm : Ooops..."); |
| |
| aArray[n] = (SmStructureNode *) m_aNodeStack.Pop(); |
| n++; |
| } |
| |
| Power(); |
| |
| SmNode *pFirstNode = m_aNodeStack.Pop(); |
| 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('{', GetTokenIndex()); |
| |
| // |
| // parse in 4.0 style |
| // |
| Function(); |
| |
| SmNode *pFunc = m_aNodeStack.Pop(); |
| |
| if (m_aCurToken.eType == TLPARENT) |
| { Term(); |
| } |
| else |
| { Align(); |
| } |
| |
| // insert closing brace |
| Insert('}', GetTokenIndex()); |
| |
| SmStructureNode *pSNode = new SmExpressionNode(pFunc->GetToken()); |
| pSNode->SetSubNodes(pFunc, m_aNodeStack.Pop()); |
| m_aNodeStack.Push(pSNode); |
| } |
| } |
| else |
| Error(PE_UNEXPECTED_CHAR); |
| } |
| } |
| |
| |
| void SmParser::Escape() |
| { |
| NextToken(); |
| |
| sal_Unicode cChar; |
| switch (m_aCurToken.eType) |
| { case TLPARENT : cChar = MS_LPARENT; break; |
| case TRPARENT : cChar = MS_RPARENT; break; |
| case TLBRACKET : cChar = MS_LBRACKET; break; |
| case TRBRACKET : cChar = MS_RBRACKET; break; |
| case TLDBRACKET : cChar = MS_LDBRACKET; break; |
| case TRDBRACKET : cChar = MS_RDBRACKET; break; |
| case TLBRACE : |
| case TLGROUP : cChar = MS_LBRACE; break; |
| case TRBRACE : |
| case TRGROUP : cChar = MS_RBRACE; break; |
| case TLANGLE : cChar = MS_LANGLE; break; |
| case TRANGLE : cChar = MS_RANGLE; break; |
| case TLCEIL : cChar = MS_LCEIL; break; |
| case TRCEIL : cChar = MS_RCEIL; break; |
| case TLFLOOR : cChar = MS_LFLOOR; break; |
| case TRFLOOR : cChar = MS_RFLOOR; break; |
| case TLLINE : |
| case TRLINE : cChar = MS_LINE; break; |
| case TLDLINE : |
| case TRDLINE : cChar = MS_DLINE; 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 = m_aNodeStack.Pop(); |
| |
| // get argument |
| Power(); |
| |
| pSNode->SetSubNodes(pOperator, m_aNodeStack.Pop()); |
| 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(); |
| |
| DBG_ASSERT(m_aCurToken.eType == TSPECIAL, "Sm: falsches Token"); |
| pNode = new SmGlyphSpecialNode(m_aCurToken); |
| break; |
| |
| default : |
| DBG_ASSERT(0, "Sm: unbekannter Fall"); |
| } |
| m_aNodeStack.Push(pNode); |
| |
| NextToken(); |
| } |
| |
| |
| void SmParser::UnOper() |
| { |
| DBG_ASSERT(TokenInGroup(TGUNOPER), "Sm: falsches Token"); |
| |
| SmToken aNodeToken = m_aCurToken; |
| SmTokenType eType = m_aCurToken.eType; |
| sal_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 = m_aNodeStack.Pop(); |
| break; |
| |
| case TUOPER : |
| NextToken(); |
| GlyphSpecial(); |
| pOper = m_aNodeStack.Pop(); |
| break; |
| |
| case TPLUS : |
| case TMINUS : |
| case TPLUSMINUS : |
| case TMINUSPLUS : |
| case TNEG : |
| case TFACT : |
| OpSubSup(); |
| pOper = m_aNodeStack.Pop(); |
| break; |
| |
| default : |
| Error(PE_UNOPER_EXPECTED); |
| } |
| |
| // get argument |
| Power(); |
| pArg = m_aNodeStack.Pop(); |
| |
| 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() |
| { |
| DBG_ASSERT(TokenInGroup(TGATTRIBUT), "Sm: falsche Tokengruppe"); |
| |
| 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() |
| { |
| DBG_ASSERT(TokenInGroup(TGFONTATTR), "Sm: falsche Tokengruppe"); |
| |
| 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 : |
| DBG_ASSERT(0, "Sm: unbekannter Fall"); |
| } |
| } |
| |
| |
| void SmParser::Color() |
| { |
| DBG_ASSERT(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() |
| { |
| DBG_ASSERT(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, ... |
| sal_Bool lcl_IsNumber(const UniString& rText) |
| { |
| sal_Bool bPoint = sal_False; |
| const sal_Unicode* pBuffer = rText.GetBuffer(); |
| for(xub_StrLen nPos = 0; nPos < rText.Len(); nPos++, pBuffer++) |
| { |
| const sal_Unicode cChar = *pBuffer; |
| if(cChar == '.') |
| { |
| if(bPoint) |
| return sal_False; |
| else |
| bPoint = sal_True; |
| } |
| else if ( !IsDigit( cChar ) ) |
| return sal_False; |
| } |
| return sal_True; |
| } |
| |
| void SmParser::FontSize() |
| { |
| DBG_ASSERT(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; |
| if ((fTmp = m_aCurToken.aText.ToDouble()) != 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() |
| { |
| DBG_ASSERT(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(sal_True); |
| pBody = m_aNodeStack.Pop(); |
| |
| 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(sal_False); |
| pBody = m_aNodeStack.Pop(); |
| |
| 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 : |
| DBG_ASSERT(0, "Sm: unbekannter Fall"); |
| } |
| |
| 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) |
| { DBG_ASSERT(pLeft, "Sm: NULL pointer"); |
| DBG_ASSERT(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(sal_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] = m_aNodeStack.Pop(); |
| |
| 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)] = m_aNodeStack.Pop(); |
| |
| 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)] = m_aNodeStack.Pop(); |
| |
| if (m_aCurToken.eType != TRGROUP) |
| Error(PE_RGROUP_EXPECTED); |
| |
| NextToken(); |
| |
| SmStructureNode *pSNode = new SmTableNode(m_aCurToken); |
| 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)] = m_aNodeStack.Pop(); |
| |
| 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() |
| { |
| sal_Bool bReplace = sal_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 = sal_True; |
| } |
| else if (IsExportSymbolNames()) |
| { |
| const SmLocalizedSymbolData &rLSD = SM_MOD()->GetLocSymbolData(); |
| aNewName = rLSD.GetExportSymbolName( rName.Copy( 1 ) ); |
| bReplace = sal_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) |
| { |
| DBG_ASSERT( 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) == rName) |
| { |
| aNewName = pTo->GetString(i); |
| bReplace = sal_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_eConversion = CONVERT_NONE; |
| m_bImportSymNames = m_bExportSymNames = sal_False; |
| m_nLang = Application::GetSettings().GetUILanguage(); |
| } |
| |
| |
| SmNode *SmParser::Parse(const String &rBuffer) |
| { |
| ClearUsedSymbols(); |
| |
| m_aBufferString = rBuffer; |
| m_aBufferString.ConvertLineEnd( LINEEND_LF ); |
| m_nBufferIndex = |
| m_nTokenIndex = 0; |
| m_Row = 1; |
| m_nColOff = 0; |
| m_nCurError = -1; |
| |
| for (sal_uInt16 i = 0; i < m_aErrDescList.Count(); i++) |
| delete m_aErrDescList.Remove(i); |
| |
| m_aErrDescList.Clear(); |
| |
| m_aNodeStack.Clear(); |
| |
| SetLanguage( Application::GetSettings().GetUILanguage() ); |
| NextToken(); |
| Table(); |
| |
| return m_aNodeStack.Pop(); |
| } |
| |
| |
| sal_uInt16 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 += SmResId(nRID); |
| |
| m_aErrDescList.Insert(pErrDesc); |
| |
| return (sal_uInt16) m_aErrDescList.GetPos(pErrDesc); |
| } |
| |
| |
| const SmErrorDesc *SmParser::NextError() |
| { |
| if (m_aErrDescList.Count()) |
| if (m_nCurError > 0) return m_aErrDescList.Seek(--m_nCurError); |
| else |
| { |
| m_nCurError = 0; |
| return m_aErrDescList.Seek(m_nCurError); |
| } |
| else return 0; |
| } |
| |
| |
| const SmErrorDesc *SmParser::PrevError() |
| { |
| if (m_aErrDescList.Count()) |
| if (m_nCurError < (int) (m_aErrDescList.Count() - 1)) return m_aErrDescList.Seek(++m_nCurError); |
| else |
| { |
| m_nCurError = (int) (m_aErrDescList.Count() - 1); |
| return m_aErrDescList.Seek(m_nCurError); |
| } |
| else return 0; |
| } |
| |
| |
| const SmErrorDesc *SmParser::GetError(sal_uInt16 i) |
| { |
| return (/*i >= 0 &&*/ i < m_aErrDescList.Count()) |
| ? m_aErrDescList.Seek(i) |
| : m_aErrDescList.Seek(m_nCurError); |
| } |
| |
| |
