basic/source/basmgr/basmgr.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 <vcl/errinf.hxx>
  21 #include <tools/stream.hxx>
  22 #include <sot/storage.hxx>
  23 #include <tools/urlobj.hxx>
  24 #include <svl/hint.hxx>
  25 #include <basic/sbx.hxx>
  26 #include <basic/sbmeth.hxx>
  27 #include <sot/storinfo.hxx>
  28 #include <unotools/pathoptions.hxx>
  29 #include <tools/debug.hxx>
  30 #include <tools/diagnose_ex.h>
  31 #include <basic/sbmod.hxx>
  32 #include <unotools/transliterationwrapper.hxx>
  33 #include <sal/log.hxx>
  34
  35 #include <basic/sberrors.hxx>
  36 #include <basic/sbuno.hxx>
  37 #include <basic/basmgr.hxx>
  38 #include <global.hxx>
  39 #include <com/sun/star/script/XLibraryContainer.hpp>
  40 #include <com/sun/star/script/XPersistentLibraryContainer.hpp>
  41
  42 #include <memory>
  43 #include <vector>
  44
  45 #define LIB_SEP         0x01
  46 #define LIBINFO_SEP     0x02
  47 #define LIBINFO_ID      0x1491
  48 #define PASSWORD_MARKER 0x31452134
  49
  50
  51 // Library API, implemented for XML import/export
  52
  53 #include <com/sun/star/container/XNameContainer.hpp>
  54 #include <com/sun/star/container/XContainer.hpp>
  55 #include <com/sun/star/script/XStarBasicAccess.hpp>
  56 #include <com/sun/star/script/XStarBasicModuleInfo.hpp>
  57 #include <com/sun/star/script/XStarBasicDialogInfo.hpp>
  58 #include <com/sun/star/script/XStarBasicLibraryInfo.hpp>
  59 #include <com/sun/star/script/XLibraryContainerPassword.hpp>
  60 #include <com/sun/star/script/ModuleInfo.hpp>
  61 #include <com/sun/star/script/vba/XVBACompatibility.hpp>
  62 #include <com/sun/star/script/vba/XVBAModuleInfo.hpp>
  63 #include <com/sun/star/ucb/ContentCreationException.hpp>
  64
  65 #include <cppuhelper/implbase.hxx>
  66
  67 using com::sun::star::uno::Reference;
  68 using namespace com::sun::star;
  69 using namespace com::sun::star::script;
  70 using namespace cppu;
  71
  72 typedef WeakImplHelper< container::XNameContainer > NameContainerHelper;
  73 typedef WeakImplHelper< script::XStarBasicModuleInfo > ModuleInfoHelper;
  74 typedef WeakImplHelper< script::XStarBasicAccess > StarBasicAccessHelper;
  75
  76 // Version 1
  77 //    sal_uInt32    nEndPos
  78 //    sal_uInt16    nId
  79 //    sal_uInt16    nVer
  80 //    bool      bDoLoad
  81 //    String    LibName
  82 //    String    AbsStorageName
  83 //    String    RelStorageName
  84 // Version 2
  85 //  + bool      bReference
  86
  87 static const char szStdLibName[] = "Standard";
  88 static const char szBasicStorage[] = "StarBASIC";
  89 static const char szOldManagerStream[] = "BasicManager";
  90 static const char szManagerStream[] = "BasicManager2";
  91 static const char szImbedded[] = "LIBIMBEDDED";
  92 static const char szCryptingKey[] = "CryptedBasic";
  93
  94
  95 const StreamMode eStreamReadMode = StreamMode::READ | StreamMode::NOCREATE | StreamMode::SHARE_DENYALL;
  96 const StreamMode eStorageReadMode = StreamMode::READ | StreamMode::SHARE_DENYWRITE;
  97
  98
  99 // BasicManager impl data
 100 struct BasicManagerImpl
 101 {
 102     LibraryContainerInfo    maContainerInfo;
 103
 104     std::vector<std::unique_ptr<BasicLibInfo>> aLibs;
 105     OUString         aBasicLibPath;
 106
 107     BasicManagerImpl()
 108     {}
 109 };
 110
 111 // BasMgrContainerListenerImpl
 112
 113
 114 typedef ::cppu::WeakImplHelper< container::XContainerListener > ContainerListenerHelper;
 115
 116 class BasMgrContainerListenerImpl: public ContainerListenerHelper
 117 {
 118     BasicManager* mpMgr;
 119     OUString maLibName;      // empty -> no lib, but lib container
 120
 121 public:
 122     BasMgrContainerListenerImpl( BasicManager* pMgr, const OUString& aLibName )
 123         : mpMgr( pMgr )
 124         , maLibName( aLibName ) {}
 125
 126     static void insertLibraryImpl( const uno::Reference< script::XLibraryContainer >& xScriptCont, BasicManager* pMgr,
 127                                    const uno::Any& aLibAny, const OUString& aLibName );
 128     static void addLibraryModulesImpl( BasicManager const * pMgr, const uno::Reference< container::XNameAccess >& xLibNameAccess,
 129                                        const OUString& aLibName );
 130
 131
 132     // XEventListener
 133     virtual void SAL_CALL disposing( const lang::EventObject& Source ) override;
 134
 135     // XContainerListener
 136     virtual void SAL_CALL elementInserted( const container::ContainerEvent& Event ) override;
 137     virtual void SAL_CALL elementReplaced( const container::ContainerEvent& Event ) override;
 138     virtual void SAL_CALL elementRemoved( const container::ContainerEvent& Event ) override;
 139 };
 140
 141
 142 // BasMgrContainerListenerImpl
 143
 144
 145 void BasMgrContainerListenerImpl::insertLibraryImpl( const uno::Reference< script::XLibraryContainer >& xScriptCont,
 146     BasicManager* pMgr, const uno::Any& aLibAny, const OUString& aLibName )
 147 {
 148     Reference< container::XNameAccess > xLibNameAccess;
 149     aLibAny >>= xLibNameAccess;
 150
 151     if( !pMgr->GetLib( aLibName ) )
 152     {
 153         StarBASIC* pLib =
 154             pMgr->CreateLibForLibContainer( aLibName, xScriptCont );
 155         DBG_ASSERT( pLib, "XML Import: Basic library could not be created");
 156     }
 157
 158     uno::Reference< container::XContainer> xLibContainer( xLibNameAccess, uno::UNO_QUERY );
 159     if( xLibContainer.is() )
 160     {
 161         // Register listener for library
 162         Reference< container::XContainerListener > xLibraryListener
 163             = new BasMgrContainerListenerImpl( pMgr, aLibName );
 164         xLibContainer->addContainerListener( xLibraryListener );
 165     }
 166
 167     if( xScriptCont->isLibraryLoaded( aLibName ) )
 168     {
 169         addLibraryModulesImpl( pMgr, xLibNameAccess, aLibName );
 170     }
 171 }
 172
 173
 174 void BasMgrContainerListenerImpl::addLibraryModulesImpl( BasicManager const * pMgr,
 175     const uno::Reference< container::XNameAccess >& xLibNameAccess, const OUString& aLibName )
 176 {
 177     uno::Sequence< OUString > aModuleNames = xLibNameAccess->getElementNames();
 178     sal_Int32 nModuleCount = aModuleNames.getLength();
 179
 180     StarBASIC* pLib = pMgr->GetLib( aLibName );
 181     DBG_ASSERT( pLib, "BasMgrContainerListenerImpl::addLibraryModulesImpl: Unknown lib!");
 182     if( pLib )
 183     {
 184         const OUString* pNames = aModuleNames.getConstArray();
 185         for( sal_Int32 j = 0 ; j < nModuleCount ; j++ )
 186         {
 187             OUString aModuleName = pNames[ j ];
 188             uno::Any aElement = xLibNameAccess->getByName( aModuleName );
 189             OUString aMod;
 190             aElement >>= aMod;
 191             uno::Reference< vba::XVBAModuleInfo > xVBAModuleInfo( xLibNameAccess, uno::UNO_QUERY );
 192             if ( xVBAModuleInfo.is() && xVBAModuleInfo->hasModuleInfo( aModuleName ) )
 193             {
 194                 ModuleInfo aInfo = xVBAModuleInfo->getModuleInfo( aModuleName );
 195                 pLib->MakeModule( aModuleName, aInfo, aMod );
 196             }
 197             else
 198                 pLib->MakeModule( aModuleName, aMod );
 199         }
 200
 201         pLib->SetModified( false );
 202     }
 203 }
 204
 205
 206 // XEventListener
 207
 208
 209 void SAL_CALL BasMgrContainerListenerImpl::disposing( const lang::EventObject& ) {}
 210
 211 // XContainerListener
 212
 213
 214 void SAL_CALL BasMgrContainerListenerImpl::elementInserted( const container::ContainerEvent& Event )
 215 {
 216     bool bLibContainer = maLibName.isEmpty();
 217     OUString aName;
 218     Event.Accessor >>= aName;
 219
 220     if( bLibContainer )
 221     {
 222         uno::Reference< script::XLibraryContainer > xScriptCont( Event.Source, uno::UNO_QUERY );
 223         if (xScriptCont.is())
 224             insertLibraryImpl(xScriptCont, mpMgr, Event.Element, aName);
 225         StarBASIC* pLib = mpMgr->GetLib( aName );
 226         if ( pLib )
 227         {
 228             uno::Reference< vba::XVBACompatibility > xVBACompat( xScriptCont, uno::UNO_QUERY );
 229             if ( xVBACompat.is() )
 230                 pLib->SetVBAEnabled( xVBACompat->getVBACompatibilityMode() );
 231         }
 232     }
 233     else
 234     {
 235
 236         StarBASIC* pLib = mpMgr->GetLib( maLibName );
 237         DBG_ASSERT( pLib, "BasMgrContainerListenerImpl::elementInserted: Unknown lib!");
 238         if( pLib )
 239         {
 240             SbModule* pMod = pLib->FindModule( aName );
 241             if( !pMod )
 242             {
 243                 OUString aMod;
 244                 Event.Element >>= aMod;
 245                 uno::Reference< vba::XVBAModuleInfo > xVBAModuleInfo( Event.Source, uno::UNO_QUERY );
 246                 if ( xVBAModuleInfo.is() && xVBAModuleInfo->hasModuleInfo( aName ) )
 247                 {
 248                     ModuleInfo aInfo = xVBAModuleInfo->getModuleInfo( aName );
 249                     pLib->MakeModule( aName, aInfo, aMod );
 250                 }
 251                 else
 252                     pLib->MakeModule( aName, aMod );
 253                 pLib->SetModified( false );
 254             }
 255         }
 256     }
 257 }
 258
 259
 260 void SAL_CALL BasMgrContainerListenerImpl::elementReplaced( const container::ContainerEvent& Event )
 261 {
 262     OUString aName;
 263     Event.Accessor >>= aName;
 264
 265     // Replace not possible for library container
 266     DBG_ASSERT( !maLibName.isEmpty(), "library container fired elementReplaced()");
 267
 268     StarBASIC* pLib = mpMgr->GetLib( maLibName );
 269     if( pLib )
 270     {
 271         SbModule* pMod = pLib->FindModule( aName );
 272         OUString aMod;
 273         Event.Element >>= aMod;
 274
 275         if( pMod )
 276                 pMod->SetSource32( aMod );
 277         else
 278                 pLib->MakeModule( aName, aMod );
 279
 280         pLib->SetModified( false );
 281     }
 282 }
 283
 284
 285 void SAL_CALL BasMgrContainerListenerImpl::elementRemoved( const container::ContainerEvent& Event )
 286 {
 287     OUString aName;
 288     Event.Accessor >>= aName;
 289
 290     bool bLibContainer = maLibName.isEmpty();
 291     if( bLibContainer )
 292     {
 293         StarBASIC* pLib = mpMgr->GetLib( aName );
 294         if( pLib )
 295         {
 296             sal_uInt16 nLibId = mpMgr->GetLibId( aName );
 297             mpMgr->RemoveLib( nLibId, false );
 298         }
 299     }
 300     else
 301     {
 302         StarBASIC* pLib = mpMgr->GetLib( maLibName );
 303         SbModule* pMod = pLib ? pLib->FindModule( aName ) : nullptr;
 304         if( pMod )
 305         {
 306             pLib->Remove( pMod );
 307             pLib->SetModified( false );
 308         }
 309     }
 310 }
 311
 312 BasicError::BasicError( ErrCode nId, BasicErrorReason nR )
 313 {
 314     nErrorId    = nId;
 315     nReason     = nR;
 316 }
 317
 318 BasicError::BasicError( const BasicError& rErr )
 319 {
 320     nErrorId    = rErr.nErrorId;
 321     nReason     = rErr.nReason;
 322 }
 323
 324
 325 class BasicLibInfo
 326 {
 327 private:
 328     StarBASICRef    xLib;
 329     OUString          aLibName;
 330     OUString          aStorageName;   // string is sufficient, unique at runtime
 331     OUString          aRelStorageName;
 332     OUString          aPassword;
 333
 334     bool              bDoLoad;
 335     bool              bReference;
 336
 337     // Lib represents library in new UNO library container
 338     uno::Reference< script::XLibraryContainer > mxScriptCont;
 339
 340 public:
 341     BasicLibInfo();
 342
 343     bool              IsReference() const     { return bReference; }
 344     void              SetReference(bool b)    { bReference = b; }
 345
 346     bool              IsExtern() const        { return aStorageName != szImbedded; }
 347
 348     void              SetStorageName( const OUString& rName )   { aStorageName = rName; }
 349     const OUString&   GetStorageName() const                  { return aStorageName; }
 350
 351     void              SetRelStorageName( const OUString& rN )   { aRelStorageName = rN; }
 352     const OUString&   GetRelStorageName() const               { return aRelStorageName; }
 353
 354     StarBASICRef      GetLib() const
 355     {
 356         if( mxScriptCont.is() && mxScriptCont->hasByName( aLibName ) &&
 357             !mxScriptCont->isLibraryLoaded( aLibName ) )
 358                 return StarBASICRef();
 359         return xLib;
 360     }
 361     StarBASICRef&     GetLibRef()                         { return xLib; }
 362     void              SetLib( StarBASIC* pBasic )         { xLib = pBasic; }
 363
 364     const OUString&   GetLibName() const                  { return aLibName; }
 365     void              SetLibName( const OUString& rName )   { aLibName = rName; }
 366
 367     // Only temporary for Load/Save
 368     bool              DoLoad()                            { return bDoLoad; }
 369
 370     bool              HasPassword() const                 { return !aPassword.isEmpty(); }
 371     const OUString&   GetPassword() const                 { return aPassword; }
 372     void              SetPassword( const OUString& rNewPassword )
 373                                                         { aPassword = rNewPassword; }
 374
 375     static BasicLibInfo*    Create( SotStorageStream& rSStream );
 376
 377     const uno::Reference< script::XLibraryContainer >& GetLibraryContainer() const
 378         { return mxScriptCont; }
 379     void SetLibraryContainer( const uno::Reference< script::XLibraryContainer >& xScriptCont )
 380         { mxScriptCont = xScriptCont; }
 381 };
 382
 383
 384 BasicLibInfo::BasicLibInfo()
 385     : aStorageName(szImbedded)
 386     , aRelStorageName(szImbedded)
 387     , bDoLoad(false)
 388     , bReference(false)
 389 {
 390 }
 391
 392 BasicLibInfo* BasicLibInfo::Create( SotStorageStream& rSStream )
 393 {
 394     BasicLibInfo* pInfo = new BasicLibInfo;
 395
 396     sal_uInt32 nEndPos;
 397     sal_uInt16 nId;
 398     sal_uInt16 nVer;
 399
 400     rSStream.ReadUInt32( nEndPos );
 401     rSStream.ReadUInt16( nId );
 402     rSStream.ReadUInt16( nVer );
 403
 404     DBG_ASSERT( nId == LIBINFO_ID, "No BasicLibInfo?!" );
 405     if( nId == LIBINFO_ID )
 406     {
 407         // Reload?
 408         bool bDoLoad;
 409         rSStream.ReadCharAsBool( bDoLoad );
 410         pInfo->bDoLoad = bDoLoad;
 411
 412         // The name of the lib...
 413         OUString aName = rSStream.ReadUniOrByteString(rSStream.GetStreamCharSet());
 414         pInfo->SetLibName( aName );
 415
 416         // Absolute path...
 417         OUString aStorageName = rSStream.ReadUniOrByteString(rSStream.GetStreamCharSet());
 418         pInfo->SetStorageName( aStorageName );
 419
 420         // Relative path...
 421         OUString aRelStorageName = rSStream.ReadUniOrByteString(rSStream.GetStreamCharSet());
 422         pInfo->SetRelStorageName( aRelStorageName );
 423
 424         if ( nVer >= 2 )
 425         {
 426             bool bReferenz;
 427             rSStream.ReadCharAsBool( bReferenz );
 428             pInfo->SetReference(bReferenz);
 429         }
 430
 431         rSStream.Seek( nEndPos );
 432     }
 433     return pInfo;
 434 }
 435
 436 BasicManager::BasicManager( SotStorage& rStorage, const OUString& rBaseURL, StarBASIC* pParentFromStdLib, OUString const * pLibPath, bool bDocMgr ) : mbDocMgr( bDocMgr )
 437 {
 438     Init();
 439
 440     if( pLibPath )
 441     {
 442         mpImpl->aBasicLibPath = *pLibPath;
 443     }
 444     OUString aStorName( rStorage.GetName() );
 445     maStorageName = INetURLObject(aStorName, INetProtocol::File).GetMainURL( INetURLObject::DecodeMechanism::NONE );
 446
 447
 448     // If there is no Manager Stream, no further actions are necessary
 449     if ( rStorage.IsStream( szManagerStream ) )
 450     {
 451         LoadBasicManager( rStorage, rBaseURL );
 452         // StdLib contains Parent:
 453         StarBASIC* pStdLib = GetStdLib();
 454         DBG_ASSERT( pStdLib, "Standard-Lib not loaded?" );
 455         if ( !pStdLib )
 456         {
 457             // Should never happen, but if it happens we won't crash...
 458             pStdLib = new StarBASIC( nullptr, mbDocMgr );
 459
 460             if (mpImpl->aLibs.empty())
 461                 CreateLibInfo();
 462
 463             BasicLibInfo& rStdLibInfo = *mpImpl->aLibs.front();
 464
 465             rStdLibInfo.SetLib( pStdLib );
 466             StarBASICRef xStdLib = rStdLibInfo.GetLib();
 467             xStdLib->SetName( szStdLibName );
 468             rStdLibInfo.SetLibName( szStdLibName );
 469             xStdLib->SetFlag( SbxFlagBits::DontStore | SbxFlagBits::ExtSearch );
 470             xStdLib->SetModified( false );
 471         }
 472         else
 473         {
 474             pStdLib->SetParent( pParentFromStdLib );
 475             // The other get StdLib as parent:
 476
 477             for ( sal_uInt16 nBasic = 1; nBasic < GetLibCount(); nBasic++ )
 478             {
 479                 StarBASIC* pBasic = GetLib( nBasic );
 480                 if ( pBasic )
 481                 {
 482                     pStdLib->Insert( pBasic );
 483                     pBasic->SetFlag( SbxFlagBits::ExtSearch );
 484                 }
 485             }
 486             // Modified through insert
 487             pStdLib->SetModified( false );
 488         }
 489     }
 490     else
 491     {
 492         ImpCreateStdLib( pParentFromStdLib );
 493         if ( rStorage.IsStream( szOldManagerStream ) )
 494             LoadOldBasicManager( rStorage );
 495     }
 496 }
 497
 498 static void copyToLibraryContainer( StarBASIC* pBasic, const LibraryContainerInfo& rInfo )
 499 {
 500     uno::Reference< script::XLibraryContainer > xScriptCont( rInfo.mxScriptCont.get() );
 501     if ( !xScriptCont.is() )
 502         return;
 503
 504     OUString aLibName = pBasic->GetName();
 505     if( !xScriptCont->hasByName( aLibName ) )
 506         xScriptCont->createLibrary( aLibName );
 507
 508     uno::Any aLibAny = xScriptCont->getByName( aLibName );
 509     uno::Reference< container::XNameContainer > xLib;
 510     aLibAny >>= xLib;
 511     if ( !xLib.is() )
 512         return;
 513
 514     for ( const auto& pModule: pBasic->GetModules() )
 515     {
 516         OUString aModName = pModule->GetName();
 517         if( !xLib->hasByName( aModName ) )
 518         {
 519             OUString aSource = pModule->GetSource32();
 520             uno::Any aSourceAny;
 521             aSourceAny <<= aSource;
 522             xLib->insertByName( aModName, aSourceAny );
 523         }
 524     }
 525 }
 526
 527 const uno::Reference< script::XPersistentLibraryContainer >& BasicManager::GetDialogLibraryContainer()  const
 528 {
 529     return mpImpl->maContainerInfo.mxDialogCont;
 530 }
 531
 532 const uno::Reference< script::XPersistentLibraryContainer >& BasicManager::GetScriptLibraryContainer()  const
 533 {
 534     return mpImpl->maContainerInfo.mxScriptCont;
 535 }
 536
 537 void BasicManager::SetLibraryContainerInfo( const LibraryContainerInfo& rInfo )
 538 {
 539     mpImpl->maContainerInfo = rInfo;
 540
 541     uno::Reference< script::XLibraryContainer > xScriptCont( mpImpl->maContainerInfo.mxScriptCont.get() );
 542     if( xScriptCont.is() )
 543     {
 544         // Register listener for lib container
 545         uno::Reference< container::XContainerListener > xLibContainerListener
 546             = new BasMgrContainerListenerImpl( this, "" );
 547
 548         uno::Reference< container::XContainer> xLibContainer( xScriptCont, uno::UNO_QUERY );
 549         xLibContainer->addContainerListener( xLibContainerListener );
 550
 551         const uno::Sequence< OUString > aScriptLibNames = xScriptCont->getElementNames();
 552
 553         if( aScriptLibNames.hasElements() )
 554         {
 555             for(const auto& rScriptLibName : aScriptLibNames)
 556             {
 557                 uno::Any aLibAny = xScriptCont->getByName( rScriptLibName );
 558
 559                 if ( rScriptLibName == "Standard" || rScriptLibName == "VBAProject")
 560                     xScriptCont->loadLibrary( rScriptLibName );
 561
 562                 BasMgrContainerListenerImpl::insertLibraryImpl
 563                     ( xScriptCont, this, aLibAny, rScriptLibName );
 564             }
 565         }
 566         else
 567         {
 568             // No libs? Maybe an 5.2 document already loaded
 569             for (auto const& rpBasLibInfo : mpImpl->aLibs)
 570             {
 571                 StarBASIC* pLib = rpBasLibInfo->GetLib().get();
 572                 if( !pLib )
 573                 {
 574                     bool bLoaded = ImpLoadLibrary( rpBasLibInfo.get(), nullptr );
 575                     if( bLoaded )
 576                         pLib = rpBasLibInfo->GetLib().get();
 577                 }
 578                 if( pLib )
 579                 {
 580                     copyToLibraryContainer( pLib, mpImpl->maContainerInfo );
 581                     if (rpBasLibInfo->HasPassword())
 582                     {
 583                         OldBasicPassword* pOldBasicPassword =
 584                             mpImpl->maContainerInfo.mpOldBasicPassword;
 585                         if( pOldBasicPassword )
 586                         {
 587                             pOldBasicPassword->setLibraryPassword(
 588                                 pLib->GetName(), rpBasLibInfo->GetPassword() );
 589                         }
 590                     }
 591                 }
 592             }
 593         }
 594     }
 595
 596     SetGlobalUNOConstant( "BasicLibraries", uno::Any( mpImpl->maContainerInfo.mxScriptCont ) );
 597     SetGlobalUNOConstant( "DialogLibraries", uno::Any( mpImpl->maContainerInfo.mxDialogCont ) );
 598 }
 599
 600 BasicManager::BasicManager( StarBASIC* pSLib, OUString const * pLibPath, bool bDocMgr ) : mbDocMgr( bDocMgr )
 601 {
 602     Init();
 603     DBG_ASSERT( pSLib, "BasicManager cannot be created with a NULL-Pointer!" );
 604
 605     if( pLibPath )
 606     {
 607         mpImpl->aBasicLibPath = *pLibPath;
 608     }
 609     BasicLibInfo* pStdLibInfo = CreateLibInfo();
 610     pStdLibInfo->SetLib( pSLib );
 611     StarBASICRef xStdLib = pStdLibInfo->GetLib();
 612     xStdLib->SetName(szStdLibName);
 613     pStdLibInfo->SetLibName(szStdLibName );
 614     pSLib->SetFlag( SbxFlagBits::DontStore | SbxFlagBits::ExtSearch );
 615
 616     // Save is only necessary if basic has changed
 617     xStdLib->SetModified( false );
 618 }
 619
 620 void BasicManager::ImpMgrNotLoaded( const OUString& rStorageName )
 621 {
 622     // pErrInf is only destroyed if the error os processed by an
 623     // ErrorHandler
 624     StringErrorInfo* pErrInf = new StringErrorInfo( ERRCODE_BASMGR_MGROPEN, rStorageName, DialogMask::ButtonsOk );
 625     aErrors.emplace_back(*pErrInf, BasicErrorReason::OPENMGRSTREAM);
 626
 627     // Create a stdlib otherwise we crash!
 628     BasicLibInfo* pStdLibInfo = CreateLibInfo();
 629     pStdLibInfo->SetLib( new StarBASIC( nullptr, mbDocMgr ) );
 630     StarBASICRef xStdLib = pStdLibInfo->GetLib();
 631     xStdLib->SetName( szStdLibName );
 632     pStdLibInfo->SetLibName( szStdLibName );
 633     xStdLib->SetFlag( SbxFlagBits::DontStore | SbxFlagBits::ExtSearch );
 634     xStdLib->SetModified( false );
 635 }
 636
 637
 638 void BasicManager::ImpCreateStdLib( StarBASIC* pParentFromStdLib )
 639 {
 640     BasicLibInfo* pStdLibInfo = CreateLibInfo();
 641     StarBASIC* pStdLib = new StarBASIC( pParentFromStdLib, mbDocMgr );
 642     pStdLibInfo->SetLib( pStdLib );
 643     pStdLib->SetName( szStdLibName );
 644     pStdLibInfo->SetLibName( szStdLibName );
 645     pStdLib->SetFlag( SbxFlagBits::DontStore | SbxFlagBits::ExtSearch );
 646 }
 647
 648 void BasicManager::LoadBasicManager( SotStorage& rStorage, const OUString& rBaseURL )
 649 {
 650     tools::SvRef<SotStorageStream> xManagerStream = rStorage.OpenSotStream( szManagerStream, eStreamReadMode );
 651
 652     OUString aStorName( rStorage.GetName() );
 653     // #i13114 removed, DBG_ASSERT( aStorName.Len(), "No Storage Name!" );
 654
 655     if ( !xManagerStream.is() || xManagerStream->GetError() || ( xManagerStream->TellEnd() == 0 ) )
 656     {
 657         ImpMgrNotLoaded( aStorName );
 658         return;
 659     }
 660
 661     maStorageName = INetURLObject(aStorName, INetProtocol::File).GetMainURL( INetURLObject::DecodeMechanism::NONE );
 662     // #i13114 removed, DBG_ASSERT(aStorageName.Len() != 0, "Bad storage name");
 663
 664     OUString aRealStorageName = maStorageName;  // for relative paths, can be modified through BaseURL
 665
 666     if ( !rBaseURL.isEmpty() )
 667     {
 668         INetURLObject aObj( rBaseURL );
 669         if ( aObj.GetProtocol() == INetProtocol::File )
 670         {
 671             aRealStorageName = aObj.PathToFileName();
 672         }
 673     }
 674
 675     xManagerStream->SetBufferSize( 1024 );
 676     xManagerStream->Seek( STREAM_SEEK_TO_BEGIN );
 677
 678     sal_uInt32 nEndPos;
 679     xManagerStream->ReadUInt32( nEndPos );
 680
 681     sal_uInt16 nLibs;
 682     xManagerStream->ReadUInt16( nLibs );
 683     // Plausibility!
 684     if( nLibs & 0xF000 )
 685     {
 686         SAL_WARN( "basic", "BasicManager-Stream defect!" );
 687         return;
 688     }
 689     const size_t nMinBasicLibSize(8);
 690     const size_t nMaxPossibleLibs = xManagerStream->remainingSize() / nMinBasicLibSize;
 691     if (nLibs > nMaxPossibleLibs)
 692     {
 693         SAL_WARN("basic", "Parsing error: " << nMaxPossibleLibs <<
 694                  " max possible entries, but " << nLibs << " claimed, truncating");
 695         nLibs = nMaxPossibleLibs;
 696     }
 697     for (sal_uInt16 nL = 0; nL < nLibs; ++nL)
 698     {
 699         BasicLibInfo* pInfo = BasicLibInfo::Create( *xManagerStream );
 700
 701         // Correct absolute pathname if relative is existing.
 702         // Always try relative first if there are two stands on disk
 703         if ( !pInfo->GetRelStorageName().isEmpty() && pInfo->GetRelStorageName() != szImbedded )
 704         {
 705             INetURLObject aObj( aRealStorageName, INetProtocol::File );
 706             aObj.removeSegment();
 707             bool bWasAbsolute = false;
 708             aObj = aObj.smartRel2Abs( pInfo->GetRelStorageName(), bWasAbsolute );
 709
 710             //*** TODO: Replace if still necessary
 711             //*** TODO-End
 712             if ( ! mpImpl->aBasicLibPath.isEmpty() )
 713             {
 714                 // Search lib in path
 715                 OUString aSearchFile = pInfo->GetRelStorageName();
 716                 OUString aSearchFileOldFormat(aSearchFile);
 717                 SvtPathOptions aPathCFG;
 718                 if( aPathCFG.SearchFile( aSearchFileOldFormat, SvtPathOptions::PATH_BASIC ) )
 719                 {
 720                     pInfo->SetStorageName( aSearchFile );
 721                 }
 722             }
 723         }
 724
 725         mpImpl->aLibs.push_back(std::unique_ptr<BasicLibInfo>(pInfo));
 726         // Libs from external files should be loaded only when necessary.
 727         // But references are loaded at once, otherwise some big customers get into trouble
 728         if ( pInfo->DoLoad() &&
 729             ( !pInfo->IsExtern() ||  pInfo->IsReference()))
 730         {
 731             ImpLoadLibrary( pInfo, &rStorage );
 732         }
 733     }
 734
 735     xManagerStream->Seek( nEndPos );
 736     xManagerStream->SetBufferSize( 0 );
 737     xManagerStream.clear();
 738 }
 739
 740 void BasicManager::LoadOldBasicManager( SotStorage& rStorage )
 741 {
 742     tools::SvRef<SotStorageStream> xManagerStream = rStorage.OpenSotStream( szOldManagerStream, eStreamReadMode );
 743
 744     OUString aStorName( rStorage.GetName() );
 745     DBG_ASSERT( aStorName.getLength(), "No Storage Name!" );
 746
 747     if ( !xManagerStream.is() || xManagerStream->GetError() || ( xManagerStream->TellEnd() == 0 ) )
 748     {
 749         ImpMgrNotLoaded( aStorName );
 750         return;
 751     }
 752
 753     xManagerStream->SetBufferSize( 1024 );
 754     xManagerStream->Seek( STREAM_SEEK_TO_BEGIN );
 755     sal_uInt32 nBasicStartOff, nBasicEndOff;
 756     xManagerStream->ReadUInt32( nBasicStartOff );
 757     xManagerStream->ReadUInt32( nBasicEndOff );
 758
 759     DBG_ASSERT( !xManagerStream->GetError(), "Invalid Manager-Stream!" );
 760
 761     xManagerStream->Seek( nBasicStartOff );
 762     if (!ImplLoadBasic( *xManagerStream, mpImpl->aLibs.front()->GetLibRef() ))
 763     {
 764         StringErrorInfo* pErrInf = new StringErrorInfo( ERRCODE_BASMGR_MGROPEN, aStorName, DialogMask::ButtonsOk );
 765         aErrors.emplace_back(*pErrInf, BasicErrorReason::OPENMGRSTREAM);
 766         // and it proceeds ...
 767     }
 768     xManagerStream->Seek( nBasicEndOff+1 ); // +1: 0x00 as separator
 769     OUString aLibs = xManagerStream->ReadUniOrByteString(xManagerStream->GetStreamCharSet());
 770     xManagerStream->SetBufferSize( 0 );
 771     xManagerStream.clear(); // Close stream
 772
 773     if ( !aLibs.isEmpty() )
 774     {
 775         INetURLObject aCurStorage( aStorName, INetProtocol::File );
 776         sal_Int32 nLibPos {0};
 777         do {
 778             const OUString aLibInfo(aLibs.getToken(0, LIB_SEP, nLibPos));
 779             sal_Int32 nInfoPos {0};
 780             const OUString aLibName( aLibInfo.getToken( 0, LIBINFO_SEP, nInfoPos ) );
 781             DBG_ASSERT( nInfoPos >= 0, "Invalid Lib-Info!" );
 782             const OUString aLibAbsStorageName( aLibInfo.getToken( 0, LIBINFO_SEP, nInfoPos ) );
 783             // TODO: fail also here if there are no more tokens?
 784             const OUString aLibRelStorageName( aLibInfo.getToken( 0, LIBINFO_SEP, nInfoPos ) );
 785             DBG_ASSERT( nInfoPos < 0, "Invalid Lib-Info!" );
 786             INetURLObject aLibAbsStorage( aLibAbsStorageName, INetProtocol::File );
 787
 788             INetURLObject aLibRelStorage( aStorName );
 789             aLibRelStorage.removeSegment();
 790             bool bWasAbsolute = false;
 791             aLibRelStorage = aLibRelStorage.smartRel2Abs( aLibRelStorageName, bWasAbsolute);
 792             DBG_ASSERT(!bWasAbsolute, "RelStorageName was absolute!" );
 793
 794             tools::SvRef<SotStorage> xStorageRef;
 795             if ( aLibAbsStorage == aCurStorage || aLibRelStorageName == szImbedded )
 796             {
 797                 xStorageRef = &rStorage;
 798             }
 799             else
 800             {
 801                 xStorageRef = new SotStorage( false, aLibAbsStorage.GetMainURL
 802                     ( INetURLObject::DecodeMechanism::NONE ), eStorageReadMode );
 803                 if ( xStorageRef->GetError() != ERRCODE_NONE )
 804                     xStorageRef = new SotStorage( false, aLibRelStorage.
 805                     GetMainURL( INetURLObject::DecodeMechanism::NONE ), eStorageReadMode );
 806             }
 807             if ( xStorageRef.is() )
 808             {
 809                 AddLib( *xStorageRef, aLibName, false );
 810             }
 811             else
 812             {
 813                 StringErrorInfo* pErrInf = new StringErrorInfo( ERRCODE_BASMGR_LIBLOAD, aStorName, DialogMask::ButtonsOk );
 814                 aErrors.emplace_back(*pErrInf, BasicErrorReason::STORAGENOTFOUND);
 815             }
 816         } while (nLibPos>=0);
 817     }
 818 }
 819
 820 BasicManager::~BasicManager()
 821 {
 822     // Notify listener if something needs to be saved
 823     Broadcast( SfxHint( SfxHintId::Dying) );
 824 }
 825
 826 bool BasicManager::HasExeCode( const OUString& sLib )
 827 {
 828     StarBASIC* pLib = GetLib(sLib);
 829     if ( pLib )
 830     {
 831         for (const auto& pModule: pLib->GetModules())
 832         {
 833             if (pModule->HasExeCode())
 834                 return true;
 835         }
 836     }
 837     return false;
 838 }
 839
 840 void BasicManager::Init()
 841 {
 842     mpImpl.reset( new BasicManagerImpl );
 843 }
 844
 845 BasicLibInfo* BasicManager::CreateLibInfo()
 846 {
 847     BasicLibInfo* pInf(new BasicLibInfo);
 848     mpImpl->aLibs.push_back(std::unique_ptr<BasicLibInfo>(pInf));
 849     return pInf;
 850 }
 851
 852 bool BasicManager::ImpLoadLibrary( BasicLibInfo* pLibInfo, SotStorage* pCurStorage )
 853 {
 854     try {
 855     DBG_ASSERT( pLibInfo, "LibInfo!?" );
 856
 857     OUString aStorageName( pLibInfo->GetStorageName() );
 858     if ( aStorageName.isEmpty() || aStorageName == szImbedded )
 859     {
 860         aStorageName = GetStorageName();
 861     }
 862     tools::SvRef<SotStorage> xStorage;
 863     // The current must not be opened again...
 864     if ( pCurStorage )
 865     {
 866         OUString aStorName( pCurStorage->GetName() );
 867         // #i13114 removed, DBG_ASSERT( aStorName.Len(), "No Storage Name!" );
 868
 869         INetURLObject aCurStorageEntry(aStorName, INetProtocol::File);
 870         // #i13114 removed, DBG_ASSERT(aCurStorageEntry.GetMainURL( INetURLObject::DecodeMechanism::NONE ).Len() != 0, "Bad storage name");
 871
 872         INetURLObject aStorageEntry(aStorageName, INetProtocol::File);
 873         // #i13114 removed, DBG_ASSERT(aCurStorageEntry.GetMainURL( INetURLObject::DecodeMechanism::NONE ).Len() != 0, "Bad storage name");
 874
 875         if ( aCurStorageEntry == aStorageEntry )
 876         {
 877             xStorage = pCurStorage;
 878         }
 879     }
 880
 881     if ( !xStorage.is() )
 882     {
 883         xStorage = new SotStorage( false, aStorageName, eStorageReadMode );
 884     }
 885     tools::SvRef<SotStorage> xBasicStorage = xStorage->OpenSotStorage( szBasicStorage, eStorageReadMode, false );
 886
 887     if ( !xBasicStorage.is() || xBasicStorage->GetError() )
 888     {
 889         StringErrorInfo* pErrInf = new StringErrorInfo( ERRCODE_BASMGR_MGROPEN, xStorage->GetName(), DialogMask::ButtonsOk );
 890         aErrors.emplace_back(*pErrInf, BasicErrorReason::OPENLIBSTORAGE);
 891     }
 892     else
 893     {
 894         // In the Basic-Storage every lib is in a Stream...
 895         tools::SvRef<SotStorageStream> xBasicStream = xBasicStorage->OpenSotStream( pLibInfo->GetLibName(), eStreamReadMode );
 896         if ( !xBasicStream.is() || xBasicStream->GetError() )
 897         {
 898             StringErrorInfo* pErrInf = new StringErrorInfo( ERRCODE_BASMGR_LIBLOAD , pLibInfo->GetLibName(), DialogMask::ButtonsOk );
 899             aErrors.emplace_back(*pErrInf, BasicErrorReason::OPENLIBSTREAM);
 900         }
 901         else
 902         {
 903             bool bLoaded = false;
 904             if ( xBasicStream->TellEnd() != 0 )
 905             {
 906                 if ( !pLibInfo->GetLib().is() )
 907                 {
 908                     pLibInfo->SetLib( new StarBASIC( GetStdLib(), mbDocMgr ) );
 909                 }
 910                 xBasicStream->SetBufferSize( 1024 );
 911                 xBasicStream->Seek( STREAM_SEEK_TO_BEGIN );
 912                 bLoaded = ImplLoadBasic( *xBasicStream, pLibInfo->GetLibRef() );
 913                 xBasicStream->SetBufferSize( 0 );
 914                 StarBASICRef xStdLib = pLibInfo->GetLib();
 915                 xStdLib->SetName( pLibInfo->GetLibName() );
 916                 xStdLib->SetModified( false );
 917                 xStdLib->SetFlag( SbxFlagBits::DontStore );
 918             }
 919             if ( !bLoaded )
 920             {
 921                 StringErrorInfo* pErrInf = new StringErrorInfo( ERRCODE_BASMGR_LIBLOAD, pLibInfo->GetLibName(), DialogMask::ButtonsOk );
 922                 aErrors.emplace_back(*pErrInf, BasicErrorReason::BASICLOADERROR);
 923             }
 924             else
 925             {
 926                 // Perhaps there are additional information in the stream...
 927                 xBasicStream->SetCryptMaskKey(szCryptingKey);
 928                 xBasicStream->RefreshBuffer();
 929                 sal_uInt32 nPasswordMarker = 0;
 930                 xBasicStream->ReadUInt32( nPasswordMarker );
 931                 if ( ( nPasswordMarker == PASSWORD_MARKER ) && !xBasicStream->eof() )
 932                 {
 933                     OUString aPassword = xBasicStream->ReadUniOrByteString(
 934                         xBasicStream->GetStreamCharSet());
 935                     pLibInfo->SetPassword( aPassword );
 936                 }
 937                 xBasicStream->SetCryptMaskKey(OString());
 938                 CheckModules( pLibInfo->GetLib().get(), pLibInfo->IsReference() );
 939             }
 940             return bLoaded;
 941         }
 942     }
 943     }
 944     catch (const css::ucb::ContentCreationException&)
 945     {
 946     }
 947     return false;
 948 }
 949
 950 bool BasicManager::ImplEncryptStream( SvStream& rStrm )
 951 {
 952     sal_uInt64 const nPos = rStrm.Tell();
 953     sal_uInt32 nCreator;
 954     rStrm.ReadUInt32( nCreator );
 955     rStrm.Seek( nPos );
 956     bool bProtected = false;
 957     if ( nCreator != SBXCR_SBX )
 958     {
 959         // Should only be the case for encrypted Streams
 960         bProtected = true;
 961         rStrm.SetCryptMaskKey(szCryptingKey);
 962         rStrm.RefreshBuffer();
 963     }
 964     return bProtected;
 965 }
 966
 967 // This code is necessary to load the BASIC of Beta 1
 968 // TODO: Which Beta 1?
 969 bool BasicManager::ImplLoadBasic( SvStream& rStrm, StarBASICRef& rOldBasic ) const
 970 {
 971     bool bProtected = ImplEncryptStream( rStrm );
 972     SbxBaseRef xNew = SbxBase::Load( rStrm );
 973     bool bLoaded = false;
 974     if( xNew.is() )
 975     {
 976         if( auto pNew = dynamic_cast<StarBASIC*>( xNew.get() ) )
 977         {
 978             // Use the Parent of the old BASICs
 979             if( rOldBasic.is() )
 980             {
 981                 pNew->SetParent( rOldBasic->GetParent() );
 982                 if( pNew->GetParent() )
 983                 {
 984                     pNew->GetParent()->Insert( pNew );
 985                 }
 986                 pNew->SetFlag( SbxFlagBits::ExtSearch );
 987             }
 988             rOldBasic = pNew;
 989
 990             // Fill new library container (5.2 -> 6.0)
 991             copyToLibraryContainer( pNew, mpImpl->maContainerInfo );
 992
 993             pNew->SetModified( false );
 994             bLoaded = true;
 995         }
 996     }
 997     if ( bProtected )
 998     {
 999         rStrm.SetCryptMaskKey(OString());
1000     }
1001     return bLoaded;
1002 }
1003
1004 void BasicManager::CheckModules( StarBASIC* pLib, bool bReference )
1005 {
1006     if ( !pLib )
1007     {
1008         return;
1009     }
1010     bool bModified = pLib->IsModified();
1011
1012     for ( const auto& pModule: pLib->GetModules() )
1013     {
1014         DBG_ASSERT(pModule, "Module not received!");
1015         if ( !pModule->IsCompiled() && !StarBASIC::GetErrorCode() )
1016         {
1017             pModule->Compile();
1018         }
1019     }
1020
1021     // #67477, AB 8.12.99 On demand compile in referenced libs should not
1022     // cause modified
1023     if( !bModified && bReference )
1024     {
1025         OSL_FAIL( "Referenced basic library is not compiled!" );
1026         pLib->SetModified( false );
1027     }
1028 }
1029
1030 StarBASIC* BasicManager::AddLib( SotStorage& rStorage, const OUString& rLibName, bool bReference )
1031 {
1032     OUString aStorName( rStorage.GetName() );
1033     DBG_ASSERT( !aStorName.isEmpty(), "No Storage Name!" );
1034
1035     OUString aStorageName = INetURLObject(aStorName, INetProtocol::File).GetMainURL( INetURLObject::DecodeMechanism::NONE );
1036     DBG_ASSERT(!aStorageName.isEmpty(), "Bad storage name");
1037
1038     OUString aNewLibName( rLibName );
1039     while ( HasLib( aNewLibName ) )
1040     {
1041         aNewLibName += "_";
1042     }
1043     BasicLibInfo* pLibInfo = CreateLibInfo();
1044     // Use original name otherwise ImpLoadLibrary fails...
1045     pLibInfo->SetLibName( rLibName );
1046     // but doesn't work this way if name exists twice
1047     sal_uInt16 nLibId = static_cast<sal_uInt16>(mpImpl->aLibs.size()) - 1;
1048
1049     // Set StorageName before load because it is compared with pCurStorage
1050     pLibInfo->SetStorageName( aStorageName );
1051     bool bLoaded = ImpLoadLibrary( pLibInfo, &rStorage );
1052
1053     if ( bLoaded )
1054     {
1055         if ( aNewLibName != rLibName )
1056         {
1057             pLibInfo->SetLibName(aNewLibName);
1058         }
1059         if ( bReference )
1060         {
1061             pLibInfo->GetLib()->SetModified( false );   // Don't save in this case
1062             pLibInfo->SetRelStorageName( OUString() );
1063             pLibInfo->SetReference(true);
1064         }
1065         else
1066         {
1067             pLibInfo->GetLib()->SetModified( true ); // Must be saved after Add!
1068             pLibInfo->SetStorageName( szImbedded ); // Save in BasicManager-Storage
1069         }
1070     }
1071     else
1072     {
1073         RemoveLib( nLibId, false );
1074         pLibInfo = nullptr;
1075     }
1076
1077     return pLibInfo ? &*pLibInfo->GetLib() : nullptr;
1078
1079 }
1080
1081 bool BasicManager::IsReference( sal_uInt16 nLib )
1082 {
1083     DBG_ASSERT( nLib < mpImpl->aLibs.size(), "Lib does not exist!" );
1084     if ( nLib < mpImpl->aLibs.size() )
1085     {
1086         return mpImpl->aLibs[nLib]->IsReference();
1087     }
1088     return false;
1089 }
1090
1091 void BasicManager::RemoveLib( sal_uInt16 nLib )
1092 {
1093     // Only physical deletion if no reference
1094     RemoveLib( nLib, !IsReference( nLib ) );
1095 }
1096
1097 bool BasicManager::RemoveLib( sal_uInt16 nLib, bool bDelBasicFromStorage )
1098 {
1099     DBG_ASSERT( nLib, "Standard-Lib cannot be removed!" );
1100
1101     DBG_ASSERT( !nLib || nLib  < mpImpl->aLibs.size(), "Lib not found!" );
1102
1103     if( !nLib || nLib  < mpImpl->aLibs.size() )
1104     {
1105         StringErrorInfo* pErrInf = new StringErrorInfo( ERRCODE_BASMGR_REMOVELIB, OUString(), DialogMask::ButtonsOk );
1106         aErrors.emplace_back(*pErrInf, BasicErrorReason::STDLIB);
1107         return false;
1108     }
1109
1110     auto const itLibInfo = mpImpl->aLibs.begin() + nLib;
1111
1112     // If one of the streams cannot be opened, this is not an error,
1113     // because BASIC was never written before...
1114     if (bDelBasicFromStorage && !(*itLibInfo)->IsReference() &&
1115            (!(*itLibInfo)->IsExtern() || SotStorage::IsStorageFile((*itLibInfo)->GetStorageName())))
1116     {
1117         tools::SvRef<SotStorage> xStorage;
1118         try
1119         {
1120             if (!(*itLibInfo)->IsExtern())
1121             {
1122                 xStorage = new SotStorage(false, GetStorageName());
1123             }
1124             else
1125             {
1126                 xStorage = new SotStorage(false, (*itLibInfo)->GetStorageName());
1127             }
1128         }
1129         catch (const css::ucb::ContentCreationException&)
1130         {
1131             TOOLS_WARN_EXCEPTION("basic", "BasicManager::RemoveLib:");
1132         }
1133
1134         if (xStorage.is() && xStorage->IsStorage(szBasicStorage))
1135         {
1136             tools::SvRef<SotStorage> xBasicStorage = xStorage->OpenSotStorage
1137                             ( szBasicStorage, StreamMode::STD_READWRITE, false );
1138
1139             if ( !xBasicStorage.is() || xBasicStorage->GetError() )
1140             {
1141                 StringErrorInfo* pErrInf = new StringErrorInfo( ERRCODE_BASMGR_REMOVELIB, OUString(), DialogMask::ButtonsOk );
1142                 aErrors.emplace_back(*pErrInf, BasicErrorReason::OPENLIBSTORAGE);
1143             }
1144             else if (xBasicStorage->IsStream((*itLibInfo)->GetLibName()))
1145             {
1146                 xBasicStorage->Remove((*itLibInfo)->GetLibName());
1147                 xBasicStorage->Commit();
1148
1149                 // If no further stream available,
1150                 // delete the SubStorage.
1151                 SvStorageInfoList aInfoList;
1152                 xBasicStorage->FillInfoList( &aInfoList );
1153                 if ( aInfoList.empty() )
1154                 {
1155                     xBasicStorage.clear();
1156                     xStorage->Remove( szBasicStorage );
1157                     xStorage->Commit();
1158                     // If no further Streams or SubStorages available,
1159                     // delete the Storage, too.
1160                     aInfoList.clear();
1161                     xStorage->FillInfoList( &aInfoList );
1162                     if ( aInfoList.empty() )
1163                     {
1164                         //OUString aName_( xStorage->GetName() );
1165                         xStorage.clear();
1166                         //*** TODO: Replace if still necessary
1167                         //SfxContentHelper::Kill( aName );
1168                         //*** TODO-End
1169                     }
1170                 }
1171             }
1172         }
1173     }
1174     if ((*itLibInfo)->GetLib().is())
1175     {
1176         GetStdLib()->Remove( (*itLibInfo)->GetLib().get() );
1177     }
1178     mpImpl->aLibs.erase(itLibInfo);
1179     return true;    // Remove was successful, del unimportant
1180 }
1181
1182 sal_uInt16 BasicManager::GetLibCount() const
1183 {
1184     return static_cast<sal_uInt16>(mpImpl->aLibs.size());
1185 }
1186
1187 StarBASIC* BasicManager::GetLib( sal_uInt16 nLib ) const
1188 {
1189     DBG_ASSERT( nLib < mpImpl->aLibs.size(), "Lib does not exist!" );
1190     if ( nLib < mpImpl->aLibs.size() )
1191     {
1192         return mpImpl->aLibs[nLib]->GetLib().get();
1193     }
1194     return nullptr;
1195 }
1196
1197 StarBASIC* BasicManager::GetStdLib() const
1198 {
1199     StarBASIC* pLib = GetLib( 0 );
1200     return pLib;
1201 }
1202
1203 StarBASIC* BasicManager::GetLib( const OUString& rName ) const
1204 {
1205     for (auto const& rpLib : mpImpl->aLibs)
1206     {
1207         if (rpLib->GetLibName().equalsIgnoreAsciiCase(rName)) // Check if available...
1208         {
1209             return rpLib->GetLib().get();
1210         }
1211     }
1212     return nullptr;
1213 }
1214
1215 sal_uInt16 BasicManager::GetLibId( const OUString& rName ) const
1216 {
1217     for (size_t i = 0; i < mpImpl->aLibs.size(); i++)
1218     {
1219         if (mpImpl->aLibs[i]->GetLibName().equalsIgnoreAsciiCase( rName ))
1220         {
1221             return static_cast<sal_uInt16>(i);
1222         }
1223     }
1224     return LIB_NOTFOUND;
1225 }
1226
1227 bool BasicManager::HasLib( const OUString& rName ) const
1228 {
1229     for (const auto& rpLib : mpImpl->aLibs)
1230     {
1231         if (rpLib->GetLibName().equalsIgnoreAsciiCase(rName)) // Check if available...
1232         {
1233             return true;
1234         }
1235     }
1236     return false;
1237 }
1238
1239 OUString BasicManager::GetLibName( sal_uInt16 nLib )
1240 {
1241     DBG_ASSERT(  nLib < mpImpl->aLibs.size(), "Lib?!" );
1242     if ( nLib < mpImpl->aLibs.size() )
1243     {
1244         return mpImpl->aLibs[nLib]->GetLibName();
1245     }
1246     return OUString();
1247 }
1248
1249 bool BasicManager::LoadLib( sal_uInt16 nLib )
1250 {
1251     bool bDone = false;
1252     DBG_ASSERT( nLib < mpImpl->aLibs.size() , "Lib?!" );
1253     if ( nLib < mpImpl->aLibs.size() )
1254     {
1255         BasicLibInfo& rLibInfo = *mpImpl->aLibs[nLib];
1256         uno::Reference< script::XLibraryContainer > xLibContainer = rLibInfo.GetLibraryContainer();
1257         if( xLibContainer.is() )
1258         {
1259             OUString aLibName = rLibInfo.GetLibName();
1260             xLibContainer->loadLibrary( aLibName );
1261             bDone = xLibContainer->isLibraryLoaded( aLibName );
1262         }
1263         else
1264         {
1265             bDone = ImpLoadLibrary( &rLibInfo, nullptr );
1266             StarBASIC* pLib = GetLib( nLib );
1267             if ( pLib )
1268             {
1269                 GetStdLib()->Insert( pLib );
1270                 pLib->SetFlag( SbxFlagBits::ExtSearch );
1271             }
1272         }
1273     }
1274     else
1275     {
1276         StringErrorInfo* pErrInf = new StringErrorInfo( ERRCODE_BASMGR_LIBLOAD, OUString(), DialogMask::ButtonsOk );
1277         aErrors.emplace_back(*pErrInf, BasicErrorReason::LIBNOTFOUND);
1278     }
1279     return bDone;
1280 }
1281
1282 StarBASIC* BasicManager::CreateLib( const OUString& rLibName )
1283 {
1284     if ( GetLib( rLibName ) )
1285     {
1286         return nullptr;
1287     }
1288     BasicLibInfo* pLibInfo = CreateLibInfo();
1289     StarBASIC* pNew = new StarBASIC( GetStdLib(), mbDocMgr );
1290     GetStdLib()->Insert( pNew );
1291     pNew->SetFlag( SbxFlagBits::ExtSearch | SbxFlagBits::DontStore );
1292     pLibInfo->SetLib( pNew );
1293     pLibInfo->SetLibName( rLibName );
1294     pLibInfo->GetLib()->SetName( rLibName );
1295     return pLibInfo->GetLib().get();
1296 }
1297
1298 // For XML import/export:
1299 StarBASIC* BasicManager::CreateLib( const OUString& rLibName, const OUString& Password,
1300                                     const OUString& LinkTargetURL )
1301 {
1302     // Ask if lib exists because standard lib is always there
1303     StarBASIC* pLib = GetLib( rLibName );
1304     if( !pLib )
1305     {
1306         if( !LinkTargetURL.isEmpty())
1307         {
1308             try
1309             {
1310                 tools::SvRef<SotStorage> xStorage = new SotStorage(false, LinkTargetURL, StreamMode::READ | StreamMode::SHARE_DENYWRITE);
1311                 if (!xStorage->GetError())
1312                 {
1313                     pLib = AddLib(*xStorage, rLibName, true);
1314                 }
1315             }
1316             catch (const css::ucb::ContentCreationException&)
1317             {
1318                 TOOLS_WARN_EXCEPTION("basic", "BasicManager::RemoveLib:");
1319             }
1320             DBG_ASSERT( pLib, "XML Import: Linked basic library could not be loaded");
1321         }
1322         else
1323         {
1324             pLib = CreateLib( rLibName );
1325             if( Password.isEmpty())
1326             {
1327                 BasicLibInfo* pLibInfo = FindLibInfo( pLib );
1328                 pLibInfo ->SetPassword( Password );
1329             }
1330         }
1331         //ExternalSourceURL ?
1332     }
1333     return pLib;
1334 }
1335
1336 StarBASIC* BasicManager::CreateLibForLibContainer( const OUString& rLibName,
1337     const uno::Reference< script::XLibraryContainer >& xScriptCont )
1338 {
1339     if ( GetLib( rLibName ) )
1340     {
1341         return nullptr;
1342     }
1343     BasicLibInfo* pLibInfo = CreateLibInfo();
1344     StarBASIC* pNew = new StarBASIC( GetStdLib(), mbDocMgr );
1345     GetStdLib()->Insert( pNew );
1346     pNew->SetFlag( SbxFlagBits::ExtSearch | SbxFlagBits::DontStore );
1347     pLibInfo->SetLib( pNew );
1348     pLibInfo->SetLibName( rLibName );
1349     pLibInfo->GetLib()->SetName( rLibName );
1350     pLibInfo->SetLibraryContainer( xScriptCont );
1351     return pNew;
1352 }
1353
1354
1355 BasicLibInfo* BasicManager::FindLibInfo( StarBASIC const * pBasic )
1356 {
1357     for (auto const& rpLib : mpImpl->aLibs)
1358     {
1359         if (rpLib->GetLib().get() == pBasic)
1360         {
1361             return rpLib.get();
1362         }
1363     }
1364     return nullptr;
1365 }
1366
1367
1368 bool BasicManager::IsBasicModified() const
1369 {
1370     for (auto const& rpLib : mpImpl->aLibs)
1371     {
1372         if (rpLib->GetLib().is() && rpLib->GetLib()->IsModified())
1373         {
1374             return true;
1375         }
1376     }
1377     return false;
1378 }
1379
1380
1381 bool BasicManager::GetGlobalUNOConstant( const OUString& rName, uno::Any& aOut )
1382 {
1383     bool bRes = false;
1384     StarBASIC* pStandardLib = GetStdLib();
1385     OSL_PRECOND( pStandardLib, "BasicManager::GetGlobalUNOConstant: no lib to read from!" );
1386     if ( pStandardLib )
1387         bRes = pStandardLib->GetUNOConstant( rName, aOut );
1388     return bRes;
1389 }
1390
1391 uno::Any BasicManager::SetGlobalUNOConstant( const OUString& rName, const uno::Any& _rValue )
1392 {
1393     uno::Any aOldValue;
1394
1395     StarBASIC* pStandardLib = GetStdLib();
1396     OSL_PRECOND( pStandardLib, "BasicManager::SetGlobalUNOConstant: no lib to insert into!" );
1397     if ( !pStandardLib )
1398         return aOldValue;
1399
1400     // obtain the old value
1401     SbxVariable* pVariable = pStandardLib->Find( rName, SbxClassType::Object );
1402     if ( pVariable )
1403         aOldValue = sbxToUnoValue( pVariable );
1404     SbxObjectRef xUnoObj = GetSbUnoObject( _rValue.getValueType ().getTypeName () , _rValue );
1405     xUnoObj->SetName(rName);
1406     xUnoObj->SetFlag( SbxFlagBits::DontStore );
1407     pStandardLib->Insert( xUnoObj.get() );
1408
1409     return aOldValue;
1410 }
1411
1412 bool BasicManager::LegacyPsswdBinaryLimitExceeded( std::vector< OUString >& _out_rModuleNames )
1413 {
1414     try
1415     {
1416         uno::Reference< container::XNameAccess > xScripts( GetScriptLibraryContainer(), uno::UNO_QUERY_THROW );
1417         uno::Reference< script::XLibraryContainerPassword > xPassword( GetScriptLibraryContainer(), uno::UNO_QUERY_THROW );
1418
1419         const uno::Sequence< OUString > aNames( xScripts->getElementNames() );
1420         for ( auto const & scriptElementName : aNames )
1421         {
1422             if( !xPassword->isLibraryPasswordProtected( scriptElementName ) )
1423                 continue;
1424
1425             StarBASIC* pBasicLib = GetLib( scriptElementName );
1426             if ( !pBasicLib )
1427                 continue;
1428
1429             uno::Reference< container::XNameAccess > xScriptLibrary( xScripts->getByName( scriptElementName ), uno::UNO_QUERY_THROW );
1430             const uno::Sequence< OUString > aElementNames( xScriptLibrary->getElementNames() );
1431             sal_Int32 nLen = aElementNames.getLength();
1432
1433             std::vector< OUString > aBigModules( nLen );
1434             sal_Int32 nBigModules = 0;
1435
1436             for ( auto const & libraryElementName : aElementNames )
1437             {
1438                 SbModule* pMod = pBasicLib->FindModule( libraryElementName );
1439                 if ( pMod && pMod->ExceedsLegacyModuleSize() )
1440                     aBigModules[ nBigModules++ ] = libraryElementName;
1441             }
1442
1443             if ( nBigModules )
1444             {
1445                 _out_rModuleNames.swap(aBigModules);
1446                 return true;
1447             }
1448         }
1449     }
1450     catch( const uno::Exception& )
1451     {
1452         DBG_UNHANDLED_EXCEPTION("basic");
1453     }
1454     return false;
1455 }
1456
1457
1458 namespace
1459 {
1460     SbMethod* lcl_queryMacro( BasicManager* i_manager, OUString const& i_fullyQualifiedName )
1461     {
1462         sal_Int32 nLast = 0;
1463         const OUString sLibName {i_fullyQualifiedName.getToken( 0, '.', nLast )};
1464         const OUString sModule {i_fullyQualifiedName.getToken( 0, '.', nLast )};
1465         OUString sMacro;
1466         if(nLast >= 0)
1467         {
1468             sMacro = i_fullyQualifiedName.copy(nLast);
1469         }
1470         else
1471         {
1472             sMacro = i_fullyQualifiedName;
1473         }
1474
1475         utl::TransliterationWrapper& rTransliteration = SbGlobal::GetTransliteration();
1476         sal_uInt16 nLibCount = i_manager->GetLibCount();
1477         for ( sal_uInt16 nLib = 0; nLib < nLibCount; ++nLib )
1478         {
1479             if ( rTransliteration.isEqual( i_manager->GetLibName( nLib ), sLibName ) )
1480             {
1481                 StarBASIC* pLib = i_manager->GetLib( nLib );
1482                 if( !pLib )
1483                 {
1484                     bool const bLoaded = i_manager->LoadLib( nLib );
1485                     if (bLoaded)
1486                     {
1487                         pLib = i_manager->GetLib( nLib );
1488                     }
1489                 }
1490
1491                 if( pLib )
1492                 {
1493                     for ( const auto& pMod: pLib->GetModules() )
1494                     {
1495                         if ( rTransliteration.isEqual( pMod->GetName(), sModule ) )
1496                         {
1497                             SbMethod* pMethod = static_cast<SbMethod*>(pMod->Find( sMacro, SbxClassType::Method ));
1498                             if( pMethod )
1499                             {
1500                                 return pMethod;
1501                             }
1502                         }
1503                     }
1504                 }
1505             }
1506         }
1507         return nullptr;
1508     }
1509 }
1510
1511 bool BasicManager::HasMacro( OUString const& i_fullyQualifiedName ) const
1512 {
1513     return ( lcl_queryMacro( const_cast< BasicManager* >( this ), i_fullyQualifiedName ) != nullptr );
1514 }
1515
1516 ErrCode BasicManager::ExecuteMacro( OUString const& i_fullyQualifiedName, SbxArray* i_arguments, SbxValue* i_retValue )
1517 {
1518     SbMethod* pMethod = lcl_queryMacro( this, i_fullyQualifiedName );
1519     ErrCode nError = ERRCODE_NONE;
1520     if ( pMethod )
1521     {
1522         if ( i_arguments )
1523             pMethod->SetParameters( i_arguments );
1524         nError = pMethod->Call( i_retValue );
1525     }
1526     else
1527         nError = ERRCODE_BASIC_PROC_UNDEFINED;
1528     return nError;
1529 }
1530
1531 ErrCode BasicManager::ExecuteMacro( OUString const& i_fullyQualifiedName, OUString const& i_commaSeparatedArgs, SbxValue* i_retValue )
1532 {
1533     SbMethod* pMethod = lcl_queryMacro( this, i_fullyQualifiedName );
1534     if ( !pMethod )
1535     {
1536         return ERRCODE_BASIC_PROC_UNDEFINED;
1537     }
1538     // arguments must be quoted
1539     OUString sQuotedArgs;
1540     OUStringBuffer sArgs( i_commaSeparatedArgs );
1541     if ( sArgs.getLength()<2 || sArgs[1] == '\"')
1542     {
1543         // no args or already quoted args
1544         sQuotedArgs = sArgs.makeStringAndClear();
1545     }
1546     else
1547     {
1548         // quote parameters
1549         sArgs.remove( 0, 1 );
1550         sArgs.remove( sArgs.getLength() - 1, 1 );
1551
1552         OUStringBuffer aBuff;
1553         OUString sArgs2 = sArgs.makeStringAndClear();
1554
1555         aBuff.append("(");
1556         if (!sArgs2.isEmpty())
1557         {
1558
1559             sal_Int32 nPos {0};
1560             for (;;)
1561             {
1562                 aBuff.append( "\"" );
1563                 aBuff.append( sArgs2.getToken(0, ',', nPos) );
1564                 aBuff.append( "\"" );
1565                 if (nPos<0)
1566                     break;
1567                 aBuff.append( "," );
1568             }
1569         }
1570         aBuff.append( ")" );
1571
1572         sQuotedArgs = aBuff.makeStringAndClear();
1573     }
1574
1575     // add quoted arguments and do the call
1576     OUString sCall = "["
1577                    + pMethod->GetName()
1578                    + sQuotedArgs
1579                    + "]";
1580
1581     SbxVariable* pRet = pMethod->GetParent()->Execute( sCall );
1582     if ( pRet && ( pRet != pMethod ) )
1583     {
1584         *i_retValue = *pRet;
1585     }
1586     return SbxBase::GetError();
1587 }
1588
1589
1590 class ModuleInfo_Impl : public ModuleInfoHelper
1591 {
1592     OUString maName;
1593     OUString maLanguage;
1594     OUString maSource;
1595
1596 public:
1597     ModuleInfo_Impl( const OUString& aName, const OUString& aLanguage, const OUString& aSource )
1598         : maName( aName ), maLanguage( aLanguage), maSource( aSource ) {}
1599
1600     // Methods XStarBasicModuleInfo
1601     virtual OUString SAL_CALL getName() override
1602         { return maName; }
1603     virtual OUString SAL_CALL getLanguage() override
1604         { return maLanguage; }
1605     virtual OUString SAL_CALL getSource() override
1606         { return maSource; }
1607 };
1608
1609
1610 class DialogInfo_Impl : public WeakImplHelper< script::XStarBasicDialogInfo >
1611 {
1612     OUString maName;
1613     uno::Sequence< sal_Int8 > mData;
1614
1615 public:
1616     DialogInfo_Impl( const OUString& aName, const uno::Sequence< sal_Int8 >& Data )
1617         : maName( aName ), mData( Data ) {}
1618
1619     // Methods XStarBasicDialogInfo
1620     virtual OUString SAL_CALL getName() override
1621         { return maName; }
1622     virtual uno::Sequence< sal_Int8 > SAL_CALL getData() override
1623         { return mData; }
1624 };
1625
1626
1627 class LibraryInfo_Impl : public WeakImplHelper< script::XStarBasicLibraryInfo >
1628 {
1629     OUString maName;
1630     uno::Reference< container::XNameContainer > mxModuleContainer;
1631     uno::Reference< container::XNameContainer > mxDialogContainer;
1632     OUString maPassword;
1633     OUString maExternaleSourceURL;
1634     OUString maLinkTargetURL;
1635
1636 public:
1637     LibraryInfo_Impl
1638     (
1639         const OUString& aName,
1640         uno::Reference< container::XNameContainer > const & xModuleContainer,
1641         uno::Reference< container::XNameContainer > const & xDialogContainer,
1642         const OUString& aPassword,
1643         const OUString& aExternaleSourceURL,
1644         const OUString& aLinkTargetURL
1645     )
1646         : maName( aName )
1647         , mxModuleContainer( xModuleContainer )
1648         , mxDialogContainer( xDialogContainer )
1649         , maPassword( aPassword )
1650         , maExternaleSourceURL( aExternaleSourceURL )
1651         , maLinkTargetURL( aLinkTargetURL )
1652     {}
1653
1654     // Methods XStarBasicLibraryInfo
1655     virtual OUString SAL_CALL getName() override
1656         { return maName; }
1657     virtual uno::Reference< container::XNameContainer > SAL_CALL getModuleContainer() override
1658         { return mxModuleContainer; }
1659     virtual uno::Reference< container::XNameContainer > SAL_CALL getDialogContainer() override
1660         { return mxDialogContainer; }
1661     virtual OUString SAL_CALL getPassword() override
1662         { return maPassword; }
1663     virtual OUString SAL_CALL getExternalSourceURL() override
1664         { return maExternaleSourceURL; }
1665     virtual OUString SAL_CALL getLinkTargetURL() override
1666         { return maLinkTargetURL; }
1667 };
1668
1669
1670 class ModuleContainer_Impl : public NameContainerHelper
1671 {
1672     StarBASIC* mpLib;
1673
1674 public:
1675     explicit ModuleContainer_Impl( StarBASIC* pLib )
1676         :mpLib( pLib ) {}
1677
1678     // Methods XElementAccess
1679     virtual uno::Type SAL_CALL getElementType() override;
1680     virtual sal_Bool SAL_CALL hasElements() override;
1681
1682     // Methods XNameAccess
1683     virtual uno::Any SAL_CALL getByName( const OUString& aName ) override;
1684     virtual uno::Sequence< OUString > SAL_CALL getElementNames() override;
1685     virtual sal_Bool SAL_CALL hasByName( const OUString& aName ) override;
1686
1687     // Methods XNameReplace
1688     virtual void SAL_CALL replaceByName( const OUString& aName, const uno::Any& aElement ) override;
1689
1690     // Methods XNameContainer
1691     virtual void SAL_CALL insertByName( const OUString& aName, const uno::Any& aElement ) override;
1692     virtual void SAL_CALL removeByName( const OUString& Name ) override;
1693 };
1694
1695 // Methods XElementAccess
1696 uno::Type ModuleContainer_Impl::getElementType()
1697 {
1698     uno::Type aModuleType = cppu::UnoType<script::XStarBasicModuleInfo>::get();
1699     return aModuleType;
1700 }
1701
1702 sal_Bool ModuleContainer_Impl::hasElements()
1703 {
1704     return mpLib && !mpLib->GetModules().empty();
1705 }
1706
1707 // Methods XNameAccess
1708 uno::Any ModuleContainer_Impl::getByName( const OUString& aName )
1709 {
1710     SbModule* pMod = mpLib ? mpLib->FindModule( aName ) : nullptr;
1711     if( !pMod )
1712         throw container::NoSuchElementException();
1713     uno::Reference< script::XStarBasicModuleInfo > xMod = new ModuleInfo_Impl( aName, "StarBasic", pMod->GetSource32() );
1714     uno::Any aRetAny;
1715     aRetAny <<= xMod;
1716     return aRetAny;
1717 }
1718
1719 uno::Sequence< OUString > ModuleContainer_Impl::getElementNames()
1720 {
1721     sal_uInt16 nMods = mpLib ? mpLib->GetModules().size() : 0;
1722     uno::Sequence< OUString > aRetSeq( nMods );
1723     OUString* pRetSeq = aRetSeq.getArray();
1724     for( sal_uInt16 i = 0 ; i < nMods ; i++ )
1725     {
1726         pRetSeq[i] = mpLib->GetModules()[i]->GetName();
1727     }
1728     return aRetSeq;
1729 }
1730
1731 sal_Bool ModuleContainer_Impl::hasByName( const OUString& aName )
1732 {
1733     SbModule* pMod = mpLib ? mpLib->FindModule( aName ) : nullptr;
1734     bool bRet = (pMod != nullptr);
1735     return bRet;
1736 }
1737
1738
1739 // Methods XNameReplace
1740 void ModuleContainer_Impl::replaceByName( const OUString& aName, const uno::Any& aElement )
1741 {
1742     removeByName( aName );
1743     insertByName( aName, aElement );
1744 }
1745
1746
1747 // Methods XNameContainer
1748 void ModuleContainer_Impl::insertByName( const OUString& aName, const uno::Any& aElement )
1749 {
1750     uno::Type aModuleType = cppu::UnoType<script::XStarBasicModuleInfo>::get();
1751     const uno::Type& aAnyType = aElement.getValueType();
1752     if( aModuleType != aAnyType )
1753     {
1754         throw lang::IllegalArgumentException();
1755     }
1756     uno::Reference< script::XStarBasicModuleInfo > xMod;
1757     aElement >>= xMod;
1758     mpLib->MakeModule( aName, xMod->getSource() );
1759 }
1760
1761 void ModuleContainer_Impl::removeByName( const OUString& Name )
1762 {
1763     SbModule* pMod = mpLib ? mpLib->FindModule( Name ) : nullptr;
1764     if( !pMod )
1765     {
1766         throw container::NoSuchElementException();
1767     }
1768     mpLib->Remove( pMod );
1769 }
1770
1771
1772 static uno::Sequence< sal_Int8 > implGetDialogData( SbxObject* pDialog )
1773 {
1774     SvMemoryStream aMemStream;
1775     pDialog->Store( aMemStream );
1776     sal_Int32 nLen = aMemStream.Tell();
1777     if (nLen < 0) { abort(); }
1778     uno::Sequence< sal_Int8 > aData( nLen );
1779     sal_Int8* pDestData = aData.getArray();
1780     const sal_Int8* pSrcData = static_cast<const sal_Int8*>(aMemStream.GetData());
1781     memcpy( pDestData, pSrcData, nLen );
1782     return aData;
1783 }
1784
1785 static SbxObject* implCreateDialog( const uno::Sequence< sal_Int8 >& aData )
1786 {
1787     sal_Int8* pData = const_cast< uno::Sequence< sal_Int8 >& >(aData).getArray();
1788     SvMemoryStream aMemStream( pData, aData.getLength(), StreamMode::READ );
1789     SbxBase* pBase = SbxBase::Load( aMemStream );
1790     return dynamic_cast<SbxObject*>(pBase);
1791 }
1792
1793 // HACK! Because this value is defined in basctl/inc/vcsbxdef.hxx
1794 // which we can't include here, we have to use the value directly
1795 #define SBXID_DIALOG        101
1796
1797
1798 class DialogContainer_Impl : public NameContainerHelper
1799 {
1800     StarBASIC* mpLib;
1801
1802 public:
1803     explicit DialogContainer_Impl( StarBASIC* pLib )
1804         :mpLib( pLib ) {}
1805
1806     // Methods XElementAccess
1807     virtual uno::Type SAL_CALL getElementType() override;
1808     virtual sal_Bool SAL_CALL hasElements() override;
1809
1810     // Methods XNameAccess
1811     virtual uno::Any SAL_CALL getByName( const OUString& aName ) override;
1812     virtual uno::Sequence< OUString > SAL_CALL getElementNames() override;
1813     virtual sal_Bool SAL_CALL hasByName( const OUString& aName ) override;
1814
1815     // Methods XNameReplace
1816     virtual void SAL_CALL replaceByName( const OUString& aName, const uno::Any& aElement ) override;
1817
1818     // Methods XNameContainer
1819     virtual void SAL_CALL insertByName( const OUString& aName, const uno::Any& aElement ) override;
1820     virtual void SAL_CALL removeByName( const OUString& Name ) override;
1821 };
1822
1823 // Methods XElementAccess
1824 uno::Type DialogContainer_Impl::getElementType()
1825 {
1826     uno::Type aModuleType = cppu::UnoType<script::XStarBasicDialogInfo>::get();
1827     return aModuleType;
1828 }
1829
1830 sal_Bool DialogContainer_Impl::hasElements()
1831 {
1832     bool bRet = false;
1833
1834     sal_Int16 nCount = mpLib->GetObjects()->Count();
1835     for( sal_Int16 nObj = 0; nObj < nCount ; nObj++ )
1836     {
1837         SbxVariable* pVar = mpLib->GetObjects()->Get( nObj );
1838         SbxObject* pObj = dynamic_cast<SbxObject*>(pVar);
1839         if ( pObj && (pObj->GetSbxId() == SBXID_DIALOG ) )
1840         {
1841             bRet = true;
1842             break;
1843         }
1844     }
1845     return bRet;
1846 }
1847
1848 // Methods XNameAccess
1849 uno::Any DialogContainer_Impl::getByName( const OUString& aName )
1850 {
1851     SbxVariable* pVar = mpLib->GetObjects()->Find( aName, SbxClassType::DontCare );
1852     SbxObject* pObj = dynamic_cast<SbxObject*>(pVar);
1853     if( !( pObj && pObj->GetSbxId() == SBXID_DIALOG ) )
1854     {
1855         throw container::NoSuchElementException();
1856     }
1857
1858     uno::Reference< script::XStarBasicDialogInfo > xDialog =
1859         new DialogInfo_Impl(aName, implGetDialogData(pObj));
1860
1861     uno::Any aRetAny;
1862     aRetAny <<= xDialog;
1863     return aRetAny;
1864 }
1865
1866 uno::Sequence< OUString > DialogContainer_Impl::getElementNames()
1867 {
1868     sal_Int16 nCount = mpLib->GetObjects()->Count();
1869     uno::Sequence< OUString > aRetSeq( nCount );
1870     OUString* pRetSeq = aRetSeq.getArray();
1871     sal_Int32 nDialogCounter = 0;
1872
1873     for( sal_Int16 nObj = 0; nObj < nCount ; nObj++ )
1874     {
1875         SbxVariable* pVar = mpLib->GetObjects()->Get( nObj );
1876         SbxObject* pObj = dynamic_cast<SbxObject*> (pVar);
1877         if ( pObj && ( pObj->GetSbxId() == SBXID_DIALOG ) )
1878         {
1879             pRetSeq[ nDialogCounter ] = pVar->GetName();
1880             nDialogCounter++;
1881         }
1882     }
1883     aRetSeq.realloc( nDialogCounter );
1884     return aRetSeq;
1885 }
1886
1887 sal_Bool DialogContainer_Impl::hasByName( const OUString& aName )
1888 {
1889     bool bRet = false;
1890     SbxVariable* pVar = mpLib->GetObjects()->Find( aName, SbxClassType::DontCare );
1891     SbxObject* pObj = dynamic_cast<SbxObject*>(pVar);
1892     if( pObj &&  ( pObj->GetSbxId() == SBXID_DIALOG ) )
1893     {
1894         bRet = true;
1895     }
1896     return bRet;
1897 }
1898
1899
1900 // Methods XNameReplace
1901 void DialogContainer_Impl::replaceByName( const OUString& aName, const uno::Any& aElement )
1902 {
1903     removeByName( aName );
1904     insertByName( aName, aElement );
1905 }
1906
1907
1908 // Methods XNameContainer
1909 void DialogContainer_Impl::insertByName( const OUString&, const uno::Any& aElement )
1910 {
1911     uno::Type aModuleType = cppu::UnoType<script::XStarBasicDialogInfo>::get();
1912     const uno::Type& aAnyType = aElement.getValueType();
1913     if( aModuleType != aAnyType )
1914     {
1915         throw lang::IllegalArgumentException();
1916     }
1917     uno::Reference< script::XStarBasicDialogInfo > xMod;
1918     aElement >>= xMod;
1919     SbxObjectRef xDialog = implCreateDialog( xMod->getData() );
1920     mpLib->Insert( xDialog.get() );
1921 }
1922
1923 void DialogContainer_Impl::removeByName( const OUString& Name )
1924 {
1925     SbxVariable* pVar = mpLib->GetObjects()->Find( Name, SbxClassType::DontCare );
1926     SbxObject* pObj = dynamic_cast<SbxObject*>(pVar);
1927     if( !( pObj && ( pObj->GetSbxId() == SBXID_DIALOG ) ) )
1928     {
1929         throw container::NoSuchElementException();
1930     }
1931     mpLib->Remove( pVar );
1932 }
1933
1934
1935 class LibraryContainer_Impl : public NameContainerHelper
1936 {
1937     BasicManager* mpMgr;
1938
1939 public:
1940     explicit LibraryContainer_Impl( BasicManager* pMgr )
1941         :mpMgr( pMgr ) {}
1942
1943     // Methods XElementAccess
1944     virtual uno::Type SAL_CALL getElementType() override;
1945     virtual sal_Bool SAL_CALL hasElements() override;
1946
1947     // Methods XNameAccess
1948     virtual uno::Any SAL_CALL getByName( const OUString& aName ) override;
1949     virtual uno::Sequence< OUString > SAL_CALL getElementNames() override;
1950     virtual sal_Bool SAL_CALL hasByName( const OUString& aName ) override;
1951
1952     // Methods XNameReplace
1953     virtual void SAL_CALL replaceByName( const OUString& aName, const uno::Any& aElement ) override;
1954
1955     // Methods XNameContainer
1956     virtual void SAL_CALL insertByName( const OUString& aName, const uno::Any& aElement ) override;
1957     virtual void SAL_CALL removeByName( const OUString& Name ) override;
1958 };
1959
1960
1961 // Methods XElementAccess
1962 uno::Type LibraryContainer_Impl::getElementType()
1963 {
1964     uno::Type aType = cppu::UnoType<script::XStarBasicLibraryInfo>::get();
1965     return aType;
1966 }
1967
1968 sal_Bool LibraryContainer_Impl::hasElements()
1969 {
1970     sal_Int32 nLibs = mpMgr->GetLibCount();
1971     bool bRet = (nLibs > 0);
1972     return bRet;
1973 }
1974
1975 // Methods XNameAccess
1976 uno::Any LibraryContainer_Impl::getByName( const OUString& aName )
1977 {
1978     uno::Any aRetAny;
1979     if( !mpMgr->HasLib( aName ) )
1980         throw container::NoSuchElementException();
1981     StarBASIC* pLib = mpMgr->GetLib( aName );
1982
1983     uno::Reference< container::XNameContainer > xModuleContainer =
1984         new ModuleContainer_Impl( pLib );
1985
1986     uno::Reference< container::XNameContainer > xDialogContainer =
1987         new DialogContainer_Impl( pLib );
1988
1989     BasicLibInfo* pLibInfo = mpMgr->FindLibInfo( pLib );
1990
1991     OUString aPassword = pLibInfo->GetPassword();
1992
1993     // TODO Only provide extern info!
1994     OUString aExternaleSourceURL;
1995     OUString aLinkTargetURL;
1996     if( pLibInfo->IsReference() )
1997     {
1998         aLinkTargetURL = pLibInfo->GetStorageName();
1999     }
2000     else if( pLibInfo->IsExtern() )
2001     {
2002         aExternaleSourceURL = pLibInfo->GetStorageName();
2003     }
2004     uno::Reference< script::XStarBasicLibraryInfo > xLibInfo = new LibraryInfo_Impl
2005     (
2006         aName,
2007         xModuleContainer,
2008         xDialogContainer,
2009         aPassword,
2010         aExternaleSourceURL,
2011         aLinkTargetURL
2012     );
2013
2014     aRetAny <<= xLibInfo;
2015     return aRetAny;
2016 }
2017
2018 uno::Sequence< OUString > LibraryContainer_Impl::getElementNames()
2019 {
2020     sal_uInt16 nLibs = mpMgr->GetLibCount();
2021     uno::Sequence< OUString > aRetSeq( nLibs );
2022     OUString* pRetSeq = aRetSeq.getArray();
2023     for( sal_uInt16 i = 0 ; i < nLibs ; i++ )
2024     {
2025         pRetSeq[i] = mpMgr->GetLibName( i );
2026     }
2027     return aRetSeq;
2028 }
2029
2030 sal_Bool LibraryContainer_Impl::hasByName( const OUString& aName )
2031 {
2032     bool bRet = mpMgr->HasLib( aName );
2033     return bRet;
2034 }
2035
2036 // Methods XNameReplace
2037 void LibraryContainer_Impl::replaceByName( const OUString& aName, const uno::Any& aElement )
2038 {
2039     removeByName( aName );
2040     insertByName( aName, aElement );
2041 }
2042
2043 // Methods XNameContainer
2044 void LibraryContainer_Impl::insertByName( const OUString&, const uno::Any& )
2045 {
2046     // TODO: Insert a complete Library?!
2047 }
2048
2049 void LibraryContainer_Impl::removeByName( const OUString& Name )
2050 {
2051     StarBASIC* pLib = mpMgr->GetLib( Name );
2052     if( !pLib )
2053     {
2054         throw container::NoSuchElementException();
2055     }
2056     sal_uInt16 nLibId = mpMgr->GetLibId( Name );
2057     mpMgr->RemoveLib( nLibId );
2058 }
2059
2060
2061 typedef WeakImplHelper< script::XStarBasicAccess > StarBasicAccessHelper;
2062
2063
2064 class StarBasicAccess_Impl : public StarBasicAccessHelper
2065 {
2066     BasicManager* mpMgr;
2067     uno::Reference< container::XNameContainer > mxLibContainer;
2068
2069 public:
2070     explicit StarBasicAccess_Impl( BasicManager* pMgr )
2071         :mpMgr( pMgr ) {}
2072
2073 public:
2074     // Methods
2075     virtual uno::Reference< container::XNameContainer > SAL_CALL getLibraryContainer() override;
2076     virtual void SAL_CALL createLibrary( const OUString& LibName, const OUString& Password,
2077         const OUString& ExternalSourceURL, const OUString& LinkTargetURL ) override;
2078     virtual void SAL_CALL addModule( const OUString& LibraryName, const OUString& ModuleName,
2079         const OUString& Language, const OUString& Source ) override;
2080     virtual void SAL_CALL addDialog( const OUString& LibraryName, const OUString& DialogName,
2081         const uno::Sequence< sal_Int8 >& Data ) override;
2082 };
2083
2084 uno::Reference< container::XNameContainer > SAL_CALL StarBasicAccess_Impl::getLibraryContainer()
2085 {
2086     if( !mxLibContainer.is() )
2087         mxLibContainer = new LibraryContainer_Impl( mpMgr );
2088     return mxLibContainer;
2089 }
2090
2091 void SAL_CALL StarBasicAccess_Impl::createLibrary
2092 (
2093     const OUString& LibName,
2094     const OUString& Password,
2095     const OUString&,
2096     const OUString& LinkTargetURL
2097 )
2098 {
2099     StarBASIC* pLib = mpMgr->CreateLib( LibName, Password, LinkTargetURL );
2100     DBG_ASSERT( pLib, "XML Import: Basic library could not be created");
2101 }
2102
2103 void SAL_CALL StarBasicAccess_Impl::addModule
2104 (
2105     const OUString& LibraryName,
2106     const OUString& ModuleName,
2107     const OUString&,
2108     const OUString& Source
2109 )
2110 {
2111     StarBASIC* pLib = mpMgr->GetLib( LibraryName );
2112     DBG_ASSERT( pLib, "XML Import: Lib for module unknown");
2113     if( pLib )
2114     {
2115         pLib->MakeModule( ModuleName, Source );
2116     }
2117 }
2118
2119 void SAL_CALL StarBasicAccess_Impl::addDialog
2120 (
2121     const OUString&,
2122     const OUString&,
2123     const uno::Sequence< sal_Int8 >&
2124 )
2125 {}
2126
2127 // Basic XML Import/Export
2128 uno::Reference< script::XStarBasicAccess > getStarBasicAccess( BasicManager* pMgr )
2129 {
2130     uno::Reference< script::XStarBasicAccess > xRet =
2131         new StarBasicAccess_Impl( pMgr );
2132     return xRet;
2133 }
2134
2135 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */