| /************************************************************** | |
| * | |
| * Licensed to the Apache Software Foundation (ASF) under one | |
| * or more contributor license agreements. See the NOTICE file | |
| * distributed with this work for additional information | |
| * regarding copyright ownership. The ASF licenses this file | |
| * to you under the Apache License, Version 2.0 (the | |
| * "License"); you may not use this file except in compliance | |
| * with the License. You may obtain a copy of the License at | |
| * | |
| * http://www.apache.org/licenses/LICENSE-2.0 | |
| * | |
| * Unless required by applicable law or agreed to in writing, | |
| * software distributed under the License is distributed on an | |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY | |
| * KIND, either express or implied. See the License for the | |
| * specific language governing permissions and limitations | |
| * under the License. | |
| * | |
| *************************************************************/ | |
| // MARKER(update_precomp.py): autogen include statement, do not remove | |
| #include "precompiled_basic.hxx" | |
| #include <stdio.h> | |
| #include "sb.hxx" | |
| #include <tools/rcid.h> | |
| #include <tools/config.hxx> | |
| #include <tools/stream.hxx> | |
| #ifndef __RSC //autogen | |
| #include <tools/errinf.hxx> | |
| #endif | |
| #include <basic/sbx.hxx> | |
| #include <tools/list.hxx> | |
| #include <tools/shl.hxx> | |
| #include <tools/rc.hxx> | |
| #include <vcl/svapp.hxx> | |
| #include <comphelper/processfactory.hxx> | |
| #include "sbunoobj.hxx" | |
| #include "sbjsmeth.hxx" | |
| #include "sbjsmod.hxx" | |
| #include "sbintern.hxx" | |
| #include "disas.hxx" | |
| #include "runtime.hxx" | |
| #include <basic/sbuno.hxx> | |
| #include <basic/sbobjmod.hxx> | |
| #include "stdobj.hxx" | |
| #include "filefmt.hxx" | |
| #include "sb.hrc" | |
| #include <basrid.hxx> | |
| #include <vos/mutex.hxx> | |
| #include <cppuhelper/implbase1.hxx> | |
| #include <com/sun/star/lang/XMultiServiceFactory.hpp> | |
| #include <com/sun/star/util/XCloseBroadcaster.hpp> | |
| #include <com/sun/star/util/XCloseListener.hpp> | |
| #include "errobject.hxx" | |
| #include <map> | |
| #include <hash_map> | |
| #include <vector> | |
| #include <algorithm> | |
| #include <com/sun/star/script/ModuleType.hpp> | |
| #include <com/sun/star/script/ModuleInfo.hpp> | |
| using namespace ::com::sun::star::script; | |
| // #pragma SW_SEGMENT_CLASS( SBASIC, SBASIC_CODE ) | |
| SV_IMPL_VARARR(SbTextPortions,SbTextPortion) | |
| TYPEINIT1(StarBASIC,SbxObject) | |
| #define RTLNAME "@SBRTL" | |
| // i#i68894# | |
| using namespace ::com::sun::star; | |
| using com::sun::star::uno::Reference; | |
| using com::sun::star::uno::Any; | |
| using com::sun::star::uno::UNO_QUERY; | |
| using com::sun::star::lang::XMultiServiceFactory; | |
| const static String aThisComponent( RTL_CONSTASCII_USTRINGPARAM("ThisComponent") ); | |
| const static String aVBAHook( RTL_CONSTASCII_USTRINGPARAM( "VBAGlobals" ) ); | |
| // ============================================================================ | |
| class DocBasicItem : public ::cppu::WeakImplHelper1< util::XCloseListener > | |
| { | |
| public: | |
| explicit DocBasicItem( StarBASIC& rDocBasic ); | |
| virtual ~DocBasicItem(); | |
| inline const SbxObjectRef& getClassModules() const { return mxClassModules; } | |
| inline bool isDocClosed() const { return mbDocClosed; } | |
| void clearDependingVarsOnDelete( StarBASIC& rDeletedBasic ); | |
| void startListening(); | |
| void stopListening(); | |
| virtual void SAL_CALL queryClosing( const lang::EventObject& rSource, sal_Bool bGetsOwnership ); | |
| virtual void SAL_CALL notifyClosing( const lang::EventObject& rSource ); | |
| virtual void SAL_CALL disposing( const lang::EventObject& rSource ); | |
| private: | |
| StarBASIC& mrDocBasic; | |
| SbxObjectRef mxClassModules; | |
| bool mbDocClosed; | |
| bool mbDisposed; | |
| }; | |
| // ---------------------------------------------------------------------------- | |
| DocBasicItem::DocBasicItem( StarBASIC& rDocBasic ) : | |
| mrDocBasic( rDocBasic ), | |
| mxClassModules( new SbxObject( String() ) ), | |
| mbDocClosed( false ), | |
| mbDisposed( false ) | |
| { | |
| } | |
| DocBasicItem::~DocBasicItem() | |
| { | |
| stopListening(); | |
| } | |
| void DocBasicItem::clearDependingVarsOnDelete( StarBASIC& rDeletedBasic ) | |
| { | |
| mrDocBasic.implClearDependingVarsOnDelete( &rDeletedBasic ); | |
| } | |
| void DocBasicItem::startListening() | |
| { | |
| Any aThisComp; | |
| mrDocBasic.GetUNOConstant( "ThisComponent", aThisComp ); | |
| Reference< util::XCloseBroadcaster > xCloseBC( aThisComp, UNO_QUERY ); | |
| mbDisposed = !xCloseBC.is(); | |
| if( xCloseBC.is() ) | |
| try { xCloseBC->addCloseListener( this ); } catch( uno::Exception& ) {} | |
| } | |
| void DocBasicItem::stopListening() | |
| { | |
| if( mbDisposed ) return; | |
| mbDisposed = true; | |
| Any aThisComp; | |
| mrDocBasic.GetUNOConstant( "ThisComponent", aThisComp ); | |
| Reference< util::XCloseBroadcaster > xCloseBC( aThisComp, UNO_QUERY ); | |
| if( xCloseBC.is() ) | |
| try { xCloseBC->removeCloseListener( this ); } catch( uno::Exception& ) {} | |
| } | |
| void SAL_CALL DocBasicItem::queryClosing( const lang::EventObject& /*rSource*/, sal_Bool /*bGetsOwnership*/ ) | |
| { | |
| } | |
| void SAL_CALL DocBasicItem::notifyClosing( const lang::EventObject& /*rEvent*/ ) | |
| { | |
| stopListening(); | |
| mbDocClosed = true; | |
| } | |
| void SAL_CALL DocBasicItem::disposing( const lang::EventObject& /*rEvent*/ ) | |
| { | |
| stopListening(); | |
| } | |
| // ---------------------------------------------------------------------------- | |
| namespace { | |
| typedef ::rtl::Reference< DocBasicItem > DocBasicItemRef; | |
| typedef std::map< const StarBASIC*, DocBasicItemRef > DocBasicItemMap; | |
| static DocBasicItemMap GaDocBasicItems; | |
| const DocBasicItem* lclFindDocBasicItem( const StarBASIC* pDocBasic ) | |
| { | |
| DocBasicItemMap::iterator it = GaDocBasicItems.find( pDocBasic ); | |
| return (it != GaDocBasicItems.end()) ? it->second.get() : 0; | |
| } | |
| void lclInsertDocBasicItem( StarBASIC& rDocBasic ) | |
| { | |
| DocBasicItemRef& rxDocBasicItem = GaDocBasicItems[ &rDocBasic ]; | |
| rxDocBasicItem.set( new DocBasicItem( rDocBasic ) ); | |
| rxDocBasicItem->startListening(); | |
| } | |
| void lclRemoveDocBasicItem( StarBASIC& rDocBasic ) | |
| { | |
| DocBasicItemMap::iterator it = GaDocBasicItems.find( &rDocBasic ); | |
| if( it != GaDocBasicItems.end() ) | |
| { | |
| it->second->stopListening(); | |
| GaDocBasicItems.erase( it ); | |
| } | |
| DocBasicItemMap::iterator it_end = GaDocBasicItems.end(); | |
| for( it = GaDocBasicItems.begin(); it != it_end; ++it ) | |
| it->second->clearDependingVarsOnDelete( rDocBasic ); | |
| } | |
| StarBASIC* lclGetDocBasicForModule( SbModule* pModule ) | |
| { | |
| StarBASIC* pRetBasic = NULL; | |
| SbxObject* pCurParent = pModule; | |
| while( pCurParent->GetParent() != NULL ) | |
| { | |
| pCurParent = pCurParent->GetParent(); | |
| StarBASIC* pDocBasic = PTR_CAST( StarBASIC, pCurParent ); | |
| if( pDocBasic != NULL && pDocBasic->IsDocBasic() ) | |
| { | |
| pRetBasic = pDocBasic; | |
| break; | |
| } | |
| } | |
| return pRetBasic; | |
| } | |
| } // namespace | |
| // ============================================================================ | |
| SbxObject* StarBASIC::getVBAGlobals( ) | |
| { | |
| if ( !pVBAGlobals ) | |
| { | |
| Any aThisDoc; | |
| if ( GetUNOConstant("ThisComponent", aThisDoc) ) | |
| { | |
| Reference< XMultiServiceFactory > xDocFac( aThisDoc, UNO_QUERY ); | |
| if ( xDocFac.is() ) | |
| { | |
| try | |
| { | |
| xDocFac->createInstance( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "ooo.vba.VBAGlobals" ) ) ); | |
| } | |
| catch( Exception& ) | |
| { | |
| // Ignore | |
| } | |
| } | |
| } | |
| pVBAGlobals = (SbUnoObject*)Find( aVBAHook , SbxCLASS_DONTCARE ); | |
| } | |
| return pVBAGlobals; | |
| } | |
| // i#i68894# | |
| SbxVariable* StarBASIC::VBAFind( const String& rName, SbxClassType t ) | |
| { | |
| if( rName == aThisComponent ) | |
| return NULL; | |
| // rename to init globals | |
| if ( getVBAGlobals( ) ) | |
| return pVBAGlobals->Find( rName, t ); | |
| return NULL; | |
| } | |
| // Create array for conversion SFX <-> VB error code | |
| struct SFX_VB_ErrorItem | |
| { | |
| sal_uInt16 nErrorVB; | |
| SbError nErrorSFX; | |
| }; | |
| const SFX_VB_ErrorItem __FAR_DATA SFX_VB_ErrorTab[] = | |
| { | |
| { 1, SbERR_BASIC_EXCEPTION }, // #87844 Map exception to error code 1 | |
| { 2, SbERR_SYNTAX }, | |
| { 3, SbERR_NO_GOSUB }, | |
| { 4, SbERR_REDO_FROM_START }, | |
| { 5, SbERR_BAD_ARGUMENT }, | |
| { 6, SbERR_MATH_OVERFLOW }, | |
| { 7, SbERR_NO_MEMORY }, | |
| { 8, SbERR_ALREADY_DIM }, | |
| { 9, SbERR_OUT_OF_RANGE }, | |
| { 10, SbERR_DUPLICATE_DEF }, | |
| { 11, SbERR_ZERODIV }, | |
| { 12, SbERR_VAR_UNDEFINED }, | |
| { 13, SbERR_CONVERSION }, | |
| { 14, SbERR_BAD_PARAMETER }, | |
| { 18, SbERR_USER_ABORT }, | |
| { 20, SbERR_BAD_RESUME }, | |
| { 28, SbERR_STACK_OVERFLOW }, | |
| { 35, SbERR_PROC_UNDEFINED }, | |
| { 48, SbERR_BAD_DLL_LOAD }, | |
| { 49, SbERR_BAD_DLL_CALL }, | |
| { 51, SbERR_INTERNAL_ERROR }, | |
| { 52, SbERR_BAD_CHANNEL }, | |
| { 53, SbERR_FILE_NOT_FOUND }, | |
| { 54, SbERR_BAD_FILE_MODE }, | |
| { 55, SbERR_FILE_ALREADY_OPEN }, | |
| { 57, SbERR_IO_ERROR }, | |
| { 58, SbERR_FILE_EXISTS }, | |
| { 59, SbERR_BAD_RECORD_LENGTH }, | |
| { 61, SbERR_DISK_FULL }, | |
| { 62, SbERR_READ_PAST_EOF }, | |
| { 63, SbERR_BAD_RECORD_NUMBER }, | |
| { 67, SbERR_TOO_MANY_FILES }, | |
| { 68, SbERR_NO_DEVICE }, | |
| { 70, SbERR_ACCESS_DENIED }, | |
| { 71, SbERR_NOT_READY }, | |
| { 73, SbERR_NOT_IMPLEMENTED }, | |
| { 74, SbERR_DIFFERENT_DRIVE }, | |
| { 75, SbERR_ACCESS_ERROR }, | |
| { 76, SbERR_PATH_NOT_FOUND }, | |
| { 91, SbERR_NO_OBJECT }, | |
| { 93, SbERR_BAD_PATTERN }, | |
| { 94, SBERR_IS_NULL }, | |
| { 250, SbERR_DDE_ERROR }, | |
| { 280, SbERR_DDE_WAITINGACK }, | |
| { 281, SbERR_DDE_OUTOFCHANNELS }, | |
| { 282, SbERR_DDE_NO_RESPONSE }, | |
| { 283, SbERR_DDE_MULT_RESPONSES }, | |
| { 284, SbERR_DDE_CHANNEL_LOCKED }, | |
| { 285, SbERR_DDE_NOTPROCESSED }, | |
| { 286, SbERR_DDE_TIMEOUT }, | |
| { 287, SbERR_DDE_USER_INTERRUPT }, | |
| { 288, SbERR_DDE_BUSY }, | |
| { 289, SbERR_DDE_NO_DATA }, | |
| { 290, SbERR_DDE_WRONG_DATA_FORMAT }, | |
| { 291, SbERR_DDE_PARTNER_QUIT }, | |
| { 292, SbERR_DDE_CONV_CLOSED }, | |
| { 293, SbERR_DDE_NO_CHANNEL }, | |
| { 294, SbERR_DDE_INVALID_LINK }, | |
| { 295, SbERR_DDE_QUEUE_OVERFLOW }, | |
| { 296, SbERR_DDE_LINK_ALREADY_EST }, | |
| { 297, SbERR_DDE_LINK_INV_TOPIC }, | |
| { 298, SbERR_DDE_DLL_NOT_FOUND }, | |
| { 323, SbERR_CANNOT_LOAD }, | |
| { 341, SbERR_BAD_INDEX }, | |
| { 366, SbERR_NO_ACTIVE_OBJECT }, | |
| { 380, SbERR_BAD_PROP_VALUE }, | |
| { 382, SbERR_PROP_READONLY }, | |
| { 394, SbERR_PROP_WRITEONLY }, | |
| { 420, SbERR_INVALID_OBJECT }, | |
| { 423, SbERR_NO_METHOD }, | |
| { 424, SbERR_NEEDS_OBJECT }, | |
| { 425, SbERR_INVALID_USAGE_OBJECT }, | |
| { 430, SbERR_NO_OLE }, | |
| { 438, SbERR_BAD_METHOD }, | |
| { 440, SbERR_OLE_ERROR }, | |
| { 445, SbERR_BAD_ACTION }, | |
| { 446, SbERR_NO_NAMED_ARGS }, | |
| { 447, SbERR_BAD_LOCALE }, | |
| { 448, SbERR_NAMED_NOT_FOUND }, | |
| { 449, SbERR_NOT_OPTIONAL }, | |
| { 450, SbERR_WRONG_ARGS }, | |
| { 451, SbERR_NOT_A_COLL }, | |
| { 452, SbERR_BAD_ORDINAL }, | |
| { 453, SbERR_DLLPROC_NOT_FOUND }, | |
| { 460, SbERR_BAD_CLIPBD_FORMAT }, | |
| { 951, SbERR_UNEXPECTED }, | |
| { 952, SbERR_EXPECTED }, | |
| { 953, SbERR_SYMBOL_EXPECTED }, | |
| { 954, SbERR_VAR_EXPECTED }, | |
| { 955, SbERR_LABEL_EXPECTED }, | |
| { 956, SbERR_LVALUE_EXPECTED }, | |
| { 957, SbERR_VAR_DEFINED }, | |
| { 958, SbERR_PROC_DEFINED }, | |
| { 959, SbERR_LABEL_DEFINED }, | |
| { 960, SbERR_UNDEF_VAR }, | |
| { 961, SbERR_UNDEF_ARRAY }, | |
| { 962, SbERR_UNDEF_PROC }, | |
| { 963, SbERR_UNDEF_LABEL }, | |
| { 964, SbERR_UNDEF_TYPE }, | |
| { 965, SbERR_BAD_EXIT }, | |
| { 966, SbERR_BAD_BLOCK }, | |
| { 967, SbERR_BAD_BRACKETS }, | |
| { 968, SbERR_BAD_DECLARATION }, | |
| { 969, SbERR_BAD_PARAMETERS }, | |
| { 970, SbERR_BAD_CHAR_IN_NUMBER }, | |
| { 971, SbERR_MUST_HAVE_DIMS }, | |
| { 972, SbERR_NO_IF }, | |
| { 973, SbERR_NOT_IN_SUBR }, | |
| { 974, SbERR_NOT_IN_MAIN }, | |
| { 975, SbERR_WRONG_DIMS }, | |
| { 976, SbERR_BAD_OPTION }, | |
| { 977, SbERR_CONSTANT_REDECLARED }, | |
| { 978, SbERR_PROG_TOO_LARGE }, | |
| { 979, SbERR_NO_STRINGS_ARRAYS }, | |
| { 1000, SbERR_PROPERTY_NOT_FOUND }, | |
| { 1001, SbERR_METHOD_NOT_FOUND }, | |
| { 1002, SbERR_ARG_MISSING }, | |
| { 1003, SbERR_BAD_NUMBER_OF_ARGS }, | |
| { 1004, SbERR_METHOD_FAILED }, | |
| { 1005, SbERR_SETPROP_FAILED }, | |
| { 1006, SbERR_GETPROP_FAILED }, | |
| { 1007, SbERR_BASIC_COMPAT }, | |
| { 0xFFFF, 0xFFFFFFFFL } // End mark | |
| }; | |
| // The StarBASIC factory is a hack. When a SbModule is created, its pointer | |
| // is saved and given to the following SbProperties/SbMethods. This restores | |
| // the Modul-relationshop. But it works only when a modul is loaded. | |
| // Can cause troubles with separately loaded properties! | |
| SbxBase* SbiFactory::Create( sal_uInt16 nSbxId, sal_uInt32 nCreator ) | |
| { | |
| if( nCreator == SBXCR_SBX ) | |
| { | |
| String aEmpty; | |
| switch( nSbxId ) | |
| { | |
| case SBXID_BASIC: | |
| return new StarBASIC( NULL ); | |
| case SBXID_BASICMOD: | |
| return new SbModule( aEmpty ); | |
| case SBXID_BASICPROP: | |
| return new SbProperty( aEmpty, SbxVARIANT, NULL ); | |
| case SBXID_BASICMETHOD: | |
| return new SbMethod( aEmpty, SbxVARIANT, NULL ); | |
| case SBXID_JSCRIPTMOD: | |
| return new SbJScriptModule( aEmpty ); | |
| case SBXID_JSCRIPTMETH: | |
| return new SbJScriptMethod( aEmpty, SbxVARIANT, NULL ); | |
| } | |
| } | |
| return NULL; | |
| } | |
| SbxObject* SbiFactory::CreateObject( const String& rClass ) | |
| { | |
| if( rClass.EqualsIgnoreCaseAscii( "StarBASIC" ) ) | |
| return new StarBASIC( NULL ); | |
| else | |
| if( rClass.EqualsIgnoreCaseAscii( "StarBASICModule" ) ) | |
| { | |
| String aEmpty; | |
| return new SbModule( aEmpty ); | |
| } | |
| else | |
| if( rClass.EqualsIgnoreCaseAscii( "Collection" ) ) | |
| { | |
| String aCollectionName( RTL_CONSTASCII_USTRINGPARAM("Collection") ); | |
| return new BasicCollection( aCollectionName ); | |
| } | |
| else | |
| if( rClass.EqualsIgnoreCaseAscii( "FileSystemObject" ) ) | |
| { | |
| try | |
| { | |
| Reference< XMultiServiceFactory > xFactory( comphelper::getProcessServiceFactory(), UNO_SET_THROW ); | |
| ::rtl::OUString aServiceName( RTL_CONSTASCII_USTRINGPARAM( "ooo.vba.FileSystemObject" ) ); | |
| Reference< XInterface > xInterface( xFactory->createInstance( aServiceName ), UNO_SET_THROW ); | |
| return new SbUnoObject( aServiceName, uno::makeAny( xInterface ) ); | |
| } | |
| catch( Exception& ) | |
| {} | |
| } | |
| return NULL; | |
| } | |
| // Factory class to create OLE objects | |
| class SbOLEFactory : public SbxFactory | |
| { | |
| public: | |
| virtual SbxBase* Create( sal_uInt16 nSbxId, sal_uInt32 = SBXCR_SBX ); | |
| virtual SbxObject* CreateObject( const String& ); | |
| }; | |
| SbxBase* SbOLEFactory::Create( sal_uInt16, sal_uInt32 ) | |
| { | |
| // Not supported | |
| return NULL; | |
| } | |
| SbUnoObject* createOLEObject_Impl( const String& aType ); // sbunoobj.cxx | |
| SbxObject* SbOLEFactory::CreateObject( const String& rClassName ) | |
| { | |
| SbxObject* pRet = createOLEObject_Impl( rClassName ); | |
| return pRet; | |
| } | |
| //======================================================================== | |
| // SbFormFactory, show user forms by: dim as new <user form name> | |
| class SbFormFactory : public SbxFactory | |
| { | |
| public: | |
| virtual SbxBase* Create( sal_uInt16 nSbxId, sal_uInt32 = SBXCR_SBX ); | |
| virtual SbxObject* CreateObject( const String& ); | |
| }; | |
| SbxBase* SbFormFactory::Create( sal_uInt16, sal_uInt32 ) | |
| { | |
| // Not supported | |
| return NULL; | |
| } | |
| SbxObject* SbFormFactory::CreateObject( const String& rClassName ) | |
| { | |
| if( SbModule* pMod = pMOD ) | |
| { | |
| if( SbxVariable* pVar = pMod->Find( rClassName, SbxCLASS_OBJECT ) ) | |
| { | |
| if( SbUserFormModule* pFormModule = PTR_CAST( SbUserFormModule, pVar->GetObject() ) ) | |
| { | |
| bool bInitState = pFormModule->getInitState(); | |
| if( bInitState ) | |
| { | |
| // Not the first instantiate, reset | |
| bool bTriggerTerminateEvent = false; | |
| pFormModule->ResetApiObj( bTriggerTerminateEvent ); | |
| pFormModule->setInitState( false ); | |
| } | |
| else | |
| { | |
| pFormModule->Load(); | |
| } | |
| return pFormModule->CreateInstance(); | |
| } | |
| } | |
| } | |
| return 0; | |
| } | |
| //======================================================================== | |
| // SbTypeFactory | |
| SbxObject* cloneTypeObjectImpl( const SbxObject& rTypeObj ) | |
| { | |
| SbxObject* pRet = new SbxObject( rTypeObj ); | |
| pRet->PutObject( pRet ); | |
| // Copy the properties, not only the reference to them | |
| SbxArray* pProps = pRet->GetProperties(); | |
| sal_uInt32 nCount = pProps->Count32(); | |
| for( sal_uInt32 i = 0 ; i < nCount ; i++ ) | |
| { | |
| SbxVariable* pVar = pProps->Get32( i ); | |
| SbxProperty* pProp = PTR_CAST( SbxProperty, pVar ); | |
| if( pProp ) | |
| { | |
| SbxProperty* pNewProp = new SbxProperty( *pProp ); | |
| SbxDataType eVarType = pVar->GetType(); | |
| if( eVarType & SbxARRAY ) | |
| { | |
| SbxBase* pParObj = pVar->GetObject(); | |
| SbxDimArray* pSource = PTR_CAST(SbxDimArray,pParObj); | |
| SbxDimArray* pDest = new SbxDimArray( pVar->GetType() ); | |
| sal_Int32 lb = 0; | |
| sal_Int32 ub = 0; | |
| pDest->setHasFixedSize( pSource->hasFixedSize() ); | |
| if ( pSource->GetDims() && pSource->hasFixedSize() ) | |
| { | |
| for ( sal_Int32 j = 1 ; j <= pSource->GetDims(); ++j ) | |
| { | |
| pSource->GetDim32( (sal_Int32)j, lb, ub ); | |
| pDest->AddDim32( lb, ub ); | |
| } | |
| } | |
| else | |
| pDest->unoAddDim( 0, -1 ); // variant array | |
| sal_uInt16 nSavFlags = pVar->GetFlags(); | |
| pNewProp->ResetFlag( SBX_FIXED ); | |
| // need to reset the FIXED flag | |
| // when calling PutObject ( because the type will not match Object ) | |
| pNewProp->PutObject( pDest ); | |
| pNewProp->SetFlags( nSavFlags ); | |
| } | |
| if( eVarType == SbxOBJECT ) | |
| { | |
| SbxBase* pObjBase = pVar->GetObject(); | |
| SbxObject* pSrcObj = PTR_CAST(SbxObject,pObjBase); | |
| SbxObject* pDestObj = NULL; | |
| if( pSrcObj != NULL ) | |
| pDestObj = cloneTypeObjectImpl( *pSrcObj ); | |
| pNewProp->PutObject( pDestObj ); | |
| } | |
| pProps->PutDirect( pNewProp, i ); | |
| } | |
| } | |
| return pRet; | |
| } | |
| // Factory class to create user defined objects (type command) | |
| class SbTypeFactory : public SbxFactory | |
| { | |
| public: | |
| virtual SbxBase* Create( sal_uInt16 nSbxId, sal_uInt32 = SBXCR_SBX ); | |
| virtual SbxObject* CreateObject( const String& ); | |
| }; | |
| SbxBase* SbTypeFactory::Create( sal_uInt16, sal_uInt32 ) | |
| { | |
| // Not supported | |
| return NULL; | |
| } | |
| SbxObject* SbTypeFactory::CreateObject( const String& rClassName ) | |
| { | |
| SbxObject* pRet = NULL; | |
| SbModule* pMod = pMOD; | |
| if( pMod ) | |
| { | |
| const SbxObject* pObj = pMod->FindType( rClassName ); | |
| if( pObj ) | |
| pRet = cloneTypeObjectImpl( *pObj ); | |
| } | |
| return pRet; | |
| } | |
| SbxObject* createUserTypeImpl( const String& rClassName ) | |
| { | |
| SbxObject* pRetObj = pTYPEFAC->CreateObject( rClassName ); | |
| return pRetObj; | |
| } | |
| TYPEINIT1(SbClassModuleObject,SbModule) | |
| SbClassModuleObject::SbClassModuleObject( SbModule* pClassModule ) | |
| : SbModule( pClassModule->GetName() ) | |
| , mpClassModule( pClassModule ) | |
| , mbInitializeEventDone( false ) | |
| { | |
| aOUSource = pClassModule->aOUSource; | |
| aComment = pClassModule->aComment; | |
| pImage = pClassModule->pImage; | |
| pBreaks = pClassModule->pBreaks; | |
| SetClassName( pClassModule->GetName() ); | |
| // Allow search only internally | |
| ResetFlag( SBX_GBLSEARCH ); | |
| // Copy the methods from original class module | |
| SbxArray* pClassMethods = pClassModule->GetMethods(); | |
| sal_uInt32 nMethodCount = pClassMethods->Count32(); | |
| sal_uInt32 i; | |
| for( i = 0 ; i < nMethodCount ; i++ ) | |
| { | |
| SbxVariable* pVar = pClassMethods->Get32( i ); | |
| // Exclude SbIfaceMapperMethod to copy them in a second step | |
| SbIfaceMapperMethod* pIfaceMethod = PTR_CAST( SbIfaceMapperMethod, pVar ); | |
| if( !pIfaceMethod ) | |
| { | |
| SbMethod* pMethod = PTR_CAST(SbMethod, pVar ); | |
| if( pMethod ) | |
| { | |
| sal_uInt16 nFlags_ = pMethod->GetFlags(); | |
| pMethod->SetFlag( SBX_NO_BROADCAST ); | |
| SbMethod* pNewMethod = new SbMethod( *pMethod ); | |
| pNewMethod->ResetFlag( SBX_NO_BROADCAST ); | |
| pMethod->SetFlags( nFlags_ ); | |
| pNewMethod->pMod = this; | |
| pNewMethod->SetParent( this ); | |
| pMethods->PutDirect( pNewMethod, i ); | |
| StartListening( pNewMethod->GetBroadcaster(), sal_True ); | |
| } | |
| } | |
| } | |
| // Copy SbIfaceMapperMethod in a second step to ensure that | |
| // the corresponding base methods have already been copied | |
| for( i = 0 ; i < nMethodCount ; i++ ) | |
| { | |
| SbxVariable* pVar = pClassMethods->Get32( i ); | |
| SbIfaceMapperMethod* pIfaceMethod = PTR_CAST( SbIfaceMapperMethod, pVar ); | |
| if( pIfaceMethod ) | |
| { | |
| SbMethod* pImplMethod = pIfaceMethod->getImplMethod(); | |
| if( !pImplMethod ) | |
| { | |
| DBG_ERROR( "No ImplMethod" ); | |
| continue; | |
| } | |
| // Search for own copy of ImplMethod | |
| String aImplMethodName = pImplMethod->GetName(); | |
| SbxVariable* p = pMethods->Find( aImplMethodName, SbxCLASS_METHOD ); | |
| SbMethod* pImplMethodCopy = p ? PTR_CAST(SbMethod,p) : NULL; | |
| if( !pImplMethodCopy ) | |
| { | |
| DBG_ERROR( "Found no ImplMethod copy" ); | |
| continue; | |
| } | |
| SbIfaceMapperMethod* pNewIfaceMethod = | |
| new SbIfaceMapperMethod( pIfaceMethod->GetName(), pImplMethodCopy ); | |
| pMethods->PutDirect( pNewIfaceMethod, i ); | |
| } | |
| } | |
| // Copy the properties from original class module | |
| SbxArray* pClassProps = pClassModule->GetProperties(); | |
| sal_uInt32 nPropertyCount = pClassProps->Count32(); | |
| for( i = 0 ; i < nPropertyCount ; i++ ) | |
| { | |
| SbxVariable* pVar = pClassProps->Get32( i ); | |
| SbProcedureProperty* pProcedureProp = PTR_CAST( SbProcedureProperty, pVar ); | |
| if( pProcedureProp ) | |
| { | |
| sal_uInt16 nFlags_ = pProcedureProp->GetFlags(); | |
| pProcedureProp->SetFlag( SBX_NO_BROADCAST ); | |
| SbProcedureProperty* pNewProp = new SbProcedureProperty | |
| ( pProcedureProp->GetName(), pProcedureProp->GetType() ); | |
| // ( pProcedureProp->GetName(), pProcedureProp->GetType(), this ); | |
| pNewProp->SetFlags( nFlags_ ); // Copy flags | |
| pNewProp->ResetFlag( SBX_NO_BROADCAST ); // except the Broadcast if it was set | |
| pProcedureProp->SetFlags( nFlags_ ); | |
| pProps->PutDirect( pNewProp, i ); | |
| StartListening( pNewProp->GetBroadcaster(), sal_True ); | |
| } | |
| else | |
| { | |
| SbxProperty* pProp = PTR_CAST( SbxProperty, pVar ); | |
| if( pProp ) | |
| { | |
| sal_uInt16 nFlags_ = pProp->GetFlags(); | |
| pProp->SetFlag( SBX_NO_BROADCAST ); | |
| SbxProperty* pNewProp = new SbxProperty( *pProp ); | |
| // Special handling for modules instances and collections, they need | |
| // to be instantiated, otherwise all refer to the same base object | |
| SbxDataType eVarType = pProp->GetType(); | |
| if( eVarType == SbxOBJECT ) | |
| { | |
| SbxBase* pObjBase = pProp->GetObject(); | |
| SbxObject* pObj = PTR_CAST(SbxObject,pObjBase); | |
| if( pObj != NULL ) | |
| { | |
| String aObjClass = pObj->GetClassName(); | |
| SbClassModuleObject* pClassModuleObj = PTR_CAST(SbClassModuleObject,pObjBase); | |
| if( pClassModuleObj != NULL ) | |
| { | |
| SbModule* pLclClassModule = pClassModuleObj->getClassModule(); | |
| SbClassModuleObject* pNewObj = new SbClassModuleObject( pLclClassModule ); | |
| pNewObj->SetName( pProp->GetName() ); | |
| pNewObj->SetParent( pLclClassModule->pParent ); | |
| pNewProp->PutObject( pNewObj ); | |
| } | |
| else if( aObjClass.EqualsIgnoreCaseAscii( "Collection" ) ) | |
| { | |
| String aCollectionName( RTL_CONSTASCII_USTRINGPARAM("Collection") ); | |
| BasicCollection* pNewCollection = new BasicCollection( aCollectionName ); | |
| pNewCollection->SetName( pProp->GetName() ); | |
| pNewCollection->SetParent( pClassModule->pParent ); | |
| pNewProp->PutObject( pNewCollection ); | |
| } | |
| } | |
| } | |
| pNewProp->ResetFlag( SBX_NO_BROADCAST ); | |
| pNewProp->SetParent( this ); | |
| pProps->PutDirect( pNewProp, i ); | |
| pProp->SetFlags( nFlags_ ); | |
| } | |
| } | |
| } | |
| SetModuleType( ModuleType::CLASS ); | |
| mbVBACompat = pClassModule->mbVBACompat; | |
| } | |
| SbClassModuleObject::~SbClassModuleObject() | |
| { | |
| // do not trigger termination event when document is already closed | |
| if( StarBASIC::IsRunning() ) | |
| if( StarBASIC* pDocBasic = lclGetDocBasicForModule( this ) ) | |
| if( const DocBasicItem* pDocBasicItem = lclFindDocBasicItem( pDocBasic ) ) | |
| if( !pDocBasicItem->isDocClosed() ) | |
| triggerTerminateEvent(); | |
| // Must be deleted by base class dtor because this data | |
| // is not owned by the SbClassModuleObject object | |
| pImage = NULL; | |
| pBreaks = NULL; | |
| } | |
| void SbClassModuleObject::SFX_NOTIFY( SfxBroadcaster& rBC, const TypeId& rBCType, | |
| const SfxHint& rHint, const TypeId& rHintType ) | |
| { | |
| handleProcedureProperties( rBC, rHint ); | |
| } | |
| SbxVariable* SbClassModuleObject::Find( const XubString& rName, SbxClassType t ) | |
| { | |
| SbxVariable* pRes = SbxObject::Find( rName, t ); | |
| if( pRes ) | |
| { | |
| triggerInitializeEvent(); | |
| SbIfaceMapperMethod* pIfaceMapperMethod = PTR_CAST(SbIfaceMapperMethod,pRes); | |
| if( pIfaceMapperMethod ) | |
| { | |
| pRes = pIfaceMapperMethod->getImplMethod(); | |
| pRes->SetFlag( SBX_EXTFOUND ); | |
| } | |
| } | |
| return pRes; | |
| } | |
| void SbClassModuleObject::triggerInitializeEvent( void ) | |
| { | |
| static String aInitMethodName( RTL_CONSTASCII_USTRINGPARAM("Class_Initialize") ); | |
| if( mbInitializeEventDone ) | |
| return; | |
| mbInitializeEventDone = true; | |
| // Search method | |
| SbxVariable* pMeth = SbxObject::Find( aInitMethodName, SbxCLASS_METHOD ); | |
| if( pMeth ) | |
| { | |
| SbxValues aVals; | |
| pMeth->Get( aVals ); | |
| } | |
| } | |
| void SbClassModuleObject::triggerTerminateEvent( void ) | |
| { | |
| static String aTermMethodName( RTL_CONSTASCII_USTRINGPARAM("Class_Terminate") ); | |
| if( !mbInitializeEventDone || GetSbData()->bRunInit ) | |
| return; | |
| // Search method | |
| SbxVariable* pMeth = SbxObject::Find( aTermMethodName, SbxCLASS_METHOD ); | |
| if( pMeth ) | |
| { | |
| SbxValues aVals; | |
| pMeth->Get( aVals ); | |
| } | |
| } | |
| SbClassData::SbClassData( void ) | |
| { | |
| mxIfaces = new SbxArray(); | |
| } | |
| void SbClassData::clear( void ) | |
| { | |
| mxIfaces->Clear(); | |
| maRequiredTypes.clear(); | |
| } | |
| SbClassFactory::SbClassFactory( void ) | |
| { | |
| String aDummyName; | |
| xClassModules = new SbxObject( aDummyName ); | |
| } | |
| SbClassFactory::~SbClassFactory() | |
| {} | |
| void SbClassFactory::AddClassModule( SbModule* pClassModule ) | |
| { | |
| SbxObjectRef xToUseClassModules = xClassModules; | |
| if( StarBASIC* pDocBasic = lclGetDocBasicForModule( pClassModule ) ) | |
| if( const DocBasicItem* pDocBasicItem = lclFindDocBasicItem( pDocBasic ) ) | |
| xToUseClassModules = pDocBasicItem->getClassModules(); | |
| SbxObject* pParent = pClassModule->GetParent(); | |
| xToUseClassModules->Insert( pClassModule ); | |
| pClassModule->SetParent( pParent ); | |
| } | |
| void SbClassFactory::RemoveClassModule( SbModule* pClassModule ) | |
| { | |
| xClassModules->Remove( pClassModule ); | |
| } | |
| SbxBase* SbClassFactory::Create( sal_uInt16, sal_uInt32 ) | |
| { | |
| // Not supported | |
| return NULL; | |
| } | |
| SbxObject* SbClassFactory::CreateObject( const String& rClassName ) | |
| { | |
| SbxObjectRef xToUseClassModules = xClassModules; | |
| if( SbModule* pMod = pMOD ) | |
| if( StarBASIC* pDocBasic = lclGetDocBasicForModule( pMod ) ) | |
| if( const DocBasicItem* pDocBasicItem = lclFindDocBasicItem( pDocBasic ) ) | |
| xToUseClassModules = pDocBasicItem->getClassModules(); | |
| SbxVariable* pVar = xToUseClassModules->Find( rClassName, SbxCLASS_OBJECT ); | |
| SbxObject* pRet = NULL; | |
| if( pVar ) | |
| { | |
| SbModule* pVarMod = (SbModule*)pVar; | |
| pRet = new SbClassModuleObject( pVarMod ); | |
| } | |
| return pRet; | |
| } | |
| SbModule* SbClassFactory::FindClass( const String& rClassName ) | |
| { | |
| SbxVariable* pVar = xClassModules->Find( rClassName, SbxCLASS_DONTCARE ); | |
| SbModule* pMod = pVar ? (SbModule*)pVar : NULL; | |
| return pMod; | |
| } | |
| StarBASIC::StarBASIC( StarBASIC* p, sal_Bool bIsDocBasic ) | |
| : SbxObject( String( RTL_CONSTASCII_USTRINGPARAM("StarBASIC") ) ), bDocBasic( bIsDocBasic ) | |
| { | |
| SetParent( p ); | |
| pLibInfo = NULL; | |
| bNoRtl = bBreak = sal_False; | |
| bVBAEnabled = sal_False; | |
| pModules = new SbxArray; | |
| if( !GetSbData()->nInst++ ) | |
| { | |
| pSBFAC = new SbiFactory; | |
| AddFactory( pSBFAC ); | |
| pTYPEFAC = new SbTypeFactory; | |
| AddFactory( pTYPEFAC ); | |
| pCLASSFAC = new SbClassFactory; | |
| AddFactory( pCLASSFAC ); | |
| pOLEFAC = new SbOLEFactory; | |
| AddFactory( pOLEFAC ); | |
| pFORMFAC = new SbFormFactory; | |
| AddFactory( pFORMFAC ); | |
| pUNOFAC = new SbUnoFactory; | |
| AddFactory( pUNOFAC ); | |
| } | |
| pRtl = new SbiStdObject( String( RTL_CONSTASCII_USTRINGPARAM(RTLNAME) ), this ); | |
| // Search via StarBasic is always global | |
| SetFlag( SBX_GBLSEARCH ); | |
| pVBAGlobals = NULL; | |
| bQuit = sal_False; | |
| if( bDocBasic ) | |
| lclInsertDocBasicItem( *this ); | |
| } | |
| // #51727 Override SetModified so that the modified state | |
| // is not given to the parent | |
| void StarBASIC::SetModified( sal_Bool b ) | |
| { | |
| SbxBase::SetModified( b ); | |
| } | |
| extern void lcl_closeTraceFile(); | |
| StarBASIC::~StarBASIC() | |
| { | |
| #ifdef DBG_TRACE_BASIC | |
| lcl_closeTraceFile(); | |
| #endif | |
| // Needs to be first action as it can trigger events | |
| disposeComVariablesForBasic( this ); | |
| if( !--GetSbData()->nInst ) | |
| { | |
| RemoveFactory( pSBFAC ); | |
| delete pSBFAC; pSBFAC = NULL; | |
| RemoveFactory( pUNOFAC ); | |
| delete pUNOFAC; pUNOFAC = NULL; | |
| RemoveFactory( pTYPEFAC ); | |
| delete pTYPEFAC; pTYPEFAC = NULL; | |
| RemoveFactory( pCLASSFAC ); | |
| delete pCLASSFAC; pCLASSFAC = NULL; | |
| RemoveFactory( pOLEFAC ); | |
| delete pOLEFAC; pOLEFAC = NULL; | |
| RemoveFactory( pFORMFAC ); | |
| delete pFORMFAC; pFORMFAC = NULL; | |
| #ifdef DBG_UTIL | |
| // There is no need to clean SbiData at program end, | |
| // but we dislike MLK's at Purify | |
| // TODO: Where else??? | |
| SbiGlobals** pp = (SbiGlobals**) ::GetAppData( SHL_SBC ); | |
| SbiGlobals* p = *pp; | |
| if( p ) | |
| { | |
| delete p; | |
| *pp = 0; | |
| } | |
| #endif | |
| } | |
| else if( bDocBasic ) | |
| { | |
| SbxError eOld = SbxBase::GetError(); | |
| lclRemoveDocBasicItem( *this ); | |
| SbxBase::ResetError(); | |
| if( eOld != SbxERR_OK ) | |
| SbxBase::SetError( eOld ); | |
| } | |
| // #100326 Set Parent NULL in registered listeners | |
| if( xUnoListeners.Is() ) | |
| { | |
| sal_uInt16 uCount = xUnoListeners->Count(); | |
| for( sal_uInt16 i = 0 ; i < uCount ; i++ ) | |
| { | |
| SbxVariable* pListenerObj = xUnoListeners->Get( i ); | |
| pListenerObj->SetParent( NULL ); | |
| } | |
| xUnoListeners = NULL; | |
| } | |
| clearUnoMethodsForBasic( this ); | |
| } | |
| // Override new() operator, so that everyone can create a new instance | |
| void* StarBASIC::operator new( size_t n ) | |
| { | |
| if( n < sizeof( StarBASIC ) ) | |
| { | |
| // DBG_ASSERT( sal_False, "Warnung: inkompatibler BASIC-Stand!" ); | |
| n = sizeof( StarBASIC ); | |
| } | |
| return ::operator new( n ); | |
| } | |
| void StarBASIC::operator delete( void* p ) | |
| { | |
| ::operator delete( p ); | |
| } | |
| void StarBASIC::implClearDependingVarsOnDelete( StarBASIC* pDeletedBasic ) | |
| { | |
| if( this != pDeletedBasic ) | |
| { | |
| for( sal_uInt16 i = 0; i < pModules->Count(); i++ ) | |
| { | |
| SbModule* p = (SbModule*)pModules->Get( i ); | |
| p->ClearVarsDependingOnDeletedBasic( pDeletedBasic ); | |
| } | |
| } | |
| for( sal_uInt16 nObj = 0; nObj < pObjs->Count(); nObj++ ) | |
| { | |
| SbxVariable* pVar = pObjs->Get( nObj ); | |
| StarBASIC* pBasic = PTR_CAST(StarBASIC,pVar); | |
| if( pBasic && pBasic != pDeletedBasic ) | |
| pBasic->implClearDependingVarsOnDelete( pDeletedBasic ); | |
| } | |
| } | |
| /************************************************************************** | |
| * | |
| * Creation/Management of modules | |
| * | |
| **************************************************************************/ | |
| SbModule* StarBASIC::MakeModule( const String& rName, const String& rSrc ) | |
| { | |
| return MakeModule32( rName, rSrc ); | |
| } | |
| SbModule* StarBASIC::MakeModule32( const String& rName, const ::rtl::OUString& rSrc ) | |
| { | |
| ModuleInfo mInfo; | |
| mInfo.ModuleType = ModuleType::NORMAL; | |
| return MakeModule32( rName, mInfo, rSrc ); | |
| } | |
| SbModule* StarBASIC::MakeModule32( const String& rName, const ModuleInfo& mInfo, const rtl::OUString& rSrc ) | |
| { | |
| OSL_TRACE("create module %s type mInfo %d", rtl::OUStringToOString( rName, RTL_TEXTENCODING_UTF8 ).getStr(), mInfo.ModuleType ); | |
| SbModule* p = NULL; | |
| switch ( mInfo.ModuleType ) | |
| { | |
| case ModuleType::DOCUMENT: | |
| // In theory we should be able to create Object modules | |
| // in ordinary basic ( in vba mode thought these are create | |
| // by the application/basic and not by the user ) | |
| p = new SbObjModule( rName, mInfo, isVBAEnabled() ); | |
| break; | |
| case ModuleType::CLASS: | |
| p = new SbModule( rName, isVBAEnabled() ); | |
| p->SetModuleType( ModuleType::CLASS ); | |
| break; | |
| case ModuleType::FORM: | |
| p = new SbUserFormModule( rName, mInfo, isVBAEnabled() ); | |
| break; | |
| default: | |
| p = new SbModule( rName, isVBAEnabled() ); | |
| } | |
| p->SetSource32( rSrc ); | |
| p->SetParent( this ); | |
| pModules->Insert( p, pModules->Count() ); | |
| SetModified( sal_True ); | |
| return p; | |
| } | |
| void StarBASIC::Insert( SbxVariable* pVar ) | |
| { | |
| if( pVar->IsA( TYPE(SbModule) ) ) | |
| { | |
| pModules->Insert( pVar, pModules->Count() ); | |
| pVar->SetParent( this ); | |
| StartListening( pVar->GetBroadcaster(), sal_True ); | |
| } | |
| else | |
| { | |
| sal_Bool bWasModified = IsModified(); | |
| SbxObject::Insert( pVar ); | |
| if( !bWasModified && pVar->IsSet( SBX_DONTSTORE ) ) | |
| SetModified( sal_False ); | |
| } | |
| } | |
| void StarBASIC::Remove( SbxVariable* pVar ) | |
| { | |
| if( pVar->IsA( TYPE(SbModule) ) ) | |
| { | |
| // #87540 Can be last reference! | |
| SbxVariableRef xVar = pVar; | |
| pModules->Remove( pVar ); | |
| pVar->SetParent( 0 ); | |
| EndListening( pVar->GetBroadcaster() ); | |
| } | |
| else | |
| SbxObject::Remove( pVar ); | |
| } | |
| sal_Bool StarBASIC::Compile( SbModule* pMod ) | |
| { | |
| return pMod ? pMod->Compile() : sal_False; | |
| } | |
| sal_Bool StarBASIC::Disassemble( SbModule* pMod, String& rText ) | |
| { | |
| rText.Erase(); | |
| if( pMod ) | |
| pMod->Disassemble( rText ); | |
| return sal_Bool( rText.Len() != 0 ); | |
| } | |
| void StarBASIC::Clear() | |
| { | |
| while( pModules->Count() ) | |
| pModules->Remove( pModules->Count() - 1 ); | |
| } | |
| SbModule* StarBASIC::FindModule( const String& rName ) | |
| { | |
| for( sal_uInt16 i = 0; i < pModules->Count(); i++ ) | |
| { | |
| SbModule* p = (SbModule*) pModules->Get( i ); | |
| if( p->GetName().EqualsIgnoreCaseAscii( rName ) ) | |
| return p; | |
| } | |
| return NULL; | |
| } | |
| struct ClassModuleRunInitItem | |
| { | |
| SbModule* m_pModule; | |
| bool m_bProcessing; | |
| bool m_bRunInitDone; | |
| //ModuleVector m_vModulesDependingOnThisModule; | |
| ClassModuleRunInitItem( void ) | |
| : m_pModule( NULL ) | |
| , m_bProcessing( false ) | |
| , m_bRunInitDone( false ) | |
| {} | |
| ClassModuleRunInitItem( SbModule* pModule ) | |
| : m_pModule( pModule ) | |
| , m_bProcessing( false ) | |
| , m_bRunInitDone( false ) | |
| {} | |
| }; | |
| // Derive from has_map type instead of typedef | |
| // to allow forward declaration in sbmod.hxx | |
| class ModuleInitDependencyMap : public | |
| std::hash_map< ::rtl::OUString, ClassModuleRunInitItem, | |
| ::rtl::OUStringHash, ::std::equal_to< ::rtl::OUString > > | |
| {}; | |
| void SbModule::implProcessModuleRunInit( ModuleInitDependencyMap& rMap, ClassModuleRunInitItem& rItem ) | |
| { | |
| rItem.m_bProcessing = true; | |
| //bool bAnyDependencies = true; | |
| SbModule* pModule = rItem.m_pModule; | |
| if( pModule->pClassData != NULL ) | |
| { | |
| StringVector& rReqTypes = pModule->pClassData->maRequiredTypes; | |
| if( rReqTypes.size() > 0 ) | |
| { | |
| for( StringVector::iterator it = rReqTypes.begin() ; it != rReqTypes.end() ; ++it ) | |
| { | |
| String& rStr = *it; | |
| // Is required type a class module? | |
| ModuleInitDependencyMap::iterator itFind = rMap.find( rStr ); | |
| if( itFind != rMap.end() ) | |
| { | |
| ClassModuleRunInitItem& rParentItem = itFind->second; | |
| if( rParentItem.m_bProcessing ) | |
| { | |
| // TODO: raise error? | |
| DBG_ERROR( "Cyclic module dependency detected" ); | |
| continue; | |
| } | |
| if( !rParentItem.m_bRunInitDone ) | |
| implProcessModuleRunInit( rMap, rParentItem ); | |
| } | |
| } | |
| } | |
| } | |
| pModule->RunInit(); | |
| rItem.m_bRunInitDone = true; | |
| rItem.m_bProcessing = false; | |
| } | |
| // Run Init-Code of all modules (including inserted libraries) | |
| void StarBASIC::InitAllModules( StarBASIC* pBasicNotToInit ) | |
| { | |
| ::vos::OGuard guard( Application::GetSolarMutex() ); | |
| // Init own modules | |
| for ( sal_uInt16 nMod = 0; nMod < pModules->Count(); nMod++ ) | |
| { | |
| SbModule* pModule = (SbModule*)pModules->Get( nMod ); | |
| if( !pModule->IsCompiled() ) | |
| pModule->Compile(); | |
| } | |
| // compile modules first then RunInit ( otherwise there is | |
| // can be order dependency, e.g. classmodule A has a member | |
| // of of type classmodule B and classmodule B hasn't been compiled yet ) | |
| // Consider required types to init in right order. Class modules | |
| // that are required by other modules have to be initialized first. | |
| ModuleInitDependencyMap aMIDMap; | |
| for ( sal_uInt16 nMod = 0; nMod < pModules->Count(); nMod++ ) | |
| { | |
| SbModule* pModule = (SbModule*)pModules->Get( nMod ); | |
| String aModuleName = pModule->GetName(); | |
| if( pModule->isProxyModule() ) | |
| aMIDMap[aModuleName] = ClassModuleRunInitItem( pModule ); | |
| } | |
| ModuleInitDependencyMap::iterator it; | |
| for( it = aMIDMap.begin() ; it != aMIDMap.end(); ++it ) | |
| { | |
| ClassModuleRunInitItem& rItem = it->second; | |
| SbModule::implProcessModuleRunInit( aMIDMap, rItem ); | |
| } | |
| // Call RunInit on standard modules | |
| for ( sal_uInt16 nMod = 0; nMod < pModules->Count(); nMod++ ) | |
| { | |
| SbModule* pModule = (SbModule*)pModules->Get( nMod ); | |
| if( !pModule->isProxyModule() ) | |
| pModule->RunInit(); | |
| } | |
| // Check all objects if they are BASIC, | |
| // if yes initialize | |
| for ( sal_uInt16 nObj = 0; nObj < pObjs->Count(); nObj++ ) | |
| { | |
| SbxVariable* pVar = pObjs->Get( nObj ); | |
| StarBASIC* pBasic = PTR_CAST(StarBASIC,pVar); | |
| if( pBasic && pBasic != pBasicNotToInit ) | |
| pBasic->InitAllModules(); | |
| } | |
| } | |
| // #88329 Put modules back to not initialised state to | |
| // force reinitialisation at next start | |
| void StarBASIC::DeInitAllModules( void ) | |
| { | |
| // Deinit own modules | |
| for ( sal_uInt16 nMod = 0; nMod < pModules->Count(); nMod++ ) | |
| { | |
| SbModule* pModule = (SbModule*)pModules->Get( nMod ); | |
| if( pModule->pImage && !pModule->isProxyModule() && !pModule->ISA(SbObjModule) ) | |
| pModule->pImage->bInit = false; | |
| } | |
| for ( sal_uInt16 nObj = 0; nObj < pObjs->Count(); nObj++ ) | |
| { | |
| SbxVariable* pVar = pObjs->Get( nObj ); | |
| StarBASIC* pBasic = PTR_CAST(StarBASIC,pVar); | |
| if( pBasic ) | |
| pBasic->DeInitAllModules(); | |
| } | |
| } | |
| // #43011 For TestTool, to delete global vars | |
| void StarBASIC::ClearGlobalVars( void ) | |
| { | |
| SbxArrayRef xProps( GetProperties() ); | |
| sal_uInt16 nPropCount = xProps->Count(); | |
| for ( sal_uInt16 nProp = 0 ; nProp < nPropCount ; ++nProp ) | |
| { | |
| SbxBase* pVar = xProps->Get( nProp ); | |
| pVar->Clear(); | |
| } | |
| SetModified( sal_True ); | |
| } | |
| // This implementation at first searches within the runtime library, | |
| // then it looks for an element within one module. This moudle can be | |
| // a public var or an entrypoint. If it is not found and we look for a | |
| // method and a module with the given name is found the search continues | |
| // for entrypoint "Main". | |
| // If this fails again a conventional search over objects is performend. | |
| SbxVariable* StarBASIC::Find( const String& rName, SbxClassType t ) | |
| { | |
| static String aMainStr( RTL_CONSTASCII_USTRINGPARAM("Main") ); | |
| SbxVariable* pRes = NULL; | |
| SbModule* pNamed = NULL; | |
| // "Extended" search in Runtime Lib | |
| // but only if SbiRuntime has not set the flag | |
| if( !bNoRtl ) | |
| { | |
| if( t == SbxCLASS_DONTCARE || t == SbxCLASS_OBJECT ) | |
| { | |
| if( rName.EqualsIgnoreCaseAscii( RTLNAME ) ) | |
| pRes = pRtl; | |
| } | |
| if( !pRes ) | |
| pRes = ((SbiStdObject*) (SbxObject*) pRtl)->Find( rName, t ); | |
| if( pRes ) | |
| pRes->SetFlag( SBX_EXTFOUND ); | |
| } | |
| // Search module | |
| if( !pRes ) | |
| for( sal_uInt16 i = 0; i < pModules->Count(); i++ ) | |
| { | |
| SbModule* p = (SbModule*) pModules->Get( i ); | |
| if( p->IsVisible() ) | |
| { | |
| // Remember modul fpr Main() call | |
| // or is the name equal?!? | |
| if( p->GetName().EqualsIgnoreCaseAscii( rName ) ) | |
| { | |
| if( t == SbxCLASS_OBJECT || t == SbxCLASS_DONTCARE ) | |
| { | |
| pRes = p; break; | |
| } | |
| pNamed = p; | |
| } | |
| // Only variables qualified by the Module Name e.g. Sheet1.foo | |
| // should work for Documant && Class type Modules | |
| sal_Int32 nType = p->GetModuleType(); | |
| if ( nType == ModuleType::DOCUMENT || nType == ModuleType::FORM ) | |
| continue; | |
| // otherwise check if the element is available | |
| // unset GBLSEARCH-Flag (due to Rekursion) | |
| sal_uInt16 nGblFlag = p->GetFlags() & SBX_GBLSEARCH; | |
| p->ResetFlag( SBX_GBLSEARCH ); | |
| pRes = p->Find( rName, t ); | |
| p->SetFlag( nGblFlag ); | |
| if( pRes ) | |
| break; | |
| } | |
| } | |
| if( !pRes && pNamed && ( t == SbxCLASS_METHOD || t == SbxCLASS_DONTCARE ) && | |
| !pNamed->GetName().EqualsIgnoreCaseAscii( aMainStr ) ) | |
| pRes = pNamed->Find( aMainStr, SbxCLASS_METHOD ); | |
| if( !pRes ) | |
| pRes = SbxObject::Find( rName, t ); | |
| return pRes; | |
| } | |
| sal_Bool StarBASIC::Call( const String& rName, SbxArray* pParam ) | |
| { | |
| sal_Bool bRes = SbxObject::Call( rName, pParam ); | |
| if( !bRes ) | |
| { | |
| SbxError eErr = SbxBase::GetError(); | |
| SbxBase::ResetError(); | |
| if( eErr != SbxERR_OK ) | |
| RTError( (SbError)eErr, 0, 0, 0 ); | |
| } | |
| return bRes; | |
| } | |
| // Find method via name (e.g. query via BASIC IDE) | |
| SbxBase* StarBASIC::FindSBXInCurrentScope( const String& rName ) | |
| { | |
| if( !pINST ) | |
| return NULL; | |
| if( !pINST->pRun ) | |
| return NULL; | |
| return pINST->pRun->FindElementExtern( rName ); | |
| } | |
| // Preserve old interface | |
| SbxVariable* StarBASIC::FindVarInCurrentScopy | |
| ( const String& rName, sal_uInt16& rStatus ) | |
| { | |
| rStatus = 1; // Presumption: nothing found | |
| SbxVariable* pVar = NULL; | |
| SbxBase* pSbx = FindSBXInCurrentScope( rName ); | |
| if( pSbx ) | |
| { | |
| if( !pSbx->ISA(SbxMethod) && !pSbx->ISA(SbxObject) ) | |
| pVar = PTR_CAST(SbxVariable,pSbx); | |
| } | |
| if( pVar ) | |
| rStatus = 0; // We found something | |
| return pVar; | |
| } | |
| void StarBASIC::QuitAndExitApplication() | |
| { | |
| Stop(); | |
| bQuit = sal_True; | |
| } | |
| void StarBASIC::Stop() | |
| { | |
| SbiInstance* p = pINST; | |
| while( p ) | |
| { | |
| p->Stop(); | |
| p = p->pNext; | |
| } | |
| } | |
| sal_Bool StarBASIC::IsRunning() | |
| { | |
| return sal_Bool( pINST != NULL ); | |
| } | |
| /************************************************************************** | |
| * | |
| * Object factories and others | |
| * | |
| **************************************************************************/ | |
| // Activation of an object. There is no need to access active objects | |
| // with name via BASIC. If NULL is given, everything is activated. | |
| void StarBASIC::ActivateObject( const String* pName, sal_Bool bActivate ) | |
| { | |
| if( pName ) | |
| { | |
| SbxObject* p = (SbxObject*) SbxObject::Find( *pName, SbxCLASS_OBJECT ); | |
| if( p ) | |
| { | |
| if( bActivate ) | |
| p->SetFlag( SBX_EXTSEARCH ); | |
| else | |
| p->ResetFlag( SBX_EXTSEARCH ); | |
| } | |
| } | |
| else | |
| { | |
| for( sal_uInt16 i = 0; i < GetObjects()->Count(); i++ ) | |
| { | |
| SbxObject* p = (SbxObject*) GetObjects()->Get( i ); | |
| if( bActivate ) | |
| p->SetFlag( SBX_EXTSEARCH ); | |
| else | |
| p->ResetFlag( SBX_EXTSEARCH ); | |
| } | |
| } | |
| } | |
| /************************************************************************** | |
| * | |
| * Debugging and error handling | |
| * | |
| **************************************************************************/ | |
| SbMethod* StarBASIC::GetActiveMethod( sal_uInt16 nLevel ) | |
| { | |
| if( pINST ) | |
| return pINST->GetCaller( nLevel ); | |
| else | |
| return NULL; | |
| } | |
| SbModule* StarBASIC::GetActiveModule() | |
| { | |
| if( pINST && !IsCompilerError() ) | |
| return pINST->GetActiveModule(); | |
| else | |
| return pCMOD; | |
| } | |
| sal_uInt16 StarBASIC::BreakPoint( sal_uInt16 l, sal_uInt16 c1, sal_uInt16 c2 ) | |
| { | |
| SetErrorData( 0, l, c1, c2 ); | |
| bBreak = sal_True; | |
| if( GetSbData()->aBreakHdl.IsSet() ) | |
| return (sal_uInt16) GetSbData()->aBreakHdl.Call( this ); | |
| else | |
| return BreakHdl(); | |
| } | |
| sal_uInt16 StarBASIC::StepPoint( sal_uInt16 l, sal_uInt16 c1, sal_uInt16 c2 ) | |
| { | |
| SetErrorData( 0, l, c1, c2 ); | |
| bBreak = sal_False; | |
| if( GetSbData()->aBreakHdl.IsSet() ) | |
| return (sal_uInt16) GetSbData()->aBreakHdl.Call( this ); | |
| else | |
| return BreakHdl(); | |
| } | |
| sal_uInt16 __EXPORT StarBASIC::BreakHdl() | |
| { | |
| return (sal_uInt16) ( aBreakHdl.IsSet() | |
| ? aBreakHdl.Call( this ) : SbDEBUG_CONTINUE ); | |
| } | |
| // Calls for error handler and break handler | |
| sal_uInt16 StarBASIC::GetLine() { return GetSbData()->nLine; } | |
| sal_uInt16 StarBASIC::GetCol1() { return GetSbData()->nCol1; } | |
| sal_uInt16 StarBASIC::GetCol2() { return GetSbData()->nCol2; } | |
| // Specific to error handler | |
| SbError StarBASIC::GetErrorCode() { return GetSbData()->nCode; } | |
| const String& StarBASIC::GetErrorText() { return GetSbData()->aErrMsg; } | |
| sal_Bool StarBASIC::IsCompilerError() { return GetSbData()->bCompiler; } | |
| void StarBASIC::SetGlobalLanguageMode( SbLanguageMode eLanguageMode ) | |
| { | |
| GetSbData()->eLanguageMode = eLanguageMode; | |
| } | |
| SbLanguageMode StarBASIC::GetGlobalLanguageMode() | |
| { | |
| return GetSbData()->eLanguageMode; | |
| } | |
| // Local settings | |
| SbLanguageMode StarBASIC::GetLanguageMode() | |
| { | |
| // Use global settings? | |
| if( eLanguageMode == SB_LANG_GLOBAL ) | |
| return GetSbData()->eLanguageMode; | |
| else | |
| return eLanguageMode; | |
| } | |
| // AB: 29.3.96 | |
| // Das Mapping zwischen alten und neuen Fehlercodes erfolgt, indem die Tabelle | |
| // SFX_VB_ErrorTab[] durchsucht wird. Dies ist zwar nicht besonders performant, | |
| // verbraucht aber viel weniger Speicher als entsprechende switch-Bloecke. | |
| // Die Umrechnung von Fehlercodes muss nicht schnell sein, daher auch keine | |
| // binaere Suche bei VB-Error -> SFX-Error. | |
| // Neue Fehler-Codes auf alte, Sbx-Kompatible zurueckmappen | |
| sal_uInt16 StarBASIC::GetVBErrorCode( SbError nError ) | |
| { | |
| sal_uInt16 nRet = 0; | |
| if( SbiRuntime::isVBAEnabled() ) | |
| { | |
| switch( nError ) | |
| { | |
| case SbERR_BASIC_ARRAY_FIX: | |
| return 10; | |
| case SbERR_BASIC_STRING_OVERFLOW: | |
| return 14; | |
| case SbERR_BASIC_EXPR_TOO_COMPLEX: | |
| return 16; | |
| case SbERR_BASIC_OPER_NOT_PERFORM: | |
| return 17; | |
| case SbERR_BASIC_TOO_MANY_DLL: | |
| return 47; | |
| case SbERR_BASIC_LOOP_NOT_INIT: | |
| return 92; | |
| default: | |
| nRet = 0; | |
| } | |
| } | |
| // Suchschleife | |
| const SFX_VB_ErrorItem* pErrItem; | |
| sal_uInt16 nIndex = 0; | |
| do | |
| { | |
| pErrItem = SFX_VB_ErrorTab + nIndex; | |
| if( pErrItem->nErrorSFX == nError ) | |
| { | |
| nRet = pErrItem->nErrorVB; | |
| break; | |
| } | |
| nIndex++; | |
| } | |
| while( pErrItem->nErrorVB != 0xFFFF ); // bis End-Marke | |
| return nRet; | |
| } | |
| SbError StarBASIC::GetSfxFromVBError( sal_uInt16 nError ) | |
| { | |
| SbError nRet = 0L; | |
| if( SbiRuntime::isVBAEnabled() ) | |
| { | |
| switch( nError ) | |
| { | |
| case 1: | |
| case 2: | |
| case 4: | |
| case 8: | |
| case 12: | |
| case 73: | |
| return 0L; | |
| case 10: | |
| return SbERR_BASIC_ARRAY_FIX; | |
| case 14: | |
| return SbERR_BASIC_STRING_OVERFLOW; | |
| case 16: | |
| return SbERR_BASIC_EXPR_TOO_COMPLEX; | |
| case 17: | |
| return SbERR_BASIC_OPER_NOT_PERFORM; | |
| case 47: | |
| return SbERR_BASIC_TOO_MANY_DLL; | |
| case 92: | |
| return SbERR_BASIC_LOOP_NOT_INIT; | |
| default: | |
| nRet = 0L; | |
| } | |
| } | |
| const SFX_VB_ErrorItem* pErrItem; | |
| sal_uInt16 nIndex = 0; | |
| do | |
| { | |
| pErrItem = SFX_VB_ErrorTab + nIndex; | |
| if( pErrItem->nErrorVB == nError ) | |
| { | |
| nRet = pErrItem->nErrorSFX; | |
| break; | |
| } | |
| else if( pErrItem->nErrorVB > nError ) | |
| break; // kann nicht mehr gefunden werden | |
| nIndex++; | |
| } | |
| while( pErrItem->nErrorVB != 0xFFFF ); // bis End-Marke | |
| return nRet; | |
| } | |
| // Error- / Break-Daten setzen | |
| void StarBASIC::SetErrorData | |
| ( SbError nCode, sal_uInt16 nLine, sal_uInt16 nCol1, sal_uInt16 nCol2 ) | |
| { | |
| SbiGlobals& aGlobals = *GetSbData(); | |
| aGlobals.nCode = nCode; | |
| aGlobals.nLine = nLine; | |
| aGlobals.nCol1 = nCol1; | |
| aGlobals.nCol2 = nCol2; | |
| } | |
| //---------------------------------------------------------------- | |
| // Hilfsklasse zum Zugriff auf String SubResourcen einer Resource. | |
| // Quelle: sfx2\source\doc\docfile.cxx (TLX) | |
| struct BasicStringList_Impl : private Resource | |
| { | |
| ResId aResId; | |
| BasicStringList_Impl( ResId& rErrIdP, sal_uInt16 nId) | |
| : Resource( rErrIdP ),aResId(nId, *rErrIdP.GetResMgr() ){} | |
| ~BasicStringList_Impl() { FreeResource(); } | |
| String GetString(){ return String( aResId ); } | |
| sal_Bool IsErrorTextAvailable( void ) | |
| { return IsAvailableRes(aResId.SetRT(RSC_STRING)); } | |
| }; | |
| //---------------------------------------------------------------- | |
| // #60175 Flag, das bei Basic-Fehlern das Anziehen der SFX-Resourcen verhindert | |
| static sal_Bool bStaticSuppressSfxResource = sal_False; | |
| void StarBASIC::StaticSuppressSfxResource( sal_Bool bSuppress ) | |
| { | |
| bStaticSuppressSfxResource = bSuppress; | |
| } | |
| // Hack for #83750, use bStaticSuppressSfxResource as setup flag | |
| sal_Bool runsInSetup( void ) | |
| { | |
| return bStaticSuppressSfxResource; | |
| } | |
| void StarBASIC::MakeErrorText( SbError nId, const String& aMsg ) | |
| { | |
| vos::OGuard aSolarGuard( Application::GetSolarMutex() ); | |
| if( bStaticSuppressSfxResource ) | |
| { | |
| GetSbData()->aErrMsg = String( RTL_CONSTASCII_USTRINGPARAM("No resource: Error message not available") ); | |
| return; | |
| } | |
| sal_uInt16 nOldID = GetVBErrorCode( nId ); | |
| // Hilfsklasse instanzieren | |
| BasResId aId( RID_BASIC_START ); | |
| BasicStringList_Impl aMyStringList( aId, sal_uInt16(nId & ERRCODE_RES_MASK) ); | |
| if( aMyStringList.IsErrorTextAvailable() ) | |
| { | |
| // Merge Message mit Zusatztext | |
| String aMsg1 = aMyStringList.GetString(); | |
| // Argument-Platzhalter durch %s ersetzen | |
| String aSrgStr( RTL_CONSTASCII_USTRINGPARAM("$(ARG1)") ); | |
| sal_uInt16 nResult = aMsg1.Search( aSrgStr ); | |
| if( nResult != STRING_NOTFOUND ) | |
| { | |
| aMsg1.Erase( nResult, aSrgStr.Len() ); | |
| aMsg1.Insert( aMsg, nResult ); | |
| } | |
| GetSbData()->aErrMsg = aMsg1; | |
| } | |
| else if( nOldID != 0 ) | |
| { | |
| String aStdMsg( RTL_CONSTASCII_USTRINGPARAM("Fehler ") ); | |
| aStdMsg += String::CreateFromInt32( nOldID); | |
| aStdMsg += String( RTL_CONSTASCII_USTRINGPARAM(": Kein Fehlertext verfuegbar!") ); | |
| GetSbData()->aErrMsg = aStdMsg; | |
| } | |
| else | |
| GetSbData()->aErrMsg = String::EmptyString(); | |
| } | |
| sal_Bool StarBASIC::CError | |
| ( SbError code, const String& rMsg, sal_uInt16 l, sal_uInt16 c1, sal_uInt16 c2 ) | |
| { | |
| vos::OGuard aSolarGuard( Application::GetSolarMutex() ); | |
| // Compiler-Fehler waehrend der Laufzeit -> Programm anhalten | |
| if( IsRunning() ) | |
| { | |
| // #109018 Check if running Basic is affected | |
| StarBASIC* pStartedBasic = pINST->GetBasic(); | |
| if( pStartedBasic != this ) | |
| return sal_False; | |
| Stop(); | |
| } | |
| // Flag setzen, damit GlobalRunInit den Fehler mitbekommt | |
| GetSbData()->bGlobalInitErr = sal_True; | |
| // Fehlertext basteln | |
| MakeErrorText( code, rMsg ); | |
| // Umsetzung des Codes fuer String-Transport in SFX-Error | |
| if( rMsg.Len() ) | |
| code = (sal_uIntPtr)*new StringErrorInfo( code, String(rMsg) ); | |
| SetErrorData( code, l, c1, c2 ); | |
| GetSbData()->bCompiler = sal_True; | |
| sal_Bool bRet; | |
| if( GetSbData()->aErrHdl.IsSet() ) | |
| bRet = (sal_Bool) GetSbData()->aErrHdl.Call( this ); | |
| else | |
| bRet = ErrorHdl(); | |
| GetSbData()->bCompiler = sal_False; // nur sal_True fuer Error-Handler | |
| return bRet; | |
| } | |
| sal_Bool StarBASIC::RTError | |
| ( SbError code, sal_uInt16 l, sal_uInt16 c1, sal_uInt16 c2 ) | |
| { | |
| return RTError( code, String(), l, c1, c2 ); | |
| } | |
| sal_Bool StarBASIC::RTError( SbError code, const String& rMsg, sal_uInt16 l, sal_uInt16 c1, sal_uInt16 c2 ) | |
| { | |
| vos::OGuard aSolarGuard( Application::GetSolarMutex() ); | |
| SbError c = code; | |
| if( (c & ERRCODE_CLASS_MASK) == ERRCODE_CLASS_COMPILER ) | |
| c = 0; | |
| MakeErrorText( c, rMsg ); | |
| // Umsetzung des Codes fuer String-Transport in SFX-Error | |
| if( rMsg.Len() ) | |
| { | |
| // very confusing, even though MakeErrorText sets up the error text | |
| // seems that this is not used ( if rMsg already has content ) | |
| // In the case of VBA MakeErrorText also formats the error to be alittle more | |
| // like vba ( adds an error number etc ) | |
| if ( SbiRuntime::isVBAEnabled() && ( code == SbERR_BASIC_COMPAT ) ) | |
| { | |
| String aTmp = '\''; | |
| aTmp += String::CreateFromInt32( SbxErrObject::getUnoErrObject()->getNumber() ); | |
| aTmp += String( RTL_CONSTASCII_USTRINGPARAM("\'\n") ); | |
| aTmp += GetSbData()->aErrMsg.Len() ? GetSbData()->aErrMsg : rMsg; | |
| code = (sal_uIntPtr)*new StringErrorInfo( code, aTmp ); | |
| } | |
| else | |
| code = (sal_uIntPtr)*new StringErrorInfo( code, String(rMsg) ); | |
| } | |
| SetErrorData( code, l, c1, c2 ); | |
| if( GetSbData()->aErrHdl.IsSet() ) | |
| return (sal_Bool) GetSbData()->aErrHdl.Call( this ); | |
| else | |
| return ErrorHdl(); | |
| } | |
| void StarBASIC::Error( SbError n ) | |
| { | |
| Error( n, String() ); | |
| } | |
| void StarBASIC::Error( SbError n, const String& rMsg ) | |
| { | |
| if( pINST ) | |
| pINST->Error( n, rMsg ); | |
| } | |
| void StarBASIC::FatalError( SbError n ) | |
| { | |
| if( pINST ) | |
| pINST->FatalError( n ); | |
| } | |
| void StarBASIC::FatalError( SbError _errCode, const String& _details ) | |
| { | |
| if( pINST ) | |
| pINST->FatalError( _errCode, _details ); | |
| } | |
| SbError StarBASIC::GetErrBasic() | |
| { | |
| if( pINST ) | |
| return pINST->GetErr(); | |
| else | |
| return 0; | |
| } | |
| // #66536 Zusatz-Message fuer RTL-Funktion Error zugreifbar machen | |
| String StarBASIC::GetErrorMsg() | |
| { | |
| if( pINST ) | |
| return pINST->GetErrorMsg(); | |
| else | |
| return String(); | |
| } | |
| sal_uInt16 StarBASIC::GetErl() | |
| { | |
| if( pINST ) | |
| return pINST->GetErl(); | |
| else | |
| return 0; | |
| } | |
| sal_Bool __EXPORT StarBASIC::ErrorHdl() | |
| { | |
| return (sal_Bool) ( aErrorHdl.IsSet() | |
| ? aErrorHdl.Call( this ) : sal_False ); | |
| } | |
| Link StarBASIC::GetGlobalErrorHdl() | |
| { | |
| return GetSbData()->aErrHdl; | |
| } | |
| void StarBASIC::SetGlobalErrorHdl( const Link& rLink ) | |
| { | |
| GetSbData()->aErrHdl = rLink; | |
| } | |
| Link StarBASIC::GetGlobalBreakHdl() | |
| { | |
| return GetSbData()->aBreakHdl; | |
| } | |
| void StarBASIC::SetGlobalBreakHdl( const Link& rLink ) | |
| { | |
| GetSbData()->aBreakHdl = rLink; | |
| } | |
| SbxArrayRef StarBASIC::getUnoListeners( void ) | |
| { | |
| if( !xUnoListeners.Is() ) | |
| xUnoListeners = new SbxArray(); | |
| return xUnoListeners; | |
| } | |
| /************************************************************************** | |
| * | |
| * Laden und Speichern | |
| * | |
| **************************************************************************/ | |
| sal_Bool StarBASIC::LoadData( SvStream& r, sal_uInt16 nVer ) | |
| { | |
| if( !SbxObject::LoadData( r, nVer ) ) | |
| return sal_False; | |
| // #95459 Delete dialogs, otherwise endless recursion | |
| // in SbxVarable::GetType() if dialogs are accessed | |
| sal_uInt16 nObjCount = pObjs->Count(); | |
| SbxVariable** ppDeleteTab = new SbxVariable*[ nObjCount ]; | |
| sal_uInt16 nObj; | |
| for( nObj = 0 ; nObj < nObjCount ; nObj++ ) | |
| { | |
| SbxVariable* pVar = pObjs->Get( nObj ); | |
| StarBASIC* pBasic = PTR_CAST( StarBASIC, pVar ); | |
| ppDeleteTab[nObj] = pBasic ? NULL : pVar; | |
| } | |
| for( nObj = 0 ; nObj < nObjCount ; nObj++ ) | |
| { | |
| SbxVariable* pVar = ppDeleteTab[nObj]; | |
| if( pVar ) | |
| pObjs->Remove( pVar ); | |
| } | |
| delete[] ppDeleteTab; | |
| sal_uInt16 nMod; | |
| pModules->Clear(); | |
| r >> nMod; | |
| for( sal_uInt16 i = 0; i < nMod; i++ ) | |
| { | |
| SbModule* pMod = (SbModule*) SbxBase::Load( r ); | |
| if( !pMod ) | |
| return sal_False; | |
| else if( pMod->ISA(SbJScriptModule) ) | |
| { | |
| // Ref zuweisen, damit pMod deleted wird | |
| SbModuleRef xRef = pMod; | |
| } | |
| else | |
| { | |
| pMod->SetParent( this ); | |
| pModules->Put( pMod, i ); | |
| } | |
| } | |
| // HACK fuer SFX-Mist! | |
| SbxVariable* p = Find( String( RTL_CONSTASCII_USTRINGPARAM("FALSE") ), SbxCLASS_PROPERTY ); | |
| if( p ) | |
| Remove( p ); | |
| p = Find( String( RTL_CONSTASCII_USTRINGPARAM("TRUE") ), SbxCLASS_PROPERTY ); | |
| if( p ) | |
| Remove( p ); | |
| // Ende des Hacks! | |
| // Suche ueber StarBASIC ist immer global | |
| DBG_ASSERT( IsSet( SBX_GBLSEARCH ), "Basic ohne GBLSEARCH geladen" ); | |
| SetFlag( SBX_GBLSEARCH ); | |
| return sal_True; | |
| } | |
| sal_Bool StarBASIC::StoreData( SvStream& r ) const | |
| { | |
| if( !SbxObject::StoreData( r ) ) | |
| return sal_False; | |
| r << (sal_uInt16) pModules->Count(); | |
| for( sal_uInt16 i = 0; i < pModules->Count(); i++ ) | |
| { | |
| SbModule* p = (SbModule*) pModules->Get( i ); | |
| if( !p->Store( r ) ) | |
| return sal_False; | |
| } | |
| return sal_True; | |
| } | |
| sal_Bool StarBASIC::LoadOldModules( SvStream& ) | |
| { | |
| return sal_False; | |
| } | |
| bool StarBASIC::GetUNOConstant( const sal_Char* _pAsciiName, ::com::sun::star::uno::Any& aOut ) | |
| { | |
| bool bRes = false; | |
| ::rtl::OUString sVarName( ::rtl::OUString::createFromAscii( _pAsciiName ) ); | |
| SbUnoObject* pGlobs = dynamic_cast<SbUnoObject*>( Find( sVarName, SbxCLASS_DONTCARE ) ); | |
| if ( pGlobs ) | |
| { | |
| aOut = pGlobs->getUnoAny(); | |
| bRes = true; | |
| } | |
| return bRes; | |
| } | |
| Reference< frame::XModel > StarBASIC::GetModelFromBasic( SbxObject* pBasic ) | |
| { | |
| OSL_PRECOND( pBasic != NULL, "getModelFromBasic: illegal call!" ); | |
| if ( !pBasic ) | |
| return NULL; | |
| // look for the ThisComponent variable, first in the parent (which | |
| // might be the document's Basic), then in the parent's parent (which might be | |
| // the application Basic) | |
| const ::rtl::OUString sThisComponent( RTL_CONSTASCII_USTRINGPARAM( "ThisComponent" ) ); | |
| SbxVariable* pThisComponent = NULL; | |
| SbxObject* pLookup = pBasic->GetParent(); | |
| while ( pLookup && !pThisComponent ) | |
| { | |
| pThisComponent = pLookup->Find( sThisComponent, SbxCLASS_OBJECT ); | |
| pLookup = pLookup->GetParent(); | |
| } | |
| if ( !pThisComponent ) | |
| { | |
| OSL_TRACE("Failed to get ThisComponent"); | |
| // the application Basic, at the latest, should have this variable | |
| return NULL; | |
| } | |
| Any aThisComponentAny( sbxToUnoValue( pThisComponent ) ); | |
| Reference< frame::XModel > xModel( aThisComponentAny, UNO_QUERY ); | |
| if ( !xModel.is() ) | |
| { | |
| // it's no XModel. Okay, ThisComponent nowadays is allowed to be a controller. | |
| Reference< frame::XController > xController( aThisComponentAny, UNO_QUERY ); | |
| if ( xController.is() ) | |
| xModel = xController->getModel(); | |
| } | |
| if ( !xModel.is() ) | |
| return NULL; | |
| #if OSL_DEBUG_LEVEL > 0 | |
| OSL_TRACE("Have model ThisComponent points to url %s", | |
| ::rtl::OUStringToOString( xModel->getURL(), | |
| RTL_TEXTENCODING_ASCII_US ).pData->buffer ); | |
| #endif | |
| return xModel; | |
| } | |
| //======================================================================== | |
| // #118116 Implementation Collection object | |
| TYPEINIT1(BasicCollection,SbxObject) | |
| static const char pCountStr[] = "Count"; | |
| static const char pAddStr[] = "Add"; | |
| static const char pItemStr[] = "Item"; | |
| static const char pRemoveStr[] = "Remove"; | |
| static sal_uInt16 nCountHash = 0, nAddHash, nItemHash, nRemoveHash; | |
| SbxInfoRef BasicCollection::xAddInfo = NULL; | |
| SbxInfoRef BasicCollection::xItemInfo = NULL; | |
| // Items may share a name (an item added without a key keeps the name of the | |
| // variable it was copied from), so each name maps to all of its holders. | |
| class CollectionNameMap : public | |
| std::hash_map< ::rtl::OUString, std::vector< SbxVariable* >, | |
| ::rtl::OUStringHash, ::std::equal_to< ::rtl::OUString > > | |
| {}; | |
| // Matches EqualsIgnoreCaseAscii: only ASCII letters are folded | |
| static ::rtl::OUString lcl_foldCollectionName( const String& rName ) | |
| { | |
| return ::rtl::OUString( rName ).toAsciiUpperCase(); | |
| } | |
| BasicCollection::BasicCollection( const XubString& rClass ) | |
| : SbxObject( rClass ), mpNameMap( new CollectionNameMap ) | |
| { | |
| if( !nCountHash ) | |
| { | |
| nCountHash = MakeHashCode( String::CreateFromAscii( pCountStr ) ); | |
| nAddHash = MakeHashCode( String::CreateFromAscii( pAddStr ) ); | |
| nItemHash = MakeHashCode( String::CreateFromAscii( pItemStr ) ); | |
| nRemoveHash = MakeHashCode( String::CreateFromAscii( pRemoveStr ) ); | |
| } | |
| Initialize(); | |
| } | |
| BasicCollection::~BasicCollection() | |
| { | |
| delete mpNameMap; | |
| } | |
| void BasicCollection::Clear() | |
| { | |
| SbxObject::Clear(); | |
| Initialize(); | |
| } | |
| void BasicCollection::Initialize() | |
| { | |
| xItemArray = new SbxArray(); | |
| mpNameMap->clear(); | |
| SetType( SbxOBJECT ); | |
| SetFlag( SBX_FIXED ); | |
| ResetFlag( SBX_WRITE ); | |
| SbxVariable* p; | |
| p = Make( String::CreateFromAscii( pCountStr ), SbxCLASS_PROPERTY, SbxINTEGER ); | |
| p->ResetFlag( SBX_WRITE ); | |
| p->SetFlag( SBX_DONTSTORE ); | |
| p = Make( String::CreateFromAscii( pAddStr ), SbxCLASS_METHOD, SbxEMPTY ); | |
| p->SetFlag( SBX_DONTSTORE ); | |
| p = Make( String::CreateFromAscii( pItemStr ), SbxCLASS_METHOD, SbxVARIANT ); | |
| p->SetFlag( SBX_DONTSTORE ); | |
| p = Make( String::CreateFromAscii( pRemoveStr ), SbxCLASS_METHOD, SbxEMPTY ); | |
| p->SetFlag( SBX_DONTSTORE ); | |
| if ( !xAddInfo.Is() ) | |
| { | |
| xAddInfo = new SbxInfo; | |
| xAddInfo->AddParam( String( RTL_CONSTASCII_USTRINGPARAM("Item") ), SbxVARIANT, SBX_READ ); | |
| xAddInfo->AddParam( String( RTL_CONSTASCII_USTRINGPARAM("Key") ), SbxVARIANT, SBX_READ | SBX_OPTIONAL ); | |
| xAddInfo->AddParam( String( RTL_CONSTASCII_USTRINGPARAM("Before") ), SbxVARIANT, SBX_READ | SBX_OPTIONAL ); | |
| xAddInfo->AddParam( String( RTL_CONSTASCII_USTRINGPARAM("After") ), SbxVARIANT, SBX_READ | SBX_OPTIONAL ); | |
| } | |
| if ( !xItemInfo.Is() ) | |
| { | |
| xItemInfo = new SbxInfo; | |
| xItemInfo->AddParam( String( RTL_CONSTASCII_USTRINGPARAM("Index") ), SbxVARIANT, SBX_READ | SBX_OPTIONAL); | |
| } | |
| } | |
| SbxVariable* BasicCollection::Find( const XubString& rName, SbxClassType t ) | |
| { | |
| SbxVariable* pFind = SbxObject::Find( rName, t ); | |
| return pFind; | |
| } | |
| void BasicCollection::SFX_NOTIFY( SfxBroadcaster& rCst, const TypeId& rId1, | |
| const SfxHint& rHint, const TypeId& rId2 ) | |
| { | |
| const SbxHint* p = PTR_CAST(SbxHint,&rHint); | |
| if( p ) | |
| { | |
| sal_uIntPtr nId = p->GetId(); | |
| sal_Bool bRead = sal_Bool( nId == SBX_HINT_DATAWANTED ); | |
| sal_Bool bWrite = sal_Bool( nId == SBX_HINT_DATACHANGED ); | |
| sal_Bool bRequestInfo = sal_Bool( nId == SBX_HINT_INFOWANTED ); | |
| SbxVariable* pVar = p->GetVar(); | |
| SbxArray* pArg = pVar->GetParameters(); | |
| XubString aVarName( pVar->GetName() ); | |
| if( bRead || bWrite ) | |
| { | |
| if( pVar->GetHashCode() == nCountHash | |
| && aVarName.EqualsIgnoreCaseAscii( pCountStr ) ) | |
| pVar->PutLong( xItemArray->Count32() ); | |
| else if( pVar->GetHashCode() == nAddHash | |
| && aVarName.EqualsIgnoreCaseAscii( pAddStr ) ) | |
| CollAdd( pArg ); | |
| else if( pVar->GetHashCode() == nItemHash | |
| && aVarName.EqualsIgnoreCaseAscii( pItemStr ) ) | |
| CollItem( pArg ); | |
| else if( pVar->GetHashCode() == nRemoveHash | |
| && aVarName.EqualsIgnoreCaseAscii( pRemoveStr ) ) | |
| CollRemove( pArg ); | |
| else | |
| SbxObject::SFX_NOTIFY( rCst, rId1, rHint, rId2 ); | |
| return; | |
| } | |
| else if ( bRequestInfo ) | |
| { | |
| if( pVar->GetHashCode() == nAddHash | |
| && aVarName.EqualsIgnoreCaseAscii( pAddStr ) ) | |
| pVar->SetInfo( xAddInfo ); | |
| else if( pVar->GetHashCode() == nItemHash | |
| && aVarName.EqualsIgnoreCaseAscii( pItemStr ) ) | |
| pVar->SetInfo( xItemInfo ); | |
| } | |
| } | |
| SbxObject::SFX_NOTIFY( rCst, rId1, rHint, rId2 ); | |
| } | |
| sal_Int32 BasicCollection::implGetIndex( SbxVariable* pIndexVar ) | |
| { | |
| sal_Int32 nIndex = -1; | |
| if( pIndexVar->GetType() == SbxSTRING ) | |
| nIndex = implGetIndexForName( pIndexVar->GetString() ); | |
| else | |
| nIndex = pIndexVar->GetLong() - 1; | |
| return nIndex; | |
| } | |
| void BasicCollection::implRegisterName( SbxVariable* pVar ) | |
| { | |
| // Nameless items are never found by name, see implFindByName | |
| if( pVar->GetName().Len() ) | |
| (*mpNameMap)[ lcl_foldCollectionName( pVar->GetName() ) ].push_back( pVar ); | |
| } | |
| void BasicCollection::implUnregisterName( SbxVariable* pVar ) | |
| { | |
| if( !pVar->GetName().Len() ) | |
| return; | |
| CollectionNameMap::iterator it = mpNameMap->find( lcl_foldCollectionName( pVar->GetName() ) ); | |
| if( it == mpNameMap->end() ) | |
| return; | |
| std::vector< SbxVariable* >& rVars = it->second; | |
| rVars.erase( std::remove( rVars.begin(), rVars.end(), pVar ), rVars.end() ); | |
| if( rVars.empty() ) | |
| mpNameMap->erase( it ); | |
| } | |
| // Returns the item with the lowest index that has the given name | |
| SbxVariable* BasicCollection::implFindByName( const String& rName ) | |
| { | |
| sal_Int32 nCount = xItemArray->Count32(); | |
| if( !rName.Len() ) | |
| { | |
| // Nameless items are not indexed | |
| for( sal_Int32 i = 0 ; i < nCount ; i++ ) | |
| { | |
| SbxVariable* pVar = xItemArray->Get32( i ); | |
| if( !pVar->GetName().Len() ) | |
| return pVar; | |
| } | |
| return NULL; | |
| } | |
| CollectionNameMap::iterator it = mpNameMap->find( lcl_foldCollectionName( rName ) ); | |
| if( it == mpNameMap->end() ) | |
| return NULL; | |
| std::vector< SbxVariable* >& rVars = it->second; | |
| if( rVars.size() == 1 ) | |
| return rVars[0]; | |
| for( sal_Int32 i = 0 ; i < nCount ; i++ ) | |
| { | |
| SbxVariable* pVar = xItemArray->Get32( i ); | |
| if( std::find( rVars.begin(), rVars.end(), pVar ) != rVars.end() ) | |
| return pVar; | |
| } | |
| return NULL; | |
| } | |
| sal_Int32 BasicCollection::implGetIndexForName( const String& rName ) | |
| { | |
| SbxVariable* pFound = implFindByName( rName ); | |
| if( !pFound ) | |
| return -1; | |
| sal_Int32 nCount = xItemArray->Count32(); | |
| for( sal_Int32 i = 0 ; i < nCount ; i++ ) | |
| { | |
| if( xItemArray->Get32( i ) == pFound ) | |
| return i; | |
| } | |
| return -1; | |
| } | |
| void BasicCollection::CollAdd( SbxArray* pPar_ ) | |
| { | |
| sal_uInt16 nCount = pPar_->Count(); | |
| if( nCount < 2 || nCount > 5 ) | |
| { | |
| SetError( SbxERR_WRONG_ARGS ); | |
| return; | |
| } | |
| SbxVariable* pItem = pPar_->Get(1); | |
| if( pItem ) | |
| { | |
| int nNextIndex; | |
| if( nCount < 4 ) | |
| { | |
| nNextIndex = xItemArray->Count(); | |
| } | |
| else | |
| { | |
| SbxVariable* pBefore = pPar_->Get(3); | |
| if( nCount == 5 ) | |
| { | |
| if( !( pBefore->IsErr() || ( pBefore->GetType() == SbxEMPTY ) ) ) | |
| { | |
| SetError( SbERR_BAD_ARGUMENT ); | |
| return; | |
| } | |
| SbxVariable* pAfter = pPar_->Get(4); | |
| sal_Int32 nAfterIndex = implGetIndex( pAfter ); | |
| if( nAfterIndex == -1 ) | |
| { | |
| SetError( SbERR_BAD_ARGUMENT ); | |
| return; | |
| } | |
| nNextIndex = nAfterIndex + 1; | |
| } | |
| else // if( nCount == 4 ) | |
| { | |
| sal_Int32 nBeforeIndex = implGetIndex( pBefore ); | |
| if( nBeforeIndex == -1 ) | |
| { | |
| SetError( SbERR_BAD_ARGUMENT ); | |
| return; | |
| } | |
| nNextIndex = nBeforeIndex; | |
| } | |
| } | |
| SbxVariableRef pNewItem = new SbxVariable( *pItem ); | |
| if( nCount >= 3 ) | |
| { | |
| SbxVariable* pKey = pPar_->Get(2); | |
| if( !( pKey->IsErr() || ( pKey->GetType() == SbxEMPTY ) ) ) | |
| { | |
| if( pKey->GetType() != SbxSTRING ) | |
| { | |
| SetError( SbERR_BAD_ARGUMENT ); | |
| return; | |
| } | |
| String aKey = pKey->GetString(); | |
| if( implGetIndexForName( aKey ) != -1 ) | |
| { | |
| SetError( SbERR_BAD_ARGUMENT ); | |
| return; | |
| } | |
| pNewItem->SetName( aKey ); | |
| } | |
| } | |
| pNewItem->SetFlag( SBX_READWRITE ); | |
| xItemArray->Insert32( pNewItem, nNextIndex ); | |
| implRegisterName( pNewItem ); | |
| } | |
| else | |
| { | |
| SetError( SbERR_BAD_ARGUMENT ); | |
| return; | |
| } | |
| } | |
| void BasicCollection::CollItem( SbxArray* pPar_ ) | |
| { | |
| if( pPar_->Count() != 2 ) | |
| { | |
| SetError( SbxERR_WRONG_ARGS ); | |
| return; | |
| } | |
| SbxVariable* pRes = NULL; | |
| SbxVariable* p = pPar_->Get( 1 ); | |
| if( p->GetType() == SbxSTRING ) | |
| { | |
| pRes = implFindByName( p->GetString() ); | |
| } | |
| else | |
| { | |
| sal_Int32 nIndex = implGetIndex( p ); | |
| if( nIndex >= 0 && nIndex < (sal_Int32)xItemArray->Count32() ) | |
| pRes = xItemArray->Get32( nIndex ); | |
| } | |
| if( !pRes ) | |
| SetError( SbERR_BAD_ARGUMENT ); | |
| else | |
| *(pPar_->Get(0)) = *pRes; | |
| } | |
| void BasicCollection::CollRemove( SbxArray* pPar_ ) | |
| { | |
| if( pPar_ == NULL || pPar_->Count() != 2 ) | |
| { | |
| SetError( SbxERR_WRONG_ARGS ); | |
| return; | |
| } | |
| SbxVariable* p = pPar_->Get( 1 ); | |
| sal_Int32 nIndex = implGetIndex( p ); | |
| if( nIndex >= 0 && nIndex < (sal_Int32)xItemArray->Count32() ) | |
| { | |
| implUnregisterName( xItemArray->Get32( nIndex ) ); | |
| xItemArray->Remove32( nIndex ); | |
| // Correct for stack if necessary | |
| SbiInstance* pInst = pINST; | |
| SbiRuntime* pRT = pInst ? pInst->pRun : NULL; | |
| if( pRT ) | |
| { | |
| SbiForStack* pStack = pRT->FindForStackItemForCollection( this ); | |
| if( pStack != NULL ) | |
| { | |
| if( pStack->nCurCollectionIndex >= nIndex ) | |
| --pStack->nCurCollectionIndex; | |
| } | |
| } | |
| } | |
| else | |
| SetError( SbERR_BAD_ARGUMENT ); | |
| } |