sc/source/filter/lotus/lotimpop.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  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include "lotfilter.hxx"
  21 #include <lotimpop.hxx>
  22 #include <osl/mutex.hxx>
  23 #include <sal/log.hxx>
  24
  25 #include <document.hxx>
  26 #include <formulacell.hxx>
  27 #include <global.hxx>
  28
  29 #include <root.hxx>
  30 #include <lotfntbf.hxx>
  31 #include <lotform.hxx>
  32 #include <tool.h>
  33 #include <namebuff.hxx>
  34 #include <lotattr.hxx>
  35 #include <stringutil.hxx>
  36 #include <config_fuzzers.h>
  37
  38 #include <unotools/configmgr.hxx>
  39
  40 LOTUS_ROOT::LOTUS_ROOT( ScDocument* pDocP, rtl_TextEncoding eQ )
  41     :
  42         pDoc( pDocP),
  43         maRangeNames(),
  44         eCharsetQ( eQ),
  45         eFirstType( Lotus123Typ::X),
  46         eActType( Lotus123Typ::X),
  47         pRngNmBffWK3( new RangeNameBufferWK3() ),
  48         maAttrTable( this )
  49 {
  50 }
  51
  52 LOTUS_ROOT::~LOTUS_ROOT()
  53 {
  54 }
  55
  56 static osl::Mutex aLotImpSemaphore;
  57
  58 ImportLotus::ImportLotus(LotusContext &rContext, SvStream& aStream, ScDocument* pDoc, rtl_TextEncoding eQ)
  59     : ImportTyp(pDoc, eQ)
  60     , pIn(&aStream)
  61     , aConv(rContext, *pIn, pDoc->GetSharedStringPool(), eQ, false)
  62     , nTab(0)
  63     , nExtTab(0)
  64 {
  65     // good point to start locking of import lotus
  66     aLotImpSemaphore.acquire();
  67
  68     rContext.pLotusRoot = new LOTUS_ROOT(pDoc, eQ);
  69 }
  70
  71 ImportLotus::~ImportLotus()
  72 {
  73     LotusContext &rContext = aConv.getContext();
  74     delete rContext.pLotusRoot;
  75     rContext.pLotusRoot = nullptr;
  76
  77     // no need 4 pLotusRoot anymore
  78     aLotImpSemaphore.release();
  79 }
  80
  81 void ImportLotus::Bof()
  82 {
  83     sal_uInt16  nFileCode, nFileSub, nSaveCnt;
  84     sal_uInt8   nMajorId, nMinorId, nFlags;
  85
  86     Read( nFileCode );
  87     Read( nFileSub );
  88     LotusContext &rContext = aConv.getContext();
  89     Read( rContext.pLotusRoot->aActRange );
  90     Read( nSaveCnt );
  91     Read( nMajorId );
  92     Read( nMinorId );
  93     Skip( 1 );
  94     Read( nFlags );
  95
  96     if( nFileSub == 0x0004 )
  97     {
  98         if( nFileCode == 0x1000 )
  99         {// <= WK3
 100             rContext.pLotusRoot->eFirstType = rContext.pLotusRoot->eActType = Lotus123Typ::WK3;
 101         }
 102         else if( nFileCode == 0x1002 )
 103         {// WK4
 104             rContext.pLotusRoot->eFirstType = rContext.pLotusRoot->eActType = Lotus123Typ::WK4;
 105         }
 106     }
 107 }
 108
 109 bool ImportLotus::BofFm3()
 110 {
 111     sal_uInt16  nFileCode, nFileSub;
 112
 113     Read( nFileCode );
 114     Read( nFileSub );
 115
 116     return ( nFileCode == 0x8007 && ( nFileSub == 0x0000 || nFileSub == 0x00001 ) );
 117 }
 118
 119 void ImportLotus::Columnwidth( sal_uInt16 nRecLen )
 120 {
 121     SAL_WARN_IF( nRecLen < 4, "sc.filter", "*ImportLotus::Columnwidth(): Record too short!" );
 122
 123     sal_uInt8    nLTab, nWindow2;
 124     sal_uInt16    nCnt = (nRecLen < 4) ? 0 : ( nRecLen - 4 ) / 2;
 125
 126     Read( nLTab );
 127     Read( nWindow2 );
 128
 129     if( !pD->HasTable( static_cast<SCTAB> (nLTab) ) )
 130         pD->MakeTable( static_cast<SCTAB> (nLTab) );
 131
 132     if( !nWindow2 )
 133     {
 134         Skip( 2 );
 135
 136         sal_uInt8   nCol, nSpaces;
 137
 138         while( nCnt )
 139         {
 140             Read( nCol );
 141             Read( nSpaces );
 142             // Attention: ambiguous Correction factor!
 143             pD->SetColWidth( static_cast<SCCOL> (nCol), static_cast<SCTAB> (nLTab), static_cast<sal_uInt16>( TWIPS_PER_CHAR * 1.28 * nSpaces ) );
 144
 145             nCnt--;
 146         }
 147     }
 148 }
 149
 150 void ImportLotus::Hiddencolumn( sal_uInt16 nRecLen )
 151 {
 152     SAL_WARN_IF( nRecLen < 4, "sc.filter", "*ImportLotus::Hiddencolumn(): Record too short!" );
 153
 154     sal_uInt8    nLTab, nWindow2;
 155     sal_uInt16    nCnt = (nRecLen < 4) ? 0 : ( nRecLen - 4 ) / 2;
 156
 157     Read( nLTab );
 158     Read( nWindow2 );
 159
 160     if( !nWindow2 )
 161     {
 162         Skip( 2 );
 163
 164         sal_uInt8   nCol;
 165
 166         while( nCnt )
 167         {
 168             Read( nCol );
 169
 170             pD->SetColHidden(static_cast<SCCOL>(nCol), static_cast<SCCOL>(nCol), static_cast<SCTAB>(nLTab), true);
 171             nCnt--;
 172         }
 173     }
 174 }
 175
 176 void ImportLotus::Userrange()
 177 {
 178     sal_uInt16      nRangeType;
 179     ScRange     aScRange;
 180
 181     Read( nRangeType );
 182
 183     sal_Char aBuffer[ 17 ];
 184     pIn->ReadBytes(aBuffer, 16);
 185     aBuffer[ 16 ] = 0;
 186     OUString      aName( aBuffer, strlen(aBuffer), eQuellChar );
 187
 188     Read( aScRange );
 189
 190     LotusContext &rContext = aConv.getContext();
 191     rContext.pLotusRoot->pRngNmBffWK3->Add( aName, aScRange );
 192 }
 193
 194 void ImportLotus::Errcell()
 195 {
 196     ScAddress   aA;
 197
 198     Read( aA );
 199
 200     ScSetStringParam aParam;
 201     aParam.setTextInput();
 202     pD->EnsureTable(aA.Tab());
 203     pD->SetString(aA, "#ERR!", &aParam);
 204 }
 205
 206 void ImportLotus::Nacell()
 207 {
 208     ScAddress   aA;
 209
 210     Read( aA );
 211
 212     ScSetStringParam aParam;
 213     aParam.setTextInput();
 214     pD->EnsureTable(aA.Tab());
 215     pD->SetString(aA, "#NA!", &aParam);
 216 }
 217
 218 void ImportLotus::Labelcell()
 219 {
 220     ScAddress   aA;
 221     OUString    aLabel;
 222     sal_Char    cAlign;
 223
 224     Read( aA );
 225     Read( cAlign );
 226     Read( aLabel );
 227
 228     ScSetStringParam aParam;
 229     aParam.setTextInput();
 230     pD->EnsureTable(aA.Tab());
 231     pD->SetString(aA, aLabel, &aParam);
 232 }
 233
 234 void ImportLotus::Numbercell()
 235 {
 236     ScAddress   aAddr;
 237     double      fVal;
 238
 239     Read( aAddr );
 240     Read( fVal );
 241
 242     pD->EnsureTable(aAddr.Tab());
 243     pD->SetValue(aAddr, fVal);
 244 }
 245
 246 void ImportLotus::Smallnumcell()
 247 {
 248     ScAddress   aAddr;
 249     sal_Int16       nVal;
 250
 251     Read( aAddr );
 252     Read( nVal );
 253
 254     pD->EnsureTable(aAddr.Tab());
 255     pD->SetValue(aAddr, SnumToDouble(nVal));
 256 }
 257
 258 void ImportLotus::Formulacell( sal_uInt16 n )
 259 {
 260     SAL_WARN_IF( !pIn, "sc.filter", "-ImportLotus::Formulacell(): Null-Stream!" );
 261
 262     ScAddress           aAddr;
 263
 264     Read( aAddr );
 265     Skip( 10 );
 266
 267     n -= std::min<sal_uInt16>(n, 14);
 268
 269     std::unique_ptr<ScTokenArray> pErg;
 270     sal_Int32 nRest = n;
 271
 272     aConv.Reset( aAddr );
 273     aConv.SetWK3();
 274     aConv.Convert( pErg, nRest );
 275     if (!aConv.good())
 276         return;
 277
 278     ScFormulaCell* pCell = pErg ? new ScFormulaCell(pD, aAddr, std::move(pErg)) : new ScFormulaCell(pD, aAddr);
 279     pCell->AddRecalcMode( ScRecalcMode::ONLOAD_ONCE );
 280     pD->EnsureTable(aAddr.Tab());
 281     pD->SetFormulaCell(aAddr, pCell);
 282 }
 283
 284 void ImportLotus::Read( OUString &r )
 285 {
 286     ScfTools::AppendCString( *pIn, r, eQuellChar );
 287 }
 288
 289 void ImportLotus::RowPresentation( sal_uInt16 nRecLen )
 290 {
 291     SAL_WARN_IF( nRecLen < 5, "sc.filter", "*ImportLotus::RowPresentation(): Record too short!" );
 292
 293     sal_uInt8    nLTab, nFlags;
 294     sal_uInt16  nRow, nHeight;
 295     sal_uInt16    nCnt = (nRecLen < 4) ? 0 : ( nRecLen - 4 ) / 8;
 296
 297     Read( nLTab );
 298     Skip( 1 );
 299
 300     while( nCnt )
 301     {
 302         Read( nRow );
 303         Read( nHeight );
 304         Skip( 2 );
 305         Read( nFlags );
 306         Skip( 1 );
 307
 308         if( nFlags & 0x02 )     // Fixed / Stretch to fit fonts
 309         {   // fixed
 310             // Height in Lotus in 1/32 Points
 311             nHeight *= 20;  // -> 32 * TWIPS
 312             nHeight /= 32;  // -> TWIPS
 313
 314             pD->SetRowFlags( static_cast<SCROW> (nRow), static_cast<SCTAB> (nLTab), pD->GetRowFlags( static_cast<SCROW> (nRow), static_cast<SCTAB> (nLTab) ) | CRFlags::ManualSize );
 315
 316             pD->SetRowHeight( static_cast<SCROW> (nRow), static_cast<SCTAB> (nLTab), nHeight );
 317         }
 318
 319         nCnt--;
 320     }
 321 }
 322
 323 void ImportLotus::NamedSheet()
 324 {
 325     sal_uInt16 nTmpTab(0);
 326     Read(nTmpTab);
 327     OUString aName;
 328     Read(aName);
 329
 330     SCTAB nLTab(SanitizeTab(static_cast<SCTAB>(nTmpTab)));
 331 #if ENABLE_FUZZERS
 332     //ofz#14167 arbitrary sheet limit to make fuzzing useful
 333     if (nLTab > 5)
 334         nLTab = 5;
 335 #endif
 336
 337     if (pD->HasTable(nLTab))
 338         pD->RenameTab(nLTab, aName);
 339     else
 340         pD->InsertTab(nLTab, aName);
 341 }
 342
 343 void ImportLotus::Font_Face()
 344 {
 345     sal_uInt8   nNum;
 346     OUString    aName;
 347
 348     Read( nNum );
 349
 350     if( nNum >= LotusFontBuffer::nSize )
 351         return;     // nonsense
 352
 353     Read( aName );
 354
 355     LotusContext &rContext = aConv.getContext();
 356     rContext.pLotusRoot->maFontBuff.SetName( nNum, aName );
 357 }
 358
 359 void ImportLotus::Font_Type()
 360 {
 361     LotusContext &rContext = aConv.getContext();
 362     for( sal_uInt16 nCnt = 0 ; nCnt < LotusFontBuffer::nSize ; nCnt++ )
 363     {
 364         sal_uInt16 nType;
 365         Read( nType );
 366         rContext.pLotusRoot->maFontBuff.SetType( nCnt, nType );
 367     }
 368 }
 369
 370 void ImportLotus::Font_Ysize()
 371 {
 372     LotusContext &rContext = aConv.getContext();
 373     for( sal_uInt16 nCnt = 0 ; nCnt < LotusFontBuffer::nSize ; nCnt++ )
 374     {
 375         sal_uInt16 nSize;
 376         Read( nSize );
 377         rContext.pLotusRoot->maFontBuff.SetHeight( nCnt, nSize );
 378     }
 379 }
 380
 381 void ImportLotus::Row_( const sal_uInt16 nRecLen )
 382 {
 383     SAL_WARN_IF( nExtTab < 0, "sc.filter", "*ImportLotus::Row_(): not possible!" );
 384
 385     sal_uInt16            nCntDwn = (nRecLen < 4) ? 0 : ( nRecLen - 4 ) / 5;
 386     SCCOL           nColCnt = 0;
 387     sal_uInt8           nRepeats;
 388     LotAttrWK3      aAttr;
 389
 390     bool            bCenter = false;
 391     SCCOL           nCenterStart = 0, nCenterEnd = 0;
 392
 393     sal_uInt16 nTmpRow(0);
 394     Read(nTmpRow);
 395     SCROW nRow(SanitizeRow(static_cast<SCROW>(nTmpRow)));
 396     sal_uInt16 nHeight(0);
 397     Read(nHeight);
 398
 399     nHeight &= 0x0FFF;
 400     nHeight *= 22;
 401
 402     SCTAB nDestTab(static_cast<SCTAB>(nExtTab));
 403
 404     if( nHeight )
 405         pD->SetRowHeight(nRow, nDestTab, nHeight);
 406
 407     LotusContext &rContext = aConv.getContext();
 408     while( nCntDwn )
 409     {
 410         Read( aAttr );
 411         Read( nRepeats );
 412
 413         if( aAttr.HasStyles() )
 414             rContext.pLotusRoot->maAttrTable.SetAttr(
 415                 nColCnt, static_cast<SCCOL> ( nColCnt + nRepeats ), nRow, aAttr );
 416
 417         // Do this here and NOT in class LotAttrTable, as we only add attributes if the other
 418         // attributes are set
 419         //  -> for Center-Attribute default is centered
 420         if( aAttr.IsCentered() )
 421         {
 422             if( bCenter )
 423             {
 424                 if (pD->HasData(nColCnt, nRow, nDestTab))
 425                 {
 426                     // new Center after previous Center
 427                     pD->DoMerge(nDestTab, nCenterStart, nRow, nCenterEnd, nRow);
 428                     nCenterStart = nColCnt;
 429                 }
 430             }
 431             else
 432             {
 433                 // fully new Center
 434                 bCenter = true;
 435                 nCenterStart = nColCnt;
 436             }
 437             nCenterEnd = nColCnt + static_cast<SCCOL>(nRepeats);
 438         }
 439         else
 440         {
 441             if( bCenter )
 442             {
 443                 // possibly reset old Center
 444                 pD->DoMerge(nDestTab, nCenterStart, nRow, nCenterEnd, nRow);
 445                 bCenter = false;
 446             }
 447         }
 448
 449         nColCnt = nColCnt + static_cast<SCCOL>(nRepeats);
 450         nColCnt++;
 451
 452         nCntDwn--;
 453     }
 454
 455     if( bCenter )
 456         // possibly reset old Center
 457         pD->DoMerge(nDestTab, nCenterStart, nRow, nCenterEnd, nRow);
 458 }
 459 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */