basic/source/classes/image.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 <tools/stream.hxx>
  21 #include <tools/tenccvt.hxx>
  22 #include <basic/sbx.hxx>
  23 #include "sb.hxx"
  24 #include <string.h>     // memset() etc
  25 #include "image.hxx"
  26 #include <codegen.hxx>
  27 SbiImage::SbiImage()
  28 {
  29     pStringOff = NULL;
  30     pStrings   = NULL;
  31     pCode      = NULL;
  32     pLegacyPCode       = NULL;
  33     nFlags     = 0;
  34     nStrings   = 0;
  35     nStringSize= 0;
  36     nCodeSize  = 0;
  37     nLegacyCodeSize  =
  38     nDimBase   = 0;
  39     bInit      =
  40     bError     = false;
  41     bFirstInit = true;
  42     eCharSet   = osl_getThreadTextEncoding();
  43 }
  44
  45 SbiImage::~SbiImage()
  46 {
  47     Clear();
  48 }
  49
  50 void SbiImage::Clear()
  51 {
  52     delete[] pStringOff;
  53     delete[] pStrings;
  54     delete[] pCode;
  55     ReleaseLegacyBuffer();
  56     pStringOff = NULL;
  57     pStrings   = NULL;
  58     pCode      = NULL;
  59     nFlags     = 0;
  60     nStrings   = 0;
  61     nStringSize= 0;
  62     nLegacyCodeSize  = 0;
  63     nCodeSize  = 0;
  64     eCharSet   = osl_getThreadTextEncoding();
  65     nDimBase   = 0;
  66     bError     = false;
  67 }
  68
  69 /**************************************************************************
  70 *
  71 *    Service-Routines for Load/Store
  72 *
  73 **************************************************************************/
  74
  75 bool SbiGood( SvStream& r )
  76 {
  77     return !r.IsEof() && r.GetError() == SVSTREAM_OK;
  78 }
  79
  80 // Open Record
  81 sal_uIntPtr SbiOpenRecord( SvStream& r, sal_uInt16 nSignature, sal_uInt16 nElem )
  82 {
  83     sal_uIntPtr nPos = r.Tell();
  84     r << nSignature << (sal_Int32) 0 << nElem;
  85     return nPos;
  86 }
  87
  88 // Close Record
  89 void SbiCloseRecord( SvStream& r, sal_uIntPtr nOff )
  90 {
  91     sal_uIntPtr nPos = r.Tell();
  92     r.Seek( nOff + 2 );
  93     r << (sal_Int32) ( nPos - nOff - 8 );
  94     r.Seek( nPos );
  95 }
  96
  97 /**************************************************************************
  98 *
  99 *    Load/Store
 100 *
 101 **************************************************************************/
 102
 103 bool SbiImage::Load( SvStream& r, sal_uInt32& nVersion )
 104 {
 105
 106     sal_uInt16 nSign, nCount;
 107     sal_uInt32 nLen, nOff;
 108
 109     Clear();
 110     // Read Master-Record
 111     r >> nSign >> nLen >> nCount;
 112     sal_uIntPtr nLast = r.Tell() + nLen;
 113     sal_uInt32 nCharSet;               // System charset
 114     sal_uInt32 lDimBase;
 115     sal_uInt16 nReserved1;
 116     sal_uInt32 nReserved2;
 117     sal_uInt32 nReserved3;
 118     bool bBadVer = false;
 119     if( nSign == B_MODULE )
 120     {
 121         r >> nVersion >> nCharSet >> lDimBase
 122           >> nFlags >> nReserved1 >> nReserved2 >> nReserved3;
 123         eCharSet = (CharSet) nCharSet;
 124         eCharSet = GetSOLoadTextEncoding( eCharSet );
 125         bBadVer  = ( nVersion > B_CURVERSION );
 126         nDimBase = (sal_uInt16) lDimBase;
 127     }
 128
 129     bool bLegacy = ( nVersion < B_EXT_IMG_VERSION );
 130
 131     sal_uIntPtr nNext;
 132     while( ( nNext = r.Tell() ) < nLast )
 133     {
 134
 135         r >> nSign >> nLen >> nCount;
 136         nNext += nLen + 8;
 137         if( r.GetError() == SVSTREAM_OK )
 138         {
 139             switch( nSign )
 140             {
 141             case B_NAME:
 142                 aName = r.ReadUniOrByteString(eCharSet);
 143                 break;
 144             case B_COMMENT:
 145                 aComment = r.ReadUniOrByteString(eCharSet );
 146                 break;
 147             case B_SOURCE:
 148             {
 149                 aOUSource = r.ReadUniOrByteString(eCharSet);
 150                 break;
 151             }
 152             case B_EXTSOURCE:
 153             {
 154                 for( sal_uInt16 j = 0 ; j < nCount ; j++ )
 155                 {
 156                     aOUSource += r.ReadUniOrByteString(eCharSet);
 157                 }
 158                 break;
 159             }
 160             case B_PCODE:
 161                 if( bBadVer ) break;
 162                 pCode = new char[ nLen ];
 163                 nCodeSize = nLen;
 164                 r.Read( pCode, nCodeSize );
 165                 if ( bLegacy )
 166                 {
 167                     ReleaseLegacyBuffer(); // release any previously held buffer
 168                     nLegacyCodeSize = (sal_uInt16) nCodeSize;
 169                     pLegacyPCode = pCode;
 170
 171                     PCodeBuffConvertor< sal_uInt16, sal_uInt32 > aLegacyToNew( (sal_uInt8*)pLegacyPCode, nLegacyCodeSize );
 172                     aLegacyToNew.convert();
 173                     pCode = (char*)aLegacyToNew.GetBuffer();
 174                     nCodeSize = aLegacyToNew.GetSize();
 175                     // we don't release the legacy buffer
 176                     // right now, thats because the module
 177                     // needs it to fix up the method
 178                     // nStart members. When that is done
 179                     // the module can release the buffer
 180                     // or it can wait until this routine
 181                     // is called again or when this class                       // destructs all of which will trigger
 182                     // release of the buffer.
 183                 }
 184                 break;
 185             case B_PUBLICS:
 186             case B_POOLDIR:
 187             case B_SYMPOOL:
 188             case B_LINERANGES:
 189                 break;
 190             case B_STRINGPOOL:
 191                 if( bBadVer ) break;
 192                 MakeStrings( nCount );
 193                 short i;
 194                 for( i = 0; i < nStrings && SbiGood( r ); i++ )
 195                 {
 196                     r >> nOff;
 197                     pStringOff[ i ] = (sal_uInt16) nOff;
 198                 }
 199                 r >> nLen;
 200                 if( SbiGood( r ) )
 201                 {
 202                     delete [] pStrings;
 203                     pStrings = new sal_Unicode[ nLen ];
 204                     nStringSize = (sal_uInt16) nLen;
 205
 206                     char* pByteStrings = new char[ nLen ];
 207                     r.Read( pByteStrings, nStringSize );
 208                     for( short j = 0; j < nStrings; j++ )
 209                     {
 210                         sal_uInt16 nOff2 = (sal_uInt16) pStringOff[ j ];
 211                         OUString aStr( pByteStrings + nOff2, strlen(pByteStrings + nOff2), eCharSet );
 212                         memcpy( pStrings + nOff2, aStr.getStr(), (aStr.getLength() + 1) * sizeof( sal_Unicode ) );
 213                     }
 214                     delete[] pByteStrings;
 215                 }
 216                 break;
 217             case B_MODEND:
 218                 goto done;
 219             default:
 220                 break;
 221             }
 222         }
 223         else
 224         {
 225             break;
 226         }
 227         r.Seek( nNext );
 228     }
 229 done:
 230     r.Seek( nLast );
 231     if( !SbiGood( r ) )
 232     {
 233         bError = true;
 234     }
 235     return !bError;
 236 }
 237
 238 bool SbiImage::Save( SvStream& r, sal_uInt32 nVer )
 239 {
 240     bool bLegacy = ( nVer < B_EXT_IMG_VERSION );
 241
 242     // detect if old code exceeds legacy limits
 243     // if so, then disallow save
 244     if ( bLegacy && ExceedsLegacyLimits() )
 245     {
 246         SbiImage aEmptyImg;
 247         aEmptyImg.aName = aName;
 248         aEmptyImg.Save( r, B_LEGACYVERSION );
 249         return true;
 250     }
 251     // First of all the header
 252     sal_uIntPtr nStart = SbiOpenRecord( r, B_MODULE, 1 );
 253     sal_uIntPtr nPos;
 254
 255     eCharSet = GetSOStoreTextEncoding( eCharSet );
 256     if ( bLegacy )
 257     {
 258         r << (sal_Int32) B_LEGACYVERSION;
 259     }
 260     else
 261     {
 262         r << (sal_Int32) B_CURVERSION;
 263     }
 264     r  << (sal_Int32) eCharSet
 265        << (sal_Int32) nDimBase
 266        << (sal_Int16) nFlags
 267        << (sal_Int16) 0
 268        << (sal_Int32) 0
 269        << (sal_Int32) 0;
 270
 271     // Name?
 272     if( !aName.isEmpty() && SbiGood( r ) )
 273     {
 274         nPos = SbiOpenRecord( r, B_NAME, 1 );
 275         r.WriteUniOrByteString( aName, eCharSet );
 276         SbiCloseRecord( r, nPos );
 277     }
 278     // Comment?
 279     if( !aComment.isEmpty() && SbiGood( r ) )
 280     {
 281         nPos = SbiOpenRecord( r, B_COMMENT, 1 );
 282         r.WriteUniOrByteString( aComment, eCharSet );
 283         SbiCloseRecord( r, nPos );
 284     }
 285     // Source?
 286     if( !aOUSource.isEmpty() && SbiGood( r ) )
 287     {
 288         nPos = SbiOpenRecord( r, B_SOURCE, 1 );
 289         OUString aTmp;
 290         sal_Int32 nLen = aOUSource.getLength();
 291         const sal_Int32 nMaxUnitSize = STRING_MAXLEN - 1;
 292         if( nLen > STRING_MAXLEN )
 293         {
 294             aTmp = aOUSource.copy( 0, nMaxUnitSize );
 295         }
 296         else
 297         {
 298             aTmp = aOUSource;
 299         }
 300         r.WriteUniOrByteString( aTmp, eCharSet );
 301         SbiCloseRecord( r, nPos );
 302
 303         if( nLen > STRING_MAXLEN )
 304         {
 305             sal_Int32 nRemainingLen = nLen - nMaxUnitSize;
 306             sal_uInt16 nUnitCount = sal_uInt16( (nRemainingLen + nMaxUnitSize - 1) / nMaxUnitSize );
 307             nPos = SbiOpenRecord( r, B_EXTSOURCE, nUnitCount );
 308             for( sal_uInt16 i = 0 ; i < nUnitCount ; i++ )
 309             {
 310                 sal_Int32 nCopyLen = (nRemainingLen > nMaxUnitSize) ? nMaxUnitSize : nRemainingLen;
 311                 OUString aTmp2 = aOUSource.copy( (i+1) * nMaxUnitSize, nCopyLen );
 312                 nRemainingLen -= nCopyLen;
 313                 r.WriteUniOrByteString( aTmp2, eCharSet );
 314             }
 315             SbiCloseRecord( r, nPos );
 316         }
 317     }
 318     // Binary data?
 319     if( pCode && SbiGood( r ) )
 320     {
 321         nPos = SbiOpenRecord( r, B_PCODE, 1 );
 322         if ( bLegacy )
 323         {
 324             ReleaseLegacyBuffer(); // release any previously held buffer
 325             PCodeBuffConvertor< sal_uInt32, sal_uInt16 > aNewToLegacy( (sal_uInt8*)pCode, nCodeSize );
 326             aNewToLegacy.convert();
 327             pLegacyPCode = (char*)aNewToLegacy.GetBuffer();
 328             nLegacyCodeSize = aNewToLegacy.GetSize();
 329             r.Write( pLegacyPCode, nLegacyCodeSize );
 330         }
 331         else
 332         {
 333             r.Write( pCode, nCodeSize );
 334         }
 335         SbiCloseRecord( r, nPos );
 336     }
 337     // String-Pool?
 338     if( nStrings )
 339     {
 340         nPos = SbiOpenRecord( r, B_STRINGPOOL, nStrings );
 341         // For every String:
 342         //  sal_uInt32 Offset of the Strings in the Stringblock
 343         short i;
 344
 345         for( i = 0; i < nStrings && SbiGood( r ); i++ )
 346         {
 347             r << (sal_uInt32) pStringOff[ i ];
 348         }
 349         // Then the String-Block
 350         char* pByteStrings = new char[ nStringSize ];
 351         for( i = 0; i < nStrings; i++ )
 352         {
 353             sal_uInt16 nOff = (sal_uInt16) pStringOff[ i ];
 354             OString aStr(OUStringToOString(OUString(pStrings + nOff), eCharSet));
 355             memcpy( pByteStrings + nOff, aStr.getStr(), (aStr.getLength() + 1) * sizeof( char ) );
 356         }
 357         r << (sal_uInt32) nStringSize;
 358         r.Write( pByteStrings, nStringSize );
 359
 360         delete[] pByteStrings;
 361         SbiCloseRecord( r, nPos );
 362     }
 363     // Set overall length
 364     SbiCloseRecord( r, nStart );
 365     if( !SbiGood( r ) )
 366     {
 367         bError = true;
 368     }
 369     return !bError;
 370 }
 371
 372 /**************************************************************************
 373 *
 374 *    Routines called by the compiler
 375 *
 376 **************************************************************************/
 377
 378 void SbiImage::MakeStrings( short nSize )
 379 {
 380     nStrings = 0;
 381     nStringIdx = 0;
 382     nStringOff = 0;
 383     nStringSize = 1024;
 384     pStrings = new sal_Unicode[ nStringSize ];
 385     pStringOff = new sal_uInt32[ nSize ];
 386     if( pStrings && pStringOff )
 387     {
 388         nStrings = nSize;
 389         memset( pStringOff, 0, nSize * sizeof( sal_uInt32 ) );
 390         memset( pStrings, 0, nStringSize * sizeof( sal_Unicode ) );
 391     }
 392     else
 393     {
 394         bError = true;
 395     }
 396 }
 397
 398 // Add a string to StringPool. The String buffer is dynamically
 399 // growing in 1K-Steps
 400 void SbiImage::AddString( const OUString& r )
 401 {
 402     if( nStringIdx >= nStrings )
 403     {
 404         bError = true;
 405     }
 406     if( !bError )
 407     {
 408         sal_Int32  len = r.getLength() + 1;
 409         sal_uInt32 needed = nStringOff + len;
 410         if( needed > 0xFFFFFF00L )
 411         {
 412             bError = true;  // out of mem!
 413         }
 414         else if( needed > nStringSize )
 415         {
 416             sal_uInt32 nNewLen = needed + 1024;
 417             nNewLen &= 0xFFFFFC00;  // trim to 1K border
 418             sal_Unicode* p = NULL;
 419             if( (p = new sal_Unicode[ nNewLen ]) != NULL )
 420             {
 421                 memcpy( p, pStrings, nStringSize * sizeof( sal_Unicode ) );
 422                 delete[] pStrings;
 423                 pStrings = p;
 424                 nStringSize = sal::static_int_cast< sal_uInt16 >(nNewLen);
 425             }
 426             else
 427             {
 428                 bError = true;
 429             }
 430         }
 431         if( !bError )
 432         {
 433             pStringOff[ nStringIdx++ ] = nStringOff;
 434             memcpy( pStrings + nStringOff, r.getStr(), len * sizeof( sal_Unicode ) );
 435             nStringOff = nStringOff + len;
 436             // Last String? The update the size of the buffer
 437             if( nStringIdx >= nStrings )
 438             {
 439                 nStringSize = nStringOff;
 440             }
 441         }
 442     }
 443 }
 444
 445 // Add code block
 446 // The block was fetched by the compiler from class SbBuffer and
 447 // is already created with new. Additionally it contains all Integers
 448 // in Big Endian format, so can be directly read/written.
 449 void SbiImage::AddCode( char* p, sal_uInt32 s )
 450 {
 451     pCode = p;
 452     nCodeSize = s;
 453 }
 454
 455 // Add user type
 456 void SbiImage::AddType(SbxObject* pObject)
 457 {
 458     if( !rTypes.Is() )
 459     {
 460         rTypes = new SbxArray;
 461     }
 462     SbxObject *pCopyObject = new SbxObject(*pObject);
 463     rTypes->Insert (pCopyObject,rTypes->Count());
 464 }
 465
 466 void SbiImage::AddEnum(SbxObject* pObject) // Register enum type
 467 {
 468     if( !rEnums.Is() )
 469     {
 470         rEnums = new SbxArray;
 471     }
 472     rEnums->Insert( pObject, rEnums->Count() );
 473 }
 474
 475
 476 /**************************************************************************
 477 *
 478 *    Accessing the image
 479 *
 480 **************************************************************************/
 481
 482 // Note: IDs start with 1
 483 OUString SbiImage::GetString( short nId ) const
 484 {
 485     if( nId && nId <= nStrings )
 486     {
 487         sal_uInt32 nOff = pStringOff[ nId - 1 ];
 488         sal_Unicode* pStr = pStrings + nOff;
 489
 490         // #i42467: Special treatment for vbNullChar
 491         if( *pStr == 0 )
 492         {
 493             sal_uInt32 nNextOff = (nId < nStrings) ? pStringOff[ nId ] : nStringOff;
 494             sal_uInt32 nLen = nNextOff - nOff - 1;
 495             if( nLen == 1 )
 496             {
 497                 // Force length 1 and make char 0 afterwards
 498                 OUString aNullCharStr( (sal_Unicode)0);
 499                 return aNullCharStr;
 500             }
 501         }
 502         else
 503         {
 504             return OUString(pStr);
 505         }
 506     }
 507     return OUString();
 508 }
 509
 510 const SbxObject* SbiImage::FindType (OUString aTypeName) const
 511 {
 512     return rTypes.Is() ? (SbxObject*)rTypes->Find(aTypeName,SbxCLASS_OBJECT) : NULL;
 513 }
 514
 515 sal_uInt16 SbiImage::CalcLegacyOffset( sal_Int32 nOffset )
 516 {
 517     return SbiCodeGen::calcLegacyOffSet( (sal_uInt8*)pCode, nOffset ) ;
 518 }
 519
 520 sal_uInt32 SbiImage::CalcNewOffset( sal_Int16 nOffset )
 521 {
 522     return SbiCodeGen::calcNewOffSet( (sal_uInt8*)pLegacyPCode, nOffset ) ;
 523 }
 524
 525 void  SbiImage::ReleaseLegacyBuffer()
 526 {
 527     delete[] pLegacyPCode;
 528     pLegacyPCode = NULL;
 529     nLegacyCodeSize = 0;
 530 }
 531
 532 bool SbiImage::ExceedsLegacyLimits()
 533 {
 534     return ( nStringSize > 0xFF00L ) || ( CalcLegacyOffset( nCodeSize ) > 0xFF00L );
 535 }
 536
 537 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */