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