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