xref: /aoo42x/main/basic/source/basmgr/basmgr.cxx (revision c6948b83)
1 /**************************************************************
2  *
3  * Licensed to the Apache Software Foundation (ASF) under one
4  * or more contributor license agreements.  See the NOTICE file
5  * distributed with this work for additional information
6  * regarding copyright ownership.  The ASF licenses this file
7  * to you under the Apache License, Version 2.0 (the
8  * "License"); you may not use this file except in compliance
9  * with the License.  You may obtain a copy of the License at
10  *
11  *   http://www.apache.org/licenses/LICENSE-2.0
12  *
13  * Unless required by applicable law or agreed to in writing,
14  * software distributed under the License is distributed on an
15  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16  * KIND, either express or implied.  See the License for the
17  * specific language governing permissions and limitations
18  * under the License.
19  *
20  *************************************************************/
21 
22 
23 
24 // MARKER(update_precomp.py): autogen include statement, do not remove
25 #include "precompiled_basic.hxx"
26 #include <tools/stream.hxx>
27 #include <sot/storage.hxx>
28 #include <tools/urlobj.hxx>
29 #include <svl/smplhint.hxx>
30 #include <vcl/svapp.hxx>
31 #include <vcl/window.hxx>
32 #include <vcl/wrkwin.hxx>
33 #include <vcl/msgbox.hxx>
34 #include <basic/sbx.hxx>
35 #include <sot/storinfo.hxx>
36 #include <unotools/pathoptions.hxx>
37 #include <tools/debug.hxx>
38 #include <tools/diagnose_ex.h>
39 #include <basic/sbmod.hxx>
40 #include <basic/sbobjmod.hxx>
41 #include <unotools/intlwrapper.hxx>
42 #include <comphelper/processfactory.hxx>
43 
44 #include <basic/sbuno.hxx>
45 #include <basic/basmgr.hxx>
46 #include <sbunoobj.hxx>
47 #include "basrid.hxx"
48 #include "sbintern.hxx"
49 #include <sb.hrc>
50 
51 
52 #define LIB_SEP			0x01
53 #define LIBINFO_SEP		0x02
54 #define LIBINFO_ID		0x1491
55 #define PASSWORD_MARKER	0x31452134
56 
57 
58 // Library API, implemented for XML import/export
59 
60 #include <com/sun/star/container/XNameContainer.hpp>
61 #include <com/sun/star/container/XContainer.hpp>
62 #include <com/sun/star/script/XStarBasicAccess.hpp>
63 #include <com/sun/star/script/XStarBasicModuleInfo.hpp>
64 #include <com/sun/star/script/XStarBasicDialogInfo.hpp>
65 #include <com/sun/star/script/XStarBasicLibraryInfo.hpp>
66 #include <com/sun/star/script/XLibraryContainerPassword.hpp>
67 #include <com/sun/star/script/ModuleInfo.hpp>
68 #include <com/sun/star/script/vba/XVBACompatibility.hpp>
69 #include <com/sun/star/script/vba/XVBAModuleInfo.hpp>
70 
71 #include <cppuhelper/implbase1.hxx>
72 
73 using com::sun::star::uno::Reference;
74 using namespace com::sun::star::container;
75 using namespace com::sun::star::uno;
76 using namespace com::sun::star::lang;
77 using namespace com::sun::star::script;
78 using namespace cppu;
79 
80 typedef WeakImplHelper1< XNameContainer > NameContainerHelper;
81 typedef WeakImplHelper1< XStarBasicModuleInfo > ModuleInfoHelper;
82 typedef WeakImplHelper1< XStarBasicDialogInfo > DialogInfoHelper;
83 typedef WeakImplHelper1< XStarBasicLibraryInfo > LibraryInfoHelper;
84 typedef WeakImplHelper1< XStarBasicAccess > StarBasicAccessHelper;
85 
86 
87 
88 #define CURR_VER		2
89 
90 // Version 1
91 //	  sal_uIntPtr 	nEndPos
92 //	  sal_uInt16 	nId
93 //	  sal_uInt16	nVer
94 //	  sal_Bool		bDoLoad
95 //	  String	LibName
96 //	  String	AbsStorageName
97 //	  String	RelStorageName
98 // Version 2
99 //	+ sal_Bool		bReference
100 
101 static const char* szStdLibName = "Standard";
102 static const char szBasicStorage[] = "StarBASIC";
103 static const char* szOldManagerStream = "BasicManager";
104 static const char szManagerStream[] = "BasicManager2";
105 static const char* szImbedded = "LIBIMBEDDED";
106 static const char* szCryptingKey = "CryptedBasic";
107 static const char* szScriptLanguage = "StarBasic";
108 
109 TYPEINIT1( BasicManager, SfxBroadcaster );
110 DBG_NAME( BasicManager );
111 
112 StreamMode eStreamReadMode = STREAM_READ | STREAM_NOCREATE | STREAM_SHARE_DENYALL;
113 StreamMode eStorageReadMode = STREAM_READ | STREAM_SHARE_DENYWRITE;
114 
115 DECLARE_LIST( BasErrorLst, BasicError* )
116 
117 //----------------------------------------------------------------------------
118 // BasicManager impl data
119 struct BasicManagerImpl
120 {
121     LibraryContainerInfo    maContainerInfo;
122 
123     // Save stream data
124     SvMemoryStream*  mpManagerStream;
125     SvMemoryStream** mppLibStreams;
126     sal_Int32        mnLibStreamCount;
127     sal_Bool         mbModifiedByLibraryContainer;
128     sal_Bool         mbError;
129 
BasicManagerImplBasicManagerImpl130 	BasicManagerImpl( void )
131         : mpManagerStream( NULL )
132         , mppLibStreams( NULL )
133         , mnLibStreamCount( 0 )
134         , mbModifiedByLibraryContainer( sal_False )
135         , mbError( sal_False )
136 	{}
137     ~BasicManagerImpl();
138 };
139 
~BasicManagerImpl()140 BasicManagerImpl::~BasicManagerImpl()
141 {
142     delete mpManagerStream;
143     if( mppLibStreams )
144     {
145         for( sal_Int32 i = 0 ; i < mnLibStreamCount ; i++ )
146             delete mppLibStreams[i];
147         delete[] mppLibStreams;
148     }
149 }
150 
151 //============================================================================
152 // BasMgrContainerListenerImpl
153 //============================================================================
154 
155 typedef ::cppu::WeakImplHelper1< ::com::sun::star::container::XContainerListener > ContainerListenerHelper;
156 
157 class BasMgrContainerListenerImpl: public ContainerListenerHelper
158 {
159 	BasicManager* mpMgr;
160 	::rtl::OUString maLibName;		// empty -> no lib, but lib container
161 
162 public:
BasMgrContainerListenerImpl(BasicManager * pMgr,::rtl::OUString aLibName)163 	BasMgrContainerListenerImpl( BasicManager* pMgr, ::rtl::OUString aLibName )
164         : mpMgr( pMgr )
165         , maLibName( aLibName ) {}
166 
167 	static void insertLibraryImpl( const Reference< XLibraryContainer >& xScriptCont, BasicManager* pMgr,
168 		Any aLibAny, ::rtl::OUString aLibName );
169 	static void addLibraryModulesImpl( BasicManager* pMgr, Reference< XNameAccess > xLibNameAccess,
170 		::rtl::OUString aLibName );
171 
172 
173 	// XEventListener
174 	virtual void SAL_CALL disposing( const ::com::sun::star::lang::EventObject& Source )
175 		throw(::com::sun::star::uno::RuntimeException);
176 
177 	// XContainerListener
178 	virtual void SAL_CALL elementInserted( const ::com::sun::star::container::ContainerEvent& Event )
179 		throw(::com::sun::star::uno::RuntimeException);
180 	virtual void SAL_CALL elementReplaced( const ::com::sun::star::container::ContainerEvent& Event )
181 		throw(::com::sun::star::uno::RuntimeException);
182 	virtual void SAL_CALL elementRemoved( const ::com::sun::star::container::ContainerEvent& Event )
183 		throw(::com::sun::star::uno::RuntimeException);
184 };
185 
186 
187 //============================================================================
188 // BasMgrContainerListenerImpl
189 //============================================================================
190 
insertLibraryImpl(const Reference<XLibraryContainer> & xScriptCont,BasicManager * pMgr,Any aLibAny,::rtl::OUString aLibName)191 void BasMgrContainerListenerImpl::insertLibraryImpl( const Reference< XLibraryContainer >& xScriptCont,
192 	BasicManager* pMgr, Any aLibAny, ::rtl::OUString aLibName )
193 {
194 	Reference< XNameAccess > xLibNameAccess;
195 	aLibAny >>= xLibNameAccess;
196 
197 	if( !pMgr->GetLib( aLibName ) )
198 	{
199 		BasicManager* pBasMgr = static_cast< BasicManager* >( pMgr );
200 #ifdef DBG_UTIL
201 		StarBASIC* pLib =
202 #endif
203 		pBasMgr->CreateLibForLibContainer( aLibName, xScriptCont );
204 		DBG_ASSERT( pLib, "XML Import: Basic library could not be created");
205 	}
206 
207 	Reference< XContainer> xLibContainer( xLibNameAccess, UNO_QUERY );
208 	if( xLibContainer.is() )
209 	{
210 		// Register listener for library
211 		Reference< XContainerListener > xLibraryListener
212 			= static_cast< XContainerListener* >
213 				( new BasMgrContainerListenerImpl( pMgr, aLibName ) );
214 		xLibContainer->addContainerListener( xLibraryListener );
215 	}
216 
217 	if( xScriptCont->isLibraryLoaded( aLibName ) )
218 	{
219 		addLibraryModulesImpl( pMgr, xLibNameAccess, aLibName );
220 	}
221 }
222 
223 
addLibraryModulesImpl(BasicManager * pMgr,Reference<XNameAccess> xLibNameAccess,::rtl::OUString aLibName)224 void BasMgrContainerListenerImpl::addLibraryModulesImpl( BasicManager* pMgr,
225 	Reference< XNameAccess > xLibNameAccess, ::rtl::OUString aLibName )
226 {
227 	Sequence< ::rtl::OUString > aModuleNames = xLibNameAccess->getElementNames();
228 	sal_Int32 nModuleCount = aModuleNames.getLength();
229 
230 	StarBASIC* pLib = pMgr->GetLib( aLibName );
231 	DBG_ASSERT( pLib, "BasMgrContainerListenerImpl::addLibraryModulesImpl: Unknown lib!");
232 	if( pLib )
233 	{
234 		const ::rtl::OUString* pNames = aModuleNames.getConstArray();
235 		for( sal_Int32 j = 0 ; j < nModuleCount ; j++ )
236 		{
237 			::rtl::OUString aModuleName = pNames[ j ];
238 			Any aElement = xLibNameAccess->getByName( aModuleName );
239             ::rtl::OUString aMod;
240             aElement >>= aMod;
241             Reference< vba::XVBAModuleInfo > xVBAModuleInfo( xLibNameAccess, UNO_QUERY );
242             if ( xVBAModuleInfo.is() && xVBAModuleInfo->hasModuleInfo( aModuleName ) )
243 			{
244                 ModuleInfo mInfo = xVBAModuleInfo->getModuleInfo( aModuleName );
245 				OSL_TRACE("#addLibraryModulesImpl - aMod");
246                 pLib->MakeModule32( aModuleName, mInfo, aMod );
247 			}
248 			else
249 		pLib->MakeModule32( aModuleName, aMod );
250 		}
251 	}
252 
253 	pLib->SetModified( sal_False );
254 }
255 
256 
257 
258 // XEventListener
259 //----------------------------------------------------------------------------
260 
disposing(const EventObject & Source)261 void SAL_CALL BasMgrContainerListenerImpl::disposing( const EventObject& Source )
262 	throw( RuntimeException )
263 {
264 	(void)Source;
265 }
266 
267 // XContainerListener
268 //----------------------------------------------------------------------------
269 
elementInserted(const ContainerEvent & Event)270 void SAL_CALL BasMgrContainerListenerImpl::elementInserted( const ContainerEvent& Event )
271 	throw( RuntimeException )
272 {
273 	sal_Bool bLibContainer = maLibName.isEmpty();
274 	::rtl::OUString aName;
275 	Event.Accessor >>= aName;
276 
277 	mpMgr->mpImpl->mbModifiedByLibraryContainer = sal_True;
278 
279 	if( bLibContainer )
280 	{
281 		Reference< XLibraryContainer > xScriptCont( Event.Source, UNO_QUERY );
282 		insertLibraryImpl( xScriptCont, mpMgr, Event.Element, aName );
283         StarBASIC* pLib = mpMgr->GetLib( aName );
284         if ( pLib )
285         {
286             Reference< vba::XVBACompatibility > xVBACompat( xScriptCont, UNO_QUERY );
287             if ( xVBACompat.is() )
288                 pLib->SetVBAEnabled( xVBACompat->getVBACompatibilityMode() );
289         }
290 	}
291 	else
292 	{
293 
294 		StarBASIC* pLib = mpMgr->GetLib( maLibName );
295 		DBG_ASSERT( pLib, "BasMgrContainerListenerImpl::elementInserted: Unknown lib!");
296 		if( pLib )
297 		{
298     		SbModule* pMod = pLib->FindModule( aName );
299             if( !pMod )
300             {
301         	::rtl::OUString aMod;
302         	Event.Element >>= aMod;
303                 Reference< vba::XVBAModuleInfo > xVBAModuleInfo( Event.Source, UNO_QUERY );
304                 if ( xVBAModuleInfo.is() && xVBAModuleInfo->hasModuleInfo( aName ) )
305                 {
306                     ModuleInfo mInfo = xVBAModuleInfo->getModuleInfo( aName );
307                     pLib->MakeModule32( aName, mInfo, aMod );
308                 }
309                 else
310 			        pLib->MakeModule32( aName, aMod );
311 			    pLib->SetModified( sal_False );
312             }
313 		}
314 	}
315 }
316 
317 //----------------------------------------------------------------------------
318 
elementReplaced(const ContainerEvent & Event)319 void SAL_CALL BasMgrContainerListenerImpl::elementReplaced( const ContainerEvent& Event )
320 	throw( RuntimeException )
321 {
322 	::rtl::OUString aName;
323 	Event.Accessor >>= aName;
324 
325 	mpMgr->mpImpl->mbModifiedByLibraryContainer = sal_True;
326 
327 	// Replace not possible for library container
328 #ifdef DBG_UTIL
329 	sal_Bool bLibContainer = maLibName.isEmpty();
330 #endif
331 	DBG_ASSERT( !bLibContainer, "library container fired elementReplaced()");
332 
333 	StarBASIC* pLib = mpMgr->GetLib( maLibName );
334 	if( pLib )
335 	{
336 		SbModule* pMod = pLib->FindModule( aName );
337 		::rtl::OUString aMod;
338 		Event.Element >>= aMod;
339 
340 		if( pMod )
341 				pMod->SetSource32( aMod );
342 		else
343 				pLib->MakeModule32( aName, aMod );
344 
345 		pLib->SetModified( sal_False );
346 	}
347 }
348 
349 //----------------------------------------------------------------------------
350 
elementRemoved(const ContainerEvent & Event)351 void SAL_CALL BasMgrContainerListenerImpl::elementRemoved( const ContainerEvent& Event )
352 	throw( RuntimeException )
353 {
354 	::rtl::OUString aName;
355 	Event.Accessor >>= aName;
356 
357 	mpMgr->mpImpl->mbModifiedByLibraryContainer = sal_True;
358 
359 	sal_Bool bLibContainer = maLibName.isEmpty();
360 	if( bLibContainer )
361 	{
362 		StarBASIC* pLib = mpMgr->GetLib( aName );
363 		if( pLib )
364 		{
365 			sal_uInt16 nLibId = mpMgr->GetLibId( aName );
366 			mpMgr->RemoveLib( nLibId, sal_False );
367 		}
368 	}
369 	else
370 	{
371 		StarBASIC* pLib = mpMgr->GetLib( maLibName );
372 		SbModule* pMod = pLib ? pLib->FindModule( aName ) : NULL;
373 		if( pMod )
374 		{
375 			pLib->Remove( pMod );
376 			pLib->SetModified( sal_False );
377 		}
378 	}
379 }
380 
381 
382 //=====================================================================
383 
384 class BasicErrorManager
385 {
386 private:
387 	BasErrorLst	aErrorList;
388 
389 public:
390 				~BasicErrorManager();
391 
392 	void		Reset();
393 	void		InsertError( const BasicError& rError );
394 
HasErrors()395 	sal_Bool		HasErrors()			{ return (sal_Bool)aErrorList.Count(); }
GetFirstError()396 	BasicError*	GetFirstError()		{ return aErrorList.First(); }
GetNextError()397 	BasicError*	GetNextError()		{ return aErrorList.Next(); }
398 };
399 
400 
~BasicErrorManager()401 BasicErrorManager::~BasicErrorManager()
402 {
403 	Reset();
404 }
405 
Reset()406 void BasicErrorManager::Reset()
407 {
408 	BasicError* pError = (BasicError*)aErrorList.First();
409 	while ( pError )
410 	{
411 		delete pError;
412 		pError = (BasicError*)aErrorList.Next();
413 	}
414 	aErrorList.Clear();
415 }
416 
InsertError(const BasicError & rError)417 void BasicErrorManager::InsertError( const BasicError& rError )
418 {
419 	aErrorList.Insert( new BasicError( rError ), LIST_APPEND );
420 }
421 
422 
BasicError()423 BasicError::BasicError()
424 {
425 	nErrorId	= 0;
426 	nReason 	= 0;
427 }
428 
BasicError(sal_uIntPtr nId,sal_uInt16 nR,const String & rErrStr)429 BasicError::BasicError( sal_uIntPtr nId, sal_uInt16 nR, const String& rErrStr ) :
430 	aErrStr( rErrStr )
431 {
432 	nErrorId 	= nId;
433 	nReason 	= nR;
434 }
435 
BasicError(const BasicError & rErr)436 BasicError::BasicError( const BasicError& rErr ) :
437 	aErrStr( rErr.aErrStr )
438 {
439 	nErrorId 	= rErr.nErrorId;
440 	nReason		= rErr.nReason;
441 }
442 
443 
444 class BasicLibInfo
445 {
446 private:
447 	StarBASICRef	xLib;
448 	String			aLibName;
449 	String			aStorageName;	// String is sufficient, unique at runtime
450 	String			aRelStorageName;
451 	String			aPassword;
452 
453 	sal_Bool			bDoLoad;
454 	sal_Bool			bReference;
455 	sal_Bool			bPasswordVerified;
456 	sal_Bool			bFoundInPath;	// Must not relativated again!
457 
458 	// Lib represents library in new UNO library container
459 	Reference< XLibraryContainer > mxScriptCont;
460 
461 public:
462 	BasicLibInfo();
463 	BasicLibInfo( const String& rStorageName );
464 
IsReference() const465 	sal_Bool			IsReference() const		{ return bReference; }
IsReference()466 	sal_Bool&			IsReference()			{ return bReference; }
467 
IsExtern() const468 	sal_Bool			IsExtern() const 		{ return ! aStorageName.EqualsAscii(szImbedded); }
469 
SetStorageName(const String & rName)470 	void			SetStorageName( const String& rName )	{ aStorageName = rName; }
GetStorageName() const471 	const String&	GetStorageName() const					{ return aStorageName; }
472 
SetRelStorageName(const String & rN)473 	void			SetRelStorageName( const String& rN )	{ aRelStorageName = rN; }
GetRelStorageName() const474 	const String&	GetRelStorageName()	const				{ return aRelStorageName; }
475 	void			CalcRelStorageName( const String& rMgrStorageName );
476 
GetLib() const477 	StarBASICRef	GetLib() const
478 	{
479 		if( mxScriptCont.is() && mxScriptCont->hasByName( aLibName ) &&
480 			!mxScriptCont->isLibraryLoaded( aLibName ) )
481 				return StarBASICRef();
482 		return xLib;
483 	}
GetLibRef()484 	StarBASICRef&	GetLibRef()							{ return xLib; }
SetLib(StarBASIC * pBasic)485 	void			SetLib( StarBASIC* pBasic )			{ xLib = pBasic; }
486 
GetLibName() const487 	const String&	GetLibName() const					{ return aLibName; }
SetLibName(const String & rName)488 	void			SetLibName( const String& rName )	{ aLibName = rName; }
489 
490 	// Only temporary for Load/Save
DoLoad()491 	sal_Bool			DoLoad()							{ return bDoLoad; }
492 
HasPassword() const493 	sal_Bool			HasPassword() const 				{ return aPassword.Len() != 0; }
GetPassword() const494 	const String&	GetPassword() const					{ return aPassword; }
SetPassword(const String & rNewPassword)495 	void			SetPassword( const String& rNewPassword )
496 														{ aPassword = rNewPassword;	}
IsPasswordVerified() const497 	sal_Bool			IsPasswordVerified() const			{ return bPasswordVerified; }
SetPasswordVerified()498 	void			SetPasswordVerified()				{ bPasswordVerified = sal_True; }
499 
IsFoundInPath() const500 	sal_Bool			IsFoundInPath() const				{ return bFoundInPath; }
SetFoundInPath(sal_Bool bInPath)501 	void			SetFoundInPath( sal_Bool bInPath )		{ bFoundInPath = bInPath; }
502 
503 	void 					Store( SotStorageStream& rSStream, const String& rBasMgrStorageName, sal_Bool bUseOldReloadInfo );
504 	static BasicLibInfo*	Create( SotStorageStream& rSStream );
505 
GetLibraryContainer(void)506 	Reference< XLibraryContainer > GetLibraryContainer( void )
507 		{ return mxScriptCont; }
SetLibraryContainer(const Reference<XLibraryContainer> & xScriptCont)508 	void SetLibraryContainer( const Reference< XLibraryContainer >& xScriptCont )
509 		{ mxScriptCont = xScriptCont; }
510 };
511 
512 DECLARE_LIST( BasicLibsBase, BasicLibInfo* )
513 
514 class BasicLibs : public BasicLibsBase
515 {
516 public:
517 	String	aBasicLibPath; // TODO: Should be member of manager, but currently not incompatible
518 };
519 
BasicLibInfo()520 BasicLibInfo::BasicLibInfo()
521 {
522 	bReference 			= sal_False;
523 	bPasswordVerified 	= sal_False;
524 	bDoLoad 			= sal_False;
525 	bFoundInPath		= sal_False;
526 	mxScriptCont		= NULL;
527 	aStorageName 		= String::CreateFromAscii(szImbedded);
528 	aRelStorageName 	= String::CreateFromAscii(szImbedded);
529 }
530 
BasicLibInfo(const String & rStorageName)531 BasicLibInfo::BasicLibInfo( const String& rStorageName )
532 {
533 	bReference 			= sal_True;
534 	bPasswordVerified 	= sal_False;
535 	bDoLoad 			= sal_False;
536 	mxScriptCont		= NULL;
537 	aStorageName 		= rStorageName;
538 }
539 
Store(SotStorageStream & rSStream,const String & rBasMgrStorageName,sal_Bool bUseOldReloadInfo)540 void BasicLibInfo::Store( SotStorageStream& rSStream, const String& rBasMgrStorageName, sal_Bool bUseOldReloadInfo )
541 {
542 	sal_uIntPtr nStartPos = rSStream.Tell();
543 	sal_uInt32 nEndPos = 0;
544 
545 	sal_uInt16 nId = LIBINFO_ID;
546 	sal_uInt16 nVer = CURR_VER;
547 
548 	rSStream << nEndPos;
549 	rSStream << nId;
550 	rSStream << nVer;
551 
552     String aCurStorageName = INetURLObject(rBasMgrStorageName, INET_PROT_FILE).GetMainURL( INetURLObject::NO_DECODE );
553     DBG_ASSERT(aCurStorageName.Len() != 0, "Bad storage name");
554 
555     // If not set initialize StorageName
556     if ( aStorageName.Len() == 0 )
557         aStorageName = aCurStorageName;
558 
559     // Load again?
560     sal_Bool bDoLoad_ = xLib.Is();
561     if ( bUseOldReloadInfo )
562         bDoLoad_ = DoLoad();
563     rSStream << bDoLoad_;
564 
565     // The name of the lib...
566     rSStream.WriteByteString(GetLibName());
567 
568     // Absolute path...
569     if ( ! GetStorageName().EqualsAscii(szImbedded) )
570     {
571         String aSName = INetURLObject( GetStorageName(), INET_PROT_FILE).GetMainURL( INetURLObject::NO_DECODE );
572         DBG_ASSERT(aSName.Len() != 0, "Bad storage name");
573         rSStream.WriteByteString( aSName );
574     }
575     else
576         rSStream.WriteByteString( szImbedded );
577 
578     // Relative path...
579     if ( ( aStorageName == aCurStorageName ) || ( aStorageName.EqualsAscii(szImbedded) ) )
580         rSStream.WriteByteString( szImbedded );
581     else
582     {
583         // Do not determine the relative path if the file was only found in path:
584         // because the relative path would change and after moving the lib the
585         // the file cannot be found.
586         if ( !IsFoundInPath() )
587             CalcRelStorageName( aCurStorageName );
588         rSStream.WriteByteString(aRelStorageName);
589     }
590 
591 	// ------------------------------
592 	// Version 2
593 	// ------------------------------
594 
595 	// reference...
596 	rSStream << bReference;
597 
598 	// ------------------------------
599 	// End
600 	// ------------------------------
601 
602 	nEndPos = rSStream.Tell();
603 	rSStream.Seek( nStartPos );
604 	rSStream << nEndPos;
605 	rSStream.Seek( nEndPos );
606 }
607 
Create(SotStorageStream & rSStream)608 BasicLibInfo* BasicLibInfo::Create( SotStorageStream& rSStream )
609 {
610 	BasicLibInfo* pInfo = new BasicLibInfo;
611 
612 	sal_uInt32 nEndPos;
613 	sal_uInt16 nId;
614 	sal_uInt16 nVer;
615 
616 	rSStream >> nEndPos;
617 	rSStream >> nId;
618 	rSStream >> nVer;
619 
620 	DBG_ASSERT( nId == LIBINFO_ID, "Keine BasicLibInfo !?" );
621     if( nId == LIBINFO_ID )
622     {
623         // Reload?
624         sal_Bool bDoLoad;
625         rSStream >> bDoLoad;
626         pInfo->bDoLoad = bDoLoad;
627 
628         // The name of the lib...
629         String aName;
630         rSStream.ReadByteString(aName);
631         pInfo->SetLibName( aName );
632 
633         // Absolute path...
634         String aStorageName;
635         rSStream.ReadByteString(aStorageName);
636         pInfo->SetStorageName( aStorageName );
637 
638         // Relative path...
639         String aRelStorageName;
640         rSStream.ReadByteString(aRelStorageName);
641         pInfo->SetRelStorageName( aRelStorageName );
642 
643         if ( nVer >= 2 )
644         {
645             sal_Bool bReferenz;
646             rSStream >> bReferenz;
647             pInfo->IsReference() = bReferenz;
648         }
649 
650         rSStream.Seek( nEndPos );
651     }
652     return pInfo;
653 }
654 
CalcRelStorageName(const String & rMgrStorageName)655 void BasicLibInfo::CalcRelStorageName( const String& rMgrStorageName )
656 {
657 	if ( rMgrStorageName.Len() )
658 	{
659         INetURLObject aAbsURLObj( rMgrStorageName );
660 		aAbsURLObj.removeSegment();
661 		String aPath = aAbsURLObj.GetMainURL( INetURLObject::NO_DECODE );
662 		UniString aRelURL = INetURLObject::GetRelURL( aPath, GetStorageName() );
663         SetRelStorageName( aRelURL );
664 	}
665 	else
666 		SetRelStorageName( String() );
667 }
BasicManager(SotStorage & rStorage,const String & rBaseURL,StarBASIC * pParentFromStdLib,String * pLibPath,sal_Bool bDocMgr)668 BasicManager::BasicManager( SotStorage& rStorage, const String& rBaseURL, StarBASIC* pParentFromStdLib, String* pLibPath, sal_Bool bDocMgr ) : mbDocMgr( bDocMgr )
669 {
670 	DBG_CTOR( BasicManager, 0 );
671 
672 	Init();
673 
674 	if( pLibPath )
675 		pLibs->aBasicLibPath = *pLibPath;
676 
677     String aStorName( rStorage.GetName() );
678     maStorageName = INetURLObject(aStorName, INET_PROT_FILE).GetMainURL( INetURLObject::NO_DECODE );
679 
680     // #91251: Storage name not longer available for documents < 5.0
681     // Should be no real problem, because only relative storage names
682     // (links) can be affected.
683     // DBG_ASSERT( aStorName.Len(), "No Storage Name!" );
684     // DBG_ASSERT(aStorageName.Len() != 0, "Bad storage name");
685 
686     // If there is no Manager Stream, no further actions are necessary
687     if ( rStorage.IsStream( String(RTL_CONSTASCII_USTRINGPARAM(szManagerStream)) ) )
688     {
689         LoadBasicManager( rStorage, rBaseURL );
690         // StdLib contains Parent:
691         StarBASIC* pStdLib = GetStdLib();
692         DBG_ASSERT( pStdLib, "Standard-Lib not loaded?" );
693         if ( !pStdLib )
694         {
695             // Should never happen, but if it happens we won't crash...
696             pStdLib = new StarBASIC( NULL, mbDocMgr );
697 			BasicLibInfo* pStdLibInfo = pLibs->GetObject( 0 );
698 			if ( !pStdLibInfo )
699 				pStdLibInfo = CreateLibInfo();
700 			pStdLibInfo->SetLib( pStdLib );
701             StarBASICRef xStdLib = pStdLibInfo->GetLib();
702 			xStdLib->SetName( String::CreateFromAscii(szStdLibName) );
703 			pStdLibInfo->SetLibName( String::CreateFromAscii(szStdLibName) );
704 			xStdLib->SetFlag( SBX_DONTSTORE | SBX_EXTSEARCH );
705 			xStdLib->SetModified( sal_False );
706         }
707         else
708         {
709 			pStdLib->SetParent( pParentFromStdLib );
710             // The other get StdLib as parent:
711             for ( sal_uInt16 nBasic = 1; nBasic < GetLibCount(); nBasic++ )
712 			{
713 				StarBASIC* pBasic = GetLib( nBasic );
714 				if ( pBasic )
715 				{
716 //					pBasic->SetParent( pStdLib );
717 					pStdLib->Insert( pBasic );
718 					pBasic->SetFlag( SBX_EXTSEARCH );
719 				}
720 			}
721             // Modified through insert
722             pStdLib->SetModified( sal_False );
723         }
724 
725         // #91626 Save all stream data to save it unmodified if basic isn't modified
726         // in an 6.0+ office. So also the old basic dialogs can be saved.
727 	    SotStorageStreamRef xManagerStream = rStorage.OpenSotStream
728 		    ( String(RTL_CONSTASCII_USTRINGPARAM(szManagerStream)), eStreamReadMode );
729         mpImpl->mpManagerStream = new SvMemoryStream();
730         *static_cast<SvStream*>(&xManagerStream) >> *mpImpl->mpManagerStream;
731 
732 	    SotStorageRef xBasicStorage = rStorage.OpenSotStorage
733 							    ( String(RTL_CONSTASCII_USTRINGPARAM(szBasicStorage)), eStorageReadMode, sal_False );
734 	    if( xBasicStorage.Is() && !xBasicStorage->GetError() )
735 	    {
736 	        sal_uInt16 nLibs = GetLibCount();
737             mpImpl->mppLibStreams = new SvMemoryStream*[ nLibs ];
738             for( sal_uInt16 nL = 0; nL < nLibs; nL++ )
739 	        {
740 		        BasicLibInfo* pInfo = pLibs->GetObject( nL );
741 		        DBG_ASSERT( pInfo, "pInfo?!" );
742     		    SotStorageStreamRef xBasicStream = xBasicStorage->OpenSotStream( pInfo->GetLibName(), eStreamReadMode );
743                 mpImpl->mppLibStreams[nL] = new SvMemoryStream();
744                 *static_cast<SvStream*>(&xBasicStream) >> *( mpImpl->mppLibStreams[nL] );
745             }
746         }
747         else
748             mpImpl->mbError = sal_True;
749 	}
750 	else
751 	{
752 		ImpCreateStdLib( pParentFromStdLib );
753 		if ( rStorage.IsStream( String::CreateFromAscii(szOldManagerStream) ) )
754             LoadOldBasicManager( rStorage );
755 	}
756 
757 	bBasMgrModified = sal_False;
758 }
759 
copyToLibraryContainer(StarBASIC * pBasic,const LibraryContainerInfo & rInfo)760 void copyToLibraryContainer( StarBASIC* pBasic, const LibraryContainerInfo& rInfo )
761 {
762 	Reference< XLibraryContainer > xScriptCont( rInfo.mxScriptCont.get() );
763 	if ( !xScriptCont.is() )
764 		return;
765 
766 	String aLibName = pBasic->GetName();
767 	if( !xScriptCont->hasByName( aLibName ) )
768 		xScriptCont->createLibrary( aLibName );
769 
770 	Any aLibAny = xScriptCont->getByName( aLibName );
771 	Reference< XNameContainer > xLib;
772 	aLibAny >>= xLib;
773 	if ( !xLib.is() )
774 		return;
775 
776 	sal_uInt16 nModCount = pBasic->GetModules()->Count();
777 	for ( sal_uInt16 nMod = 0 ; nMod < nModCount ; nMod++ )
778 	{
779 		SbModule* pModule = (SbModule*)pBasic->GetModules()->Get( nMod );
780 		DBG_ASSERT( pModule, "Modul nicht erhalten!" );
781 
782 		String aModName = pModule->GetName();
783 		if( !xLib->hasByName( aModName ) )
784 		{
785 			::rtl::OUString aSource = pModule->GetSource32();
786 			Any aSourceAny;
787 			aSourceAny <<= aSource;
788 			xLib->insertByName( aModName, aSourceAny );
789 		}
790 	}
791 }
792 
GetDialogLibraryContainer() const793 const Reference< XPersistentLibraryContainer >& BasicManager::GetDialogLibraryContainer() const
794 {
795 	return mpImpl->maContainerInfo.mxDialogCont;
796 }
797 
GetScriptLibraryContainer() const798 const Reference< XPersistentLibraryContainer >& BasicManager::GetScriptLibraryContainer() const
799 {
800 	return mpImpl->maContainerInfo.mxScriptCont;
801 }
802 
SetLibraryContainerInfo(const LibraryContainerInfo & rInfo)803 void BasicManager::SetLibraryContainerInfo( const LibraryContainerInfo& rInfo )
804 {
805 	mpImpl->maContainerInfo = rInfo;
806 
807 	Reference< XLibraryContainer > xScriptCont( mpImpl->maContainerInfo.mxScriptCont.get() );
808 	StarBASIC* pStdLib = GetStdLib();
809 	String aLibName = pStdLib->GetName();
810 	if( xScriptCont.is() )
811 	{
812 		// Register listener for lib container
813 		::rtl::OUString aEmptyLibName;
814 		Reference< XContainerListener > xLibContainerListener
815 			= static_cast< XContainerListener* >
816 				( new BasMgrContainerListenerImpl( this, aEmptyLibName ) );
817 
818 		Reference< XContainer> xLibContainer( xScriptCont, UNO_QUERY );
819 		xLibContainer->addContainerListener( xLibContainerListener );
820 
821 		Sequence< ::rtl::OUString > aScriptLibNames = xScriptCont->getElementNames();
822 		const ::rtl::OUString* pScriptLibName = aScriptLibNames.getConstArray();
823 		sal_Int32 i, nNameCount = aScriptLibNames.getLength();
824 
825         if( nNameCount )
826         {
827 		    for( i = 0 ; i < nNameCount ; ++i, ++pScriptLibName )
828 		    {
829 			    Any aLibAny = xScriptCont->getByName( *pScriptLibName );
830 
831                 if ( pScriptLibName->equalsAscii( "Standard" ) )
832 				    xScriptCont->loadLibrary( *pScriptLibName );
833 
834 			    BasMgrContainerListenerImpl::insertLibraryImpl
835 				    ( xScriptCont, this, aLibAny, *pScriptLibName );
836 		    }
837         }
838         else
839         {
840             // No libs? Maybe an 5.2 document already loaded
841 	        sal_uInt16 nLibs = GetLibCount();
842 		    for( sal_uInt16 nL = 0; nL < nLibs; nL++ )
843 		    {
844 			    BasicLibInfo* pBasLibInfo = pLibs->GetObject( nL );
845 			    StarBASIC* pLib = pBasLibInfo->GetLib();
846 			    if( !pLib )
847                 {
848                     sal_Bool bLoaded = ImpLoadLibary( pBasLibInfo, NULL, sal_False );
849                     if( bLoaded )
850                         pLib = pBasLibInfo->GetLib();
851                 }
852 			    if( pLib )
853                 {
854                     copyToLibraryContainer( pLib, mpImpl->maContainerInfo );
855                     if( pBasLibInfo->HasPassword() )
856                     {
857                         OldBasicPassword* pOldBasicPassword =
858                             mpImpl->maContainerInfo.mpOldBasicPassword;
859                         if( pOldBasicPassword )
860                         {
861                             pOldBasicPassword->setLibraryPassword
862                                 ( pLib->GetName(), pBasLibInfo->GetPassword() );
863                             pBasLibInfo->SetPasswordVerified();
864                         }
865                     }
866                 }
867 		    }
868 
869             mpImpl->mbModifiedByLibraryContainer = sal_False;
870         }
871 	}
872 
873 	SetGlobalUNOConstant( "BasicLibraries", makeAny( mpImpl->maContainerInfo.mxScriptCont ) );
874 	SetGlobalUNOConstant( "DialogLibraries", makeAny( mpImpl->maContainerInfo.mxDialogCont ) );
875 }
876 
BasicManager(StarBASIC * pSLib,String * pLibPath,sal_Bool bDocMgr)877 BasicManager::BasicManager( StarBASIC* pSLib, String* pLibPath, sal_Bool bDocMgr ) : mbDocMgr( bDocMgr )
878 {
879 	DBG_CTOR( BasicManager, 0 );
880 	Init();
881 	DBG_ASSERT( pSLib, "BasicManager cannot be created with a NULL-Pointer!" );
882 
883 	if( pLibPath )
884 		pLibs->aBasicLibPath = *pLibPath;
885 
886 	BasicLibInfo* pStdLibInfo = CreateLibInfo();
887 	pStdLibInfo->SetLib( pSLib );
888 	StarBASICRef xStdLib = pStdLibInfo->GetLib();
889 	xStdLib->SetName( String::CreateFromAscii(szStdLibName));
890 	pStdLibInfo->SetLibName( String::CreateFromAscii(szStdLibName) );
891 	pSLib->SetFlag( SBX_DONTSTORE | SBX_EXTSEARCH );
892 
893 	// Save is only necessary if basic has changed
894 	xStdLib->SetModified( sal_False );
895 	bBasMgrModified = sal_False;
896 }
897 
BasicManager()898 BasicManager::BasicManager()
899 {
900     DBG_CTOR( BasicManager, 0 );
901     // This ctor may only be used to adapt relative paths for 'Save As'.
902     // There is no AppBasic so libs must not be loaded...
903     Init();
904 }
905 
ImpMgrNotLoaded(const String & rStorageName)906 void BasicManager::ImpMgrNotLoaded( const String& rStorageName )
907 {
908     // pErrInf is only destroyed if the error is processed by an
909     // ErrorHandler
910     StringErrorInfo* pErrInf = new StringErrorInfo( ERRCODE_BASMGR_MGROPEN, rStorageName, ERRCODE_BUTTON_OK );
911     pErrorMgr->InsertError( BasicError( *pErrInf, BASERR_REASON_OPENMGRSTREAM, rStorageName ) );
912 
913     // Create a stdlib otherwise we crash!
914     BasicLibInfo* pStdLibInfo = CreateLibInfo();
915     pStdLibInfo->SetLib( new StarBASIC( NULL, mbDocMgr ) );
916     StarBASICRef xStdLib = pStdLibInfo->GetLib();
917     xStdLib->SetName( String::CreateFromAscii(szStdLibName) );
918     pStdLibInfo->SetLibName( String::CreateFromAscii(szStdLibName) );
919     xStdLib->SetFlag( SBX_DONTSTORE | SBX_EXTSEARCH );
920     xStdLib->SetModified( sal_False );
921 }
922 
923 
ImpCreateStdLib(StarBASIC * pParentFromStdLib)924 void BasicManager::ImpCreateStdLib( StarBASIC* pParentFromStdLib )
925 {
926 	BasicLibInfo* pStdLibInfo = CreateLibInfo();
927 	StarBASIC* pStdLib = new StarBASIC( pParentFromStdLib, mbDocMgr );
928 	pStdLibInfo->SetLib( pStdLib );
929 	pStdLib->SetName( String::CreateFromAscii(szStdLibName) );
930 	pStdLibInfo->SetLibName( String::CreateFromAscii(szStdLibName) );
931 	pStdLib->SetFlag( SBX_DONTSTORE | SBX_EXTSEARCH );
932 }
933 
934 
LoadBasicManager(SotStorage & rStorage,const String & rBaseURL,sal_Bool bLoadLibs)935 void BasicManager::LoadBasicManager( SotStorage& rStorage, const String& rBaseURL, sal_Bool bLoadLibs )
936 {
937 	DBG_CHKTHIS( BasicManager, 0 );
938 
939 //	StreamMode eStreamMode = STREAM_READ | STREAM_NOCREATE | STREAM_SHARE_DENYWRITE;
940 
941 	SotStorageStreamRef xManagerStream = rStorage.OpenSotStream
942 		( String(RTL_CONSTASCII_USTRINGPARAM(szManagerStream)), eStreamReadMode );
943 
944 	String aStorName( rStorage.GetName() );
945 	// #i13114 removed, DBG_ASSERT( aStorName.Len(), "No Storage Name!" );
946 
947 	if ( !xManagerStream.Is() || xManagerStream->GetError() || ( xManagerStream->Seek( STREAM_SEEK_TO_END ) == 0 ) )
948 	{
949 		ImpMgrNotLoaded( aStorName );
950 		return;
951 	}
952 
953     maStorageName = INetURLObject(aStorName, INET_PROT_FILE).GetMainURL( INetURLObject::NO_DECODE );
954     // #i13114 removed, DBG_ASSERT(aStorageName.Len() != 0, "Bad storage name");
955 
956     String aRealStorageName = maStorageName; // for relative paths, can be modified through BaseURL
957 
958     // If loaded from template, only BaseURL is used:
959     //String aBaseURL = INetURLObject::GetBaseURL();
960     if ( rBaseURL.Len() )
961 	{
962         INetURLObject aObj( rBaseURL );
963 		if ( aObj.GetProtocol() == INET_PROT_FILE )
964 			aRealStorageName = aObj.PathToFileName();
965 	}
966 
967 	xManagerStream->SetBufferSize( 1024 );
968 	xManagerStream->Seek( STREAM_SEEK_TO_BEGIN );
969 
970 	sal_uInt32 nEndPos;
971 	*xManagerStream >> nEndPos;
972 
973 	sal_uInt16 nLibs;
974 	*xManagerStream >> nLibs;
975 	// Plausi!
976 	if( nLibs & 0xF000 )
977 	{
978 		DBG_ASSERT( sal_False, "BasicManager-Stream defect!" );
979 		return;
980 	}
981 	for ( sal_uInt16 nL = 0; nL < nLibs; nL++ )
982 	{
983 		BasicLibInfo* pInfo = BasicLibInfo::Create( *xManagerStream );
984 
985         // Correct absolute pathname if relative is existing.
986         // Always try relative first if there are two stands on disk
987         if ( pInfo->GetRelStorageName().Len() && ( ! pInfo->GetRelStorageName().EqualsAscii(szImbedded) ) )
988 		{
989             INetURLObject aObj( aRealStorageName, INET_PROT_FILE );
990             aObj.removeSegment();
991             bool bWasAbsolute = sal_False;
992             aObj = aObj.smartRel2Abs( pInfo->GetRelStorageName(), bWasAbsolute );
993 
994             //*** TODO: Replace if still necessary
995             /* if ( SfxContentHelper::Exists( aObj.GetMainURL() ) )
996                 pInfo->SetStorageName( aObj.GetMainURL() );
997 			else */
998             //*** TODO-End
999             if ( pLibs->aBasicLibPath.Len() )
1000 			{
1001                 // Search lib in path
1002 				String aSearchFile = pInfo->GetRelStorageName();
1003 				SvtPathOptions aPathCFG;
1004 				if( aPathCFG.SearchFile( aSearchFile, SvtPathOptions::PATH_BASIC ) )
1005 				{
1006                     pInfo->SetStorageName( aSearchFile );
1007 					pInfo->SetFoundInPath( sal_True );
1008 				}
1009 			}
1010 		}
1011 
1012 		pLibs->Insert( pInfo, LIST_APPEND );
1013 		// Libs from external files should be loaded only when necessary.
1014 		// But references are loaded at once, otherwise some big customers get into trouble
1015 		if ( bLoadLibs && pInfo->DoLoad() &&
1016 			( ( !pInfo->IsExtern() ) || ( pInfo->IsReference() ) ) )
1017 		{
1018             ImpLoadLibary( pInfo, &rStorage );
1019 		}
1020 	}
1021 
1022 	xManagerStream->Seek( nEndPos );
1023 	xManagerStream->SetBufferSize( 0 );
1024 	xManagerStream.Clear();
1025 }
1026 
LoadOldBasicManager(SotStorage & rStorage)1027 void BasicManager::LoadOldBasicManager( SotStorage& rStorage )
1028 {
1029 	DBG_CHKTHIS( BasicManager, 0 );
1030 
1031 //	StreamMode eStreamMode = STREAM_READ | STREAM_NOCREATE | STREAM_SHARE_DENYWRITE;
1032 
1033 	SotStorageStreamRef xManagerStream = rStorage.OpenSotStream
1034 		( String::CreateFromAscii(szOldManagerStream), eStreamReadMode );
1035 
1036 	String aStorName( rStorage.GetName() );
1037 	DBG_ASSERT( aStorName.Len(), "No Storage Name!" );
1038 
1039 	if ( !xManagerStream.Is() || xManagerStream->GetError() || ( xManagerStream->Seek( STREAM_SEEK_TO_END ) == 0 ) )
1040 	{
1041 		ImpMgrNotLoaded( aStorName );
1042 		return;
1043 	}
1044 
1045 	xManagerStream->SetBufferSize( 1024 );
1046 	xManagerStream->Seek( STREAM_SEEK_TO_BEGIN );
1047 	sal_uInt32 nBasicStartOff, nBasicEndOff;
1048 	*xManagerStream >> nBasicStartOff;
1049 	*xManagerStream >> nBasicEndOff;
1050 
1051 	DBG_ASSERT( !xManagerStream->GetError(), "Ungueltiger Manager-Stream!" );
1052 
1053 	xManagerStream->Seek( nBasicStartOff );
1054 	if( !ImplLoadBasic( *xManagerStream, pLibs->GetObject(0)->GetLibRef() ) )
1055 	{
1056 //		String aErrorText( BasicResId( IDS_SBERR_MGROPEN ) );
1057 //      aErrorText.SearchAndReplace( "XX", aStorName );
1058         StringErrorInfo* pErrInf = new StringErrorInfo( ERRCODE_BASMGR_MGROPEN, aStorName, ERRCODE_BUTTON_OK );
1059         pErrorMgr->InsertError( BasicError( *pErrInf, BASERR_REASON_OPENMGRSTREAM, aStorName ) );
1060 		// und es geht weiter...
1061 	}
1062 	xManagerStream->Seek( nBasicEndOff+1 );	// +1: 0x00 as separator
1063 	String aLibs;
1064 	xManagerStream->ReadByteString(aLibs);
1065 	xManagerStream->SetBufferSize( 0 );
1066 	xManagerStream.Clear();	// Close stream
1067 
1068 	if ( aLibs.Len() )
1069 	{
1070         String aCurStorageName( aStorName );
1071         INetURLObject aCurStorage( aCurStorageName, INET_PROT_FILE );
1072 		sal_uInt16 nLibs = aLibs.GetTokenCount( LIB_SEP );
1073 		for ( sal_uInt16 nLib = 0; nLib < nLibs; nLib++ )
1074 		{
1075 			String aLibInfo( aLibs.GetToken( nLib, LIB_SEP ) );
1076 			// TODO: Remove == 2
1077 			DBG_ASSERT( ( aLibInfo.GetTokenCount( LIBINFO_SEP ) == 2 ) || ( aLibInfo.GetTokenCount( LIBINFO_SEP ) == 3 ), "Ungueltige Lib-Info!" );
1078 			String aLibName( aLibInfo.GetToken( 0, LIBINFO_SEP ) );
1079 			String aLibAbsStorageName( aLibInfo.GetToken( 1, LIBINFO_SEP ) );
1080 			String aLibRelStorageName( aLibInfo.GetToken( 2, LIBINFO_SEP ) );
1081             INetURLObject aLibAbsStorage( aLibAbsStorageName, INET_PROT_FILE );
1082 
1083             INetURLObject aLibRelStorage( aStorName );
1084             aLibRelStorage.removeSegment();
1085             bool bWasAbsolute = sal_False;
1086             aLibRelStorage = aLibRelStorage.smartRel2Abs( aLibRelStorageName, bWasAbsolute);
1087             DBG_ASSERT(!bWasAbsolute, "RelStorageName was absolute!" );
1088 
1089 			SotStorageRef xStorageRef;
1090 			if ( ( aLibAbsStorage == aCurStorage ) || ( aLibRelStorageName.EqualsAscii(szImbedded) ) )
1091 				xStorageRef = &rStorage;
1092 			else
1093 			{
1094                 xStorageRef = new SotStorage( sal_False, aLibAbsStorage.GetMainURL
1095                     ( INetURLObject::NO_DECODE ), eStorageReadMode, sal_True );
1096                 if ( xStorageRef->GetError() != ERRCODE_NONE )
1097                     xStorageRef = new SotStorage( sal_False, aLibRelStorage.
1098                     GetMainURL( INetURLObject::NO_DECODE ), eStorageReadMode, sal_True );
1099 			}
1100 			if ( xStorageRef.Is() )
1101                 AddLib( *xStorageRef, aLibName, sal_False );
1102 			else
1103 			{
1104 //				String aErrorText( BasicResId( IDS_SBERR_LIBLOAD ) );
1105 //				aErrorText.SearchAndReplace( "XX", aLibName );
1106                 StringErrorInfo* pErrInf = new StringErrorInfo( ERRCODE_BASMGR_LIBLOAD, aStorName, ERRCODE_BUTTON_OK );
1107                 pErrorMgr->InsertError( BasicError( *pErrInf, BASERR_REASON_STORAGENOTFOUND, aStorName ) );
1108 			}
1109 		}
1110 	}
1111 }
1112 
~BasicManager()1113 BasicManager::~BasicManager()
1114 {
1115 	DBG_DTOR( BasicManager, 0 );
1116 
1117 	// Notify listener if something needs to be saved
1118 	Broadcast( SfxSimpleHint( SFX_HINT_DYING) );
1119 
1120 	// Destroy Basic-Infos...
1121 	// In reverse order
1122 	BasicLibInfo* pInf = pLibs->Last();
1123 	while ( pInf )
1124 	{
1125 		delete pInf;
1126 		pInf = pLibs->Prev();
1127 	}
1128 	pLibs->Clear();
1129 	delete pLibs;
1130 	delete pErrorMgr;
1131 	delete mpImpl;
1132 }
1133 
LegacyDeleteBasicManager(BasicManager * & _rpManager)1134 void BasicManager::LegacyDeleteBasicManager( BasicManager*& _rpManager )
1135 {
1136 	delete _rpManager;
1137 	_rpManager = NULL;
1138 }
1139 
Init()1140 void BasicManager::Init()
1141 {
1142 	DBG_CHKTHIS( BasicManager, 0 );
1143 
1144 	bBasMgrModified = sal_False;
1145 	pErrorMgr = new BasicErrorManager;
1146 	pLibs = new BasicLibs;
1147 	mpImpl = new BasicManagerImpl();
1148 }
1149 
CreateLibInfo()1150 BasicLibInfo* BasicManager::CreateLibInfo()
1151 {
1152 	DBG_CHKTHIS( BasicManager, 0 );
1153 
1154 	BasicLibInfo* pInf = new BasicLibInfo;
1155 	pLibs->Insert( pInf, LIST_APPEND );
1156 	return pInf;
1157 }
1158 
ImpLoadLibary(BasicLibInfo * pLibInfo,SotStorage * pCurStorage,sal_Bool bInfosOnly) const1159 sal_Bool BasicManager::ImpLoadLibary( BasicLibInfo* pLibInfo, SotStorage* pCurStorage, sal_Bool bInfosOnly ) const
1160 {
1161 	DBG_CHKTHIS( BasicManager, 0 );
1162 
1163 	DBG_ASSERT( pLibInfo, "LibInfo!?" );
1164 
1165 	String aStorageName( pLibInfo->GetStorageName() );
1166 	if ( !aStorageName.Len() || ( aStorageName.EqualsAscii(szImbedded) ) )
1167 		aStorageName = GetStorageName();
1168 
1169 	SotStorageRef xStorage;
1170 	// The current must not be opened again...
1171 	if ( pCurStorage )
1172 	{
1173         String aStorName( pCurStorage->GetName() );
1174         // #i13114 removed, DBG_ASSERT( aStorName.Len(), "No Storage Name!" );
1175 
1176         INetURLObject aCurStorageEntry(aStorName, INET_PROT_FILE);
1177         // #i13114 removed, DBG_ASSERT(aCurStorageEntry.GetMainURL( INetURLObject::NO_DECODE ).Len() != 0, "Bad storage name");
1178 
1179         INetURLObject aStorageEntry(aStorageName, INET_PROT_FILE);
1180         // #i13114 removed, DBG_ASSERT(aCurStorageEntry.GetMainURL( INetURLObject::NO_DECODE ).Len() != 0, "Bad storage name");
1181 
1182 		if ( aCurStorageEntry == aStorageEntry )
1183 			xStorage = pCurStorage;
1184 	}
1185 
1186 	if ( !xStorage.Is() )
1187 		xStorage = new SotStorage( sal_False, aStorageName, eStorageReadMode );
1188 
1189 	SotStorageRef xBasicStorage = xStorage->OpenSotStorage
1190 							( String(RTL_CONSTASCII_USTRINGPARAM(szBasicStorage)), eStorageReadMode, sal_False );
1191 
1192 	if ( !xBasicStorage.Is() || xBasicStorage->GetError() )
1193 	{
1194 		StringErrorInfo* pErrInf = new StringErrorInfo( ERRCODE_BASMGR_MGROPEN,	xStorage->GetName(), ERRCODE_BUTTON_OK );
1195 		pErrorMgr->InsertError( BasicError( *pErrInf, BASERR_REASON_OPENLIBSTORAGE, pLibInfo->GetLibName() ) );
1196 	}
1197 	else
1198 	{
1199 		// In the Basic-Storage every lib is in a Stream...
1200 		SotStorageStreamRef xBasicStream = xBasicStorage->OpenSotStream( pLibInfo->GetLibName(), eStreamReadMode );
1201 		if ( !xBasicStream.Is() || xBasicStream->GetError() )
1202 		{
1203 			StringErrorInfo* pErrInf = new StringErrorInfo( ERRCODE_BASMGR_LIBLOAD , pLibInfo->GetLibName(), ERRCODE_BUTTON_OK );
1204 			pErrorMgr->InsertError( BasicError( *pErrInf, BASERR_REASON_OPENLIBSTREAM, pLibInfo->GetLibName() ) );
1205 		}
1206 		else
1207 		{
1208 			sal_Bool bLoaded = sal_False;
1209 			if ( xBasicStream->Seek( STREAM_SEEK_TO_END ) != 0 )
1210 			{
1211 				if ( !bInfosOnly )
1212 				{
1213 					if ( !pLibInfo->GetLib().Is() )
1214 						pLibInfo->SetLib( new StarBASIC( GetStdLib(), mbDocMgr ) );
1215 					xBasicStream->SetBufferSize( 1024 );
1216 					xBasicStream->Seek( STREAM_SEEK_TO_BEGIN );
1217 					bLoaded = ImplLoadBasic( *xBasicStream, pLibInfo->GetLibRef() );
1218 					xBasicStream->SetBufferSize( 0 );
1219 					StarBASICRef xStdLib = pLibInfo->GetLib();
1220 					xStdLib->SetName( pLibInfo->GetLibName() );
1221 					xStdLib->SetModified( sal_False );
1222 					xStdLib->SetFlag( SBX_DONTSTORE );
1223 				}
1224 				else
1225 				{
1226 					// Skip Basic...
1227 					xBasicStream->Seek( STREAM_SEEK_TO_BEGIN );
1228 					ImplEncryptStream( *xBasicStream );
1229 					SbxBase::Skip( *xBasicStream );
1230 					bLoaded = sal_True;
1231 				}
1232 			}
1233 			if ( !bLoaded )
1234 			{
1235 				StringErrorInfo* pErrInf = new StringErrorInfo( ERRCODE_BASMGR_LIBLOAD,	pLibInfo->GetLibName(), ERRCODE_BUTTON_OK );
1236 				pErrorMgr->InsertError( BasicError( *pErrInf, BASERR_REASON_BASICLOADERROR, pLibInfo->GetLibName() ) );
1237 			}
1238 			else
1239 			{
1240 				// Perhaps there are additional information in the stream...
1241 				xBasicStream->SetKey( szCryptingKey );
1242 				xBasicStream->RefreshBuffer();
1243 				sal_uInt32 nPasswordMarker = 0;
1244 				*xBasicStream >> nPasswordMarker;
1245 				if ( ( nPasswordMarker == PASSWORD_MARKER ) && !xBasicStream->IsEof() )
1246 				{
1247 					String aPassword;
1248 					xBasicStream->ReadByteString(aPassword);
1249 					pLibInfo->SetPassword( aPassword );
1250 				}
1251 				xBasicStream->SetKey( ByteString() );
1252 				CheckModules( pLibInfo->GetLib(), pLibInfo->IsReference() );
1253 			}
1254 			return bLoaded;
1255 		}
1256 	}
1257 	return sal_False;
1258 }
1259 
ImplEncryptStream(SvStream & rStrm) const1260 sal_Bool BasicManager::ImplEncryptStream( SvStream& rStrm ) const
1261 {
1262 	sal_uIntPtr nPos = rStrm.Tell();
1263 	sal_uInt32 nCreator;
1264 	rStrm >> nCreator;
1265 	rStrm.Seek( nPos );
1266 	sal_Bool bProtected = sal_False;
1267 	if ( nCreator != SBXCR_SBX )
1268 	{
1269 		// Should only be the case for encrypted Streams
1270 		bProtected = sal_True;
1271 		rStrm.SetKey( szCryptingKey );
1272 		rStrm.RefreshBuffer();
1273 	}
1274 	return bProtected;
1275 }
1276 
1277 // This code is necessary to load the BASIC of Beta 1
1278 // TODO: Which Beta 1?
ImplLoadBasic(SvStream & rStrm,StarBASICRef & rOldBasic) const1279 sal_Bool BasicManager::ImplLoadBasic( SvStream& rStrm, StarBASICRef& rOldBasic ) const
1280 {
1281 	sal_Bool bProtected = ImplEncryptStream( rStrm );
1282 	SbxBaseRef xNew = SbxBase::Load( rStrm );
1283 	sal_Bool bLoaded = sal_False;
1284 	if( xNew.Is() )
1285 	{
1286 		if( xNew->IsA( TYPE(StarBASIC) ) )
1287 		{
1288 			StarBASIC* pNew = (StarBASIC*)(SbxBase*) xNew;
1289 			// Use the Parent of the old BASICs
1290 			if( rOldBasic.Is() )
1291 			{
1292 				pNew->SetParent( rOldBasic->GetParent() );
1293 				if( pNew->GetParent() )
1294 					pNew->GetParent()->Insert( pNew );
1295 				pNew->SetFlag( SBX_EXTSEARCH );
1296 			}
1297 			rOldBasic = pNew;
1298 
1299 			// Fill new libray container (5.2 -> 6.0)
1300 			copyToLibraryContainer( pNew, mpImpl->maContainerInfo );
1301 
1302 /*
1303 			if( rOldBasic->GetParent() )
1304 			{
1305 				rOldBasic->GetParent()->Insert( rOldBasic );
1306 				rOldBasic->SetFlag( SBX_EXTSEARCH );
1307 			}
1308 */
1309 			pNew->SetModified( sal_False );
1310 			bLoaded = sal_True;
1311 		}
1312 	}
1313 	if ( bProtected )
1314 		rStrm.SetKey( ByteString() );
1315 	return bLoaded;
1316 }
1317 
CheckModules(StarBASIC * pLib,sal_Bool bReference) const1318 void BasicManager::CheckModules( StarBASIC* pLib, sal_Bool bReference ) const
1319 {
1320 	if ( !pLib )
1321 		return;
1322 
1323 	sal_Bool bModified = pLib->IsModified();
1324 
1325 	for ( sal_uInt16 nMod = 0; nMod < pLib->GetModules()->Count(); nMod++ )
1326 	{
1327 		SbModule* pModule = (SbModule*)pLib->GetModules()->Get( nMod );
1328 		DBG_ASSERT( pModule, "Modul nicht erhalten!" );
1329 		if ( !pModule->IsCompiled() && !StarBASIC::GetErrorCode() )
1330 			pLib->Compile( pModule );
1331 	}
1332 
1333 	// #67477, AB 8.12.99 On demand compile in referenced libs should not
1334 	// cause modified
1335 	if( !bModified && bReference )
1336 	{
1337 		DBG_ERROR( "Per Reference eingebundene Basic-Library ist nicht compiliert!" );
1338 		pLib->SetModified( sal_False );
1339 	}
1340 }
1341 
AddLib(SotStorage & rStorage,const String & rLibName,sal_Bool bReference)1342 StarBASIC* BasicManager::AddLib( SotStorage& rStorage, const String& rLibName, sal_Bool bReference )
1343 {
1344 	DBG_CHKTHIS( BasicManager, 0 );
1345 
1346 	String aStorName( rStorage.GetName() );
1347 	DBG_ASSERT( aStorName.Len(), "No Storage Name!" );
1348 
1349 	String aStorageName = INetURLObject(aStorName, INET_PROT_FILE).GetMainURL( INetURLObject::NO_DECODE );
1350 	DBG_ASSERT(aStorageName.Len() != 0, "Bad storage name");
1351 
1352 	String aNewLibName( rLibName );
1353 	while ( HasLib( aNewLibName ) )
1354 		aNewLibName += '_';
1355 
1356 	BasicLibInfo* pLibInfo = CreateLibInfo();
1357 	// Use original name otherwise ImpLoadLibary fails...
1358 	pLibInfo->SetLibName( rLibName );
1359 	// Funktioniert so aber nicht, wenn Name doppelt
1360 //	sal_uInt16 nLibId = GetLibId( rLibName );
1361 	sal_uInt16 nLibId = (sal_uInt16) pLibs->GetPos( pLibInfo );
1362 
1363 	// Set StorageName before load because it is compared with pCurStorage
1364 	pLibInfo->SetStorageName( aStorageName );
1365 	sal_Bool bLoaded = ImpLoadLibary( pLibInfo, &rStorage );
1366 
1367 	if ( bLoaded )
1368 	{
1369 		if ( aNewLibName != rLibName )
1370 			SetLibName( nLibId, aNewLibName );
1371 
1372 		if ( bReference )
1373 		{
1374 			pLibInfo->GetLib()->SetModified( sal_False );	// Don't save in this case
1375 			pLibInfo->SetRelStorageName( String() );
1376 //			pLibInfo->CalcRelStorageName( GetStorageName() );
1377 			pLibInfo->IsReference() = sal_True;
1378 		}
1379 		else
1380 		{
1381 			pLibInfo->GetLib()->SetModified( sal_True ); // Must be saved after Add!
1382 			pLibInfo->SetStorageName( String::CreateFromAscii(szImbedded) ); // Save in BasicManager-Storage
1383 		}
1384 		bBasMgrModified = sal_True;
1385 	}
1386 	else
1387 	{
1388 		RemoveLib( nLibId, sal_False );
1389 		pLibInfo = 0;
1390 	}
1391 
1392 	if( pLibInfo )
1393 		return &*pLibInfo->GetLib() ;
1394 	else
1395 		return 0;
1396 }
1397 
IsReference(sal_uInt16 nLib)1398 sal_Bool BasicManager::IsReference( sal_uInt16 nLib )
1399 {
1400 	DBG_CHKTHIS( BasicManager, 0 );
1401 
1402 	BasicLibInfo* pLibInfo = pLibs->GetObject( nLib );
1403 	DBG_ASSERT( pLibInfo, "Lib?!" );
1404 	if ( pLibInfo )
1405 		return pLibInfo->IsReference();
1406 
1407 	return sal_False;
1408 }
1409 
RemoveLib(sal_uInt16 nLib)1410 sal_Bool BasicManager::RemoveLib( sal_uInt16 nLib )
1411 {
1412 	// Only pyhsical deletion if no reference
1413 	return RemoveLib( nLib, !IsReference( nLib ) );
1414 }
1415 
RemoveLib(sal_uInt16 nLib,sal_Bool bDelBasicFromStorage)1416 sal_Bool BasicManager::RemoveLib( sal_uInt16 nLib, sal_Bool bDelBasicFromStorage )
1417 {
1418 	DBG_CHKTHIS( BasicManager, 0 );
1419 	DBG_ASSERT( nLib, "Standard-Lib cannot be removed!" );
1420 
1421 	BasicLibInfo* pLibInfo = pLibs->GetObject( nLib );
1422 	DBG_ASSERT( pLibInfo, "Lib not found!" );
1423 
1424 	if ( !pLibInfo || !nLib )
1425 	{
1426 //		String aErrorText( BasicResId( IDS_SBERR_REMOVELIB ) );
1427 		StringErrorInfo* pErrInf = new StringErrorInfo( ERRCODE_BASMGR_REMOVELIB, String(), ERRCODE_BUTTON_OK );
1428 		pErrorMgr->InsertError( BasicError( *pErrInf, BASERR_REASON_STDLIB, pLibInfo->GetLibName() ) );
1429 		return sal_False;
1430 	}
1431 
1432 	// If one of the streams cannot be opened, this is not an error,
1433 	// because BASIC was never written before...
1434 	if ( bDelBasicFromStorage && !pLibInfo->IsReference() &&
1435 			( !pLibInfo->IsExtern() || SotStorage::IsStorageFile( pLibInfo->GetStorageName() ) ) )
1436 	{
1437 		SotStorageRef xStorage;
1438 		if ( !pLibInfo->IsExtern() )
1439 			xStorage = new SotStorage( sal_False, GetStorageName() );
1440 		else
1441 			xStorage = new SotStorage( sal_False, pLibInfo->GetStorageName() );
1442 
1443 		if ( xStorage->IsStorage( String(RTL_CONSTASCII_USTRINGPARAM(szBasicStorage)) ) )
1444 		{
1445 			SotStorageRef xBasicStorage = xStorage->OpenSotStorage
1446 							( String(RTL_CONSTASCII_USTRINGPARAM(szBasicStorage)), STREAM_STD_READWRITE, sal_False );
1447 
1448 			if ( !xBasicStorage.Is() || xBasicStorage->GetError() )
1449 			{
1450 //				String aErrorText( BasicResId( IDS_SBERR_REMOVELIB ) );
1451 				StringErrorInfo* pErrInf = new StringErrorInfo( ERRCODE_BASMGR_REMOVELIB, String(), ERRCODE_BUTTON_OK );
1452 				pErrorMgr->InsertError( BasicError( *pErrInf, BASERR_REASON_OPENLIBSTORAGE, pLibInfo->GetLibName() ) );
1453 			}
1454 			else if ( xBasicStorage->IsStream( pLibInfo->GetLibName() ) )
1455 			{
1456 				xBasicStorage->Remove( pLibInfo->GetLibName() );
1457 				xBasicStorage->Commit();
1458 
1459 				// If no further stream available,
1460 				// delete the SubStorage.
1461 				SvStorageInfoList aInfoList( 0, 4 );
1462 				xBasicStorage->FillInfoList( &aInfoList );
1463 				if ( !aInfoList.Count() )
1464 				{
1465 					xBasicStorage.Clear();
1466 					xStorage->Remove( String(RTL_CONSTASCII_USTRINGPARAM(szBasicStorage)) );
1467 					xStorage->Commit();
1468 					// If no further Streams or SubStorages available,
1469 					// delete the Storage, too.
1470 					aInfoList.Clear();
1471 					xStorage->FillInfoList( &aInfoList );
1472 					if ( !aInfoList.Count() )
1473 					{
1474                         String aName_( xStorage->GetName() );
1475 						xStorage.Clear();
1476                         //*** TODO: Replace if still necessary
1477                         //SfxContentHelper::Kill( aName );
1478                         //*** TODO-End
1479 					}
1480 				}
1481 			}
1482 		}
1483 	}
1484 	bBasMgrModified = sal_True;
1485 	if ( pLibInfo->GetLib().Is() )
1486 		GetStdLib()->Remove( pLibInfo->GetLib() );
1487 	delete pLibs->Remove( pLibInfo );
1488 	return sal_True;	// Remove was successful, del unimportant
1489 }
1490 
GetLibCount() const1491 sal_uInt16 BasicManager::GetLibCount() const
1492 {
1493 	DBG_CHKTHIS( BasicManager, 0 );
1494 	return (sal_uInt16)pLibs->Count();
1495 }
1496 
GetLib(sal_uInt16 nLib) const1497 StarBASIC* BasicManager::GetLib( sal_uInt16 nLib ) const
1498 {
1499 	DBG_CHKTHIS( BasicManager, 0 );
1500 	BasicLibInfo* pInf = pLibs->GetObject( nLib );
1501 	DBG_ASSERT( pInf, "Lib existiert nicht!" );
1502 	if ( pInf )
1503 		return pInf->GetLib();
1504 	return 0;
1505 }
1506 
GetStdLib() const1507 StarBASIC* BasicManager::GetStdLib() const
1508 {
1509 	DBG_CHKTHIS( BasicManager, 0 );
1510 	StarBASIC* pLib = GetLib( 0 );
1511 	return pLib;
1512 }
1513 
GetLib(const String & rName) const1514 StarBASIC* BasicManager::GetLib( const String& rName ) const
1515 {
1516 	DBG_CHKTHIS( BasicManager, 0 );
1517 
1518 	BasicLibInfo* pInf = pLibs->First();
1519 	while ( pInf )
1520 	{
1521 		if ( pInf->GetLibName().CompareIgnoreCaseToAscii( rName ) == COMPARE_EQUAL )// Check if available...
1522 			return pInf->GetLib();
1523 
1524 		pInf = pLibs->Next();
1525 	}
1526 	return 0;
1527 }
1528 
GetLibId(const String & rName) const1529 sal_uInt16 BasicManager::GetLibId( const String& rName ) const
1530 {
1531 	DBG_CHKTHIS( BasicManager, 0 );
1532 
1533 	BasicLibInfo* pInf = pLibs->First();
1534 	while ( pInf )
1535 	{
1536 		if ( pInf->GetLibName().CompareIgnoreCaseToAscii( rName ) == COMPARE_EQUAL )
1537 			return (sal_uInt16)pLibs->GetCurPos();
1538 
1539 		pInf = pLibs->Next();
1540 	}
1541 	return LIB_NOTFOUND;
1542 }
1543 
HasLib(const String & rName) const1544 sal_Bool BasicManager::HasLib( const String& rName ) const
1545 {
1546 	DBG_CHKTHIS( BasicManager, 0 );
1547 
1548 	BasicLibInfo* pInf = pLibs->First();
1549 	while ( pInf )
1550 	{
1551 		if ( pInf->GetLibName().CompareIgnoreCaseToAscii( rName ) == COMPARE_EQUAL )
1552 			return sal_True;
1553 
1554 		pInf = pLibs->Next();
1555 	}
1556 	return sal_False;
1557 }
1558 
SetLibName(sal_uInt16 nLib,const String & rName)1559 sal_Bool BasicManager::SetLibName( sal_uInt16 nLib, const String& rName )
1560 {
1561 	DBG_CHKTHIS( BasicManager, 0 );
1562 
1563 	BasicLibInfo* pLibInfo = pLibs->GetObject( nLib );
1564 	DBG_ASSERT( pLibInfo, "Lib?!" );
1565 	if ( pLibInfo )
1566 	{
1567 		pLibInfo->SetLibName( rName );
1568 		if ( pLibInfo->GetLib().Is() )
1569 		{
1570 			StarBASICRef xStdLib = pLibInfo->GetLib();
1571 			xStdLib->SetName( rName );
1572 			xStdLib->SetModified( sal_True );
1573 		}
1574 		bBasMgrModified = sal_True;
1575 		return sal_True;
1576 	}
1577 	return sal_False;
1578 }
1579 
GetLibName(sal_uInt16 nLib)1580 String BasicManager::GetLibName( sal_uInt16 nLib )
1581 {
1582 	DBG_CHKTHIS( BasicManager, 0 );
1583 
1584 	BasicLibInfo* pLibInfo = pLibs->GetObject( nLib );
1585 	DBG_ASSERT( pLibInfo, "Lib?!" );
1586 	if ( pLibInfo )
1587 		return pLibInfo->GetLibName();
1588 	return String();
1589 }
1590 
LoadLib(sal_uInt16 nLib)1591 sal_Bool BasicManager::LoadLib( sal_uInt16 nLib )
1592 {
1593 	DBG_CHKTHIS( BasicManager, 0 );
1594 
1595 	sal_Bool bDone = sal_False;
1596 	BasicLibInfo* pLibInfo = pLibs->GetObject( nLib );
1597 	DBG_ASSERT( pLibInfo, "Lib?!" );
1598 	if ( pLibInfo )
1599 	{
1600         Reference< XLibraryContainer > xLibContainer = pLibInfo->GetLibraryContainer();
1601         if( xLibContainer.is() )
1602         {
1603             String aLibName = pLibInfo->GetLibName();
1604             xLibContainer->loadLibrary( aLibName );
1605             bDone = xLibContainer->isLibraryLoaded( aLibName );;
1606         }
1607         else
1608         {
1609             bDone = ImpLoadLibary( pLibInfo, NULL, sal_False );
1610 		    StarBASIC* pLib = GetLib( nLib );
1611 		    if ( pLib )
1612 		    {
1613     //			pLib->SetParent( GetStdLib() );
1614 			    GetStdLib()->Insert( pLib );
1615 			    pLib->SetFlag( SBX_EXTSEARCH );
1616 		    }
1617         }
1618 	}
1619 	else
1620 	{
1621 //		String aErrorText( BasicResId( IDS_SBERR_LIBLOAD ) );
1622 //		aErrorText.SearchAndReplace( "XX", "" );
1623 		StringErrorInfo* pErrInf = new StringErrorInfo( ERRCODE_BASMGR_LIBLOAD,	String(), ERRCODE_BUTTON_OK );
1624 		pErrorMgr->InsertError( BasicError( *pErrInf, BASERR_REASON_LIBNOTFOUND, String::CreateFromInt32(nLib) ) );
1625 	}
1626 	return bDone;
1627 }
1628 
CreateLib(const String & rLibName)1629 StarBASIC* BasicManager::CreateLib( const String& rLibName )
1630 {
1631 	DBG_CHKTHIS( BasicManager, 0 );
1632 	if ( GetLib( rLibName ) )
1633 		return 0;
1634 
1635 	BasicLibInfo* pLibInfo = CreateLibInfo();
1636 	StarBASIC* pNew = new StarBASIC( GetStdLib(), mbDocMgr );
1637 	GetStdLib()->Insert( pNew );
1638 	pNew->SetFlag( SBX_EXTSEARCH | SBX_DONTSTORE );
1639 	pLibInfo->SetLib( pNew );
1640 	pLibInfo->SetLibName( rLibName );
1641 	pLibInfo->GetLib()->SetName( rLibName );
1642 	return pLibInfo->GetLib();
1643 }
1644 
1645 // For XML import/export:
CreateLib(const String & rLibName,const String & Password,const String & LinkTargetURL)1646 StarBASIC* BasicManager::CreateLib
1647     ( const String& rLibName, const String& Password, const String& LinkTargetURL )
1648 {
1649 	// Ask if lib exists because standard lib is always there
1650 	StarBASIC* pLib = GetLib( rLibName );
1651 	if( !pLib )
1652 	{
1653 	    if( LinkTargetURL.Len() != 0 )
1654 		{
1655 			SotStorageRef xStorage = new SotStorage( sal_False, LinkTargetURL, STREAM_READ | STREAM_SHARE_DENYWRITE );
1656 			if( !xStorage->GetError() )
1657 			{
1658 				pLib = AddLib( *xStorage, rLibName, sal_True );
1659 
1660 				//if( !pLibInfo )
1661 					//pLibInfo = FindLibInfo( pLib );
1662 				//pLibInfo->SetStorageName( LinkTargetURL );
1663 				//pLibInfo->GetLib()->SetModified( sal_False );	// Dann nicht speichern
1664 				//pLibInfo->SetRelStorageName( String() );
1665 				//pLibInfo->IsReference() = sal_True;
1666 			}
1667 			//else
1668 				//Message?
1669 
1670 			DBG_ASSERT( pLib, "XML Import: Linked basic library could not be loaded");
1671 		}
1672 		else
1673 		{
1674 			pLib = CreateLib( rLibName );
1675 			if( Password.Len() != 0 )
1676 			{
1677 				BasicLibInfo* pLibInfo = FindLibInfo( pLib );
1678 				pLibInfo ->SetPassword( Password );
1679 			}
1680 		}
1681 		//ExternalSourceURL ?
1682 	}
1683 	return pLib;
1684 }
1685 
CreateLibForLibContainer(const String & rLibName,const Reference<XLibraryContainer> & xScriptCont)1686 StarBASIC* BasicManager::CreateLibForLibContainer( const String& rLibName,
1687 	const Reference< XLibraryContainer >& xScriptCont )
1688 {
1689 	DBG_CHKTHIS( BasicManager, 0 );
1690 	if ( GetLib( rLibName ) )
1691 		return 0;
1692 
1693 	BasicLibInfo* pLibInfo = CreateLibInfo();
1694 	StarBASIC* pNew = new StarBASIC( GetStdLib(), mbDocMgr );
1695 	GetStdLib()->Insert( pNew );
1696 	pNew->SetFlag( SBX_EXTSEARCH | SBX_DONTSTORE );
1697 	pLibInfo->SetLib( pNew );
1698 	pLibInfo->SetLibName( rLibName );
1699 	pLibInfo->GetLib()->SetName( rLibName );
1700 	pLibInfo->SetLibraryContainer( xScriptCont );
1701 	return pNew;
1702 }
1703 
1704 
FindLibInfo(StarBASIC * pBasic) const1705 BasicLibInfo* BasicManager::FindLibInfo( StarBASIC* pBasic ) const
1706 {
1707 	DBG_CHKTHIS( BasicManager, 0 );
1708 
1709 	BasicLibInfo* pInf = ((BasicManager*)this)->pLibs->First();
1710 	while ( pInf )
1711 	{
1712 		if ( pInf->GetLib() == pBasic )
1713 			return pInf;
1714 
1715 		pInf = ((BasicManager*)this)->pLibs->Next();
1716 	}
1717 	return 0;
1718 }
1719 
1720 
IsModified() const1721 sal_Bool BasicManager::IsModified() const
1722 {
1723 	DBG_CHKTHIS( BasicManager, 0 );
1724 
1725 	if ( bBasMgrModified )
1726 		return sal_True;
1727 	return IsBasicModified();
1728 }
1729 
IsBasicModified() const1730 sal_Bool BasicManager::IsBasicModified() const
1731 {
1732 	DBG_CHKTHIS( BasicManager, 0 );
1733 
1734 	BasicLibInfo* pInf = pLibs->First();
1735 	while ( pInf )
1736 	{
1737 		if ( pInf->GetLib().Is() && pInf->GetLib()->IsModified() )
1738 			return sal_True;
1739 
1740 		pInf = pLibs->Next();
1741 	}
1742 	return sal_False;
1743 }
1744 
SetFlagToAllLibs(short nFlag,sal_Bool bSet) const1745 void BasicManager::SetFlagToAllLibs( short nFlag, sal_Bool bSet ) const
1746 {
1747 	sal_uInt16 nLibs = GetLibCount();
1748 	for ( sal_uInt16 nL = 0; nL < nLibs; nL++ )
1749 	{
1750 		BasicLibInfo* pInfo = pLibs->GetObject( nL );
1751 		DBG_ASSERT( pInfo, "Info?!" );
1752 		StarBASIC* pLib = pInfo->GetLib();
1753 		if ( pLib )
1754 		{
1755 			if ( bSet )
1756 				pLib->SetFlag( nFlag );
1757 			else
1758 				pLib->ResetFlag( nFlag );
1759 		}
1760 	}
1761 }
1762 
HasErrors()1763 sal_Bool BasicManager::HasErrors()
1764 {
1765 	DBG_CHKTHIS( BasicManager, 0 );
1766 	return pErrorMgr->HasErrors();
1767 }
1768 
ClearErrors()1769 void BasicManager::ClearErrors()
1770 {
1771 	DBG_CHKTHIS( BasicManager, 0 );
1772 	pErrorMgr->Reset();
1773 }
1774 
GetFirstError()1775 BasicError* BasicManager::GetFirstError()
1776 {
1777 	DBG_CHKTHIS( BasicManager, 0 );
1778 	return pErrorMgr->GetFirstError();
1779 }
1780 
GetNextError()1781 BasicError* BasicManager::GetNextError()
1782 {
1783 	DBG_CHKTHIS( BasicManager, 0 );
1784 	return pErrorMgr->GetNextError();
1785 }
GetGlobalUNOConstant(const sal_Char * _pAsciiName,::com::sun::star::uno::Any & aOut)1786 bool BasicManager::GetGlobalUNOConstant( const sal_Char* _pAsciiName, ::com::sun::star::uno::Any& aOut )
1787 {
1788     bool bRes = false;
1789     StarBASIC* pStandardLib = GetStdLib();
1790     OSL_PRECOND( pStandardLib, "BasicManager::GetGlobalUNOConstant: no lib to read from!" );
1791     if ( pStandardLib )
1792         bRes = pStandardLib->GetUNOConstant( _pAsciiName, aOut );
1793     return bRes;
1794 }
1795 
SetGlobalUNOConstant(const sal_Char * _pAsciiName,const Any & _rValue)1796 Any BasicManager::SetGlobalUNOConstant( const sal_Char* _pAsciiName, const Any& _rValue )
1797 {
1798     Any aOldValue;
1799 
1800     StarBASIC* pStandardLib = GetStdLib();
1801     OSL_PRECOND( pStandardLib, "BasicManager::SetGlobalUNOConstant: no lib to insert into!" );
1802     if ( !pStandardLib )
1803         return aOldValue;
1804 
1805     ::rtl::OUString sVarName( ::rtl::OUString::createFromAscii( _pAsciiName ) );
1806 
1807     // obtain the old value
1808     SbxVariable* pVariable = pStandardLib->Find( sVarName, SbxCLASS_OBJECT );
1809     if ( pVariable )
1810         aOldValue = sbxToUnoValue( pVariable );
1811 
1812     SbxObjectRef xUnoObj = GetSbUnoObject( sVarName, _rValue );
1813     xUnoObj->SetFlag( SBX_DONTSTORE );
1814     pStandardLib->Insert( xUnoObj );
1815 
1816     return aOldValue;
1817 }
1818 
LegacyPsswdBinaryLimitExceeded(::com::sun::star::uno::Sequence<rtl::OUString> & _out_rModuleNames)1819 bool BasicManager::LegacyPsswdBinaryLimitExceeded( ::com::sun::star::uno::Sequence< rtl::OUString >& _out_rModuleNames )
1820 {
1821     try
1822     {
1823         Reference< XNameAccess > xScripts( GetScriptLibraryContainer(), UNO_QUERY_THROW );
1824         Reference< XLibraryContainerPassword > xPassword( GetScriptLibraryContainer(), UNO_QUERY_THROW );
1825 
1826         Sequence< ::rtl::OUString > aNames( xScripts->getElementNames() );
1827         const ::rtl::OUString* pNames = aNames.getConstArray();
1828         const ::rtl::OUString* pNamesEnd = aNames.getConstArray() + aNames.getLength();
1829         for ( ; pNames != pNamesEnd; ++pNames )
1830         {
1831             if( /*pLib->mbSharedIndexFile ||*/ !xPassword->isLibraryPasswordProtected( *pNames ) )
1832                 continue;
1833 
1834             StarBASIC* pBasicLib = GetLib( *pNames );
1835             if ( !pBasicLib )
1836                 continue;
1837 
1838             Reference< XNameAccess > xScriptLibrary( xScripts->getByName( *pNames ), UNO_QUERY_THROW );
1839             Sequence< ::rtl::OUString > aElementNames( xScriptLibrary->getElementNames() );
1840             sal_Int32 nLen = aElementNames.getLength();
1841 
1842             Sequence< ::rtl::OUString > aBigModules( nLen );
1843             sal_Int32 nBigModules = 0;
1844 
1845             const ::rtl::OUString* pElementNames = aElementNames.getConstArray();
1846             const ::rtl::OUString* pElementNamesEnd = aElementNames.getConstArray() + aElementNames.getLength();
1847             for ( ; pElementNames != pElementNamesEnd; ++pElementNames )
1848             {
1849                 SbModule* pMod = pBasicLib->FindModule( *pElementNames );
1850                 if ( pMod && pMod->ExceedsLegacyModuleSize() )
1851                     aBigModules[ nBigModules++ ] = *pElementNames;
1852             }
1853 
1854             if ( nBigModules )
1855             {
1856                 aBigModules.realloc( nBigModules );
1857                 _out_rModuleNames = aBigModules;
1858                 return true;
1859             }
1860         }
1861     }
1862     catch( const Exception& )
1863     {
1864     	DBG_UNHANDLED_EXCEPTION();
1865     }
1866     return false;
1867 }
1868 
1869 
1870 namespace
1871 {
lcl_queryMacro(BasicManager * i_manager,String const & i_fullyQualifiedName)1872     SbMethod* lcl_queryMacro( BasicManager* i_manager, String const& i_fullyQualifiedName )
1873     {
1874         sal_uInt16 nLast = 0;
1875         String sMacro = i_fullyQualifiedName;
1876         String sLibName = sMacro.GetToken( 0, '.', nLast );
1877         String sModule = sMacro.GetToken( 0, '.', nLast );
1878         sMacro.Erase( 0, nLast );
1879 
1880 	    IntlWrapper aIntlWrapper( ::comphelper::getProcessServiceFactory(), Application::GetSettings().GetLocale() );
1881 	    const CollatorWrapper* pCollator = aIntlWrapper.getCollator();
1882 	    sal_uInt16 nLibCount = i_manager->GetLibCount();
1883 	    for ( sal_uInt16 nLib = 0; nLib < nLibCount; ++nLib )
1884 	    {
1885 		    if ( COMPARE_EQUAL == pCollator->compareString( i_manager->GetLibName( nLib ), sLibName ) )
1886 		    {
1887 			    StarBASIC* pLib = i_manager->GetLib( nLib );
1888 			    if( !pLib )
1889 			    {
1890 				    i_manager->LoadLib( nLib );
1891 				    pLib = i_manager->GetLib( nLib );
1892 			    }
1893 
1894 			    if( pLib )
1895 			    {
1896 				    sal_uInt16 nModCount = pLib->GetModules()->Count();
1897 				    for( sal_uInt16 nMod = 0; nMod < nModCount; ++nMod )
1898 				    {
1899 					    SbModule* pMod = (SbModule*)pLib->GetModules()->Get( nMod );
1900 					    if ( pMod && COMPARE_EQUAL == pCollator->compareString( pMod->GetName(), sModule ) )
1901 					    {
1902 						    SbMethod* pMethod = (SbMethod*)pMod->Find( sMacro, SbxCLASS_METHOD );
1903 						    if( pMethod )
1904 							    return pMethod;
1905 					    }
1906 				    }
1907 			    }
1908 		    }
1909 	    }
1910 	    return 0;
1911     }
1912 }
1913 
HasMacro(String const & i_fullyQualifiedName) const1914 bool BasicManager::HasMacro( String const& i_fullyQualifiedName ) const
1915 {
1916     return ( NULL != lcl_queryMacro( const_cast< BasicManager* >( this ), i_fullyQualifiedName ) );
1917 }
1918 
ExecuteMacro(String const & i_fullyQualifiedName,SbxArray * i_arguments,SbxValue * i_retValue)1919 ErrCode BasicManager::ExecuteMacro( String const& i_fullyQualifiedName, SbxArray* i_arguments, SbxValue* i_retValue )
1920 {
1921     SbMethod* pMethod = lcl_queryMacro( this, i_fullyQualifiedName );
1922     ErrCode nError = 0;
1923     if ( pMethod )
1924     {
1925         if ( i_arguments )
1926             pMethod->SetParameters( i_arguments );
1927         nError = pMethod->Call( i_retValue );
1928     }
1929     else
1930         nError = ERRCODE_BASIC_PROC_UNDEFINED;
1931     return nError;
1932 }
1933 
ExecuteMacro(String const & i_fullyQualifiedName,String const & i_commaSeparatedArgs,SbxValue * i_retValue)1934 ErrCode BasicManager::ExecuteMacro( String const& i_fullyQualifiedName, String const& i_commaSeparatedArgs, SbxValue* i_retValue )
1935 {
1936     SbMethod* pMethod = lcl_queryMacro( this, i_fullyQualifiedName );
1937     if ( !pMethod )
1938         return ERRCODE_BASIC_PROC_UNDEFINED;
1939 
1940     // arguments must be quoted
1941     String sQuotedArgs;
1942     String sArgs( i_commaSeparatedArgs );
1943     if ( sArgs.Len()<2 || sArgs.GetBuffer()[1] == '\"')
1944         // no args or already quoted args
1945         sQuotedArgs = sArgs;
1946     else
1947     {
1948         // quote parameters
1949         sArgs.Erase( 0, 1 );
1950         sArgs.Erase( sArgs.Len()-1, 1 );
1951 
1952         sQuotedArgs = '(';
1953 
1954         sal_uInt16 nCount = sArgs.GetTokenCount(',');
1955         for ( sal_uInt16 n=0; n<nCount; ++n )
1956         {
1957             sQuotedArgs += '\"';
1958             sQuotedArgs += sArgs.GetToken( n, ',' );
1959             sQuotedArgs += '\"';
1960             if ( n<nCount-1 )
1961                 sQuotedArgs += ',';
1962         }
1963 
1964         sQuotedArgs += ')';
1965     }
1966 
1967     // add quoted arguments and do the call
1968     String sCall( '[' );
1969     sCall += pMethod->GetName();
1970     sCall += sQuotedArgs;
1971     sCall += ']';
1972 
1973 	SbxVariable* pRet = pMethod->GetParent()->Execute( sCall );
1974     if ( pRet && ( pRet != pMethod ) )
1975         *i_retValue = *pRet;
1976     return SbxBase::GetError();
1977 }
1978 
1979 //=====================================================================
1980 
1981 class ModuleInfo_Impl : public ModuleInfoHelper
1982 {
1983 	::rtl::OUString maName;
1984 	::rtl::OUString maLanguage;
1985 	::rtl::OUString maSource;
1986 
1987 public:
ModuleInfo_Impl(const::rtl::OUString & aName,const::rtl::OUString & aLanguage,const::rtl::OUString & aSource)1988 	ModuleInfo_Impl( const ::rtl::OUString& aName, const ::rtl::OUString& aLanguage, const ::rtl::OUString& aSource )
1989 		: maName( aName ), maLanguage( aLanguage), maSource( aSource ) {}
1990 
1991     // Methods XStarBasicModuleInfo
getName()1992     virtual ::rtl::OUString SAL_CALL getName() throw(RuntimeException)
1993 		{ return maName; }
getLanguage()1994     virtual ::rtl::OUString SAL_CALL getLanguage() throw(RuntimeException)
1995 		{ return maLanguage; }
getSource()1996     virtual ::rtl::OUString SAL_CALL getSource() throw(RuntimeException)
1997 		{ return maSource; }
1998 };
1999 
2000 
2001 //=====================================================================
2002 
2003 class DialogInfo_Impl : public DialogInfoHelper
2004 {
2005 	::rtl::OUString maName;
2006 	Sequence< sal_Int8 > mData;
2007 
2008 public:
DialogInfo_Impl(const::rtl::OUString & aName,Sequence<sal_Int8> Data)2009 	DialogInfo_Impl( const ::rtl::OUString& aName, Sequence< sal_Int8 > Data )
2010 		: maName( aName ), mData( Data ) {}
2011 
2012     // Methods XStarBasicDialogInfo
getName()2013     virtual ::rtl::OUString SAL_CALL getName() throw(RuntimeException)
2014 		{ return maName; }
getData()2015     virtual Sequence< sal_Int8 > SAL_CALL getData() throw(RuntimeException)
2016 		{ return mData; }
2017 };
2018 
2019 
2020 //=====================================================================
2021 
2022 class LibraryInfo_Impl : public LibraryInfoHelper
2023 {
2024 	::rtl::OUString maName;
2025 	Reference< XNameContainer > mxModuleContainer;
2026 	Reference< XNameContainer > mxDialogContainer;
2027 	::rtl::OUString maPassword;
2028 	::rtl::OUString maExternaleSourceURL;
2029 	::rtl::OUString maLinkTargetURL;
2030 
2031 public:
LibraryInfo_Impl(const::rtl::OUString & aName,Reference<XNameContainer> xModuleContainer,Reference<XNameContainer> xDialogContainer,const::rtl::OUString & aPassword,const::rtl::OUString & aExternaleSourceURL,const::rtl::OUString & aLinkTargetURL)2032 	LibraryInfo_Impl
2033 	(
2034 		const ::rtl::OUString& aName,
2035 		Reference< XNameContainer > xModuleContainer,
2036 		Reference< XNameContainer > xDialogContainer,
2037 		const ::rtl::OUString& aPassword,
2038 		const ::rtl::OUString& aExternaleSourceURL,
2039 		const ::rtl::OUString& aLinkTargetURL
2040 	)
2041 		: maName( aName )
2042 		, mxModuleContainer( xModuleContainer )
2043 		, mxDialogContainer( xDialogContainer )
2044 		, maPassword( aPassword )
2045 		, maExternaleSourceURL( aExternaleSourceURL )
2046 		, maLinkTargetURL( aLinkTargetURL )
2047 	{}
2048 
2049     // Methods XStarBasicLibraryInfo
getName()2050     virtual ::rtl::OUString SAL_CALL getName() throw(RuntimeException)
2051 		{ return maName; }
getModuleContainer()2052     virtual Reference< XNameContainer > SAL_CALL getModuleContainer() throw(RuntimeException)
2053 		{ return mxModuleContainer; }
getDialogContainer()2054     virtual Reference< XNameContainer > SAL_CALL getDialogContainer() throw(RuntimeException)
2055 		{ return mxDialogContainer; }
getPassword()2056     virtual ::rtl::OUString SAL_CALL getPassword() throw(RuntimeException)
2057 		{ return maPassword; }
getExternalSourceURL()2058     virtual ::rtl::OUString SAL_CALL getExternalSourceURL() throw(RuntimeException)
2059 		{ return maExternaleSourceURL; }
getLinkTargetURL()2060     virtual ::rtl::OUString SAL_CALL getLinkTargetURL() throw(RuntimeException)
2061 		{ return maLinkTargetURL; }
2062 };
2063 
2064 //=====================================================================
2065 
2066 class ModuleContainer_Impl : public NameContainerHelper
2067 {
2068 	StarBASIC* mpLib;
2069 
2070 public:
ModuleContainer_Impl(StarBASIC * pLib)2071 	ModuleContainer_Impl( StarBASIC* pLib )
2072 		:mpLib( pLib ) {}
2073 
2074     // Methods XElementAccess
2075     virtual Type SAL_CALL getElementType()
2076 		throw(RuntimeException);
2077     virtual sal_Bool SAL_CALL hasElements()
2078 		throw(RuntimeException);
2079 
2080     // Methods XNameAccess
2081     virtual Any SAL_CALL getByName( const ::rtl::OUString& aName )
2082 		throw(NoSuchElementException, WrappedTargetException, RuntimeException);
2083     virtual Sequence< ::rtl::OUString > SAL_CALL getElementNames()
2084 		throw(RuntimeException);
2085     virtual sal_Bool SAL_CALL hasByName( const ::rtl::OUString& aName )
2086 		throw(RuntimeException);
2087 
2088     // Methods XNameReplace
2089     virtual void SAL_CALL replaceByName( const ::rtl::OUString& aName, const Any& aElement )
2090 		throw(IllegalArgumentException, NoSuchElementException, WrappedTargetException, RuntimeException);
2091 
2092     // Methods XNameContainer
2093     virtual void SAL_CALL insertByName( const ::rtl::OUString& aName, const Any& aElement )
2094 		throw(IllegalArgumentException, ElementExistException, WrappedTargetException, RuntimeException);
2095     virtual void SAL_CALL removeByName( const ::rtl::OUString& Name )
2096 		throw(NoSuchElementException, WrappedTargetException, RuntimeException);
2097 };
2098 
2099 // Methods XElementAccess
getElementType()2100 Type ModuleContainer_Impl::getElementType()
2101 	throw(RuntimeException)
2102 {
2103 	Type aModuleType = ::getCppuType( (const Reference< XStarBasicModuleInfo > *)0 );
2104 	return aModuleType;
2105 }
2106 
hasElements()2107 sal_Bool ModuleContainer_Impl::hasElements()
2108 	throw(RuntimeException)
2109 {
2110     SbxArray* pMods = mpLib ? mpLib->GetModules() : NULL;
2111     return pMods && pMods->Count() > 0;
2112 }
2113 
2114 // Methods XNameAccess
getByName(const::rtl::OUString & aName)2115 Any ModuleContainer_Impl::getByName( const ::rtl::OUString& aName )
2116 	throw(NoSuchElementException, WrappedTargetException, RuntimeException)
2117 {
2118     SbModule* pMod = mpLib ? mpLib->FindModule( aName ) : NULL;
2119 	if( !pMod )
2120 		throw NoSuchElementException();
2121 	Reference< XStarBasicModuleInfo > xMod = (XStarBasicModuleInfo*)new ModuleInfo_Impl
2122 		( aName, ::rtl::OUString::createFromAscii( szScriptLanguage ), pMod->GetSource32() );
2123 	Any aRetAny;
2124 	aRetAny <<= xMod;
2125 	return aRetAny;
2126 }
2127 
getElementNames()2128 Sequence< ::rtl::OUString > ModuleContainer_Impl::getElementNames()
2129 	throw(RuntimeException)
2130 {
2131     SbxArray* pMods = mpLib ? mpLib->GetModules() : NULL;
2132     sal_uInt16 nMods = pMods ? pMods->Count() : 0;
2133 	Sequence< ::rtl::OUString > aRetSeq( nMods );
2134 	::rtl::OUString* pRetSeq = aRetSeq.getArray();
2135 	for( sal_uInt16 i = 0 ; i < nMods ; i++ )
2136 	{
2137 		SbxVariable* pMod = pMods->Get( i );
2138 		pRetSeq[i] = ::rtl::OUString( pMod->GetName() );
2139 	}
2140 	return aRetSeq;
2141 }
2142 
hasByName(const::rtl::OUString & aName)2143 sal_Bool ModuleContainer_Impl::hasByName( const ::rtl::OUString& aName )
2144 	throw(RuntimeException)
2145 {
2146     SbModule* pMod = mpLib ? mpLib->FindModule( aName ) : NULL;
2147 	sal_Bool bRet = (pMod != NULL);
2148 	return bRet;
2149 }
2150 
2151 
2152 // Methods XNameReplace
replaceByName(const::rtl::OUString & aName,const Any & aElement)2153 void ModuleContainer_Impl::replaceByName( const ::rtl::OUString& aName, const Any& aElement )
2154 	throw(IllegalArgumentException, NoSuchElementException, WrappedTargetException, RuntimeException)
2155 {
2156 	removeByName( aName );
2157 	insertByName( aName, aElement );
2158 }
2159 
2160 
2161 // Methods XNameContainer
insertByName(const::rtl::OUString & aName,const Any & aElement)2162 void ModuleContainer_Impl::insertByName( const ::rtl::OUString& aName, const Any& aElement )
2163 	throw(IllegalArgumentException, ElementExistException, WrappedTargetException, RuntimeException)
2164 {
2165 	Type aModuleType = ::getCppuType( (const Reference< XStarBasicModuleInfo > *)0 );
2166 	Type aAnyType = aElement.getValueType();
2167 	if( aModuleType != aAnyType )
2168 		throw IllegalArgumentException();
2169 	Reference< XStarBasicModuleInfo > xMod;
2170 	aElement >>= xMod;
2171 	mpLib->MakeModule32( aName, xMod->getSource() );
2172 }
2173 
removeByName(const::rtl::OUString & Name)2174 void ModuleContainer_Impl::removeByName( const ::rtl::OUString& Name )
2175 	throw(NoSuchElementException, WrappedTargetException, RuntimeException)
2176 {
2177 	SbModule* pMod = mpLib ? mpLib->FindModule( Name ) : NULL;
2178 	if( !pMod )
2179 		throw NoSuchElementException();
2180 	mpLib->Remove( pMod );
2181 }
2182 
2183 
2184 //=====================================================================
2185 
implGetDialogData(SbxObject * pDialog)2186 Sequence< sal_Int8 > implGetDialogData( SbxObject* pDialog )
2187 {
2188 	SvMemoryStream aMemStream;
2189 	pDialog->Store( aMemStream );
2190 	sal_Int32 nLen = aMemStream.Tell();
2191 	Sequence< sal_Int8 > aData( nLen );
2192 	sal_Int8* pDestData = aData.getArray();
2193 	const sal_Int8* pSrcData = (const sal_Int8*)aMemStream.GetData();
2194 	rtl_copyMemory( pDestData, pSrcData, nLen );
2195 	return aData;
2196 }
2197 
implCreateDialog(Sequence<sal_Int8> aData)2198 SbxObject* implCreateDialog( Sequence< sal_Int8 > aData )
2199 {
2200 	sal_Int8* pData = aData.getArray();
2201 	SvMemoryStream aMemStream( pData, aData.getLength(), STREAM_READ );
2202 	SbxObject* pDialog = (SbxObject*)SbxBase::Load( aMemStream );
2203 	return pDialog;
2204 }
2205 
2206 // HACK! Because this value is defined in basctl/inc/vcsbxdef.hxx
2207 // which we can't include here, we have to use the value directly
2208 #define SBXID_DIALOG		101
2209 
2210 
2211 class DialogContainer_Impl : public NameContainerHelper
2212 {
2213 	StarBASIC* mpLib;
2214 
2215 public:
DialogContainer_Impl(StarBASIC * pLib)2216 	DialogContainer_Impl( StarBASIC* pLib )
2217 		:mpLib( pLib ) {}
2218 
2219     // Methods XElementAccess
2220     virtual Type SAL_CALL getElementType()
2221 		throw(RuntimeException);
2222     virtual sal_Bool SAL_CALL hasElements()
2223 		throw(RuntimeException);
2224 
2225     // Methods XNameAccess
2226     virtual Any SAL_CALL getByName( const ::rtl::OUString& aName )
2227 		throw(NoSuchElementException, WrappedTargetException, RuntimeException);
2228     virtual Sequence< ::rtl::OUString > SAL_CALL getElementNames()
2229 		throw(RuntimeException);
2230     virtual sal_Bool SAL_CALL hasByName( const ::rtl::OUString& aName )
2231 		throw(RuntimeException);
2232 
2233     // Methods XNameReplace
2234     virtual void SAL_CALL replaceByName( const ::rtl::OUString& aName, const Any& aElement )
2235 		throw(IllegalArgumentException, NoSuchElementException, WrappedTargetException, RuntimeException);
2236 
2237     // Methods XNameContainer
2238     virtual void SAL_CALL insertByName( const ::rtl::OUString& aName, const Any& aElement )
2239 		throw(IllegalArgumentException, ElementExistException, WrappedTargetException, RuntimeException);
2240     virtual void SAL_CALL removeByName( const ::rtl::OUString& Name )
2241 		throw(NoSuchElementException, WrappedTargetException, RuntimeException);
2242 };
2243 
2244 // Methods XElementAccess
getElementType()2245 Type DialogContainer_Impl::getElementType()
2246 	throw(RuntimeException)
2247 {
2248 	Type aModuleType = ::getCppuType( (const Reference< XStarBasicDialogInfo > *)0 );
2249 	return aModuleType;
2250 }
2251 
hasElements()2252 sal_Bool DialogContainer_Impl::hasElements()
2253 	throw(RuntimeException)
2254 {
2255 	sal_Bool bRet = sal_False;
2256 
2257 	mpLib->GetAll( SbxCLASS_OBJECT );
2258 	sal_Int16 nCount = mpLib->GetObjects()->Count();
2259 	for( sal_Int16 nObj = 0; nObj < nCount ; nObj++ )
2260 	{
2261 		SbxVariable* pVar = mpLib->GetObjects()->Get( nObj );
2262 		if ( pVar->ISA( SbxObject ) && ( ((SbxObject*)pVar)->GetSbxId() == SBXID_DIALOG ) )
2263 		{
2264 			bRet = sal_True;
2265 			break;
2266 		}
2267 	}
2268 	return bRet;
2269 }
2270 
2271 // Methods XNameAccess
getByName(const::rtl::OUString & aName)2272 Any DialogContainer_Impl::getByName( const ::rtl::OUString& aName )
2273 	throw(NoSuchElementException, WrappedTargetException, RuntimeException)
2274 {
2275 	SbxVariable* pVar = mpLib->GetObjects()->Find( aName, SbxCLASS_DONTCARE );
2276 	if( !( pVar && pVar->ISA( SbxObject ) &&
2277 		   ( ((SbxObject*)pVar)->GetSbxId() == SBXID_DIALOG ) ) )
2278 	{
2279 		throw NoSuchElementException();
2280 	}
2281 
2282 	Reference< XStarBasicDialogInfo > xDialog =
2283 		(XStarBasicDialogInfo*)new DialogInfo_Impl
2284 			( aName, implGetDialogData( (SbxObject*)pVar ) );
2285 
2286 	Any aRetAny;
2287 	aRetAny <<= xDialog;
2288 	return aRetAny;
2289 }
2290 
getElementNames()2291 Sequence< ::rtl::OUString > DialogContainer_Impl::getElementNames()
2292 	throw(RuntimeException)
2293 {
2294 	mpLib->GetAll( SbxCLASS_OBJECT );
2295 	sal_Int16 nCount = mpLib->GetObjects()->Count();
2296 	Sequence< ::rtl::OUString > aRetSeq( nCount );
2297 	::rtl::OUString* pRetSeq = aRetSeq.getArray();
2298 	sal_Int32 nDialogCounter = 0;
2299 
2300 	for( sal_Int16 nObj = 0; nObj < nCount ; nObj++ )
2301 	{
2302 		SbxVariable* pVar = mpLib->GetObjects()->Get( nObj );
2303 		if ( pVar->ISA( SbxObject ) && ( ((SbxObject*)pVar)->GetSbxId() == SBXID_DIALOG ) )
2304 		{
2305 			pRetSeq[ nDialogCounter ] = ::rtl::OUString( pVar->GetName() );
2306 			nDialogCounter++;
2307 		}
2308 	}
2309 	aRetSeq.realloc( nDialogCounter );
2310 	return aRetSeq;
2311 }
2312 
hasByName(const::rtl::OUString & aName)2313 sal_Bool DialogContainer_Impl::hasByName( const ::rtl::OUString& aName )
2314 	throw(RuntimeException)
2315 {
2316 	sal_Bool bRet = sal_False;
2317 	SbxVariable* pVar = mpLib->GetObjects()->Find( aName, SbxCLASS_DONTCARE );
2318 	if( pVar && pVar->ISA( SbxObject ) &&
2319 		   ( ((SbxObject*)pVar)->GetSbxId() == SBXID_DIALOG ) )
2320 	{
2321 		bRet = sal_True;
2322 	}
2323 	return bRet;
2324 }
2325 
2326 
2327 // Methods XNameReplace
replaceByName(const::rtl::OUString & aName,const Any & aElement)2328 void DialogContainer_Impl::replaceByName( const ::rtl::OUString& aName, const Any& aElement )
2329 	throw(IllegalArgumentException, NoSuchElementException, WrappedTargetException, RuntimeException)
2330 {
2331 	removeByName( aName );
2332 	insertByName( aName, aElement );
2333 }
2334 
2335 
2336 // Methods XNameContainer
insertByName(const::rtl::OUString & aName,const Any & aElement)2337 void DialogContainer_Impl::insertByName( const ::rtl::OUString& aName, const Any& aElement )
2338 	throw(IllegalArgumentException, ElementExistException, WrappedTargetException, RuntimeException)
2339 {
2340 	(void)aName;
2341 	Type aModuleType = ::getCppuType( (const Reference< XStarBasicDialogInfo > *)0 );
2342 	Type aAnyType = aElement.getValueType();
2343 	if( aModuleType != aAnyType )
2344 		throw IllegalArgumentException();
2345 	Reference< XStarBasicDialogInfo > xMod;
2346 	aElement >>= xMod;
2347 	SbxObjectRef xDialog = implCreateDialog( xMod->getData() );
2348 	mpLib->Insert( xDialog );
2349 }
2350 
removeByName(const::rtl::OUString & Name)2351 void DialogContainer_Impl::removeByName( const ::rtl::OUString& Name )
2352 	throw(NoSuchElementException, WrappedTargetException, RuntimeException)
2353 {
2354 	(void)Name;
2355 	SbxVariable* pVar = mpLib->GetObjects()->Find( Name, SbxCLASS_DONTCARE );
2356 	if( !( pVar && pVar->ISA( SbxObject ) &&
2357 		   ( ((SbxObject*)pVar)->GetSbxId() == SBXID_DIALOG ) ) )
2358 	{
2359 		throw NoSuchElementException();
2360 	}
2361 	mpLib->Remove( pVar );
2362 }
2363 
2364 
2365 //=====================================================================
2366 
2367 
2368 class LibraryContainer_Impl : public NameContainerHelper
2369 {
2370 	BasicManager* mpMgr;
2371 
2372 public:
LibraryContainer_Impl(BasicManager * pMgr)2373 	LibraryContainer_Impl( BasicManager* pMgr )
2374 		:mpMgr( pMgr ) {}
2375 
2376     // Methods XElementAccess
2377     virtual Type SAL_CALL getElementType()
2378 		throw(RuntimeException);
2379     virtual sal_Bool SAL_CALL hasElements()
2380 		throw(RuntimeException);
2381 
2382     // Methods XNameAccess
2383     virtual Any SAL_CALL getByName( const ::rtl::OUString& aName )
2384 		throw(NoSuchElementException, WrappedTargetException, RuntimeException);
2385     virtual Sequence< ::rtl::OUString > SAL_CALL getElementNames()
2386 		throw(RuntimeException);
2387     virtual sal_Bool SAL_CALL hasByName( const ::rtl::OUString& aName )
2388 		throw(RuntimeException);
2389 
2390     // Methods XNameReplace
2391     virtual void SAL_CALL replaceByName( const ::rtl::OUString& aName, const Any& aElement )
2392 		throw(IllegalArgumentException, NoSuchElementException, WrappedTargetException, RuntimeException);
2393 
2394     // Methods XNameContainer
2395     virtual void SAL_CALL insertByName( const ::rtl::OUString& aName, const Any& aElement )
2396 		throw(IllegalArgumentException, ElementExistException, WrappedTargetException, RuntimeException);
2397     virtual void SAL_CALL removeByName( const ::rtl::OUString& Name )
2398 		throw(NoSuchElementException, WrappedTargetException, RuntimeException);
2399 };
2400 
2401 
2402 // Methods XElementAccess
getElementType()2403 Type LibraryContainer_Impl::getElementType()
2404 	throw(RuntimeException)
2405 {
2406 	Type aType = ::getCppuType( (const Reference< XStarBasicLibraryInfo > *)0 );
2407 	return aType;
2408 }
2409 
hasElements()2410 sal_Bool LibraryContainer_Impl::hasElements()
2411 	throw(RuntimeException)
2412 {
2413 	sal_Int32 nLibs = mpMgr->GetLibCount();
2414 	sal_Bool bRet = (nLibs > 0);
2415 	return bRet;
2416 }
2417 
2418 // Methods XNameAccess
getByName(const::rtl::OUString & aName)2419 Any LibraryContainer_Impl::getByName( const ::rtl::OUString& aName )
2420 	throw(NoSuchElementException, WrappedTargetException, RuntimeException)
2421 {
2422 	Any aRetAny;
2423 	if( !mpMgr->HasLib( aName ) )
2424 		throw NoSuchElementException();
2425 	StarBASIC* pLib = mpMgr->GetLib( aName );
2426 
2427 	Reference< XNameContainer > xModuleContainer =
2428 		(XNameContainer*)new ModuleContainer_Impl( pLib );
2429 
2430 	Reference< XNameContainer > xDialogContainer;
2431 		(XNameContainer*)new DialogContainer_Impl( pLib );
2432 
2433 	BasicLibInfo* pLibInfo = mpMgr->FindLibInfo( pLib );
2434 
2435 	::rtl::OUString aPassword = pLibInfo->GetPassword();
2436 
2437 	// TODO Only provide external info!
2438 	::rtl::OUString aExternaleSourceURL;
2439 	::rtl::OUString aLinkTargetURL;
2440 	if( pLibInfo->IsReference() )
2441 		aLinkTargetURL = pLibInfo->GetStorageName();
2442 	else if( pLibInfo->IsExtern() )
2443 		aExternaleSourceURL = pLibInfo->GetStorageName();
2444 
2445 	Reference< XStarBasicLibraryInfo > xLibInfo = new LibraryInfo_Impl
2446 	(
2447 		aName,
2448 		xModuleContainer,
2449 		xDialogContainer,
2450 		aPassword,
2451 		aExternaleSourceURL,
2452 		aLinkTargetURL
2453 	);
2454 
2455 	aRetAny <<= xLibInfo;
2456 	return aRetAny;
2457 }
2458 
getElementNames()2459 Sequence< ::rtl::OUString > LibraryContainer_Impl::getElementNames()
2460 	throw(RuntimeException)
2461 {
2462 	sal_uInt16 nLibs = mpMgr->GetLibCount();
2463 	Sequence< ::rtl::OUString > aRetSeq( nLibs );
2464 	::rtl::OUString* pRetSeq = aRetSeq.getArray();
2465 	for( sal_uInt16 i = 0 ; i < nLibs ; i++ )
2466 	{
2467 		pRetSeq[i] = ::rtl::OUString( mpMgr->GetLibName( i ) );
2468 	}
2469 	return aRetSeq;
2470 }
2471 
hasByName(const::rtl::OUString & aName)2472 sal_Bool LibraryContainer_Impl::hasByName( const ::rtl::OUString& aName )
2473 	throw(RuntimeException)
2474 {
2475 	sal_Bool bRet = mpMgr->HasLib( aName );
2476 	return bRet;
2477 }
2478 
2479 // Methods XNameReplace
replaceByName(const::rtl::OUString & aName,const Any & aElement)2480 void LibraryContainer_Impl::replaceByName( const ::rtl::OUString& aName, const Any& aElement )
2481 	throw(IllegalArgumentException, NoSuchElementException, WrappedTargetException, RuntimeException)
2482 {
2483 	removeByName( aName );
2484 	insertByName( aName, aElement );
2485 }
2486 
2487 // Methods XNameContainer
insertByName(const::rtl::OUString & aName,const Any & aElement)2488 void LibraryContainer_Impl::insertByName( const ::rtl::OUString& aName, const Any& aElement )
2489 	throw(IllegalArgumentException, ElementExistException, WrappedTargetException, RuntimeException)
2490 {
2491 	(void)aName;
2492 	(void)aElement;
2493 	// TODO: Insert a complete Library?!
2494 }
2495 
removeByName(const::rtl::OUString & Name)2496 void LibraryContainer_Impl::removeByName( const ::rtl::OUString& Name )
2497 	throw(NoSuchElementException, WrappedTargetException, RuntimeException)
2498 {
2499 	StarBASIC* pLib = mpMgr->GetLib( Name );
2500 	if( !pLib )
2501 		throw NoSuchElementException();
2502 	sal_uInt16 nLibId = mpMgr->GetLibId( Name );
2503 	mpMgr->RemoveLib( nLibId );
2504 }
2505 
2506 //=====================================================================
2507 
2508 typedef WeakImplHelper1< XStarBasicAccess > StarBasicAccessHelper;
2509 
2510 
2511 class StarBasicAccess_Impl : public StarBasicAccessHelper
2512 {
2513 	BasicManager* mpMgr;
2514 	Reference< XNameContainer > mxLibContainer;
2515 
2516 public:
StarBasicAccess_Impl(BasicManager * pMgr)2517 	StarBasicAccess_Impl( BasicManager* pMgr )
2518 		:mpMgr( pMgr ) {}
2519 
2520 public:
2521 
2522     // Methods
2523     virtual Reference< XNameContainer > SAL_CALL getLibraryContainer()
2524 		throw(RuntimeException);
2525     virtual void SAL_CALL createLibrary( const ::rtl::OUString& LibName, const ::rtl::OUString& Password,
2526 		const ::rtl::OUString& ExternalSourceURL, const ::rtl::OUString& LinkTargetURL )
2527 			throw(ElementExistException, RuntimeException);
2528     virtual void SAL_CALL addModule( const ::rtl::OUString& LibraryName, const ::rtl::OUString& ModuleName,
2529 		const ::rtl::OUString& Language, const ::rtl::OUString& Source )
2530 			throw(NoSuchElementException, RuntimeException);
2531     virtual void SAL_CALL addDialog( const ::rtl::OUString& LibraryName, const ::rtl::OUString& DialogName,
2532 		const Sequence< sal_Int8 >& Data )
2533 			throw(NoSuchElementException, RuntimeException);
2534 
2535 };
2536 
getLibraryContainer()2537 Reference< XNameContainer > SAL_CALL StarBasicAccess_Impl::getLibraryContainer()
2538 	throw(RuntimeException)
2539 {
2540 	if( !mxLibContainer.is() )
2541 		mxLibContainer = (XNameContainer*)new LibraryContainer_Impl( mpMgr );
2542 	return mxLibContainer;
2543 }
2544 
createLibrary(const::rtl::OUString & LibName,const::rtl::OUString & Password,const::rtl::OUString & ExternalSourceURL,const::rtl::OUString & LinkTargetURL)2545 void SAL_CALL StarBasicAccess_Impl::createLibrary
2546 (
2547 	const ::rtl::OUString& LibName,
2548 	const ::rtl::OUString& Password,
2549 	const ::rtl::OUString& ExternalSourceURL,
2550 	const ::rtl::OUString& LinkTargetURL
2551 )
2552 	throw(ElementExistException, RuntimeException)
2553 {
2554 	(void)ExternalSourceURL;
2555 #ifdef DBG_UTIL
2556 	StarBASIC* pLib =
2557 #endif
2558 	mpMgr->CreateLib( LibName, Password, LinkTargetURL );
2559 	DBG_ASSERT( pLib, "XML Import: Basic library could not be created");
2560 }
2561 
addModule(const::rtl::OUString & LibraryName,const::rtl::OUString & ModuleName,const::rtl::OUString & Language,const::rtl::OUString & Source)2562 void SAL_CALL StarBasicAccess_Impl::addModule
2563 (
2564 	const ::rtl::OUString& LibraryName,
2565 	const ::rtl::OUString& ModuleName,
2566 	const ::rtl::OUString& Language,
2567 	const ::rtl::OUString& Source
2568 )
2569 	throw(NoSuchElementException, RuntimeException)
2570 {
2571 	(void)Language;
2572 	StarBASIC* pLib = mpMgr->GetLib( LibraryName );
2573 	DBG_ASSERT( pLib, "XML Import: Lib for module unknown");
2574 	if( pLib )
2575 		pLib->MakeModule32( ModuleName, Source );
2576 }
2577 
addDialog(const::rtl::OUString & LibraryName,const::rtl::OUString & DialogName,const Sequence<sal_Int8> & Data)2578 void SAL_CALL StarBasicAccess_Impl::addDialog
2579 (
2580 	const ::rtl::OUString& LibraryName,
2581 	const ::rtl::OUString& DialogName,
2582 	const Sequence< sal_Int8 >& Data
2583 )
2584 	throw(NoSuchElementException, RuntimeException)
2585 {
2586 	(void)LibraryName;
2587 	(void)DialogName;
2588 	(void)Data;
2589 }
2590 
2591 // Basic XML Import/Export
getStarBasicAccess(BasicManager * pMgr)2592 Reference< XStarBasicAccess > getStarBasicAccess( BasicManager* pMgr )
2593 {
2594 	Reference< XStarBasicAccess > xRet =
2595 		new StarBasicAccess_Impl( (BasicManager*)pMgr );
2596 	return xRet;
2597 }
2598 
2599