Line data Source code
1 : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : /*
3 : * This file is part of the LibreOffice project.
4 : *
5 : * This Source Code Form is subject to the terms of the Mozilla Public
6 : * License, v. 2.0. If a copy of the MPL was not distributed with this
7 : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 : *
9 : * This file incorporates work covered by the following license notice:
10 : *
11 : * Licensed to the Apache Software Foundation (ASF) under one or more
12 : * contributor license agreements. See the NOTICE file distributed
13 : * with this work for additional information regarding copyright
14 : * ownership. The ASF licenses this file to you under the Apache
15 : * License, Version 2.0 (the "License"); you may not use this file
16 : * except in compliance with the License. You may obtain a copy of
17 : * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 : */
19 :
20 :
21 : #include <stdio.h>
22 :
23 : #include "sb.hxx"
24 : #include <tools/rcid.h>
25 : #include <tools/stream.hxx>
26 : #include <tools/errinf.hxx>
27 : #include <basic/sbx.hxx>
28 : #include <tools/shl.hxx>
29 : #include <tools/rc.hxx>
30 : #include <vcl/svapp.hxx>
31 : #include <comphelper/processfactory.hxx>
32 : #include "image.hxx"
33 : #include "sbunoobj.hxx"
34 : #include "sbjsmeth.hxx"
35 : #include "sbjsmod.hxx"
36 : #include "sbintern.hxx"
37 : #include "runtime.hxx"
38 : #include <basic/sbuno.hxx>
39 : #include <basic/sbobjmod.hxx>
40 : #include "stdobj.hxx"
41 : #include "filefmt.hxx"
42 : #include "sb.hrc"
43 : #include <basrid.hxx>
44 : #include <osl/mutex.hxx>
45 : #include <cppuhelper/implbase1.hxx>
46 : #include <com/sun/star/lang/XMultiServiceFactory.hpp>
47 : #include <com/sun/star/util/XCloseBroadcaster.hpp>
48 : #include <com/sun/star/util/XCloseListener.hpp>
49 : #include "errobject.hxx"
50 : #include <boost/unordered_map.hpp>
51 :
52 : #include <com/sun/star/script/ModuleType.hpp>
53 : #include <com/sun/star/script/ModuleInfo.hpp>
54 : using namespace ::com::sun::star::script;
55 :
56 10240 : TYPEINIT1(StarBASIC,SbxObject)
57 :
58 : #define RTLNAME "@SBRTL"
59 : // i#i68894#
60 : using namespace ::com::sun::star;
61 : using com::sun::star::uno::Reference;
62 : using com::sun::star::uno::Any;
63 : using com::sun::star::uno::UNO_QUERY;
64 : using com::sun::star::lang::XMultiServiceFactory;
65 :
66 : // ============================================================================
67 :
68 : class DocBasicItem : public ::cppu::WeakImplHelper1< util::XCloseListener >
69 : {
70 : public:
71 : explicit DocBasicItem( StarBASIC& rDocBasic );
72 : virtual ~DocBasicItem();
73 :
74 0 : inline const SbxObjectRef& getClassModules() const { return mxClassModules; }
75 0 : inline bool isDocClosed() const { return mbDocClosed; }
76 :
77 : void clearDependingVarsOnDelete( StarBASIC& rDeletedBasic );
78 :
79 : void startListening();
80 : void stopListening();
81 :
82 : virtual void SAL_CALL queryClosing( const lang::EventObject& rSource, sal_Bool bGetsOwnership ) throw (util::CloseVetoException, uno::RuntimeException);
83 : virtual void SAL_CALL notifyClosing( const lang::EventObject& rSource ) throw (uno::RuntimeException);
84 : virtual void SAL_CALL disposing( const lang::EventObject& rSource ) throw (uno::RuntimeException);
85 :
86 : private:
87 : StarBASIC& mrDocBasic;
88 : SbxObjectRef mxClassModules;
89 : bool mbDocClosed;
90 : bool mbDisposed;
91 : };
92 :
93 : // ----------------------------------------------------------------------------
94 :
95 246 : DocBasicItem::DocBasicItem( StarBASIC& rDocBasic ) :
96 : mrDocBasic( rDocBasic ),
97 246 : mxClassModules( new SbxObject( OUString() ) ),
98 : mbDocClosed( false ),
99 492 : mbDisposed( false )
100 : {
101 246 : }
102 :
103 318 : DocBasicItem::~DocBasicItem()
104 : {
105 106 : stopListening();
106 212 : }
107 :
108 3020 : void DocBasicItem::clearDependingVarsOnDelete( StarBASIC& rDeletedBasic )
109 : {
110 3020 : mrDocBasic.implClearDependingVarsOnDelete( &rDeletedBasic );
111 3020 : }
112 :
113 246 : void DocBasicItem::startListening()
114 : {
115 246 : Any aThisComp;
116 246 : mrDocBasic.GetUNOConstant( "ThisComponent", aThisComp );
117 246 : Reference< util::XCloseBroadcaster > xCloseBC( aThisComp, UNO_QUERY );
118 246 : mbDisposed = !xCloseBC.is();
119 246 : if( xCloseBC.is() )
120 : {
121 142 : try { xCloseBC->addCloseListener( this ); } catch(const uno::Exception& ) {}
122 246 : }
123 246 : }
124 :
125 242 : void DocBasicItem::stopListening()
126 : {
127 484 : if( mbDisposed ) return;
128 94 : mbDisposed = true;
129 94 : Any aThisComp;
130 94 : mrDocBasic.GetUNOConstant( "ThisComponent", aThisComp );
131 94 : Reference< util::XCloseBroadcaster > xCloseBC( aThisComp, UNO_QUERY );
132 94 : if( xCloseBC.is() )
133 : {
134 94 : try { xCloseBC->removeCloseListener( this ); } catch(const uno::Exception& ) {}
135 94 : }
136 : }
137 :
138 2 : void SAL_CALL DocBasicItem::queryClosing( const lang::EventObject& /*rSource*/, sal_Bool /*bGetsOwnership*/ ) throw (util::CloseVetoException, uno::RuntimeException)
139 : {
140 2 : }
141 :
142 2 : void SAL_CALL DocBasicItem::notifyClosing( const lang::EventObject& /*rEvent*/ ) throw (uno::RuntimeException)
143 : {
144 2 : stopListening();
145 2 : mbDocClosed = true;
146 2 : }
147 :
148 0 : void SAL_CALL DocBasicItem::disposing( const lang::EventObject& /*rEvent*/ ) throw (uno::RuntimeException)
149 : {
150 0 : stopListening();
151 0 : }
152 :
153 : // ----------------------------------------------------------------------------
154 :
155 : namespace {
156 :
157 : typedef ::rtl::Reference< DocBasicItem > DocBasicItemRef;
158 : typedef boost::unordered_map< const StarBASIC *, DocBasicItemRef > DocBasicItemMap;
159 :
160 : class GaDocBasicItems : public rtl::Static<DocBasicItemMap,GaDocBasicItems> {};
161 :
162 0 : const DocBasicItem* lclFindDocBasicItem( const StarBASIC* pDocBasic )
163 : {
164 0 : DocBasicItemMap::iterator it = GaDocBasicItems::get().find( pDocBasic );
165 0 : DocBasicItemMap::iterator end = GaDocBasicItems::get().end();
166 0 : return (it != end) ? it->second.get() : 0;
167 : }
168 :
169 246 : void lclInsertDocBasicItem( StarBASIC& rDocBasic )
170 : {
171 246 : DocBasicItemRef& rxDocBasicItem = GaDocBasicItems::get()[ &rDocBasic ];
172 246 : rxDocBasicItem.set( new DocBasicItem( rDocBasic ) );
173 246 : rxDocBasicItem->startListening();
174 246 : }
175 :
176 134 : void lclRemoveDocBasicItem( StarBASIC& rDocBasic )
177 : {
178 134 : DocBasicItemMap::iterator it = GaDocBasicItems::get().find( &rDocBasic );
179 134 : if( it != GaDocBasicItems::get().end() )
180 : {
181 134 : it->second->stopListening();
182 134 : GaDocBasicItems::get().erase( it );
183 : }
184 134 : DocBasicItemMap::iterator it_end = GaDocBasicItems::get().end();
185 3154 : for( it = GaDocBasicItems::get().begin(); it != it_end; ++it )
186 : {
187 3020 : it->second->clearDependingVarsOnDelete( rDocBasic );
188 : }
189 134 : }
190 :
191 6 : StarBASIC* lclGetDocBasicForModule( SbModule* pModule )
192 : {
193 6 : StarBASIC* pRetBasic = NULL;
194 6 : SbxObject* pCurParent = pModule;
195 18 : while( pCurParent->GetParent() != NULL )
196 : {
197 6 : pCurParent = pCurParent->GetParent();
198 6 : StarBASIC* pDocBasic = PTR_CAST( StarBASIC, pCurParent );
199 6 : if( pDocBasic != NULL && pDocBasic->IsDocBasic() )
200 : {
201 0 : pRetBasic = pDocBasic;
202 0 : break;
203 : }
204 : }
205 6 : return pRetBasic;
206 : }
207 :
208 : } // namespace
209 :
210 : // ============================================================================
211 :
212 0 : SbxObject* StarBASIC::getVBAGlobals( )
213 : {
214 0 : if ( !pVBAGlobals )
215 : {
216 0 : Any aThisDoc;
217 0 : if ( GetUNOConstant("ThisComponent", aThisDoc) )
218 : {
219 0 : Reference< XMultiServiceFactory > xDocFac( aThisDoc, UNO_QUERY );
220 0 : if ( xDocFac.is() )
221 : {
222 : try
223 : {
224 0 : xDocFac->createInstance( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "ooo.vba.VBAGlobals" ) ) );
225 : }
226 0 : catch(const Exception& )
227 : {
228 : // Ignore
229 : }
230 0 : }
231 : }
232 0 : const OUString aVBAHook("VBAGlobals");
233 0 : pVBAGlobals = (SbUnoObject*)Find( aVBAHook , SbxCLASS_DONTCARE );
234 : }
235 0 : return pVBAGlobals;
236 : }
237 :
238 : // i#i68894#
239 0 : SbxVariable* StarBASIC::VBAFind( const rtl::OUString& rName, SbxClassType t )
240 : {
241 0 : if( rName == "ThisComponent" )
242 : {
243 0 : return NULL;
244 : }
245 : // rename to init globals
246 0 : if ( getVBAGlobals( ) )
247 : {
248 0 : return pVBAGlobals->Find( rName, t );
249 : }
250 0 : return NULL;
251 : }
252 :
253 : // Create array for conversion SFX <-> VB error code
254 : struct SFX_VB_ErrorItem
255 : {
256 : sal_uInt16 nErrorVB;
257 : SbError nErrorSFX;
258 : };
259 :
260 : const SFX_VB_ErrorItem SFX_VB_ErrorTab[] =
261 : {
262 : { 1, SbERR_BASIC_EXCEPTION }, // #87844 Map exception to error code 1
263 : { 2, SbERR_SYNTAX },
264 : { 3, SbERR_NO_GOSUB },
265 : { 4, SbERR_REDO_FROM_START },
266 : { 5, SbERR_BAD_ARGUMENT },
267 : { 6, SbERR_MATH_OVERFLOW },
268 : { 7, SbERR_NO_MEMORY },
269 : { 8, SbERR_ALREADY_DIM },
270 : { 9, SbERR_OUT_OF_RANGE },
271 : { 10, SbERR_DUPLICATE_DEF },
272 : { 11, SbERR_ZERODIV },
273 : { 12, SbERR_VAR_UNDEFINED },
274 : { 13, SbERR_CONVERSION },
275 : { 14, SbERR_BAD_PARAMETER },
276 : { 18, SbERR_USER_ABORT },
277 : { 20, SbERR_BAD_RESUME },
278 : { 28, SbERR_STACK_OVERFLOW },
279 : { 35, SbERR_PROC_UNDEFINED },
280 : { 48, SbERR_BAD_DLL_LOAD },
281 : { 49, SbERR_BAD_DLL_CALL },
282 : { 51, SbERR_INTERNAL_ERROR },
283 : { 52, SbERR_BAD_CHANNEL },
284 : { 53, SbERR_FILE_NOT_FOUND },
285 : { 54, SbERR_BAD_FILE_MODE },
286 : { 55, SbERR_FILE_ALREADY_OPEN },
287 : { 57, SbERR_IO_ERROR },
288 : { 58, SbERR_FILE_EXISTS },
289 : { 59, SbERR_BAD_RECORD_LENGTH },
290 : { 61, SbERR_DISK_FULL },
291 : { 62, SbERR_READ_PAST_EOF },
292 : { 63, SbERR_BAD_RECORD_NUMBER },
293 : { 67, SbERR_TOO_MANY_FILES },
294 : { 68, SbERR_NO_DEVICE },
295 : { 70, SbERR_ACCESS_DENIED },
296 : { 71, SbERR_NOT_READY },
297 : { 73, SbERR_NOT_IMPLEMENTED },
298 : { 74, SbERR_DIFFERENT_DRIVE },
299 : { 75, SbERR_ACCESS_ERROR },
300 : { 76, SbERR_PATH_NOT_FOUND },
301 : { 91, SbERR_NO_OBJECT },
302 : { 93, SbERR_BAD_PATTERN },
303 : { 94, SBERR_IS_NULL },
304 : { 250, SbERR_DDE_ERROR },
305 : { 280, SbERR_DDE_WAITINGACK },
306 : { 281, SbERR_DDE_OUTOFCHANNELS },
307 : { 282, SbERR_DDE_NO_RESPONSE },
308 : { 283, SbERR_DDE_MULT_RESPONSES },
309 : { 284, SbERR_DDE_CHANNEL_LOCKED },
310 : { 285, SbERR_DDE_NOTPROCESSED },
311 : { 286, SbERR_DDE_TIMEOUT },
312 : { 287, SbERR_DDE_USER_INTERRUPT },
313 : { 288, SbERR_DDE_BUSY },
314 : { 289, SbERR_DDE_NO_DATA },
315 : { 290, SbERR_DDE_WRONG_DATA_FORMAT },
316 : { 291, SbERR_DDE_PARTNER_QUIT },
317 : { 292, SbERR_DDE_CONV_CLOSED },
318 : { 293, SbERR_DDE_NO_CHANNEL },
319 : { 294, SbERR_DDE_INVALID_LINK },
320 : { 295, SbERR_DDE_QUEUE_OVERFLOW },
321 : { 296, SbERR_DDE_LINK_ALREADY_EST },
322 : { 297, SbERR_DDE_LINK_INV_TOPIC },
323 : { 298, SbERR_DDE_DLL_NOT_FOUND },
324 : { 323, SbERR_CANNOT_LOAD },
325 : { 341, SbERR_BAD_INDEX },
326 : { 366, SbERR_NO_ACTIVE_OBJECT },
327 : { 380, SbERR_BAD_PROP_VALUE },
328 : { 382, SbERR_PROP_READONLY },
329 : { 394, SbERR_PROP_WRITEONLY },
330 : { 420, SbERR_INVALID_OBJECT },
331 : { 423, SbERR_NO_METHOD },
332 : { 424, SbERR_NEEDS_OBJECT },
333 : { 425, SbERR_INVALID_USAGE_OBJECT },
334 : { 430, SbERR_NO_OLE },
335 : { 438, SbERR_BAD_METHOD },
336 : { 440, SbERR_OLE_ERROR },
337 : { 445, SbERR_BAD_ACTION },
338 : { 446, SbERR_NO_NAMED_ARGS },
339 : { 447, SbERR_BAD_LOCALE },
340 : { 448, SbERR_NAMED_NOT_FOUND },
341 : { 449, SbERR_NOT_OPTIONAL },
342 : { 450, SbERR_WRONG_ARGS },
343 : { 451, SbERR_NOT_A_COLL },
344 : { 452, SbERR_BAD_ORDINAL },
345 : { 453, SbERR_DLLPROC_NOT_FOUND },
346 : { 460, SbERR_BAD_CLIPBD_FORMAT },
347 : { 951, SbERR_UNEXPECTED },
348 : { 952, SbERR_EXPECTED },
349 : { 953, SbERR_SYMBOL_EXPECTED },
350 : { 954, SbERR_VAR_EXPECTED },
351 : { 955, SbERR_LABEL_EXPECTED },
352 : { 956, SbERR_LVALUE_EXPECTED },
353 : { 957, SbERR_VAR_DEFINED },
354 : { 958, SbERR_PROC_DEFINED },
355 : { 959, SbERR_LABEL_DEFINED },
356 : { 960, SbERR_UNDEF_VAR },
357 : { 961, SbERR_UNDEF_ARRAY },
358 : { 962, SbERR_UNDEF_PROC },
359 : { 963, SbERR_UNDEF_LABEL },
360 : { 964, SbERR_UNDEF_TYPE },
361 : { 965, SbERR_BAD_EXIT },
362 : { 966, SbERR_BAD_BLOCK },
363 : { 967, SbERR_BAD_BRACKETS },
364 : { 968, SbERR_BAD_DECLARATION },
365 : { 969, SbERR_BAD_PARAMETERS },
366 : { 970, SbERR_BAD_CHAR_IN_NUMBER },
367 : { 971, SbERR_MUST_HAVE_DIMS },
368 : { 972, SbERR_NO_IF },
369 : { 973, SbERR_NOT_IN_SUBR },
370 : { 974, SbERR_NOT_IN_MAIN },
371 : { 975, SbERR_WRONG_DIMS },
372 : { 976, SbERR_BAD_OPTION },
373 : { 977, SbERR_CONSTANT_REDECLARED },
374 : { 978, SbERR_PROG_TOO_LARGE },
375 : { 979, SbERR_NO_STRINGS_ARRAYS },
376 : { 1000, SbERR_PROPERTY_NOT_FOUND },
377 : { 1001, SbERR_METHOD_NOT_FOUND },
378 : { 1002, SbERR_ARG_MISSING },
379 : { 1003, SbERR_BAD_NUMBER_OF_ARGS },
380 : { 1004, SbERR_METHOD_FAILED },
381 : { 1005, SbERR_SETPROP_FAILED },
382 : { 1006, SbERR_GETPROP_FAILED },
383 : { 1007, SbERR_BASIC_COMPAT },
384 : { 0xFFFF, 0xFFFFFFFFL } // End mark
385 : };
386 :
387 : // The StarBASIC factory is a hack. When a SbModule is created, its pointer
388 : // is saved and given to the following SbProperties/SbMethods. This restores
389 : // the Modul-relationshop. But it works only when a modul is loaded.
390 : // Can cause troubles with separately loaded properties!
391 :
392 0 : SbxBase* SbiFactory::Create( sal_uInt16 nSbxId, sal_uInt32 nCreator )
393 : {
394 0 : if( nCreator == SBXCR_SBX )
395 : {
396 0 : OUString aEmpty;
397 0 : switch( nSbxId )
398 : {
399 : case SBXID_BASIC:
400 0 : return new StarBASIC( NULL );
401 : case SBXID_BASICMOD:
402 0 : return new SbModule( aEmpty );
403 : case SBXID_BASICPROP:
404 0 : return new SbProperty( aEmpty, SbxVARIANT, NULL );
405 : case SBXID_BASICMETHOD:
406 0 : return new SbMethod( aEmpty, SbxVARIANT, NULL );
407 : case SBXID_JSCRIPTMOD:
408 0 : return new SbJScriptModule( aEmpty );
409 : case SBXID_JSCRIPTMETH:
410 0 : return new SbJScriptMethod( aEmpty, SbxVARIANT, NULL );
411 0 : }
412 : }
413 0 : return NULL;
414 : }
415 :
416 6 : SbxObject* SbiFactory::CreateObject( const OUString& rClass )
417 : {
418 6 : if( rClass.equalsIgnoreAsciiCase( "StarBASIC" ) )
419 : {
420 0 : return new StarBASIC( NULL );
421 : }
422 6 : else if( rClass.equalsIgnoreAsciiCase( "StarBASICModule" ) )
423 : {
424 0 : return new SbModule( OUString() );
425 : }
426 6 : else if( rClass.equalsIgnoreAsciiCase( "Collection" ) )
427 : {
428 0 : return new BasicCollection( OUString("Collection"));
429 : }
430 6 : else if( rClass.equalsIgnoreAsciiCase( "FileSystemObject" ) )
431 : {
432 : try
433 : {
434 0 : Reference< XMultiServiceFactory > xFactory( comphelper::getProcessServiceFactory(), UNO_SET_THROW );
435 0 : OUString aServiceName("ooo.vba.FileSystemObject");
436 0 : Reference< XInterface > xInterface( xFactory->createInstance( aServiceName ), UNO_SET_THROW );
437 0 : return new SbUnoObject( aServiceName, uno::makeAny( xInterface ) );
438 : }
439 0 : catch(const Exception& )
440 : {
441 : }
442 : }
443 6 : return NULL;
444 : }
445 :
446 :
447 : // Factory class to create OLE objects
448 57 : class SbOLEFactory : public SbxFactory
449 : {
450 : public:
451 : virtual SbxBase* Create( sal_uInt16 nSbxId, sal_uInt32 = SBXCR_SBX );
452 : virtual SbxObject* CreateObject( const OUString& );
453 : };
454 :
455 0 : SbxBase* SbOLEFactory::Create( sal_uInt16, sal_uInt32 )
456 : {
457 : // Not supported
458 0 : return NULL;
459 : }
460 :
461 : SbUnoObject* createOLEObject_Impl( const OUString& aType ); // sbunoobj.cxx
462 :
463 6 : SbxObject* SbOLEFactory::CreateObject( const OUString& rClassName )
464 : {
465 6 : SbxObject* pRet = createOLEObject_Impl( rClassName );
466 6 : return pRet;
467 : }
468 :
469 :
470 : //========================================================================
471 : // SbFormFactory, show user forms by: dim as new <user form name>
472 :
473 57 : class SbFormFactory : public SbxFactory
474 : {
475 : public:
476 : virtual SbxBase* Create( sal_uInt16 nSbxId, sal_uInt32 = SBXCR_SBX );
477 : virtual SbxObject* CreateObject( const OUString& );
478 : };
479 :
480 0 : SbxBase* SbFormFactory::Create( sal_uInt16, sal_uInt32 )
481 : {
482 : // Not supported
483 0 : return NULL;
484 : }
485 :
486 6 : SbxObject* SbFormFactory::CreateObject( const OUString& rClassName )
487 : {
488 6 : if( SbModule* pMod = GetSbData()->pMod )
489 : {
490 6 : if( SbxVariable* pVar = pMod->Find( rClassName, SbxCLASS_OBJECT ) )
491 : {
492 0 : if( SbUserFormModule* pFormModule = PTR_CAST( SbUserFormModule, pVar->GetObject() ) )
493 : {
494 0 : bool bInitState = pFormModule->getInitState();
495 0 : if( bInitState )
496 : {
497 : // Not the first instantiate, reset
498 0 : bool bTriggerTerminateEvent = false;
499 0 : pFormModule->ResetApiObj( bTriggerTerminateEvent );
500 0 : pFormModule->setInitState( false );
501 : }
502 : else
503 : {
504 0 : pFormModule->Load();
505 : }
506 0 : return pFormModule->CreateInstance();
507 : }
508 : }
509 : }
510 6 : return 0;
511 : }
512 :
513 :
514 : //========================================================================
515 : // SbTypeFactory
516 :
517 0 : SbxObject* cloneTypeObjectImpl( const SbxObject& rTypeObj )
518 : {
519 0 : SbxObject* pRet = new SbxObject( rTypeObj );
520 0 : pRet->PutObject( pRet );
521 :
522 : // Copy the properties, not only the reference to them
523 0 : SbxArray* pProps = pRet->GetProperties();
524 0 : sal_uInt32 nCount = pProps->Count32();
525 0 : for( sal_uInt32 i = 0 ; i < nCount ; i++ )
526 : {
527 0 : SbxVariable* pVar = pProps->Get32( i );
528 0 : SbxProperty* pProp = PTR_CAST( SbxProperty, pVar );
529 0 : if( pProp )
530 : {
531 0 : SbxProperty* pNewProp = new SbxProperty( *pProp );
532 0 : SbxDataType eVarType = pVar->GetType();
533 0 : if( eVarType & SbxARRAY )
534 : {
535 0 : SbxBase* pParObj = pVar->GetObject();
536 0 : SbxDimArray* pSource = PTR_CAST(SbxDimArray,pParObj);
537 0 : SbxDimArray* pDest = new SbxDimArray( pVar->GetType() );
538 :
539 0 : pDest->setHasFixedSize( pSource->hasFixedSize() );
540 0 : if ( pSource->GetDims() && pSource->hasFixedSize() )
541 : {
542 0 : sal_Int32 lb = 0;
543 0 : sal_Int32 ub = 0;
544 0 : for ( sal_Int32 j = 1 ; j <= pSource->GetDims(); ++j )
545 : {
546 0 : pSource->GetDim32( (sal_Int32)j, lb, ub );
547 0 : pDest->AddDim32( lb, ub );
548 : }
549 : }
550 : else
551 : {
552 0 : pDest->unoAddDim( 0, -1 ); // variant array
553 : }
554 0 : sal_uInt16 nSavFlags = pVar->GetFlags();
555 0 : pNewProp->ResetFlag( SBX_FIXED );
556 : // need to reset the FIXED flag
557 : // when calling PutObject ( because the type will not match Object )
558 0 : pNewProp->PutObject( pDest );
559 0 : pNewProp->SetFlags( nSavFlags );
560 : }
561 0 : if( eVarType == SbxOBJECT )
562 : {
563 0 : SbxBase* pObjBase = pVar->GetObject();
564 0 : SbxObject* pSrcObj = PTR_CAST(SbxObject,pObjBase);
565 0 : SbxObject* pDestObj = NULL;
566 0 : if( pSrcObj != NULL )
567 0 : pDestObj = cloneTypeObjectImpl( *pSrcObj );
568 0 : pNewProp->PutObject( pDestObj );
569 : }
570 0 : pProps->PutDirect( pNewProp, i );
571 : }
572 : }
573 0 : return pRet;
574 : }
575 :
576 : // Factory class to create user defined objects (type command)
577 57 : class SbTypeFactory : public SbxFactory
578 : {
579 : public:
580 : virtual SbxBase* Create( sal_uInt16 nSbxId, sal_uInt32 = SBXCR_SBX );
581 : virtual SbxObject* CreateObject( const OUString& );
582 : };
583 :
584 0 : SbxBase* SbTypeFactory::Create( sal_uInt16, sal_uInt32 )
585 : {
586 : // Not supported
587 0 : return NULL;
588 : }
589 :
590 6 : SbxObject* SbTypeFactory::CreateObject( const OUString& rClassName )
591 : {
592 6 : SbxObject* pRet = NULL;
593 6 : SbModule* pMod = GetSbData()->pMod;
594 6 : if( pMod )
595 : {
596 6 : const SbxObject* pObj = pMod->FindType( rClassName );
597 6 : if( pObj )
598 : {
599 0 : pRet = cloneTypeObjectImpl( *pObj );
600 : }
601 : }
602 6 : return pRet;
603 : }
604 :
605 0 : SbxObject* createUserTypeImpl( const OUString& rClassName )
606 : {
607 0 : SbxObject* pRetObj = GetSbData()->pTypeFac->CreateObject( rClassName );
608 0 : return pRetObj;
609 : }
610 :
611 :
612 1059 : TYPEINIT1(SbClassModuleObject,SbModule)
613 :
614 0 : SbClassModuleObject::SbClassModuleObject( SbModule* pClassModule )
615 0 : : SbModule( pClassModule->GetName() )
616 : , mpClassModule( pClassModule )
617 0 : , mbInitializeEventDone( false )
618 : {
619 0 : aOUSource = pClassModule->aOUSource;
620 0 : aComment = pClassModule->aComment;
621 0 : pImage = pClassModule->pImage;
622 0 : pBreaks = pClassModule->pBreaks;
623 :
624 0 : SetClassName( pClassModule->GetName() );
625 :
626 : // Allow search only internally
627 0 : ResetFlag( SBX_GBLSEARCH );
628 :
629 : // Copy the methods from original class module
630 0 : SbxArray* pClassMethods = pClassModule->GetMethods();
631 0 : sal_uInt32 nMethodCount = pClassMethods->Count32();
632 : sal_uInt32 i;
633 0 : for( i = 0 ; i < nMethodCount ; i++ )
634 : {
635 0 : SbxVariable* pVar = pClassMethods->Get32( i );
636 :
637 : // Exclude SbIfaceMapperMethod to copy them in a second step
638 0 : SbIfaceMapperMethod* pIfaceMethod = PTR_CAST( SbIfaceMapperMethod, pVar );
639 0 : if( !pIfaceMethod )
640 : {
641 0 : SbMethod* pMethod = PTR_CAST(SbMethod, pVar );
642 0 : if( pMethod )
643 : {
644 0 : sal_uInt16 nFlags_ = pMethod->GetFlags();
645 0 : pMethod->SetFlag( SBX_NO_BROADCAST );
646 0 : SbMethod* pNewMethod = new SbMethod( *pMethod );
647 0 : pNewMethod->ResetFlag( SBX_NO_BROADCAST );
648 0 : pMethod->SetFlags( nFlags_ );
649 0 : pNewMethod->pMod = this;
650 0 : pNewMethod->SetParent( this );
651 0 : pMethods->PutDirect( pNewMethod, i );
652 0 : StartListening( pNewMethod->GetBroadcaster(), sal_True );
653 : }
654 : }
655 : }
656 :
657 : // Copy SbIfaceMapperMethod in a second step to ensure that
658 : // the corresponding base methods have already been copied
659 0 : for( i = 0 ; i < nMethodCount ; i++ )
660 : {
661 0 : SbxVariable* pVar = pClassMethods->Get32( i );
662 :
663 0 : SbIfaceMapperMethod* pIfaceMethod = PTR_CAST( SbIfaceMapperMethod, pVar );
664 0 : if( pIfaceMethod )
665 : {
666 0 : SbMethod* pImplMethod = pIfaceMethod->getImplMethod();
667 0 : if( !pImplMethod )
668 : {
669 : OSL_FAIL( "No ImplMethod" );
670 0 : continue;
671 : }
672 :
673 : // Search for own copy of ImplMethod
674 0 : SbxVariable* p = pMethods->Find( pImplMethod->GetName(), SbxCLASS_METHOD );
675 0 : SbMethod* pImplMethodCopy = p ? PTR_CAST(SbMethod,p) : NULL;
676 0 : if( !pImplMethodCopy )
677 : {
678 : OSL_FAIL( "Found no ImplMethod copy" );
679 0 : continue;
680 : }
681 : SbIfaceMapperMethod* pNewIfaceMethod =
682 0 : new SbIfaceMapperMethod( pIfaceMethod->GetName(), pImplMethodCopy );
683 0 : pMethods->PutDirect( pNewIfaceMethod, i );
684 : }
685 : }
686 :
687 : // Copy the properties from original class module
688 0 : SbxArray* pClassProps = pClassModule->GetProperties();
689 0 : sal_uInt32 nPropertyCount = pClassProps->Count32();
690 0 : for( i = 0 ; i < nPropertyCount ; i++ )
691 : {
692 0 : SbxVariable* pVar = pClassProps->Get32( i );
693 0 : SbProcedureProperty* pProcedureProp = PTR_CAST( SbProcedureProperty, pVar );
694 0 : if( pProcedureProp )
695 : {
696 0 : sal_uInt16 nFlags_ = pProcedureProp->GetFlags();
697 0 : pProcedureProp->SetFlag( SBX_NO_BROADCAST );
698 : SbProcedureProperty* pNewProp = new SbProcedureProperty
699 0 : ( pProcedureProp->GetName(), pProcedureProp->GetType() );
700 0 : pNewProp->SetFlags( nFlags_ ); // Copy flags
701 0 : pNewProp->ResetFlag( SBX_NO_BROADCAST ); // except the Broadcast if it was set
702 0 : pProcedureProp->SetFlags( nFlags_ );
703 0 : pProps->PutDirect( pNewProp, i );
704 0 : StartListening( pNewProp->GetBroadcaster(), sal_True );
705 : }
706 : else
707 : {
708 0 : SbxProperty* pProp = PTR_CAST( SbxProperty, pVar );
709 0 : if( pProp )
710 : {
711 0 : sal_uInt16 nFlags_ = pProp->GetFlags();
712 0 : pProp->SetFlag( SBX_NO_BROADCAST );
713 0 : SbxProperty* pNewProp = new SbxProperty( *pProp );
714 :
715 : // Special handling for modules instances and collections, they need
716 : // to be instantiated, otherwise all refer to the same base object
717 0 : SbxDataType eVarType = pProp->GetType();
718 0 : if( eVarType == SbxOBJECT )
719 : {
720 0 : SbxBase* pObjBase = pProp->GetObject();
721 0 : SbxObject* pObj = PTR_CAST(SbxObject,pObjBase);
722 0 : if( pObj != NULL )
723 : {
724 0 : OUString aObjClass = pObj->GetClassName();
725 :
726 0 : SbClassModuleObject* pClassModuleObj = PTR_CAST(SbClassModuleObject,pObjBase);
727 0 : if( pClassModuleObj != NULL )
728 : {
729 0 : SbModule* pLclClassModule = pClassModuleObj->getClassModule();
730 0 : SbClassModuleObject* pNewObj = new SbClassModuleObject( pLclClassModule );
731 0 : pNewObj->SetName( pProp->GetName() );
732 0 : pNewObj->SetParent( pLclClassModule->pParent );
733 0 : pNewProp->PutObject( pNewObj );
734 : }
735 0 : else if( aObjClass.equalsIgnoreAsciiCase( "Collection" ) )
736 : {
737 0 : OUString aCollectionName("Collection");
738 0 : BasicCollection* pNewCollection = new BasicCollection( aCollectionName );
739 0 : pNewCollection->SetName( pProp->GetName() );
740 0 : pNewCollection->SetParent( pClassModule->pParent );
741 0 : pNewProp->PutObject( pNewCollection );
742 0 : }
743 : }
744 : }
745 :
746 0 : pNewProp->ResetFlag( SBX_NO_BROADCAST );
747 0 : pNewProp->SetParent( this );
748 0 : pProps->PutDirect( pNewProp, i );
749 0 : pProp->SetFlags( nFlags_ );
750 : }
751 : }
752 : }
753 0 : SetModuleType( ModuleType::CLASS );
754 0 : mbVBACompat = pClassModule->mbVBACompat;
755 0 : }
756 :
757 0 : SbClassModuleObject::~SbClassModuleObject()
758 : {
759 : // do not trigger termination event when document is already closed
760 0 : if( StarBASIC::IsRunning() )
761 0 : if( StarBASIC* pDocBasic = lclGetDocBasicForModule( this ) )
762 0 : if( const DocBasicItem* pDocBasicItem = lclFindDocBasicItem( pDocBasic ) )
763 0 : if( !pDocBasicItem->isDocClosed() )
764 0 : triggerTerminateEvent();
765 :
766 : // Must be deleted by base class dtor because this data
767 : // is not owned by the SbClassModuleObject object
768 0 : pImage = NULL;
769 0 : pBreaks = NULL;
770 0 : }
771 :
772 0 : void SbClassModuleObject::SFX_NOTIFY( SfxBroadcaster& rBC, const TypeId& rBCType,
773 : const SfxHint& rHint, const TypeId& rHintType )
774 : {
775 0 : handleProcedureProperties( rBC, rHint );
776 0 : }
777 :
778 0 : SbxVariable* SbClassModuleObject::Find( const OUString& rName, SbxClassType t )
779 : {
780 0 : SbxVariable* pRes = SbxObject::Find( rName, t );
781 0 : if( pRes )
782 : {
783 0 : triggerInitializeEvent();
784 :
785 0 : SbIfaceMapperMethod* pIfaceMapperMethod = PTR_CAST(SbIfaceMapperMethod,pRes);
786 0 : if( pIfaceMapperMethod )
787 : {
788 0 : pRes = pIfaceMapperMethod->getImplMethod();
789 0 : pRes->SetFlag( SBX_EXTFOUND );
790 : }
791 : }
792 0 : return pRes;
793 : }
794 :
795 0 : void SbClassModuleObject::triggerInitializeEvent( void )
796 : {
797 0 : if( mbInitializeEventDone )
798 : {
799 0 : return;
800 : }
801 :
802 0 : mbInitializeEventDone = true;
803 :
804 : // Search method
805 0 : SbxVariable* pMeth = SbxObject::Find(OUString("Class_Initialize"), SbxCLASS_METHOD);
806 0 : if( pMeth )
807 : {
808 0 : SbxValues aVals;
809 0 : pMeth->Get( aVals );
810 : }
811 : }
812 :
813 0 : void SbClassModuleObject::triggerTerminateEvent( void )
814 : {
815 0 : if( !mbInitializeEventDone || GetSbData()->bRunInit )
816 : {
817 0 : return;
818 : }
819 : // Search method
820 0 : SbxVariable* pMeth = SbxObject::Find(OUString("Class_Terminate"), SbxCLASS_METHOD );
821 0 : if( pMeth )
822 : {
823 0 : SbxValues aVals;
824 0 : pMeth->Get( aVals );
825 : }
826 : }
827 :
828 :
829 0 : SbClassData::SbClassData( void )
830 : {
831 0 : mxIfaces = new SbxArray();
832 0 : }
833 :
834 0 : void SbClassData::clear( void )
835 : {
836 0 : mxIfaces->Clear();
837 0 : maRequiredTypes.clear();
838 0 : }
839 :
840 19 : SbClassFactory::SbClassFactory( void )
841 : {
842 19 : OUString aDummyName;
843 19 : xClassModules = new SbxObject( aDummyName );
844 19 : }
845 :
846 38 : SbClassFactory::~SbClassFactory()
847 38 : {}
848 :
849 0 : void SbClassFactory::AddClassModule( SbModule* pClassModule )
850 : {
851 0 : SbxObjectRef xToUseClassModules = xClassModules;
852 :
853 0 : if( StarBASIC* pDocBasic = lclGetDocBasicForModule( pClassModule ) )
854 0 : if( const DocBasicItem* pDocBasicItem = lclFindDocBasicItem( pDocBasic ) )
855 0 : xToUseClassModules = pDocBasicItem->getClassModules();
856 :
857 0 : SbxObject* pParent = pClassModule->GetParent();
858 0 : xToUseClassModules->Insert( pClassModule );
859 0 : pClassModule->SetParent( pParent );
860 0 : }
861 :
862 8 : void SbClassFactory::RemoveClassModule( SbModule* pClassModule )
863 : {
864 8 : xClassModules->Remove( pClassModule );
865 8 : }
866 :
867 0 : SbxBase* SbClassFactory::Create( sal_uInt16, sal_uInt32 )
868 : {
869 : // Not supported
870 0 : return NULL;
871 : }
872 :
873 6 : SbxObject* SbClassFactory::CreateObject( const OUString& rClassName )
874 : {
875 6 : SbxObjectRef xToUseClassModules = xClassModules;
876 :
877 6 : if( SbModule* pMod = GetSbData()->pMod )
878 : {
879 6 : if( StarBASIC* pDocBasic = lclGetDocBasicForModule( pMod ) )
880 : {
881 0 : if( const DocBasicItem* pDocBasicItem = lclFindDocBasicItem( pDocBasic ) )
882 : {
883 0 : xToUseClassModules = pDocBasicItem->getClassModules();
884 : }
885 : }
886 : }
887 6 : SbxVariable* pVar = xToUseClassModules->Find( rClassName, SbxCLASS_OBJECT );
888 6 : SbxObject* pRet = NULL;
889 6 : if( pVar )
890 : {
891 0 : SbModule* pVarMod = (SbModule*)pVar;
892 0 : pRet = new SbClassModuleObject( pVarMod );
893 : }
894 6 : return pRet;
895 : }
896 :
897 0 : SbModule* SbClassFactory::FindClass( const OUString& rClassName )
898 : {
899 0 : SbxVariable* pVar = xClassModules->Find( rClassName, SbxCLASS_DONTCARE );
900 0 : SbModule* pMod = pVar ? (SbModule*)pVar : NULL;
901 0 : return pMod;
902 : }
903 :
904 265 : StarBASIC::StarBASIC( StarBASIC* p, bool bIsDocBasic )
905 265 : : SbxObject( OUString("StarBASIC") ), bDocBasic( bIsDocBasic )
906 : {
907 265 : SetParent( p );
908 265 : pLibInfo = NULL;
909 265 : bNoRtl = bBreak = false;
910 265 : bVBAEnabled = false;
911 265 : pModules = new SbxArray;
912 :
913 265 : if( !GetSbData()->nInst++ )
914 : {
915 19 : GetSbData()->pSbFac = new SbiFactory;
916 19 : AddFactory( GetSbData()->pSbFac );
917 19 : GetSbData()->pTypeFac = new SbTypeFactory;
918 19 : AddFactory( GetSbData()->pTypeFac );
919 19 : GetSbData()->pClassFac = new SbClassFactory;
920 19 : AddFactory( GetSbData()->pClassFac );
921 19 : GetSbData()->pOLEFac = new SbOLEFactory;
922 19 : AddFactory( GetSbData()->pOLEFac );
923 19 : GetSbData()->pFormFac = new SbFormFactory;
924 19 : AddFactory( GetSbData()->pFormFac );
925 19 : GetSbData()->pUnoFac = new SbUnoFactory;
926 19 : AddFactory( GetSbData()->pUnoFac );
927 : }
928 265 : pRtl = new SbiStdObject(OUString(RTLNAME), this );
929 : // Search via StarBasic is always global
930 265 : SetFlag( SBX_GBLSEARCH );
931 265 : pVBAGlobals = NULL;
932 265 : bQuit = false;
933 :
934 265 : if( bDocBasic )
935 : {
936 246 : lclInsertDocBasicItem( *this );
937 : }
938 265 : }
939 :
940 : // #51727 Override SetModified so that the modified state
941 : // is not given to the parent
942 2527 : void StarBASIC::SetModified( sal_Bool b )
943 : {
944 2527 : SbxBase::SetModified( b );
945 2527 : }
946 :
947 568 : StarBASIC::~StarBASIC()
948 : {
949 : // Needs to be first action as it can trigger events
950 142 : disposeComVariablesForBasic( this );
951 :
952 142 : if( !--GetSbData()->nInst )
953 : {
954 8 : RemoveFactory( GetSbData()->pSbFac );
955 8 : delete GetSbData()->pSbFac; GetSbData()->pSbFac = NULL;
956 8 : RemoveFactory( GetSbData()->pUnoFac );
957 8 : delete GetSbData()->pUnoFac; GetSbData()->pUnoFac = NULL;
958 8 : RemoveFactory( GetSbData()->pTypeFac );
959 8 : delete GetSbData()->pTypeFac; GetSbData()->pTypeFac = NULL;
960 8 : RemoveFactory( GetSbData()->pClassFac );
961 8 : delete GetSbData()->pClassFac; GetSbData()->pClassFac = NULL;
962 8 : RemoveFactory( GetSbData()->pOLEFac );
963 8 : delete GetSbData()->pOLEFac; GetSbData()->pOLEFac = NULL;
964 8 : RemoveFactory( GetSbData()->pFormFac );
965 8 : delete GetSbData()->pFormFac; GetSbData()->pFormFac = NULL;
966 :
967 : #ifdef DBG_UTIL
968 : // There is no need to clean SbiData at program end,
969 : // but we dislike MLK's at Purify
970 : // TODO: Where else???
971 : SbiGlobals** pp = (SbiGlobals**) ::GetAppData( SHL_SBC );
972 : SbiGlobals* p = *pp;
973 : if( p )
974 : {
975 : delete p;
976 : *pp = 0;
977 : }
978 : #endif
979 : }
980 134 : else if( bDocBasic )
981 : {
982 134 : SbxError eOld = SbxBase::GetError();
983 :
984 134 : lclRemoveDocBasicItem( *this );
985 :
986 134 : SbxBase::ResetError();
987 134 : if( eOld != SbxERR_OK )
988 : {
989 0 : SbxBase::SetError( eOld );
990 : }
991 : }
992 :
993 : // #100326 Set Parent NULL in registered listeners
994 142 : if( xUnoListeners.Is() )
995 : {
996 0 : sal_uInt16 uCount = xUnoListeners->Count();
997 0 : for( sal_uInt16 i = 0 ; i < uCount ; i++ )
998 : {
999 0 : SbxVariable* pListenerObj = xUnoListeners->Get( i );
1000 0 : pListenerObj->SetParent( NULL );
1001 : }
1002 0 : xUnoListeners = NULL;
1003 : }
1004 :
1005 142 : clearUnoMethodsForBasic( this );
1006 426 : }
1007 :
1008 : // Override new() operator, so that everyone can create a new instance
1009 265 : void* StarBASIC::operator new( size_t n )
1010 : {
1011 265 : if( n < sizeof( StarBASIC ) )
1012 : {
1013 0 : n = sizeof( StarBASIC );
1014 : }
1015 265 : return ::operator new( n );
1016 : }
1017 :
1018 142 : void StarBASIC::operator delete( void* p )
1019 : {
1020 142 : ::operator delete( p );
1021 142 : }
1022 :
1023 3020 : void StarBASIC::implClearDependingVarsOnDelete( StarBASIC* pDeletedBasic )
1024 : {
1025 3020 : if( this != pDeletedBasic )
1026 : {
1027 3035 : for( sal_uInt16 i = 0; i < pModules->Count(); i++ )
1028 : {
1029 15 : SbModule* p = (SbModule*)pModules->Get( i );
1030 15 : p->ClearVarsDependingOnDeletedBasic( pDeletedBasic );
1031 : }
1032 : }
1033 :
1034 12071 : for( sal_uInt16 nObj = 0; nObj < pObjs->Count(); nObj++ )
1035 : {
1036 9051 : SbxVariable* pVar = pObjs->Get( nObj );
1037 9051 : StarBASIC* pBasic = PTR_CAST(StarBASIC,pVar);
1038 9051 : if( pBasic && pBasic != pDeletedBasic )
1039 : {
1040 0 : pBasic->implClearDependingVarsOnDelete( pDeletedBasic );
1041 : }
1042 : }
1043 3020 : }
1044 :
1045 :
1046 : /**************************************************************************
1047 : *
1048 : * Creation/Managment of modules
1049 : *
1050 : **************************************************************************/
1051 :
1052 8 : SbModule* StarBASIC::MakeModule( const OUString& rName, const OUString& rSrc )
1053 : {
1054 8 : return MakeModule32( rName, rSrc );
1055 : }
1056 :
1057 8 : SbModule* StarBASIC::MakeModule32( const OUString& rName, const OUString& rSrc )
1058 : {
1059 8 : ModuleInfo mInfo;
1060 8 : mInfo.ModuleType = ModuleType::NORMAL;
1061 8 : return MakeModule32( rName, mInfo, rSrc );
1062 : }
1063 23 : SbModule* StarBASIC::MakeModule32( const OUString& rName, const ModuleInfo& mInfo, const OUString& rSrc )
1064 : {
1065 :
1066 : OSL_TRACE("create module %s type mInfo %d", rtl::OUStringToOString( rName, RTL_TEXTENCODING_UTF8 ).getStr(), mInfo.ModuleType );
1067 23 : SbModule* p = NULL;
1068 23 : switch ( mInfo.ModuleType )
1069 : {
1070 : case ModuleType::DOCUMENT:
1071 : // In theory we should be able to create Object modules
1072 : // in ordinary basic ( in vba mode thought these are create
1073 : // by the application/basic and not by the user )
1074 13 : p = new SbObjModule( rName, mInfo, isVBAEnabled() );
1075 13 : break;
1076 : case ModuleType::CLASS:
1077 0 : p = new SbModule( rName, isVBAEnabled() );
1078 0 : p->SetModuleType( ModuleType::CLASS );
1079 0 : break;
1080 : case ModuleType::FORM:
1081 0 : p = new SbUserFormModule( rName, mInfo, isVBAEnabled() );
1082 0 : break;
1083 : default:
1084 10 : p = new SbModule( rName, isVBAEnabled() );
1085 10 : break;
1086 : }
1087 23 : p->SetSource32( rSrc );
1088 23 : p->SetParent( this );
1089 23 : pModules->Insert( p, pModules->Count() );
1090 23 : SetModified( sal_True );
1091 23 : return p;
1092 : }
1093 :
1094 1108 : void StarBASIC::Insert( SbxVariable* pVar )
1095 : {
1096 1108 : if( pVar->IsA( TYPE(SbModule) ) )
1097 : {
1098 0 : pModules->Insert( pVar, pModules->Count() );
1099 0 : pVar->SetParent( this );
1100 0 : StartListening( pVar->GetBroadcaster(), sal_True );
1101 : }
1102 : else
1103 : {
1104 1108 : sal_Bool bWasModified = IsModified();
1105 1108 : SbxObject::Insert( pVar );
1106 1108 : if( !bWasModified && pVar->IsSet( SBX_DONTSTORE ) )
1107 : {
1108 1099 : SetModified( sal_False );
1109 : }
1110 : }
1111 1108 : }
1112 :
1113 0 : void StarBASIC::Remove( SbxVariable* pVar )
1114 : {
1115 0 : if( pVar->IsA( TYPE(SbModule) ) )
1116 : {
1117 : // #87540 Can be last reference!
1118 0 : SbxVariableRef xVar = pVar;
1119 0 : pModules->Remove( pVar );
1120 0 : pVar->SetParent( 0 );
1121 0 : EndListening( pVar->GetBroadcaster() );
1122 : }
1123 : else
1124 : {
1125 0 : SbxObject::Remove( pVar );
1126 : }
1127 0 : }
1128 :
1129 0 : sal_Bool StarBASIC::Compile( SbModule* pMod )
1130 : {
1131 0 : return pMod ? pMod->Compile() : sal_False;
1132 : }
1133 :
1134 0 : void StarBASIC::Clear()
1135 : {
1136 0 : while( pModules->Count() )
1137 : {
1138 0 : pModules->Remove( pModules->Count() - 1 );
1139 : }
1140 0 : }
1141 :
1142 15 : SbModule* StarBASIC::FindModule( const OUString& rName )
1143 : {
1144 64 : for( sal_uInt16 i = 0; i < pModules->Count(); i++ )
1145 : {
1146 49 : SbModule* p = (SbModule*) pModules->Get( i );
1147 49 : if( p->GetName().equalsIgnoreAsciiCase( rName ) )
1148 : {
1149 0 : return p;
1150 : }
1151 : }
1152 15 : return NULL;
1153 : }
1154 :
1155 :
1156 : struct ClassModuleRunInitItem
1157 : {
1158 : SbModule* m_pModule;
1159 : bool m_bProcessing;
1160 : bool m_bRunInitDone;
1161 :
1162 0 : ClassModuleRunInitItem( void )
1163 : : m_pModule( NULL )
1164 : , m_bProcessing( false )
1165 0 : , m_bRunInitDone( false )
1166 0 : {}
1167 0 : ClassModuleRunInitItem( SbModule* pModule )
1168 : : m_pModule( pModule )
1169 : , m_bProcessing( false )
1170 0 : , m_bRunInitDone( false )
1171 0 : {}
1172 : };
1173 :
1174 : // Derive from unordered_map type instead of typedef
1175 : // to allow forward declaration in sbmod.hxx
1176 14 : class ModuleInitDependencyMap : public
1177 : boost::unordered_map< OUString, ClassModuleRunInitItem,
1178 : ::rtl::OUStringHash, ::std::equal_to< OUString > >
1179 : {};
1180 :
1181 0 : void SbModule::implProcessModuleRunInit( ModuleInitDependencyMap& rMap, ClassModuleRunInitItem& rItem )
1182 : {
1183 0 : rItem.m_bProcessing = true;
1184 :
1185 0 : SbModule* pModule = rItem.m_pModule;
1186 0 : if( pModule->pClassData != NULL )
1187 : {
1188 0 : StringVector& rReqTypes = pModule->pClassData->maRequiredTypes;
1189 0 : if( rReqTypes.size() > 0 )
1190 : {
1191 0 : for( StringVector::iterator it = rReqTypes.begin() ; it != rReqTypes.end() ; ++it )
1192 : {
1193 0 : OUString& rStr = *it;
1194 :
1195 : // Is required type a class module?
1196 0 : ModuleInitDependencyMap::iterator itFind = rMap.find( rStr );
1197 0 : if( itFind != rMap.end() )
1198 : {
1199 0 : ClassModuleRunInitItem& rParentItem = itFind->second;
1200 0 : if( rParentItem.m_bProcessing )
1201 : {
1202 : // TODO: raise error?
1203 : OSL_FAIL( "Cyclic module dependency detected" );
1204 0 : continue;
1205 : }
1206 :
1207 0 : if( !rParentItem.m_bRunInitDone )
1208 : {
1209 0 : implProcessModuleRunInit( rMap, rParentItem );
1210 : }
1211 : }
1212 : }
1213 : }
1214 : }
1215 :
1216 0 : pModule->RunInit();
1217 0 : rItem.m_bRunInitDone = true;
1218 0 : rItem.m_bProcessing = false;
1219 0 : }
1220 :
1221 : // Run Init-Code of all modules (including inserted libraries)
1222 7 : void StarBASIC::InitAllModules( StarBASIC* pBasicNotToInit )
1223 : {
1224 7 : SolarMutexGuard guard;
1225 :
1226 : // Init own modules
1227 14 : for ( sal_uInt16 nMod = 0; nMod < pModules->Count(); nMod++ )
1228 : {
1229 7 : SbModule* pModule = (SbModule*)pModules->Get( nMod );
1230 7 : if( !pModule->IsCompiled() )
1231 : {
1232 0 : pModule->Compile();
1233 : }
1234 : }
1235 : // compile modules first then RunInit ( otherwise there is
1236 : // can be order dependency, e.g. classmodule A has a member
1237 : // of of type classmodule B and classmodule B hasn't been compiled yet )
1238 :
1239 : // Consider required types to init in right order. Class modules
1240 : // that are required by other modules have to be initialized first.
1241 7 : ModuleInitDependencyMap aMIDMap;
1242 14 : for ( sal_uInt16 nMod = 0; nMod < pModules->Count(); nMod++ )
1243 : {
1244 7 : SbModule* pModule = (SbModule*)pModules->Get( nMod );
1245 7 : OUString aModuleName = pModule->GetName();
1246 7 : if( pModule->isProxyModule() )
1247 : {
1248 0 : aMIDMap[aModuleName] = ClassModuleRunInitItem( pModule );
1249 : }
1250 7 : }
1251 :
1252 7 : ModuleInitDependencyMap::iterator it;
1253 7 : for( it = aMIDMap.begin() ; it != aMIDMap.end(); ++it )
1254 : {
1255 0 : ClassModuleRunInitItem& rItem = it->second;
1256 0 : SbModule::implProcessModuleRunInit( aMIDMap, rItem );
1257 : }
1258 :
1259 : // Call RunInit on standard modules
1260 14 : for ( sal_uInt16 nMod = 0; nMod < pModules->Count(); nMod++ )
1261 : {
1262 7 : SbModule* pModule = (SbModule*)pModules->Get( nMod );
1263 7 : if( !pModule->isProxyModule() )
1264 : {
1265 7 : pModule->RunInit();
1266 : }
1267 : }
1268 :
1269 : // Check all objects if they are BASIC,
1270 : // if yes initialize
1271 7 : for ( sal_uInt16 nObj = 0; nObj < pObjs->Count(); nObj++ )
1272 : {
1273 0 : SbxVariable* pVar = pObjs->Get( nObj );
1274 0 : StarBASIC* pBasic = PTR_CAST(StarBASIC,pVar);
1275 0 : if( pBasic && pBasic != pBasicNotToInit )
1276 : {
1277 0 : pBasic->InitAllModules();
1278 : }
1279 7 : }
1280 7 : }
1281 :
1282 : // #88329 Put modules back to not initialised state to
1283 : // force reinitialisation at next start
1284 14 : void StarBASIC::DeInitAllModules( void )
1285 : {
1286 : // Deinit own modules
1287 28 : for ( sal_uInt16 nMod = 0; nMod < pModules->Count(); nMod++ )
1288 : {
1289 14 : SbModule* pModule = (SbModule*)pModules->Get( nMod );
1290 14 : if( pModule->pImage && !pModule->isProxyModule() && !pModule->ISA(SbObjModule) )
1291 : {
1292 14 : pModule->pImage->bInit = false;
1293 : }
1294 : }
1295 :
1296 14 : for ( sal_uInt16 nObj = 0; nObj < pObjs->Count(); nObj++ )
1297 : {
1298 0 : SbxVariable* pVar = pObjs->Get( nObj );
1299 0 : StarBASIC* pBasic = PTR_CAST(StarBASIC,pVar);
1300 0 : if( pBasic )
1301 : {
1302 0 : pBasic->DeInitAllModules();
1303 : }
1304 : }
1305 14 : }
1306 :
1307 : // This implementation at first searches within the runtime library,
1308 : // then it looks for an element within one module. This moudle can be
1309 : // a public var or an entrypoint. If it is not found and we look for a
1310 : // method and a module with the given name is found the search continues
1311 : // for entrypoint "Main".
1312 : // If this fails again a conventional search over objects is performend.
1313 5913 : SbxVariable* StarBASIC::Find( const OUString& rName, SbxClassType t )
1314 : {
1315 5913 : SbxVariable* pRes = NULL;
1316 5913 : SbModule* pNamed = NULL;
1317 : // "Extended" search in Runtime Lib
1318 : // but only if SbiRuntime has not set the flag
1319 5913 : if( !bNoRtl )
1320 : {
1321 5912 : if( t == SbxCLASS_DONTCARE || t == SbxCLASS_OBJECT )
1322 : {
1323 5912 : if( rName.equalsIgnoreAsciiCase( RTLNAME ) )
1324 : {
1325 0 : pRes = pRtl;
1326 : }
1327 : }
1328 5912 : if( !pRes )
1329 : {
1330 5912 : pRes = ((SbiStdObject*) (SbxObject*) pRtl)->Find( rName, t );
1331 : }
1332 5912 : if( pRes )
1333 : {
1334 0 : pRes->SetFlag( SBX_EXTFOUND );
1335 : }
1336 : }
1337 : // Search module
1338 5913 : if( !pRes )
1339 : {
1340 5927 : for( sal_uInt16 i = 0; i < pModules->Count(); i++ )
1341 : {
1342 14 : SbModule* p = (SbModule*) pModules->Get( i );
1343 14 : if( p->IsVisible() )
1344 : {
1345 : // Remember modul fpr Main() call
1346 : // or is the name equal?!?
1347 14 : if( p->GetName().equalsIgnoreAsciiCase( rName ) )
1348 : {
1349 0 : if( t == SbxCLASS_OBJECT || t == SbxCLASS_DONTCARE )
1350 : {
1351 0 : pRes = p; break;
1352 : }
1353 0 : pNamed = p;
1354 : }
1355 : // Only variables qualified by the Module Name e.g. Sheet1.foo
1356 : // should work for Documant && Class type Modules
1357 14 : sal_Int32 nType = p->GetModuleType();
1358 14 : if ( nType == ModuleType::DOCUMENT || nType == ModuleType::FORM )
1359 : {
1360 0 : continue;
1361 : }
1362 : // otherwise check if the element is available
1363 : // unset GBLSEARCH-Flag (due to Rekursion)
1364 14 : sal_uInt16 nGblFlag = p->GetFlags() & SBX_GBLSEARCH;
1365 14 : p->ResetFlag( SBX_GBLSEARCH );
1366 14 : pRes = p->Find( rName, t );
1367 14 : p->SetFlag( nGblFlag );
1368 14 : if( pRes )
1369 : {
1370 0 : break;
1371 : }
1372 : }
1373 : }
1374 : }
1375 5913 : OUString aMainStr("Main");
1376 5913 : if( !pRes && pNamed && ( t == SbxCLASS_METHOD || t == SbxCLASS_DONTCARE ) &&
1377 0 : !pNamed->GetName().equalsIgnoreAsciiCase( aMainStr ) )
1378 : {
1379 0 : pRes = pNamed->Find( aMainStr, SbxCLASS_METHOD );
1380 : }
1381 5913 : if( !pRes )
1382 : {
1383 5913 : pRes = SbxObject::Find( rName, t );
1384 : }
1385 5913 : return pRes;
1386 : }
1387 :
1388 0 : sal_Bool StarBASIC::Call( const OUString& rName, SbxArray* pParam )
1389 : {
1390 0 : sal_Bool bRes = SbxObject::Call( rName, pParam );
1391 0 : if( !bRes )
1392 : {
1393 0 : SbxError eErr = SbxBase::GetError();
1394 0 : SbxBase::ResetError();
1395 0 : if( eErr != SbxERR_OK )
1396 : {
1397 0 : RTError( (SbError)eErr, 0, 0, 0 );
1398 : }
1399 : }
1400 0 : return bRes;
1401 : }
1402 :
1403 : // Find method via name (e.g. query via BASIC IDE)
1404 0 : SbxBase* StarBASIC::FindSBXInCurrentScope( const OUString& rName )
1405 : {
1406 0 : if( !GetSbData()->pInst )
1407 : {
1408 0 : return NULL;
1409 : }
1410 0 : if( !GetSbData()->pInst->pRun )
1411 : {
1412 0 : return NULL;
1413 : }
1414 0 : return GetSbData()->pInst->pRun->FindElementExtern( rName );
1415 : }
1416 :
1417 0 : void StarBASIC::QuitAndExitApplication()
1418 : {
1419 0 : Stop();
1420 0 : bQuit = true;
1421 0 : }
1422 :
1423 0 : void StarBASIC::Stop()
1424 : {
1425 0 : SbiInstance* p = GetSbData()->pInst;
1426 0 : while( p )
1427 : {
1428 0 : p->Stop();
1429 0 : p = p->pNext;
1430 : }
1431 0 : }
1432 :
1433 0 : bool StarBASIC::IsRunning()
1434 : {
1435 0 : return GetSbData()->pInst != NULL;
1436 : }
1437 :
1438 : /**************************************************************************
1439 : *
1440 : * Debugging and error handling
1441 : *
1442 : **************************************************************************/
1443 :
1444 0 : SbMethod* StarBASIC::GetActiveMethod( sal_uInt16 nLevel )
1445 : {
1446 0 : if( GetSbData()->pInst )
1447 : {
1448 0 : return GetSbData()->pInst->GetCaller( nLevel );
1449 : }
1450 : else
1451 : {
1452 0 : return NULL;
1453 : }
1454 : }
1455 :
1456 0 : SbModule* StarBASIC::GetActiveModule()
1457 : {
1458 0 : if( GetSbData()->pInst && !IsCompilerError() )
1459 : {
1460 0 : return GetSbData()->pInst->GetActiveModule();
1461 : }
1462 : else
1463 : {
1464 0 : return GetSbData()->pCompMod;
1465 : }
1466 : }
1467 :
1468 0 : sal_uInt16 StarBASIC::BreakPoint( sal_Int32 l, sal_Int32 c1, sal_Int32 c2 )
1469 : {
1470 0 : SetErrorData( 0, l, c1, c2 );
1471 0 : bBreak = true;
1472 0 : if( GetSbData()->aBreakHdl.IsSet() )
1473 : {
1474 0 : return (sal_uInt16) GetSbData()->aBreakHdl.Call( this );
1475 : }
1476 : else
1477 : {
1478 0 : return BreakHdl();
1479 : }
1480 : }
1481 :
1482 0 : sal_uInt16 StarBASIC::StepPoint( sal_Int32 l, sal_Int32 c1, sal_Int32 c2 )
1483 : {
1484 0 : SetErrorData( 0, l, c1, c2 );
1485 0 : bBreak = false;
1486 0 : if( GetSbData()->aBreakHdl.IsSet() )
1487 : {
1488 0 : return (sal_uInt16) GetSbData()->aBreakHdl.Call( this );
1489 : }
1490 : else
1491 : {
1492 0 : return BreakHdl();
1493 : }
1494 : }
1495 :
1496 0 : sal_uInt16 StarBASIC::BreakHdl()
1497 : {
1498 0 : return (sal_uInt16) ( aBreakHdl.IsSet() ? aBreakHdl.Call( this ) : SbDEBUG_CONTINUE );
1499 : }
1500 :
1501 : // Calls for error handler and break handler
1502 0 : sal_uInt16 StarBASIC::GetLine() { return GetSbData()->nLine; }
1503 0 : sal_uInt16 StarBASIC::GetCol1() { return GetSbData()->nCol1; }
1504 0 : sal_uInt16 StarBASIC::GetCol2() { return GetSbData()->nCol2; }
1505 :
1506 : // Specific to error handler
1507 0 : SbError StarBASIC::GetErrorCode() { return GetSbData()->nCode; }
1508 0 : const OUString& StarBASIC::GetErrorText() { return GetSbData()->aErrMsg; }
1509 0 : bool StarBASIC::IsCompilerError() { return GetSbData()->bCompiler; }
1510 :
1511 : // From 1996-03-29:
1512 : // The mapping between the old and the new error codes take place by searching
1513 : // through the table SFX_VB_ErrorTab[]. This is indeed not with good performance,
1514 : // but it consumes much less memory than corresponding switch blocs.
1515 : // Because the conversion of error codes has not to be fast. there is no
1516 : // binary search by VB Error -> Error SFX.
1517 :
1518 : // Map back new error codes to old, Sbx-compatible
1519 0 : sal_uInt16 StarBASIC::GetVBErrorCode( SbError nError )
1520 : {
1521 0 : sal_uInt16 nRet = 0;
1522 :
1523 0 : if( SbiRuntime::isVBAEnabled() )
1524 : {
1525 0 : switch( nError )
1526 : {
1527 : case SbERR_BASIC_ARRAY_FIX:
1528 0 : return 10;
1529 : case SbERR_BASIC_STRING_OVERFLOW:
1530 0 : return 14;
1531 : case SbERR_BASIC_EXPR_TOO_COMPLEX:
1532 0 : return 16;
1533 : case SbERR_BASIC_OPER_NOT_PERFORM:
1534 0 : return 17;
1535 : case SbERR_BASIC_TOO_MANY_DLL:
1536 0 : return 47;
1537 : case SbERR_BASIC_LOOP_NOT_INIT:
1538 0 : return 92;
1539 : default:
1540 0 : nRet = 0;
1541 : }
1542 : }
1543 :
1544 : // search loop
1545 : const SFX_VB_ErrorItem* pErrItem;
1546 0 : sal_uInt16 nIndex = 0;
1547 0 : do
1548 : {
1549 0 : pErrItem = SFX_VB_ErrorTab + nIndex;
1550 0 : if( pErrItem->nErrorSFX == nError )
1551 : {
1552 0 : nRet = pErrItem->nErrorVB;
1553 0 : break;
1554 : }
1555 0 : nIndex++;
1556 : }
1557 : while( pErrItem->nErrorVB != 0xFFFF ); // up to end mark
1558 0 : return nRet;
1559 : }
1560 :
1561 0 : SbError StarBASIC::GetSfxFromVBError( sal_uInt16 nError )
1562 : {
1563 0 : SbError nRet = 0L;
1564 :
1565 0 : if( SbiRuntime::isVBAEnabled() )
1566 : {
1567 0 : switch( nError )
1568 : {
1569 : case 1:
1570 : case 2:
1571 : case 4:
1572 : case 8:
1573 : case 12:
1574 : case 73:
1575 0 : return 0L;
1576 : case 10:
1577 0 : return SbERR_BASIC_ARRAY_FIX;
1578 : case 14:
1579 0 : return SbERR_BASIC_STRING_OVERFLOW;
1580 : case 16:
1581 0 : return SbERR_BASIC_EXPR_TOO_COMPLEX;
1582 : case 17:
1583 0 : return SbERR_BASIC_OPER_NOT_PERFORM;
1584 : case 47:
1585 0 : return SbERR_BASIC_TOO_MANY_DLL;
1586 : case 92:
1587 0 : return SbERR_BASIC_LOOP_NOT_INIT;
1588 : default:
1589 0 : nRet = 0L;
1590 : }
1591 : }
1592 : const SFX_VB_ErrorItem* pErrItem;
1593 0 : sal_uInt16 nIndex = 0;
1594 0 : do
1595 : {
1596 0 : pErrItem = SFX_VB_ErrorTab + nIndex;
1597 0 : if( pErrItem->nErrorVB == nError )
1598 : {
1599 0 : nRet = pErrItem->nErrorSFX;
1600 0 : break;
1601 : }
1602 0 : else if( pErrItem->nErrorVB > nError )
1603 : {
1604 0 : break; // couldn't found anymore
1605 : }
1606 0 : nIndex++;
1607 : }
1608 : while( pErrItem->nErrorVB != 0xFFFF ); // up to end mark
1609 0 : return nRet;
1610 : }
1611 :
1612 : // set Error- / Break-data
1613 0 : void StarBASIC::SetErrorData( SbError nCode, sal_uInt16 nLine,
1614 : sal_uInt16 nCol1, sal_uInt16 nCol2 )
1615 : {
1616 0 : SbiGlobals& aGlobals = *GetSbData();
1617 0 : aGlobals.nCode = nCode;
1618 0 : aGlobals.nLine = nLine;
1619 0 : aGlobals.nCol1 = nCol1;
1620 0 : aGlobals.nCol2 = nCol2;
1621 0 : }
1622 :
1623 : //----------------------------------------------------------------
1624 : // help class for access to string SubResource of a Resource.
1625 : // Source: sfx2\source\doc\docfile.cxx (TLX)
1626 : struct BasicStringList_Impl : private Resource
1627 : {
1628 : ResId aResId;
1629 :
1630 0 : BasicStringList_Impl( ResId& rErrIdP, sal_uInt16 nId)
1631 0 : : Resource( rErrIdP ),aResId(nId, *rErrIdP.GetResMgr() ){}
1632 0 : ~BasicStringList_Impl() { FreeResource(); }
1633 :
1634 0 : OUString GetString(){ return aResId.toString(); }
1635 0 : sal_Bool IsErrorTextAvailable( void )
1636 0 : { return IsAvailableRes(aResId.SetRT(RSC_STRING)); }
1637 : };
1638 : //----------------------------------------------------------------
1639 :
1640 0 : void StarBASIC::MakeErrorText( SbError nId, const OUString& aMsg )
1641 : {
1642 0 : SolarMutexGuard aSolarGuard;
1643 0 : sal_uInt16 nOldID = GetVBErrorCode( nId );
1644 :
1645 : // intantiate the help class
1646 0 : BasResId aId( RID_BASIC_START );
1647 0 : BasicStringList_Impl aMyStringList( aId, sal_uInt16(nId & ERRCODE_RES_MASK) );
1648 :
1649 0 : if( aMyStringList.IsErrorTextAvailable() )
1650 : {
1651 : // merge message with additional text
1652 0 : OUStringBuffer aMsg1(aMyStringList.GetString());
1653 : // replace argument placeholder with %s
1654 0 : OUString aSrgStr( "$(ARG1)" );
1655 0 : sal_Int32 nResult = aMyStringList.GetString().indexOf( aSrgStr );
1656 :
1657 0 : if( nResult >= 0 )
1658 : {
1659 0 : aMsg1.remove(nResult, aSrgStr.getLength());
1660 0 : aMsg1.insert(nResult, aMsg);
1661 : }
1662 0 : GetSbData()->aErrMsg = aMsg1.makeStringAndClear();
1663 : }
1664 0 : else if( nOldID != 0 )
1665 : {
1666 0 : OUStringBuffer aStdMsg;
1667 0 : aStdMsg.append("Fehler ").append(static_cast<sal_Int32>(nOldID)).append(": Kein Fehlertext verfuegbar!");
1668 0 : GetSbData()->aErrMsg = aStdMsg.makeStringAndClear();
1669 : }
1670 : else
1671 : {
1672 0 : GetSbData()->aErrMsg = "";
1673 0 : }
1674 0 : }
1675 :
1676 0 : sal_Bool StarBASIC::CError( SbError code, const OUString& rMsg,
1677 : sal_Int32 l, sal_Int32 c1, sal_Int32 c2 )
1678 : {
1679 0 : SolarMutexGuard aSolarGuard;
1680 :
1681 : // compiler error during runtime -> stop programm
1682 0 : if( IsRunning() )
1683 : {
1684 : // #109018 Check if running Basic is affected
1685 0 : StarBASIC* pStartedBasic = GetSbData()->pInst->GetBasic();
1686 0 : if( pStartedBasic != this )
1687 : {
1688 0 : return sal_False;
1689 : }
1690 0 : Stop();
1691 : }
1692 :
1693 : // set flag, so that GlobalRunInit notice the error
1694 0 : GetSbData()->bGlobalInitErr = true;
1695 :
1696 : // tinker the error message
1697 0 : MakeErrorText( code, rMsg );
1698 :
1699 : // Implementation of the code for the string transport to SFX-Error
1700 0 : if( !rMsg.isEmpty() )
1701 : {
1702 0 : code = (sal_uIntPtr)*new StringErrorInfo( code, rMsg );
1703 : }
1704 0 : SetErrorData( code, l, c1, c2 );
1705 0 : GetSbData()->bCompiler = true;
1706 : sal_Bool bRet;
1707 0 : if( GetSbData()->aErrHdl.IsSet() )
1708 : {
1709 0 : bRet = (sal_Bool) GetSbData()->aErrHdl.Call( this );
1710 : }
1711 : else
1712 : {
1713 0 : bRet = ErrorHdl();
1714 : }
1715 0 : GetSbData()->bCompiler = false; // only true for error handler
1716 0 : return bRet;
1717 : }
1718 :
1719 0 : sal_Bool StarBASIC::RTError( SbError code, sal_Int32 l, sal_Int32 c1, sal_Int32 c2 )
1720 : {
1721 0 : return RTError( code, OUString(), l, c1, c2 );
1722 : }
1723 :
1724 0 : sal_Bool StarBASIC::RTError( SbError code, const OUString& rMsg, sal_Int32 l, sal_Int32 c1, sal_Int32 c2 )
1725 : {
1726 0 : SolarMutexGuard aSolarGuard;
1727 :
1728 0 : SbError c = code;
1729 0 : if( (c & ERRCODE_CLASS_MASK) == ERRCODE_CLASS_COMPILER )
1730 : {
1731 0 : c = 0;
1732 : }
1733 0 : MakeErrorText( c, rMsg );
1734 :
1735 : // Implementation of the code for the string transport to SFX-Error
1736 0 : if( !rMsg.isEmpty() )
1737 : {
1738 : // very confusing, even though MakeErrorText sets up the error text
1739 : // seems that this is not used ( if rMsg already has content )
1740 : // In the case of VBA MakeErrorText also formats the error to be alittle more
1741 : // like vba ( adds an error number etc )
1742 0 : if ( SbiRuntime::isVBAEnabled() && ( code == SbERR_BASIC_COMPAT ) )
1743 : {
1744 0 : OUStringBuffer aTmp;
1745 0 : aTmp.append('\'').append(SbxErrObject::getUnoErrObject()->getNumber())
1746 0 : .append("\'\n").append(!GetSbData()->aErrMsg.isEmpty() ? GetSbData()->aErrMsg : rMsg);
1747 0 : code = (sal_uIntPtr)*new StringErrorInfo( code, aTmp.makeStringAndClear() );
1748 : }
1749 : else
1750 : {
1751 0 : code = (sal_uIntPtr)*new StringErrorInfo( code, rMsg );
1752 : }
1753 : }
1754 :
1755 0 : SetErrorData( code, l, c1, c2 );
1756 0 : if( GetSbData()->aErrHdl.IsSet() )
1757 : {
1758 0 : return (sal_Bool) GetSbData()->aErrHdl.Call( this );
1759 : }
1760 : else
1761 : {
1762 0 : return ErrorHdl();
1763 0 : }
1764 : }
1765 :
1766 0 : void StarBASIC::Error( SbError n )
1767 : {
1768 0 : Error( n, OUString() );
1769 0 : }
1770 :
1771 0 : void StarBASIC::Error( SbError n, const OUString& rMsg )
1772 : {
1773 0 : if( GetSbData()->pInst )
1774 : {
1775 0 : GetSbData()->pInst->Error( n, rMsg );
1776 : }
1777 0 : }
1778 :
1779 0 : void StarBASIC::FatalError( SbError n )
1780 : {
1781 0 : if( GetSbData()->pInst )
1782 : {
1783 0 : GetSbData()->pInst->FatalError( n );
1784 : }
1785 0 : }
1786 :
1787 0 : void StarBASIC::FatalError( SbError _errCode, const OUString& _details )
1788 : {
1789 0 : if( GetSbData()->pInst )
1790 : {
1791 0 : GetSbData()->pInst->FatalError( _errCode, _details );
1792 : }
1793 0 : }
1794 :
1795 0 : SbError StarBASIC::GetErrBasic()
1796 : {
1797 0 : if( GetSbData()->pInst )
1798 : {
1799 0 : return GetSbData()->pInst->GetErr();
1800 : }
1801 : else
1802 : {
1803 0 : return 0;
1804 : }
1805 : }
1806 :
1807 : // make the additional message for the RTL function error accessible
1808 0 : OUString StarBASIC::GetErrorMsg()
1809 : {
1810 0 : if( GetSbData()->pInst )
1811 : {
1812 0 : return GetSbData()->pInst->GetErrorMsg();
1813 : }
1814 : else
1815 : {
1816 0 : return OUString();
1817 : }
1818 : }
1819 :
1820 0 : sal_Int32 StarBASIC::GetErl()
1821 : {
1822 0 : if( GetSbData()->pInst )
1823 : {
1824 0 : return GetSbData()->pInst->GetErl();
1825 : }
1826 : else
1827 : {
1828 0 : return 0;
1829 : }
1830 : }
1831 :
1832 0 : sal_Bool StarBASIC::ErrorHdl()
1833 : {
1834 0 : return (sal_Bool) ( aErrorHdl.IsSet()
1835 0 : ? aErrorHdl.Call( this ) : sal_False );
1836 : }
1837 :
1838 0 : Link StarBASIC::GetGlobalErrorHdl()
1839 : {
1840 0 : return GetSbData()->aErrHdl;
1841 : }
1842 :
1843 35 : void StarBASIC::SetGlobalErrorHdl( const Link& rLink )
1844 : {
1845 35 : GetSbData()->aErrHdl = rLink;
1846 35 : }
1847 :
1848 0 : void StarBASIC::SetGlobalBreakHdl( const Link& rLink )
1849 : {
1850 0 : GetSbData()->aBreakHdl = rLink;
1851 0 : }
1852 :
1853 0 : SbxArrayRef StarBASIC::getUnoListeners( void )
1854 : {
1855 0 : if( !xUnoListeners.Is() )
1856 : {
1857 0 : xUnoListeners = new SbxArray();
1858 : }
1859 0 : return xUnoListeners;
1860 : }
1861 :
1862 :
1863 : /**************************************************************************
1864 : *
1865 : * load and save
1866 : *
1867 : **************************************************************************/
1868 :
1869 0 : sal_Bool StarBASIC::LoadData( SvStream& r, sal_uInt16 nVer )
1870 : {
1871 0 : if( !SbxObject::LoadData( r, nVer ) )
1872 : {
1873 0 : return sal_False;
1874 : }
1875 : // #95459 Delete dialogs, otherwise endless recursion
1876 : // in SbxVarable::GetType() if dialogs are accessed
1877 0 : sal_uInt16 nObjCount = pObjs->Count();
1878 0 : SbxVariable** ppDeleteTab = new SbxVariable*[ nObjCount ];
1879 : sal_uInt16 nObj;
1880 :
1881 0 : for( nObj = 0 ; nObj < nObjCount ; nObj++ )
1882 : {
1883 0 : SbxVariable* pVar = pObjs->Get( nObj );
1884 0 : StarBASIC* pBasic = PTR_CAST( StarBASIC, pVar );
1885 0 : ppDeleteTab[nObj] = pBasic ? NULL : pVar;
1886 : }
1887 0 : for( nObj = 0 ; nObj < nObjCount ; nObj++ )
1888 : {
1889 0 : SbxVariable* pVar = ppDeleteTab[nObj];
1890 0 : if( pVar )
1891 : {
1892 0 : pObjs->Remove( pVar );
1893 : }
1894 : }
1895 0 : delete[] ppDeleteTab;
1896 :
1897 : sal_uInt16 nMod;
1898 0 : pModules->Clear();
1899 0 : r >> nMod;
1900 0 : for( sal_uInt16 i = 0; i < nMod; i++ )
1901 : {
1902 0 : SbModule* pMod = (SbModule*) SbxBase::Load( r );
1903 0 : if( !pMod )
1904 : {
1905 0 : return sal_False;
1906 : }
1907 0 : else if( pMod->ISA(SbJScriptModule) )
1908 : {
1909 : // assign Ref, so that pMod will be deleted
1910 0 : SbModuleRef xRef = pMod;
1911 : }
1912 : else
1913 : {
1914 0 : pMod->SetParent( this );
1915 0 : pModules->Put( pMod, i );
1916 : }
1917 : }
1918 : // HACK for SFX-Bullshit!
1919 0 : SbxVariable* p = Find( OUString("FALSE"), SbxCLASS_PROPERTY );
1920 0 : if( p )
1921 : {
1922 0 : Remove( p );
1923 : }
1924 0 : p = Find( OUString("TRUE"), SbxCLASS_PROPERTY );
1925 0 : if( p )
1926 : {
1927 0 : Remove( p );
1928 : }
1929 : // End of the hacks!
1930 : // Search via StarBASIC is at all times global
1931 : DBG_ASSERT( IsSet( SBX_GBLSEARCH ), "Basic ohne GBLSEARCH geladen" );
1932 0 : SetFlag( SBX_GBLSEARCH );
1933 0 : return sal_True;
1934 : }
1935 :
1936 0 : sal_Bool StarBASIC::StoreData( SvStream& r ) const
1937 : {
1938 0 : if( !SbxObject::StoreData( r ) )
1939 : {
1940 0 : return sal_False;
1941 : }
1942 0 : r << (sal_uInt16) pModules->Count();
1943 0 : for( sal_uInt16 i = 0; i < pModules->Count(); i++ )
1944 : {
1945 0 : SbModule* p = (SbModule*) pModules->Get( i );
1946 0 : if( !p->Store( r ) )
1947 : {
1948 0 : return sal_False;
1949 : }
1950 : }
1951 0 : return sal_True;
1952 : }
1953 :
1954 2141 : bool StarBASIC::GetUNOConstant( const sal_Char* _pAsciiName, ::com::sun::star::uno::Any& aOut )
1955 : {
1956 2141 : bool bRes = false;
1957 2141 : OUString sVarName( OUString::createFromAscii( _pAsciiName ) );
1958 2141 : SbUnoObject* pGlobs = dynamic_cast<SbUnoObject*>( Find( sVarName, SbxCLASS_DONTCARE ) );
1959 2141 : if ( pGlobs )
1960 : {
1961 484 : aOut = pGlobs->getUnoAny();
1962 484 : bRes = true;
1963 : }
1964 2141 : return bRes;
1965 : }
1966 :
1967 0 : Reference< frame::XModel > StarBASIC::GetModelFromBasic( SbxObject* pBasic )
1968 : {
1969 : OSL_PRECOND( pBasic != NULL, "getModelFromBasic: illegal call!" );
1970 0 : if ( !pBasic )
1971 : {
1972 0 : return NULL;
1973 : }
1974 : // look for the ThisComponent variable, first in the parent (which
1975 : // might be the document's Basic), then in the parent's parent (which might be
1976 : // the application Basic)
1977 0 : const OUString sThisComponent( "ThisComponent");
1978 0 : SbxVariable* pThisComponent = NULL;
1979 :
1980 0 : SbxObject* pLookup = pBasic->GetParent();
1981 0 : while ( pLookup && !pThisComponent )
1982 : {
1983 0 : pThisComponent = pLookup->Find( sThisComponent, SbxCLASS_OBJECT );
1984 0 : pLookup = pLookup->GetParent();
1985 : }
1986 0 : if ( !pThisComponent )
1987 : {
1988 : OSL_TRACE("Failed to get ThisComponent");
1989 : // the application Basic, at the latest, should have this variable
1990 0 : return NULL;
1991 : }
1992 :
1993 0 : Any aThisComponentAny( sbxToUnoValue( pThisComponent ) );
1994 0 : Reference< frame::XModel > xModel( aThisComponentAny, UNO_QUERY );
1995 0 : if ( !xModel.is() )
1996 : {
1997 : // it's no XModel. Okay, ThisComponent nowadays is allowed to be a controller.
1998 0 : Reference< frame::XController > xController( aThisComponentAny, UNO_QUERY );
1999 0 : if ( xController.is() )
2000 : {
2001 0 : xModel = xController->getModel();
2002 0 : }
2003 : }
2004 0 : if ( !xModel.is() )
2005 : {
2006 0 : return NULL;
2007 : }
2008 : #if OSL_DEBUG_LEVEL > 0
2009 : OSL_TRACE("Have model ThisComponent points to url %s",
2010 : OUStringToOString( xModel->getURL(),
2011 : RTL_TEXTENCODING_ASCII_US ).pData->buffer );
2012 : #endif
2013 :
2014 0 : return xModel;
2015 : }
2016 :
2017 :
2018 : //========================================================================
2019 : // #118116 Implementation Collection object
2020 :
2021 0 : TYPEINIT1(BasicCollection,SbxObject)
2022 :
2023 : static const char pCountStr[] = "Count";
2024 : static const char pAddStr[] = "Add";
2025 : static const char pItemStr[] = "Item";
2026 : static const char pRemoveStr[] = "Remove";
2027 : static sal_uInt16 nCountHash = 0, nAddHash, nItemHash, nRemoveHash;
2028 :
2029 28 : SbxInfoRef BasicCollection::xAddInfo = NULL;
2030 28 : SbxInfoRef BasicCollection::xItemInfo = NULL;
2031 :
2032 0 : BasicCollection::BasicCollection( const OUString& rClass )
2033 0 : : SbxObject( rClass )
2034 : {
2035 0 : if( !nCountHash )
2036 : {
2037 0 : nCountHash = MakeHashCode( OUString::createFromAscii( pCountStr ) );
2038 0 : nAddHash = MakeHashCode( OUString::createFromAscii( pAddStr ) );
2039 0 : nItemHash = MakeHashCode( OUString::createFromAscii( pItemStr ) );
2040 0 : nRemoveHash = MakeHashCode( OUString::createFromAscii( pRemoveStr ) );
2041 : }
2042 0 : Initialize();
2043 :
2044 0 : }
2045 :
2046 0 : BasicCollection::~BasicCollection()
2047 0 : {}
2048 :
2049 0 : void BasicCollection::Clear()
2050 : {
2051 0 : SbxObject::Clear();
2052 0 : Initialize();
2053 0 : }
2054 :
2055 0 : void BasicCollection::Initialize()
2056 : {
2057 0 : xItemArray = new SbxArray();
2058 0 : SetType( SbxOBJECT );
2059 0 : SetFlag( SBX_FIXED );
2060 0 : ResetFlag( SBX_WRITE );
2061 : SbxVariable* p;
2062 0 : p = Make( OUString::createFromAscii( pCountStr ), SbxCLASS_PROPERTY, SbxINTEGER );
2063 0 : p->ResetFlag( SBX_WRITE );
2064 0 : p->SetFlag( SBX_DONTSTORE );
2065 0 : p = Make( OUString::createFromAscii( pAddStr ), SbxCLASS_METHOD, SbxEMPTY );
2066 0 : p->SetFlag( SBX_DONTSTORE );
2067 0 : p = Make( OUString::createFromAscii( pItemStr ), SbxCLASS_METHOD, SbxVARIANT );
2068 0 : p->SetFlag( SBX_DONTSTORE );
2069 0 : p = Make( OUString::createFromAscii( pRemoveStr ), SbxCLASS_METHOD, SbxEMPTY );
2070 0 : p->SetFlag( SBX_DONTSTORE );
2071 0 : if ( !xAddInfo.Is() )
2072 : {
2073 0 : xAddInfo = new SbxInfo;
2074 0 : xAddInfo->AddParam( OUString( "Item" ), SbxVARIANT, SBX_READ );
2075 0 : xAddInfo->AddParam( OUString( "Key" ), SbxVARIANT, SBX_READ | SBX_OPTIONAL );
2076 0 : xAddInfo->AddParam( OUString( "Before" ), SbxVARIANT, SBX_READ | SBX_OPTIONAL );
2077 0 : xAddInfo->AddParam( OUString( "After" ), SbxVARIANT, SBX_READ | SBX_OPTIONAL );
2078 : }
2079 0 : if ( !xItemInfo.Is() )
2080 : {
2081 0 : xItemInfo = new SbxInfo;
2082 0 : xItemInfo->AddParam( OUString( "Index" ), SbxVARIANT, SBX_READ | SBX_OPTIONAL);
2083 : }
2084 0 : }
2085 :
2086 0 : SbxVariable* BasicCollection::Find( const OUString& rName, SbxClassType t )
2087 : {
2088 0 : SbxVariable* pFind = SbxObject::Find( rName, t );
2089 0 : return pFind;
2090 : }
2091 :
2092 0 : void BasicCollection::SFX_NOTIFY( SfxBroadcaster& rCst, const TypeId& rId1,
2093 : const SfxHint& rHint, const TypeId& rId2 )
2094 : {
2095 0 : const SbxHint* p = PTR_CAST(SbxHint,&rHint);
2096 0 : if( p )
2097 : {
2098 0 : sal_uIntPtr nId = p->GetId();
2099 0 : sal_Bool bRead = sal_Bool( nId == SBX_HINT_DATAWANTED );
2100 0 : sal_Bool bWrite = sal_Bool( nId == SBX_HINT_DATACHANGED );
2101 0 : sal_Bool bRequestInfo = sal_Bool( nId == SBX_HINT_INFOWANTED );
2102 0 : SbxVariable* pVar = p->GetVar();
2103 0 : SbxArray* pArg = pVar->GetParameters();
2104 0 : OUString aVarName( pVar->GetName() );
2105 0 : if( bRead || bWrite )
2106 : {
2107 0 : if( pVar->GetHashCode() == nCountHash
2108 0 : && aVarName.equalsIgnoreAsciiCaseAscii( pCountStr ) )
2109 : {
2110 0 : pVar->PutLong( xItemArray->Count32() );
2111 : }
2112 0 : else if( pVar->GetHashCode() == nAddHash
2113 0 : && aVarName.equalsIgnoreAsciiCaseAscii( pAddStr ) )
2114 : {
2115 0 : CollAdd( pArg );
2116 : }
2117 0 : else if( pVar->GetHashCode() == nItemHash
2118 0 : && aVarName.equalsIgnoreAsciiCaseAscii( pItemStr ) )
2119 : {
2120 0 : CollItem( pArg );
2121 : }
2122 0 : else if( pVar->GetHashCode() == nRemoveHash
2123 0 : && aVarName.equalsIgnoreAsciiCaseAscii( pRemoveStr ) )
2124 : {
2125 0 : CollRemove( pArg );
2126 : }
2127 : else
2128 : {
2129 0 : SbxObject::SFX_NOTIFY( rCst, rId1, rHint, rId2 );
2130 : }
2131 0 : return;
2132 : }
2133 0 : else if ( bRequestInfo )
2134 : {
2135 0 : if( pVar->GetHashCode() == nAddHash
2136 0 : && aVarName.equalsIgnoreAsciiCaseAscii( pAddStr ) )
2137 : {
2138 0 : pVar->SetInfo( xAddInfo );
2139 : }
2140 0 : else if( pVar->GetHashCode() == nItemHash
2141 0 : && aVarName.equalsIgnoreAsciiCaseAscii( pItemStr ) )
2142 : {
2143 0 : pVar->SetInfo( xItemInfo );
2144 : }
2145 0 : }
2146 : }
2147 0 : SbxObject::SFX_NOTIFY( rCst, rId1, rHint, rId2 );
2148 : }
2149 :
2150 0 : sal_Int32 BasicCollection::implGetIndex( SbxVariable* pIndexVar )
2151 : {
2152 0 : sal_Int32 nIndex = -1;
2153 0 : if( pIndexVar->GetType() == SbxSTRING )
2154 : {
2155 0 : nIndex = implGetIndexForName( pIndexVar->GetOUString() );
2156 : }
2157 : else
2158 : {
2159 0 : nIndex = pIndexVar->GetLong() - 1;
2160 : }
2161 0 : return nIndex;
2162 : }
2163 :
2164 0 : sal_Int32 BasicCollection::implGetIndexForName( const OUString& rName )
2165 : {
2166 0 : sal_Int32 nIndex = -1;
2167 0 : sal_Int32 nCount = xItemArray->Count32();
2168 0 : sal_Int32 nNameHash = MakeHashCode( rName );
2169 0 : for( sal_Int32 i = 0 ; i < nCount ; i++ )
2170 : {
2171 0 : SbxVariable* pVar = xItemArray->Get32( i );
2172 0 : if( pVar->GetHashCode() == nNameHash &&
2173 0 : pVar->GetName().equalsIgnoreAsciiCase( rName ) )
2174 : {
2175 0 : nIndex = i;
2176 0 : break;
2177 : }
2178 : }
2179 0 : return nIndex;
2180 : }
2181 :
2182 0 : void BasicCollection::CollAdd( SbxArray* pPar_ )
2183 : {
2184 0 : sal_uInt16 nCount = pPar_->Count();
2185 0 : if( nCount < 2 || nCount > 5 )
2186 : {
2187 0 : SetError( SbxERR_WRONG_ARGS );
2188 0 : return;
2189 : }
2190 :
2191 0 : SbxVariable* pItem = pPar_->Get(1);
2192 0 : if( pItem )
2193 : {
2194 : int nNextIndex;
2195 0 : if( nCount < 4 )
2196 : {
2197 0 : nNextIndex = xItemArray->Count();
2198 : }
2199 : else
2200 : {
2201 0 : SbxVariable* pBefore = pPar_->Get(3);
2202 0 : if( nCount == 5 )
2203 : {
2204 0 : if( !( pBefore->IsErr() || ( pBefore->GetType() == SbxEMPTY ) ) )
2205 : {
2206 0 : SetError( SbERR_BAD_ARGUMENT );
2207 : return;
2208 : }
2209 0 : SbxVariable* pAfter = pPar_->Get(4);
2210 0 : sal_Int32 nAfterIndex = implGetIndex( pAfter );
2211 0 : if( nAfterIndex == -1 )
2212 : {
2213 0 : SetError( SbERR_BAD_ARGUMENT );
2214 : return;
2215 : }
2216 0 : nNextIndex = nAfterIndex + 1;
2217 : }
2218 : else // if( nCount == 4 )
2219 : {
2220 0 : sal_Int32 nBeforeIndex = implGetIndex( pBefore );
2221 0 : if( nBeforeIndex == -1 )
2222 : {
2223 0 : SetError( SbERR_BAD_ARGUMENT );
2224 : return;
2225 : }
2226 0 : nNextIndex = nBeforeIndex;
2227 : }
2228 : }
2229 :
2230 0 : SbxVariableRef pNewItem = new SbxVariable( *pItem );
2231 0 : if( nCount >= 3 )
2232 : {
2233 0 : SbxVariable* pKey = pPar_->Get(2);
2234 0 : if( !( pKey->IsErr() || ( pKey->GetType() == SbxEMPTY ) ) )
2235 : {
2236 0 : if( pKey->GetType() != SbxSTRING )
2237 : {
2238 0 : SetError( SbERR_BAD_ARGUMENT );
2239 : return;
2240 : }
2241 0 : OUString aKey = pKey->GetOUString();
2242 0 : if( implGetIndexForName( aKey ) != -1 )
2243 : {
2244 0 : SetError( SbERR_BAD_ARGUMENT );
2245 : return;
2246 : }
2247 0 : pNewItem->SetName( aKey );
2248 : }
2249 : }
2250 0 : pNewItem->SetFlag( SBX_READWRITE );
2251 0 : xItemArray->Insert32( pNewItem, nNextIndex );
2252 : }
2253 : else
2254 : {
2255 0 : SetError( SbERR_BAD_ARGUMENT );
2256 0 : return;
2257 : }
2258 : }
2259 :
2260 0 : void BasicCollection::CollItem( SbxArray* pPar_ )
2261 : {
2262 0 : if( pPar_->Count() != 2 )
2263 : {
2264 0 : SetError( SbxERR_WRONG_ARGS );
2265 0 : return;
2266 : }
2267 0 : SbxVariable* pRes = NULL;
2268 0 : SbxVariable* p = pPar_->Get( 1 );
2269 0 : sal_Int32 nIndex = implGetIndex( p );
2270 0 : if( nIndex >= 0 && nIndex < (sal_Int32)xItemArray->Count32() )
2271 : {
2272 0 : pRes = xItemArray->Get32( nIndex );
2273 : }
2274 0 : if( !pRes )
2275 : {
2276 0 : SetError( SbERR_BAD_ARGUMENT );
2277 : }
2278 : else
2279 : {
2280 0 : *(pPar_->Get(0)) = *pRes;
2281 : }
2282 : }
2283 :
2284 0 : void BasicCollection::CollRemove( SbxArray* pPar_ )
2285 : {
2286 0 : if( pPar_ == NULL || pPar_->Count() != 2 )
2287 : {
2288 0 : SetError( SbxERR_WRONG_ARGS );
2289 0 : return;
2290 : }
2291 :
2292 0 : SbxVariable* p = pPar_->Get( 1 );
2293 0 : sal_Int32 nIndex = implGetIndex( p );
2294 0 : if( nIndex >= 0 && nIndex < (sal_Int32)xItemArray->Count32() )
2295 : {
2296 0 : xItemArray->Remove32( nIndex );
2297 :
2298 : // Correct for stack if necessary
2299 0 : SbiInstance* pInst = GetSbData()->pInst;
2300 0 : SbiRuntime* pRT = pInst ? pInst->pRun : NULL;
2301 0 : if( pRT )
2302 : {
2303 0 : SbiForStack* pStack = pRT->FindForStackItemForCollection( this );
2304 0 : if( pStack != NULL )
2305 : {
2306 0 : if( pStack->nCurCollectionIndex >= nIndex )
2307 : {
2308 0 : --pStack->nCurCollectionIndex;
2309 : }
2310 : }
2311 : }
2312 : }
2313 : else
2314 : {
2315 0 : SetError( SbERR_BAD_ARGUMENT );
2316 : }
2317 84 : }
2318 :
2319 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
