writerfilter/source/rtftok/rtftokenizer.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  */
   9
  10 #include <tools/stream.hxx>
  11 #include <tools/resmgr.hxx>
  12 #include <svx/dialogs.hrc>
  13 #include <vcl/svapp.hxx>
  14
  15 #include <rtftokenizer.hxx>
  16 #include <rtfskipdestination.hxx>
  17
  18
  19 namespace writerfilter {
  20 namespace rtftok {
  21
  22 std::vector<RTFSymbol> RTFTokenizer::m_aRTFControlWords;
  23 bool RTFTokenizer::m_bControlWordsSorted;
  24
  25 RTFTokenizer::RTFTokenizer(RTFDocumentImpl& rImport, SvStream* pInStream, uno::Reference<task::XStatusIndicator> const& xStatusIndicator)
  26     : m_rImport(rImport),
  27     m_pInStream(pInStream),
  28     m_xStatusIndicator(xStatusIndicator),
  29     m_nGroup(0),
  30     m_nLineNumber(0),
  31     m_nLineStartPos(0)
  32 {
  33     if (!RTFTokenizer::m_bControlWordsSorted)
  34     {
  35         RTFTokenizer::m_bControlWordsSorted = true;
  36         m_aRTFControlWords = std::vector<RTFSymbol>(aRTFControlWords, aRTFControlWords + nRTFControlWords);
  37         std::sort(m_aRTFControlWords.begin(), m_aRTFControlWords.end());
  38     }
  39 }
  40
  41 RTFTokenizer::~RTFTokenizer()
  42 {
  43 }
  44
  45 SvStream& RTFTokenizer::Strm()
  46 {
  47     return *m_pInStream;
  48 }
  49
  50 int RTFTokenizer::resolveParse()
  51 {
  52     SAL_INFO( "writerfilter", OSL_THIS_FUNC );
  53     char ch;
  54     int ret;
  55     // for hex chars
  56     int b = 0, count = 2;
  57     sal_uInt32 nPercentSize = 0;
  58     sal_uInt32 nLastPos = 0;
  59
  60     if (m_xStatusIndicator.is())
  61     {
  62         static ResMgr* pResMgr = ResMgr::CreateResMgr("svx", Application::GetSettings().GetUILanguageTag());
  63         OUString sDocLoad(ResId(RID_SVXSTR_DOC_LOAD, *pResMgr).toString());
  64
  65         sal_uInt32 nCurrentPos = Strm().Tell();
  66         Strm().Seek(STREAM_SEEK_TO_END);
  67         sal_uInt32 nEndPos = Strm().Tell();
  68         Strm().Seek(nCurrentPos);
  69         m_xStatusIndicator->start(sDocLoad, nEndPos);
  70         nPercentSize = nEndPos / 100;
  71
  72         m_xStatusIndicator->setValue(nLastPos = nCurrentPos);
  73     }
  74
  75     while ((Strm() >> ch, !Strm().IsEof()))
  76     {
  77         //SAL_INFO("writerfilter", OSL_THIS_FUNC << ": parsing character '" << ch << "'");
  78
  79         sal_uInt32 nCurrentPos = Strm().Tell();
  80         if (m_xStatusIndicator.is() && nCurrentPos > (nLastPos + nPercentSize))
  81             m_xStatusIndicator->setValue(nLastPos = nCurrentPos);
  82
  83         if (m_nGroup < 0)
  84             return ERROR_GROUP_UNDER;
  85         if (m_nGroup > 0 && m_rImport.getState().nInternalState == INTERNAL_BIN)
  86         {
  87             ret = m_rImport.resolveChars(ch);
  88             if (ret)
  89                 return ret;
  90         }
  91         else
  92         {
  93             switch (ch)
  94             {
  95                 case '{':
  96                     ret = m_rImport.pushState();
  97                     if (ret)
  98                         return ret;
  99                     break;
 100                 case '}':
 101                     ret = m_rImport.popState();
 102                     if (ret)
 103                         return ret;
 104                     if (m_nGroup == 0)
 105                     {
 106                         if (m_rImport.isSubstream())
 107                             m_rImport.finishSubstream();
 108                         return 0;
 109                     }
 110                     break;
 111                 case '\\':
 112                     ret = resolveKeyword();
 113                     if (ret)
 114                         return ret;
 115                     break;
 116                 case 0x0d:
 117                     break; // ignore this
 118                 case 0x0a:
 119                     m_nLineNumber++;
 120                     m_nLineStartPos = nCurrentPos;
 121                     break;
 122                 default:
 123                     if (m_nGroup == 0)
 124                         return ERROR_CHAR_OVER;
 125                     if (m_rImport.getState().nInternalState == INTERNAL_NORMAL)
 126                     {
 127                         ret = m_rImport.resolveChars(ch);
 128                         if (ret)
 129                             return ret;
 130                     }
 131                     else
 132                     {
 133                         SAL_INFO("writerfilter", OSL_THIS_FUNC << ": hex internal state");
 134                         b = b << 4;
 135                         sal_Int8 parsed = asHex(ch);
 136                         if (parsed == -1)
 137                             return ERROR_HEX_INVALID;
 138                         b += parsed;
 139                         count--;
 140                         if (!count)
 141                         {
 142                             ret = m_rImport.resolveChars(b);
 143                             if (ret)
 144                                 return ret;
 145                             count = 2;
 146                             b = 0;
 147                             m_rImport.getState().nInternalState = INTERNAL_NORMAL;
 148                         }
 149                     }
 150                     break;
 151             }
 152         }
 153     }
 154
 155     if (m_nGroup < 0)
 156         return ERROR_GROUP_UNDER;
 157     else if (m_nGroup > 0)
 158         return ERROR_GROUP_OVER;
 159     return 0;
 160 }
 161
 162 int RTFTokenizer::asHex(char ch)
 163 {
 164     int ret = 0;
 165     if (isdigit(ch))
 166         ret = ch - '0';
 167     else
 168     {
 169         if (islower(ch))
 170         {
 171             if (ch < 'a' || ch > 'f')
 172                 return -1;
 173             ret = ch - 'a';
 174         }
 175         else
 176         {
 177             if (ch < 'A' || ch > 'F')
 178                 return -1;
 179             ret = ch - 'A';
 180         }
 181         ret += 10;
 182     }
 183     return ret;
 184 }
 185
 186 int RTFTokenizer::getGroup() const
 187 {
 188     return m_nGroup;
 189 }
 190
 191 void RTFTokenizer::pushGroup()
 192 {
 193     m_nGroup++;
 194 }
 195
 196 void RTFTokenizer::popGroup()
 197 {
 198     m_nGroup--;
 199 }
 200
 201 int RTFTokenizer::resolveKeyword()
 202 {
 203     char ch;
 204     OStringBuffer aBuf;
 205     bool bNeg = false;
 206     bool bParam = false;
 207     int nParam = 0;
 208
 209     Strm() >> ch;
 210     if (Strm().IsEof())
 211         return ERROR_EOF;
 212
 213     if (!isalpha(ch))
 214     {
 215         aBuf.append(ch);
 216         OString aKeyword = aBuf.makeStringAndClear();
 217         // control symbols aren't followed by a space, so we can return here
 218         // without doing any SeekRel()
 219         return dispatchKeyword(aKeyword, bParam, nParam);
 220     }
 221     while(isalpha(ch))
 222     {
 223         aBuf.append(ch);
 224         Strm() >> ch;
 225         if (Strm().IsEof())
 226         {
 227             ch = ' ';
 228             break;
 229         }
 230     }
 231     if (aBuf.getLength() > 32)
 232         // See RTF spec v1.9.1, page 7
 233         // A control word's name cannot be longer than 32 letters.
 234         throw io::BufferSizeExceededException();
 235
 236     if (ch == '-')
 237     {
 238         // in case we'll have a parameter, that will be negative
 239         bNeg = true;
 240         Strm() >> ch;
 241         if (Strm().IsEof())
 242             return ERROR_EOF;
 243     }
 244     if (isdigit(ch))
 245     {
 246         OStringBuffer aParameter;
 247
 248         // we have a parameter
 249         bParam = true;
 250         while(isdigit(ch))
 251         {
 252             aParameter.append(ch);
 253             Strm() >> ch;
 254             if (Strm().IsEof())
 255             {
 256                 ch = ' ';
 257                 break;
 258             }
 259         }
 260         nParam = aParameter.makeStringAndClear().toInt32();
 261         if (bNeg)
 262             nParam = -nParam;
 263     }
 264     if (ch != ' ')
 265         Strm().SeekRel(-1);
 266     OString aKeyword = aBuf.makeStringAndClear();
 267     return dispatchKeyword(aKeyword, bParam, nParam);
 268 }
 269
 270 int RTFTokenizer::dispatchKeyword(OString& rKeyword, bool bParam, int nParam)
 271 {
 272     if (m_rImport.getState().nDestinationState == DESTINATION_SKIP)
 273         return 0;
 274     /*SAL_INFO("writefilter", OSL_THIS_FUNC << ": keyword '\\" << rKeyword.getStr() <<
 275                "' with param? " << (bParam ? 1 : 0) <<" param val: '" << (bParam ? nParam : 0) << "'");*/
 276     RTFSymbol aSymbol;
 277     aSymbol.sKeyword = rKeyword.getStr();
 278     std::vector<RTFSymbol>::iterator low = std::lower_bound(m_aRTFControlWords.begin(), m_aRTFControlWords.end(), aSymbol);
 279     int i = low - m_aRTFControlWords.begin();
 280     if (low == m_aRTFControlWords.end() || aSymbol < *low)
 281     {
 282         SAL_INFO("writerfilter", OSL_THIS_FUNC << ": unknown keyword '\\" << rKeyword.getStr() << "'");
 283         RTFSkipDestination aSkip(m_rImport);
 284         aSkip.setParsed(false);
 285         return 0;
 286     }
 287
 288     int ret;
 289     switch (m_aRTFControlWords[i].nControlType)
 290     {
 291         case CONTROL_FLAG:
 292             // flags ignore any parameter by definition
 293             ret = m_rImport.dispatchFlag(m_aRTFControlWords[i].nIndex);
 294             if (ret)
 295                 return ret;
 296             break;
 297         case CONTROL_DESTINATION:
 298             // same for destinations
 299             ret = m_rImport.dispatchDestination(m_aRTFControlWords[i].nIndex);
 300             if (ret)
 301                 return ret;
 302             break;
 303         case CONTROL_SYMBOL:
 304             // and symbols
 305             ret = m_rImport.dispatchSymbol(m_aRTFControlWords[i].nIndex);
 306             if (ret)
 307                 return ret;
 308             break;
 309         case CONTROL_TOGGLE:
 310             ret = m_rImport.dispatchToggle(m_aRTFControlWords[i].nIndex, bParam, nParam);
 311             if (ret)
 312                 return ret;
 313             break;
 314         case CONTROL_VALUE:
 315             // values require a parameter by definition
 316             if (bParam) {
 317                 ret = m_rImport.dispatchValue(m_aRTFControlWords[i].nIndex, nParam);
 318                 if (ret)
 319                     return ret;
 320             }
 321             break;
 322     }
 323
 324     return 0;
 325 }
 326
 327 OUString RTFTokenizer::getPosition()
 328 {
 329     OUStringBuffer aRet;
 330     aRet.append(m_nLineNumber + 1);
 331     aRet.append(",");
 332     aRet.append(sal_Int32(Strm().Tell() - m_nLineStartPos + 1));
 333     return aRet.makeStringAndClear();
 334 }
 335
 336 } // namespace rtftok
 337 } // namespace writerfilter
 338
 339 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */