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