    /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
    /*
     * This file is part of the LibreOffice project.
     *
     * This Source Code Form is subject to the terms of the Mozilla Public
     * License, v. 2.0. If a copy of the MPL was not distributed with this
     * file, You can obtain one at http://mozilla.org/MPL/2.0/.
     *
     * This file incorporates work covered by the following license notice:
     *
     *   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 .
     */

    #include <sb.hxx>
    #include <tools/stream.hxx>
    #include <vcl/errinf.hxx>
    #include <comphelper/solarmutex.hxx>
    #include <basic/sbx.hxx>
    #include <vcl/svapp.hxx>
    #include <comphelper/processfactory.hxx>
    #include <image.hxx>
    #include <sbunoobj.hxx>
    #include <sbjsmeth.hxx>
    #include <sbjsmod.hxx>
    #include <sbintern.hxx>
    #include <runtime.hxx>
    #include <basic/sbuno.hxx>
    #include <sbobjmod.hxx>
    #include <stdobj.hxx>
    #include <filefmt.hxx>
    #include <basic.hrc>
    #include <cppuhelper/implbase.hxx>
    #include <com/sun/star/lang/XMultiServiceFactory.hpp>
    #include <com/sun/star/util/XCloseBroadcaster.hpp>
    #include <com/sun/star/util/XCloseListener.hpp>
    #include <sal/log.hxx>
    #include <errobject.hxx>
    #include <memory>
    #include <unordered_map>

    #include <com/sun/star/script/ModuleType.hpp>
    #include <com/sun/star/script/ModuleInfo.hpp>
    #include <svtools/miscopt.hxx>
    using namespace ::com::sun::star::script;

    #define RTLNAME "@SBRTL"
    //  i#i68894#
    using namespace ::com::sun::star;
    using namespace ::com::sun::star::uno;
    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;

    class DocBasicItem : public ::cppu::WeakImplHelper< util::XCloseListener >
    {
    public:
        explicit DocBasicItem( StarBASIC& rDocBasic );
        virtual ~DocBasicItem() override;

        const SbxObjectRef& getClassModules() const { return mxClassModules; }
        bool isDocClosed() const { return mbDocClosed; }

        void clearDependingVarsOnDelete( StarBASIC& rDeletedBasic );

        void startListening();
        void stopListening();

        void setDisposed( bool bDisposed )
        {
            mbDisposed = bDisposed;
        }

        virtual void SAL_CALL queryClosing( const lang::EventObject& rSource, sal_Bool bGetsOwnership ) override;
        virtual void SAL_CALL notifyClosing( const lang::EventObject& rSource ) override;
        virtual void SAL_CALL disposing( const lang::EventObject& rSource ) override;

    private:
        StarBASIC&      mrDocBasic;
        SbxObjectRef    mxClassModules;
        bool            mbDocClosed;
        bool            mbDisposed;
    };

    DocBasicItem::DocBasicItem( StarBASIC& rDocBasic ) :
        mrDocBasic( rDocBasic ),
        mxClassModules( new SbxObject( OUString() ) ),
        mbDocClosed( false ),
        mbDisposed( false )
    {
    }

    DocBasicItem::~DocBasicItem()
    {
        // tdf#90969 HACK: don't use SolarMutexGuard - there is a horrible global
        // map GaDocBasicItems holding instances, and these get deleted from exit
        // handlers, when the SolarMutex is already dead
        comphelper::SolarMutex *pSolarMutex = comphelper::SolarMutex::get();
        if ( pSolarMutex )
            pSolarMutex->acquire();

        try
        {
            stopListening();
            mxClassModules.clear(); // release with SolarMutex locked
        }
        catch (...)
        {
            assert(false);
        }

        pSolarMutex = comphelper::SolarMutex::get();
        if ( pSolarMutex )
            pSolarMutex->release();
    }

    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(const uno::Exception& ) {}
        }
    }

    void DocBasicItem::stopListening()
    {
        if( mbDisposed ) return;
        mbDisposed = true;
        Any aThisComp;
        if (!mrDocBasic.GetUNOConstant("ThisComponent", aThisComp))
            return;

        Reference< util::XCloseBroadcaster > xCloseBC( aThisComp, UNO_QUERY );
        if( xCloseBC.is() )
        {
            try { xCloseBC->removeCloseListener( this ); } catch(const 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;

    class GaDocBasicItems : public rtl::Static<std::unordered_map< const StarBASIC *, DocBasicItemRef >,GaDocBasicItems> {};

    const DocBasicItem* lclFindDocBasicItem( const StarBASIC* pDocBasic )
    {
        auto it = GaDocBasicItems::get().find( pDocBasic );
        auto end = GaDocBasicItems::get().end();
        return (it != end) ? it->second.get() : nullptr;
    }

    void lclInsertDocBasicItem( StarBASIC& rDocBasic )
    {
        DocBasicItemRef& rxDocBasicItem = GaDocBasicItems::get()[ &rDocBasic ];
        rxDocBasicItem.set( new DocBasicItem( rDocBasic ) );
        rxDocBasicItem->startListening();
    }

    void lclRemoveDocBasicItem( StarBASIC& rDocBasic )
    {
        auto it = GaDocBasicItems::get().find( &rDocBasic );
        if( it != GaDocBasicItems::get().end() )
        {
            it->second->stopListening();
            GaDocBasicItems::get().erase( it );
        }
        auto it_end = GaDocBasicItems::get().end();
        for( it = GaDocBasicItems::get().begin(); it != it_end; ++it )
        {
            it->second->clearDependingVarsOnDelete( rDocBasic );
        }
    }

    StarBASIC* lclGetDocBasicForModule( SbModule* pModule )
    {
        StarBASIC* pRetBasic = nullptr;
        SbxObject* pCurParent = pModule;
        while( pCurParent->GetParent() != nullptr )
        {
            pCurParent = pCurParent->GetParent();
            StarBASIC* pDocBasic = dynamic_cast<StarBASIC*>( pCurParent  );
            if( pDocBasic != nullptr && pDocBasic->IsDocBasic() )
            {
                pRetBasic = pDocBasic;
                break;
            }
        }
        return pRetBasic;
    }

    } // namespace

    SbxObject* StarBASIC::getVBAGlobals( )
    {
        if ( !pVBAGlobals.is() )
        {
            Any aThisDoc;
            if ( GetUNOConstant("ThisComponent", aThisDoc) )
            {
                Reference< XMultiServiceFactory > xDocFac( aThisDoc, UNO_QUERY );
                if ( xDocFac.is() )
                {
                    try
                    {
                        xDocFac->createInstance("ooo.vba.VBAGlobals");
                    }
                    catch(const Exception& )
                    {
                        // Ignore
                    }
                }
            }
            const OUString aVBAHook("VBAGlobals");
            pVBAGlobals = static_cast<SbUnoObject*>(Find( aVBAHook , SbxClassType::DontCare ));
        }
        return pVBAGlobals.get();
    }

    //  i#i68894#
    SbxVariable* StarBASIC::VBAFind( const OUString& rName, SbxClassType t )
    {
        if( rName == "ThisComponent" )
        {
            return nullptr;
        }
        // rename to init globals
        if ( getVBAGlobals( ) )
        {
            return pVBAGlobals->Find( rName, t );
        }
        return nullptr;
    }

    // Create array for conversion SFX <-> VB error code
    struct SFX_VB_ErrorItem
    {
        sal_uInt16  nErrorVB;
        ErrCode nErrorSFX;
    };

    const SFX_VB_ErrorItem SFX_VB_ErrorTab[] =
    {
        { 1, ERRCODE_BASIC_EXCEPTION },  // #87844 Map exception to error code 1
        { 2, ERRCODE_BASIC_SYNTAX },
        { 3, ERRCODE_BASIC_NO_GOSUB },
        { 4, ERRCODE_BASIC_REDO_FROM_START },
        { 5, ERRCODE_BASIC_BAD_ARGUMENT },
        { 6, ERRCODE_BASIC_MATH_OVERFLOW },
        { 7, ERRCODE_BASIC_NO_MEMORY },
        { 8, ERRCODE_BASIC_ALREADY_DIM },
        { 9, ERRCODE_BASIC_OUT_OF_RANGE },
        { 10, ERRCODE_BASIC_DUPLICATE_DEF },
        { 11, ERRCODE_BASIC_ZERODIV },
        { 12, ERRCODE_BASIC_VAR_UNDEFINED },
        { 13, ERRCODE_BASIC_CONVERSION },
        { 14, ERRCODE_BASIC_BAD_PARAMETER },
        { 18, ERRCODE_BASIC_USER_ABORT },
        { 20, ERRCODE_BASIC_BAD_RESUME },
        { 28, ERRCODE_BASIC_STACK_OVERFLOW },
        { 35, ERRCODE_BASIC_PROC_UNDEFINED },
        { 48, ERRCODE_BASIC_BAD_DLL_LOAD },
        { 49, ERRCODE_BASIC_BAD_DLL_CALL },
        { 51, ERRCODE_BASIC_INTERNAL_ERROR },
        { 52, ERRCODE_BASIC_BAD_CHANNEL },
        { 53, ERRCODE_BASIC_FILE_NOT_FOUND },
        { 54, ERRCODE_BASIC_BAD_FILE_MODE },
        { 55, ERRCODE_BASIC_FILE_ALREADY_OPEN },
        { 57, ERRCODE_BASIC_IO_ERROR },
        { 58, ERRCODE_BASIC_FILE_EXISTS },
        { 59, ERRCODE_BASIC_BAD_RECORD_LENGTH },
        { 61, ERRCODE_BASIC_DISK_FULL },
        { 62, ERRCODE_BASIC_READ_PAST_EOF },
        { 63, ERRCODE_BASIC_BAD_RECORD_NUMBER },
        { 67, ERRCODE_BASIC_TOO_MANY_FILES },
        { 68, ERRCODE_BASIC_NO_DEVICE },
        { 70, ERRCODE_BASIC_ACCESS_DENIED },
        { 71, ERRCODE_BASIC_NOT_READY },
        { 73, ERRCODE_BASIC_NOT_IMPLEMENTED },
        { 74, ERRCODE_BASIC_DIFFERENT_DRIVE },
        { 75, ERRCODE_BASIC_ACCESS_ERROR },
        { 76, ERRCODE_BASIC_PATH_NOT_FOUND },
        { 91, ERRCODE_BASIC_NO_OBJECT },
        { 93, ERRCODE_BASIC_BAD_PATTERN },
        { 94, ERRCODE_BASIC_IS_NULL },
        { 250, ERRCODE_BASIC_DDE_ERROR },
        { 280, ERRCODE_BASIC_DDE_WAITINGACK },
        { 281, ERRCODE_BASIC_DDE_OUTOFCHANNELS },
        { 282, ERRCODE_BASIC_DDE_NO_RESPONSE },
        { 283, ERRCODE_BASIC_DDE_MULT_RESPONSES },
        { 284, ERRCODE_BASIC_DDE_CHANNEL_LOCKED },
        { 285, ERRCODE_BASIC_DDE_NOTPROCESSED },
        { 286, ERRCODE_BASIC_DDE_TIMEOUT },
        { 287, ERRCODE_BASIC_DDE_USER_INTERRUPT },
        { 288, ERRCODE_BASIC_DDE_BUSY },
        { 289, ERRCODE_BASIC_DDE_NO_DATA },
        { 290, ERRCODE_BASIC_DDE_WRONG_DATA_FORMAT },
        { 291, ERRCODE_BASIC_DDE_PARTNER_QUIT },
        { 292, ERRCODE_BASIC_DDE_CONV_CLOSED },
        { 293, ERRCODE_BASIC_DDE_NO_CHANNEL },
        { 294, ERRCODE_BASIC_DDE_INVALID_LINK },
        { 295, ERRCODE_BASIC_DDE_QUEUE_OVERFLOW },
        { 296, ERRCODE_BASIC_DDE_LINK_ALREADY_EST },
        { 297, ERRCODE_BASIC_DDE_LINK_INV_TOPIC },
        { 298, ERRCODE_BASIC_DDE_DLL_NOT_FOUND },
        { 323, ERRCODE_BASIC_CANNOT_LOAD },
        { 341, ERRCODE_BASIC_BAD_INDEX },
        { 366, ERRCODE_BASIC_NO_ACTIVE_OBJECT },
        { 380, ERRCODE_BASIC_BAD_PROP_VALUE },
        { 382, ERRCODE_BASIC_PROP_READONLY },
        { 394, ERRCODE_BASIC_PROP_WRITEONLY },
        { 420, ERRCODE_BASIC_INVALID_OBJECT },
        { 423, ERRCODE_BASIC_NO_METHOD },
        { 424, ERRCODE_BASIC_NEEDS_OBJECT },
        { 425, ERRCODE_BASIC_INVALID_USAGE_OBJECT },
        { 430, ERRCODE_BASIC_NO_OLE },
        { 438, ERRCODE_BASIC_BAD_METHOD },
        { 440, ERRCODE_BASIC_OLE_ERROR },
        { 445, ERRCODE_BASIC_BAD_ACTION },
        { 446, ERRCODE_BASIC_NO_NAMED_ARGS },
        { 447, ERRCODE_BASIC_BAD_LOCALE },
        { 448, ERRCODE_BASIC_NAMED_NOT_FOUND },
        { 449, ERRCODE_BASIC_NOT_OPTIONAL },
        { 450, ERRCODE_BASIC_WRONG_ARGS },
        { 451, ERRCODE_BASIC_NOT_A_COLL },
        { 452, ERRCODE_BASIC_BAD_ORDINAL },
        { 453, ERRCODE_BASIC_DLLPROC_NOT_FOUND },
        { 460, ERRCODE_BASIC_BAD_CLIPBD_FORMAT },
        { 951, ERRCODE_BASIC_UNEXPECTED },
        { 952, ERRCODE_BASIC_EXPECTED },
        { 953, ERRCODE_BASIC_SYMBOL_EXPECTED },
        { 954, ERRCODE_BASIC_VAR_EXPECTED },
        { 955, ERRCODE_BASIC_LABEL_EXPECTED },
        { 956, ERRCODE_BASIC_LVALUE_EXPECTED },
        { 957, ERRCODE_BASIC_VAR_DEFINED },
        { 958, ERRCODE_BASIC_PROC_DEFINED },
        { 959, ERRCODE_BASIC_LABEL_DEFINED },
        { 960, ERRCODE_BASIC_UNDEF_VAR },
        { 961, ERRCODE_BASIC_UNDEF_ARRAY },
        { 962, ERRCODE_BASIC_UNDEF_PROC },
        { 963, ERRCODE_BASIC_UNDEF_LABEL },
        { 964, ERRCODE_BASIC_UNDEF_TYPE },
        { 965, ERRCODE_BASIC_BAD_EXIT },
        { 966, ERRCODE_BASIC_BAD_BLOCK },
        { 967, ERRCODE_BASIC_BAD_BRACKETS },
        { 968, ERRCODE_BASIC_BAD_DECLARATION },
        { 969, ERRCODE_BASIC_BAD_PARAMETERS },
        { 970, ERRCODE_BASIC_BAD_CHAR_IN_NUMBER },
        { 971, ERRCODE_BASIC_MUST_HAVE_DIMS },
        { 972, ERRCODE_BASIC_NO_IF },
        { 973, ERRCODE_BASIC_NOT_IN_SUBR },
        { 974, ERRCODE_BASIC_NOT_IN_MAIN },
        { 975, ERRCODE_BASIC_WRONG_DIMS },
        { 976, ERRCODE_BASIC_BAD_OPTION },
        { 977, ERRCODE_BASIC_CONSTANT_REDECLARED },
        { 978, ERRCODE_BASIC_PROG_TOO_LARGE },
        { 979, ERRCODE_BASIC_NO_STRINGS_ARRAYS },
        { 1000, ERRCODE_BASIC_PROPERTY_NOT_FOUND },
        { 1001, ERRCODE_BASIC_METHOD_NOT_FOUND },
        { 1002, ERRCODE_BASIC_ARG_MISSING },
        { 1003, ERRCODE_BASIC_BAD_NUMBER_OF_ARGS },
        { 1004, ERRCODE_BASIC_METHOD_FAILED },
        { 1005, ERRCODE_BASIC_SETPROP_FAILED },
        { 1006, ERRCODE_BASIC_GETPROP_FAILED },
        { 1007, ERRCODE_BASIC_COMPAT },
        { 0xFFFF, ErrCode(0xFFFFFFFFUL) }     // 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 Module-relationship. But it works only when a module is loaded.
    // Can cause troubles with separately loaded properties!

    SbxBase* SbiFactory::Create( sal_uInt16 nSbxId, sal_uInt32 nCreator )
    {
        if( nCreator ==  SBXCR_SBX )
        {
            switch( nSbxId )
            {
            case SBXID_BASIC:
                return new StarBASIC( nullptr );
            case SBXID_BASICMOD:
                return new SbModule( "" );
            case SBXID_BASICPROP:
                return new SbProperty( "", SbxVARIANT, nullptr );
            case SBXID_BASICMETHOD:
                return new SbMethod( "", SbxVARIANT, nullptr );
            case SBXID_JSCRIPTMOD:
                return new SbJScriptModule;
            case SBXID_JSCRIPTMETH:
                return new SbJScriptMethod( SbxVARIANT );
            }
        }
        return nullptr;
    }

    SbxObject* SbiFactory::CreateObject( const OUString& rClass )
    {
        if( rClass.equalsIgnoreAsciiCase( "StarBASIC" ) )
        {
            return new StarBASIC( nullptr );
        }
        else if( rClass.equalsIgnoreAsciiCase( "StarBASICModule" ) )
        {
            return new SbModule( OUString() );
        }
        else if( rClass.equalsIgnoreAsciiCase( "Collection" ) )
        {
            return new BasicCollection( "Collection" );
        }
        else if( rClass.equalsIgnoreAsciiCase( "FileSystemObject" ) )
        {
            try
            {
                Reference< XMultiServiceFactory > xFactory( comphelper::getProcessServiceFactory(), UNO_SET_THROW );
                OUString aServiceName("ooo.vba.FileSystemObject");
                Reference< XInterface > xInterface( xFactory->createInstance( aServiceName ), UNO_SET_THROW );
                return new SbUnoObject( aServiceName, uno::Any( xInterface ) );
            }
            catch(const Exception& )
            {
            }
        }
        return nullptr;
    }

    // Factory class to create OLE objects
    class SbOLEFactory : public SbxFactory
    {
    public:
        virtual SbxBase* Create( sal_uInt16 nSbxId, sal_uInt32 ) override;
        virtual SbxObject* CreateObject( const OUString& ) override;
    };

    SbxBase* SbOLEFactory::Create( sal_uInt16, sal_uInt32 )
    {
        // Not supported
        return nullptr;
    }

    SbxObject* SbOLEFactory::CreateObject( const OUString& 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 ) override;
        virtual SbxObject* CreateObject( const OUString& ) override;
    };

    SbxBase* SbFormFactory::Create( sal_uInt16, sal_uInt32 )
    {
        // Not supported
        return nullptr;
    }

    SbxObject* SbFormFactory::CreateObject( const OUString& rClassName )
    {
        if( SbModule* pMod = GetSbData()->pMod )
        {
            if( SbxVariable* pVar = pMod->Find( rClassName, SbxClassType::Object ) )
            {
                if( SbUserFormModule* pFormModule = dynamic_cast<SbUserFormModule*>( pVar->GetObject() )  )
                {
                    bool bInitState = pFormModule->getInitState();
                    if( bInitState )
                    {
                        // Not the first instantiate, reset
                        pFormModule->ResetApiObj( false/*bTriggerTerminateEvent*/ );
                        pFormModule->setInitState( false );
                    }
                    else
                    {
                        pFormModule->Load();
                    }
                    return pFormModule->CreateInstance();
                }
            }
        }
        return nullptr;
    }

    // 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 = dynamic_cast<SbxProperty*>( pVar  );
            if( pProp )
            {
                SbxProperty* pNewProp = new SbxProperty( *pProp );
                SbxDataType eVarType = pVar->GetType();
                if( eVarType & SbxARRAY )
                {
                    SbxBase* pParObj = pVar->GetObject();
                    SbxDimArray* pSource = dynamic_cast<SbxDimArray*>( pParObj );
                    SbxDimArray* pDest = new SbxDimArray( pVar->GetType() );

                    pDest->setHasFixedSize( pSource && pSource->hasFixedSize() );
                    if ( pSource && pSource->GetDims() && pSource->hasFixedSize() )
                    {
                        sal_Int32 lb = 0;
                        sal_Int32 ub = 0;
                        for ( sal_Int32 j = 1 ; j <= pSource->GetDims(); ++j )
                        {
                            pSource->GetDim32( j, lb, ub );
                            pDest->AddDim32( lb, ub );
                        }
                    }
                    else
                    {
                        pDest->unoAddDim( 0, -1 ); // variant array
                    }
                    SbxFlagBits nSavFlags = pVar->GetFlags();
                    pNewProp->ResetFlag( SbxFlagBits::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 = dynamic_cast<SbxObject*>( pObjBase );
                    SbxObject* pDestObj = nullptr;
                    if( pSrcObj != nullptr )
                        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 ) override;
        virtual SbxObject* CreateObject( const OUString& ) override;
    };

    SbxBase* SbTypeFactory::Create( sal_uInt16, sal_uInt32 )
    {
        // Not supported
        return nullptr;
    }

    SbxObject* SbTypeFactory::CreateObject( const OUString& rClassName )
    {
        SbxObject* pRet = nullptr;
        SbModule* pMod = GetSbData()->pMod;
        if( pMod )
        {
            const SbxObject* pObj = pMod->FindType( rClassName );
            if( pObj )
            {
                pRet = cloneTypeObjectImpl( *pObj );
            }
        }
        return pRet;
    }

    SbxObject* createUserTypeImpl( const OUString& rClassName )
    {
        SbxObject* pRetObj = GetSbData()->pTypeFac->CreateObject( rClassName );
        return pRetObj;
    }

    SbClassModuleObject::SbClassModuleObject( SbModule* pClassModule )
        : SbModule( pClassModule->GetName() )
        , mpClassModule( pClassModule )
        , mbInitializeEventDone( false )
    {
        aOUSource = pClassModule->aOUSource;
        aComment = pClassModule->aComment;
        pImage = std::move(pClassModule->pImage);
        pBreaks = std::move(pClassModule->pBreaks);

        SetClassName( pClassModule->GetName() );

        // Allow search only internally
        ResetFlag( SbxFlagBits::GlobalSearch );

        // Copy the methods from original class module
        SbxArray* pClassMethods = pClassModule->GetMethods().get();
        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 = dynamic_cast<SbIfaceMapperMethod*>( pVar  );
            if( !pIfaceMethod )
            {
                SbMethod* pMethod = dynamic_cast<SbMethod*>( pVar  );
                if( pMethod )
                {
                    SbxFlagBits nFlags_ = pMethod->GetFlags();
                    pMethod->SetFlag( SbxFlagBits::NoBroadcast );
                    SbMethod* pNewMethod = new SbMethod( *pMethod );
                    pNewMethod->ResetFlag( SbxFlagBits::NoBroadcast );
                    pMethod->SetFlags( nFlags_ );
                    pNewMethod->pMod = this;
                    pNewMethod->SetParent( this );
                    pMethods->PutDirect( pNewMethod, i );
                    StartListening(pNewMethod->GetBroadcaster(), DuplicateHandling::Prevent);
                }
            }
        }

        // 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 = dynamic_cast<SbIfaceMapperMethod*>( pVar  );
            if( pIfaceMethod )
            {
                SbMethod* pImplMethod = pIfaceMethod->getImplMethod();
                if( !pImplMethod )
                {
                    OSL_FAIL( "No ImplMethod" );
                    continue;
                }

                // Search for own copy of ImplMethod
                SbxVariable* p = pMethods->Find( pImplMethod->GetName(), SbxClassType::Method );
                SbMethod* pImplMethodCopy = dynamic_cast<SbMethod*>( p );
                if( !pImplMethodCopy )
                {
                    OSL_FAIL( "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 = dynamic_cast<SbProcedureProperty*>( pVar  );
            if( pProcedureProp )
            {
                SbxFlagBits nFlags_ = pProcedureProp->GetFlags();
                pProcedureProp->SetFlag( SbxFlagBits::NoBroadcast );
                SbProcedureProperty* pNewProp = new SbProcedureProperty
                    ( pProcedureProp->GetName(), pProcedureProp->GetType() );
                pNewProp->SetFlags( nFlags_ ); // Copy flags
                pNewProp->ResetFlag( SbxFlagBits::NoBroadcast ); // except the Broadcast if it was set
                pProcedureProp->SetFlags( nFlags_ );
                pProps->PutDirect( pNewProp, i );
                StartListening(pNewProp->GetBroadcaster(), DuplicateHandling::Prevent);
            }
            else
            {
                SbxProperty* pProp = dynamic_cast<SbxProperty*>( pVar  );
                if( pProp )
                {
                    SbxFlagBits nFlags_ = pProp->GetFlags();
                    pProp->SetFlag( SbxFlagBits::NoBroadcast );
                    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 = dynamic_cast<SbxObject*>( pObjBase );
                        if( pObj != nullptr )
                        {
                            OUString aObjClass = pObj->GetClassName();

                            SbClassModuleObject* pClassModuleObj = dynamic_cast<SbClassModuleObject*>( pObjBase );
                            if( pClassModuleObj != nullptr )
                            {
                                SbModule* pLclClassModule = pClassModuleObj->getClassModule();
                                SbClassModuleObject* pNewObj = new SbClassModuleObject( pLclClassModule );
                                pNewObj->SetName( pProp->GetName() );
                                pNewObj->SetParent( pLclClassModule->pParent );
                                pNewProp->PutObject( pNewObj );
                            }
                            else if( aObjClass.equalsIgnoreAsciiCase( "Collection" ) )
                            {
                                BasicCollection* pNewCollection = new BasicCollection( "Collection" );
                                pNewCollection->SetName( pProp->GetName() );
                                pNewCollection->SetParent( pClassModule->pParent );
                                pNewProp->PutObject( pNewCollection );
                            }
                        }
                    }

                    pNewProp->ResetFlag( SbxFlagBits::NoBroadcast );
                    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 = nullptr;
        pBreaks = nullptr;
    }

    void SbClassModuleObject::Notify( SfxBroadcaster& rBC, const SfxHint& rHint )
    {
        handleProcedureProperties( rBC, rHint );
    }

    SbxVariable* SbClassModuleObject::Find( const OUString& rName, SbxClassType t )
    {
        SbxVariable* pRes = SbxObject::Find( rName, t );
        if( pRes )
        {
            triggerInitializeEvent();

            SbIfaceMapperMethod* pIfaceMapperMethod = dynamic_cast<SbIfaceMapperMethod*>( pRes );
            if( pIfaceMapperMethod )
            {
                pRes = pIfaceMapperMethod->getImplMethod();
                pRes->SetFlag( SbxFlagBits::ExtFound );
            }
        }
        return pRes;
    }

    void SbClassModuleObject::triggerInitializeEvent()
    {
        if( mbInitializeEventDone )
        {
            return;
        }

        mbInitializeEventDone = true;

        // Search method
        SbxVariable* pMeth = SbxObject::Find("Class_Initialize", SbxClassType::Method);
        if( pMeth )
        {
            SbxValues aVals;
            pMeth->Get( aVals );
        }
    }

    void SbClassModuleObject::triggerTerminateEvent()
    {
        if( !mbInitializeEventDone || GetSbData()->bRunInit )
        {
            return;
        }
        // Search method
        SbxVariable* pMeth = SbxObject::Find("Class_Terminate", SbxClassType::Method );
        if( pMeth )
        {
            SbxValues aVals;
            pMeth->Get( aVals );
        }
    }

    SbClassData::SbClassData()
    {
        mxIfaces = new SbxArray();
    }

    void SbClassData::clear()
    {
        mxIfaces->Clear();
        maRequiredTypes.clear();
    }

    SbClassFactory::SbClassFactory()
    {
        xClassModules = new SbxObject( OUString() );
    }

    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 nullptr;
    }

    SbxObject* SbClassFactory::CreateObject( const OUString& rClassName )
    {
        SbxObjectRef xToUseClassModules = xClassModules;

        if( SbModule* pMod = GetSbData()->pMod )
        {
            if( StarBASIC* pDocBasic = lclGetDocBasicForModule( pMod ) )
            {
                if( const DocBasicItem* pDocBasicItem = lclFindDocBasicItem( pDocBasic ) )
                {
                    xToUseClassModules = pDocBasicItem->getClassModules();
                }
            }
        }
        SbxVariable* pVar = xToUseClassModules->Find( rClassName, SbxClassType::Object );
        SbxObject* pRet = nullptr;
        if( pVar )
        {
            SbModule* pVarMod = static_cast<SbModule*>(pVar);
            pRet = new SbClassModuleObject( pVarMod );
        }
        return pRet;
    }

    SbModule* SbClassFactory::FindClass( const OUString& rClassName )
    {
        SbxVariable* pVar = xClassModules->Find( rClassName, SbxClassType::DontCare );
        SbModule* pMod = pVar ? static_cast<SbModule*>(pVar) : nullptr;
        return pMod;
    }

    StarBASIC::StarBASIC( StarBASIC* p, bool bIsDocBasic  )
        : SbxObject("StarBASIC"), bDocBasic( bIsDocBasic )
    {
        SetParent( p );
        bNoRtl = bBreak = false;
        bVBAEnabled = false;

        if( !GetSbData()->nInst++ )
        {
            GetSbData()->pSbFac.reset( new SbiFactory );
            AddFactory( GetSbData()->pSbFac.get() );
            GetSbData()->pTypeFac = new SbTypeFactory;
            AddFactory( GetSbData()->pTypeFac );
            GetSbData()->pClassFac = new SbClassFactory;
            AddFactory( GetSbData()->pClassFac );
            GetSbData()->pOLEFac = new SbOLEFactory;
            AddFactory( GetSbData()->pOLEFac );
            GetSbData()->pFormFac = new SbFormFactory;
            AddFactory( GetSbData()->pFormFac );
            GetSbData()->pUnoFac.reset( new SbUnoFactory );
            AddFactory( GetSbData()->pUnoFac.get() );
        }
        pRtl = new SbiStdObject(RTLNAME, this );
        // Search via StarBasic is always global
        SetFlag( SbxFlagBits::GlobalSearch );
        pVBAGlobals = nullptr;
        bQuit = false;

        if( bDocBasic )
        {
            lclInsertDocBasicItem( *this );
        }
    }

    // #51727 Override SetModified so that the modified state
    // is not given to the parent
    void StarBASIC::SetModified( bool b )
    {
        SbxBase::SetModified( b );
    }

    StarBASIC::~StarBASIC()
    {
        // Needs to be first action as it can trigger events
        disposeComVariablesForBasic( this );

        if( !--GetSbData()->nInst )
        {
            RemoveFactory( GetSbData()->pSbFac.get() );
            GetSbData()->pSbFac.reset();
            RemoveFactory( GetSbData()->pUnoFac.get() );
            GetSbData()->pUnoFac.reset();
            RemoveFactory( GetSbData()->pTypeFac );
            delete GetSbData()->pTypeFac; GetSbData()->pTypeFac = nullptr;
            RemoveFactory( GetSbData()->pClassFac );
            delete GetSbData()->pClassFac; GetSbData()->pClassFac = nullptr;
            RemoveFactory( GetSbData()->pOLEFac );
            delete GetSbData()->pOLEFac; GetSbData()->pOLEFac = nullptr;
            RemoveFactory( GetSbData()->pFormFac );
            delete GetSbData()->pFormFac; GetSbData()->pFormFac = nullptr;

            if( SbiGlobals::pGlobals )
            {
                delete SbiGlobals::pGlobals;
                SbiGlobals::pGlobals = nullptr;
            }
        }
        else if( bDocBasic )
        {
            ErrCode eOld = SbxBase::GetError();

            lclRemoveDocBasicItem( *this );

            SbxBase::ResetError();
            if( eOld != ERRCODE_NONE )
            {
                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( nullptr );
            }
            xUnoListeners = nullptr;
        }

        clearUnoMethodsForBasic( this );
    }

    void StarBASIC::implClearDependingVarsOnDelete( StarBASIC* pDeletedBasic )
    {
        if( this != pDeletedBasic )
        {
            for( const auto& pModule: pModules)
            {
                pModule->ClearVarsDependingOnDeletedBasic( pDeletedBasic );
            }
        }

        for( sal_uInt16 nObj = 0; nObj < pObjs->Count(); nObj++ )
        {
            SbxVariable* pVar = pObjs->Get( nObj );
            StarBASIC* pBasic = dynamic_cast<StarBASIC*>( pVar );
            if( pBasic && pBasic != pDeletedBasic )
            {
                pBasic->implClearDependingVarsOnDelete( pDeletedBasic );
            }
        }
    }

    SbModule* StarBASIC::MakeModule( const OUString& rName, const OUString& rSrc )
    {
        ModuleInfo aInfo;
        aInfo.ModuleType = ModuleType::NORMAL;
        return MakeModule(  rName, aInfo, rSrc );
    }
    SbModule* StarBASIC::MakeModule( const OUString& rName, const ModuleInfo& mInfo, const OUString& rSrc )
    {

        SAL_INFO(
            "basic",
            "create module " << rName  << " type mInfo " << mInfo.ModuleType);
        SbModule* p = nullptr;
        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() );
            break;
        }
        p->SetSource32( rSrc );
        p->SetParent( this );
        pModules.emplace_back(p);
        SetModified( true );
        return p;
    }

    void StarBASIC::Insert( SbxVariable* pVar )
    {
        if( dynamic_cast<const SbModule*>(pVar) != nullptr)
        {
            pModules.emplace_back(static_cast<SbModule*>(pVar));
            pVar->SetParent( this );
            StartListening(pVar->GetBroadcaster(), DuplicateHandling::Prevent);
        }
        else
        {
            bool bWasModified = IsModified();
            SbxObject::Insert( pVar );
            if( !bWasModified && pVar->IsSet( SbxFlagBits::DontStore ) )
            {
                SetModified( false );
            }
        }
    }

    void StarBASIC::Remove( SbxVariable* pVar )
    {
        SbModule* pModule = dynamic_cast<SbModule*>(pVar);
        if( pModule )
        {
            // #87540 Can be last reference!
            SbModuleRef xVar = pModule;
            pModules.erase(std::remove(pModules.begin(), pModules.end(), xVar));
            pVar->SetParent( nullptr );
            EndListening( pVar->GetBroadcaster() );
        }
        else
        {
            SbxObject::Remove( pVar );
        }
    }

    void StarBASIC::Clear()
    {
        pModules.clear();
    }

    SbModule* StarBASIC::FindModule( const OUString& rName )
    {
        for (const auto& pModule: pModules)
        {
            if( pModule->GetName().equalsIgnoreAsciiCase( rName ) )
            {
                return pModule.get();
            }
        }
        return nullptr;
    }

    struct ClassModuleRunInitItem
    {
        SbModule*       m_pModule;
        bool            m_bProcessing;
        bool            m_bRunInitDone;

        ClassModuleRunInitItem()
            : m_pModule( nullptr )
            , m_bProcessing( false )
            , m_bRunInitDone( false )
        {}
        explicit ClassModuleRunInitItem( SbModule* pModule )
            : m_pModule( pModule )
            , m_bProcessing( false )
            , m_bRunInitDone( false )
        {}
    };

    // Derive from unordered_map type instead of typedef
    // to allow forward declaration in sbmod.hxx
    class ModuleInitDependencyMap : public
        std::unordered_map< OUString, ClassModuleRunInitItem >
    {};

    void SbModule::implProcessModuleRunInit( ModuleInitDependencyMap& rMap, ClassModuleRunInitItem& rItem )
    {
        rItem.m_bProcessing = true;

        SbModule* pModule = rItem.m_pModule;
        if( pModule->pClassData != nullptr )
        {
            std::vector< OUString >& rReqTypes = pModule->pClassData->maRequiredTypes;
            if( rReqTypes.size() > 0 )
            {
                for( const auto& rStr : rReqTypes )
                {
                    // 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?
                            OSL_FAIL( "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 const * pBasicNotToInit )
    {
        SolarMutexGuard guard;

        // Init own modules
        for (const auto& pModule: pModules)
        {
            pModule->Compile();
        }
        // compile modules first then RunInit ( otherwise there is
        // can be order dependency, e.g. classmodule A has a member
        // 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 (const auto& pModule: pModules)
        {
            OUString aModuleName = pModule->GetName();
            if( pModule->isProxyModule() )
            {
                aMIDMap[aModuleName] = ClassModuleRunInitItem( pModule.get() );
            }
        }

        for (auto & elem : aMIDMap)
        {
            ClassModuleRunInitItem& rItem = elem.second;
            SbModule::implProcessModuleRunInit( aMIDMap, rItem );
        }

        // Call RunInit on standard modules
        for (const auto& pModule: pModules)
        {
            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 = dynamic_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()
    {
        // Deinit own modules
        for (const auto& pModule: pModules)
        {
            if( pModule->pImage && !pModule->isProxyModule() && dynamic_cast<SbObjModule*>( pModule.get()) == nullptr )
            {
                pModule->pImage->bInit = false;
            }
        }

        for ( sal_uInt16 nObj = 0; nObj < pObjs->Count(); nObj++ )
        {
            SbxVariable* pVar = pObjs->Get( nObj );
            StarBASIC* pBasic = dynamic_cast<StarBASIC*>( pVar );
            if( pBasic )
            {
                pBasic->DeInitAllModules();
            }
        }
    }

    // This implementation at first searches within the runtime library,
    // then it looks for an element within one module. This module 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 OUString& rName, SbxClassType t )
    {
        SbxVariable* pRes = nullptr;
        SbModule* pNamed = nullptr;
        // "Extended" search in Runtime Lib
        // but only if SbiRuntime has not set the flag
        if( !bNoRtl )
        {
            if( t == SbxClassType::DontCare || t == SbxClassType::Object )
            {
                if( rName.equalsIgnoreAsciiCase( RTLNAME ) )
                {
                    pRes = pRtl.get();
                }
            }
            if( !pRes )
            {
                pRes = static_cast<SbiStdObject*>(pRtl.get())->Find( rName, t );
            }
            if( pRes )
            {
                pRes->SetFlag( SbxFlagBits::ExtFound );
            }
        }
        // Search module
        if( !pRes )
        {
            for (const auto& pModule: pModules)
            {
                if( pModule->IsVisible() )
                {
                    // Remember module for Main() call
                    // or is the name equal?!?
                    if( pModule->GetName().equalsIgnoreAsciiCase( rName ) )
                    {
                        if( t == SbxClassType::Object || t == SbxClassType::DontCare )
                        {
                            pRes = pModule.get(); break;
                        }
                        pNamed = pModule.get();
                    }
                    // Only variables qualified by the Module Name e.g. Sheet1.foo
                    // should work for Document && Class type Modules
                    sal_Int32 nType = pModule->GetModuleType();
                    if ( nType == ModuleType::DOCUMENT || nType == ModuleType::FORM )
                    {
                        continue;
                    }
                    // otherwise check if the element is available
                    // unset GBLSEARCH-Flag (due to recursion)
                    SbxFlagBits nGblFlag = pModule->GetFlags() & SbxFlagBits::GlobalSearch;
                    pModule->ResetFlag( SbxFlagBits::GlobalSearch );
                    pRes = pModule->Find( rName, t );
                    pModule->SetFlag( nGblFlag );
                    if( pRes )
                    {
                        break;
                    }
                }
            }
        }
        OUString aMainStr("Main");
        if( !pRes && pNamed && ( t == SbxClassType::Method || t == SbxClassType::DontCare ) &&
            !pNamed->GetName().equalsIgnoreAsciiCase( aMainStr ) )
        {
            pRes = pNamed->Find( aMainStr, SbxClassType::Method );
        }
        if( !pRes )
        {
            pRes = SbxObject::Find( rName, t );
        }
        return pRes;
    }

    bool StarBASIC::Call( const OUString& rName, SbxArray* pParam )
    {
        bool bRes = SbxObject::Call( rName, pParam );
        if( !bRes )
        {
            ErrCode eErr = SbxBase::GetError();
            SbxBase::ResetError();
            if( eErr != ERRCODE_NONE )
            {
                RTError( eErr, OUString(), 0, 0, 0 );
            }
        }
        return bRes;
    }

    // Find method via name (e.g. query via BASIC IDE)
    SbxBase* StarBASIC::FindSBXInCurrentScope( const OUString& rName )
    {
        if( !GetSbData()->pInst )
        {
            return nullptr;
        }
        if( !GetSbData()->pInst->pRun )
        {
            return nullptr;
        }
        return GetSbData()->pInst->pRun->FindElementExtern( rName );
    }

    void StarBASIC::QuitAndExitApplication()
    {
        Stop();
        bQuit = true;
    }

    void StarBASIC::Stop()
    {
        SbiInstance* p = GetSbData()->pInst;
        if( p )
            p->Stop();
    }

    bool StarBASIC::IsRunning()
    {
        return GetSbData()->pInst != nullptr;
    }

    SbMethod* StarBASIC::GetActiveMethod( sal_uInt16 nLevel )
    {
        if( GetSbData()->pInst )
        {
            return GetSbData()->pInst->GetCaller( nLevel );
        }
        else
        {
            return nullptr;
        }
    }

    SbModule* StarBASIC::GetActiveModule()
    {
        if( GetSbData()->pInst && !GetSbData()->bCompilerError )
        {
            return GetSbData()->pInst->GetActiveModule();
        }
        else
        {
            return GetSbData()->pCompMod;
        }
    }

    BasicDebugFlags StarBASIC::BreakPoint( sal_Int32 l, sal_Int32 c1, sal_Int32 c2 )
    {
        SetErrorData( ERRCODE_NONE, l, c1, c2 );
        bBreak = true;
        if( GetSbData()->aBreakHdl.IsSet() )
        {
            return GetSbData()->aBreakHdl.Call( this );
        }
        else
        {
            return BreakHdl();
        }
    }

    BasicDebugFlags StarBASIC::StepPoint( sal_Int32 l, sal_Int32 c1, sal_Int32 c2 )
    {
        SetErrorData( ERRCODE_NONE, l, c1, c2 );
        bBreak = false;
        if( GetSbData()->aBreakHdl.IsSet() )
        {
            return GetSbData()->aBreakHdl.Call( this );
        }
        else
        {
            return BreakHdl();
        }
    }

    BasicDebugFlags StarBASIC::BreakHdl()
    {
        return aBreakHdl.IsSet() ? aBreakHdl.Call( this ) : BasicDebugFlags::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
    ErrCode const & StarBASIC::GetErrorCode() { return GetSbData()->nCode; }
    const OUString& StarBASIC::GetErrorText() { return GetSbData()->aErrMsg; }

    // From 1996-03-29:
    // The mapping between the old and the new error codes take place by searching
    // through the table SFX_VB_ErrorTab[]. This is indeed not with good performance,
    // but it consumes much less memory than corresponding switch blocs.
    // Because the conversion of error codes has not to be fast. there is no
    // binary search by VB Error -> Error SFX.

    // Map back new error codes to old, Sbx-compatible
    sal_uInt16 StarBASIC::GetVBErrorCode( ErrCode nError )
    {
        sal_uInt16 nRet = 0;

        if( SbiRuntime::isVBAEnabled() )
        {
            if ( nError == ERRCODE_BASIC_ARRAY_FIX )
                return 10;
            else if ( nError == ERRCODE_BASIC_STRING_OVERFLOW )
                return 14;
            else if ( nError == ERRCODE_BASIC_EXPR_TOO_COMPLEX )
                return 16;
            else if ( nError == ERRCODE_BASIC_OPER_NOT_PERFORM )
                return 17;
            else if ( nError == ERRCODE_BASIC_TOO_MANY_DLL )
                return 47;
            else if ( nError == ERRCODE_BASIC_LOOP_NOT_INIT )
                return 92;
            else
                nRet = 0;
        }

        // search loop
        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 );      // up to end mark
        return nRet;
    }

    ErrCode StarBASIC::GetSfxFromVBError( sal_uInt16 nError )
    {
        ErrCode nRet = ERRCODE_NONE;

        if( SbiRuntime::isVBAEnabled() )
        {
            switch( nError )
            {
            case 1:
            case 2:
            case 4:
            case 8:
            case 12:
            case 73:
                return ERRCODE_NONE;
            case 10:
                return ERRCODE_BASIC_ARRAY_FIX;
            case 14:
                return ERRCODE_BASIC_STRING_OVERFLOW;
            case 16:
                return ERRCODE_BASIC_EXPR_TOO_COMPLEX;
            case 17:
                return ERRCODE_BASIC_OPER_NOT_PERFORM;
            case 47:
                return ERRCODE_BASIC_TOO_MANY_DLL;
            case 92:
                return ERRCODE_BASIC_LOOP_NOT_INIT;
            default:
                nRet = ERRCODE_NONE;
            }
        }
        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;              // couldn't found anymore
            }
            nIndex++;
        }
        while( pErrItem->nErrorVB != 0xFFFF );      // up to end mark
        return nRet;
    }

    // set Error- / Break-data
    void StarBASIC::SetErrorData( ErrCode 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;
    }

    void StarBASIC::MakeErrorText( ErrCode nId, const OUString& aMsg )
    {
        SolarMutexGuard aSolarGuard;
        sal_uInt16 nOldID = GetVBErrorCode( nId );

        const char* pErrorMsg = nullptr;
        for (std::pair<const char *, ErrCode> const *pItem = RID_BASIC_START; pItem->second; ++pItem)
        {
            if (nId == pItem->second)
            {
                pErrorMsg = pItem->first;
                break;
            }
        }

        if (pErrorMsg)
        {
            // merge message with additional text
            OUString sError = BasResId(pErrorMsg);
            OUStringBuffer aMsg1(sError);
            // replace argument placeholder with %s
            OUString aSrgStr( "$(ARG1)" );
            sal_Int32 nResult = sError.indexOf(aSrgStr);

            if( nResult >= 0 )
            {
                aMsg1.remove(nResult, aSrgStr.getLength());
                aMsg1.insert(nResult, aMsg);
            }
            GetSbData()->aErrMsg = aMsg1.makeStringAndClear();
        }
        else if( nOldID != 0 )
        {
            OUString aStdMsg = "Error " + OUString::number(nOldID) +
                               ": No error text available!";
            GetSbData()->aErrMsg = aStdMsg;
        }
        else
        {
            GetSbData()->aErrMsg.clear();
        }
    }

    bool StarBASIC::CError( ErrCode code, const OUString& rMsg,
                                sal_Int32 l, sal_Int32 c1, sal_Int32 c2 )
    {
        SolarMutexGuard aSolarGuard;

        // compiler error during runtime -> stop program
        if( IsRunning() )
        {
            // #109018 Check if running Basic is affected
            StarBASIC* pStartedBasic = GetSbData()->pInst->GetBasic();
            if( pStartedBasic != this )
            {
                return false;
            }
            Stop();
        }

        // set flag, so that GlobalRunInit notice the error
        GetSbData()->bGlobalInitErr = true;

        // tinker the error message
        MakeErrorText( code, rMsg );

        // Implementation of the code for the string transport to SFX-Error
        if( !rMsg.isEmpty() )
        {
            code = *new StringErrorInfo( code, rMsg );
        }
        SetErrorData( code, l, c1, c2 );
        GetSbData()->bCompilerError = true;
        bool bRet;
        if( GetSbData()->aErrHdl.IsSet() )
        {
            bRet = GetSbData()->aErrHdl.Call( this );
        }
        else
        {
            bRet = ErrorHdl();
        }
        GetSbData()->bCompilerError = false;     // only true for error handler
        return bRet;
    }

    bool StarBASIC::RTError( ErrCode code, const OUString& rMsg, sal_Int32 l, sal_Int32 c1, sal_Int32 c2 )
    {
        SolarMutexGuard aSolarGuard;

        ErrCode c = code;
        if( c.GetClass() == ErrCodeClass::Compiler )
        {
            c = ERRCODE_NONE;
        }
        MakeErrorText( c, rMsg );

        // Implementation of the code for the string transport to SFX-Error
        if( !rMsg.isEmpty() )
        {
            // 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 a little more
            // like vba ( adds an error number etc )
            if ( SbiRuntime::isVBAEnabled() && ( code == ERRCODE_BASIC_COMPAT ) )
            {
                OUString aTmp = "\'" + OUString::number(SbxErrObject::getUnoErrObject()->getNumber()) +
                                "\'\n" + (!GetSbData()->aErrMsg.isEmpty() ? GetSbData()->aErrMsg : rMsg);
                code = *new StringErrorInfo( code, aTmp );
            }
            else
            {
                code = *new StringErrorInfo( code, rMsg );
            }
        }

        SetErrorData( code, l, c1, c2 );
        if( GetSbData()->aErrHdl.IsSet() )
        {
            return GetSbData()->aErrHdl.Call( this );
        }
        else
        {
            return ErrorHdl();
        }
    }

    void StarBASIC::Error( ErrCode n )
    {
        Error( n, OUString() );
    }

    void StarBASIC::Error( ErrCode n, const OUString& rMsg )
    {
        if( GetSbData()->pInst )
        {
            GetSbData()->pInst->Error( n, rMsg );
        }
    }

    void StarBASIC::FatalError( ErrCode n )
    {
        if( GetSbData()->pInst )
        {
            GetSbData()->pInst->FatalError( n );
        }
    }

    void StarBASIC::FatalError( ErrCode _errCode, const OUString& _details )
    {
        if( GetSbData()->pInst )
        {
            GetSbData()->pInst->FatalError( _errCode, _details );
        }
    }

    ErrCode StarBASIC::GetErrBasic()
    {
        if( GetSbData()->pInst )
        {
            return GetSbData()->pInst->GetErr();
        }
        else
        {
            return ERRCODE_NONE;
        }
    }

    // make the additional message for the RTL function error accessible
    OUString StarBASIC::GetErrorMsg()
    {
        if( GetSbData()->pInst )
        {
            return GetSbData()->pInst->GetErrorMsg();
        }
        else
        {
            return OUString();
        }
    }

    sal_Int32 StarBASIC::GetErl()
    {
        if( GetSbData()->pInst )
        {
            return GetSbData()->pInst->GetErl();
        }
        else
        {
            return 0;
        }
    }

    bool StarBASIC::ErrorHdl()
    {
        return aErrorHdl.Call( this );
    }

    Link<StarBASIC*,bool> const & StarBASIC::GetGlobalErrorHdl()
    {
        return GetSbData()->aErrHdl;
    }

    void StarBASIC::SetGlobalErrorHdl( const Link<StarBASIC*,bool>& rLink )
    {
        GetSbData()->aErrHdl = rLink;
    }

    void StarBASIC::SetGlobalBreakHdl( const Link<StarBASIC*,BasicDebugFlags>& rLink )
    {
        GetSbData()->aBreakHdl = rLink;
    }

    SbxArrayRef const & StarBASIC::getUnoListeners()
    {
        if( !xUnoListeners.is() )
        {
            xUnoListeners = new SbxArray();
        }
        return xUnoListeners;
    }

    bool StarBASIC::LoadData( SvStream& r, sal_uInt16 nVer )
    {
        if( !SbxObject::LoadData( r, nVer ) )
        {
            return false;
        }
        // #95459 Delete dialogs, otherwise endless recursion
        // in SbxVarable::GetType() if dialogs are accessed
        sal_uInt16 nObjCount = pObjs->Count();
        std::unique_ptr<SbxVariable*[]> ppDeleteTab(new SbxVariable*[ nObjCount ]);
        sal_uInt16 nObj;

        for( nObj = 0 ; nObj < nObjCount ; nObj++ )
        {
            SbxVariable* pVar = pObjs->Get( nObj );
            StarBASIC* pBasic = dynamic_cast<StarBASIC*>( pVar  );
            ppDeleteTab[nObj] = pBasic ? nullptr : pVar;
        }
        for( nObj = 0 ; nObj < nObjCount ; nObj++ )
        {
            SbxVariable* pVar = ppDeleteTab[nObj];
            if( pVar )
            {
                pObjs->Remove( pVar );
            }
        }
        ppDeleteTab.reset();

        sal_uInt16 nMod(0);
        pModules.clear();
        r.ReadUInt16( nMod );
        const size_t nMinSbxSize(14);
        const size_t nMaxPossibleEntries = r.remainingSize() / nMinSbxSize;
        if (nMod > nMaxPossibleEntries)
        {
            nMod = nMaxPossibleEntries;
            SAL_WARN("basic", "Parsing error: " << nMaxPossibleEntries <<
                     " max possible entries, but " << nMod << " claimed, truncating");
        }
        for (sal_uInt16 i = 0; i < nMod; ++i)
        {
            SbxBase* pBase = SbxBase::Load( r );
            SbModule* pMod = dynamic_cast<SbModule*>(pBase);
            if( !pMod )
            {
                return false;
            }
            else if( dynamic_cast<const SbJScriptModule*>( pMod) != nullptr )
            {
                // assign Ref, so that pMod will be deleted
                SbModuleRef xRef = pMod;
            }
            else
            {
                pMod->SetParent( this );
                pModules.emplace_back(pMod );
            }
        }
        // HACK for SFX-Bullshit!
        SbxVariable* p = Find( "FALSE", SbxClassType::Property );
        if( p )
        {
            Remove( p );
        }
        p = Find( "TRUE", SbxClassType::Property );
        if( p )
        {
            Remove( p );
        }
        // End of the hacks!
        // Search via StarBASIC is at all times global
        DBG_ASSERT( IsSet( SbxFlagBits::GlobalSearch ), "Basic loaded without GBLSEARCH" );
        SetFlag( SbxFlagBits::GlobalSearch );
        return true;
    }

    bool StarBASIC::StoreData( SvStream& r ) const
    {
        if( !SbxObject::StoreData( r ) )
        {
            return false;
        }
        assert(pModules.size() < SAL_MAX_UINT16);
        r.WriteUInt16( static_cast<sal_uInt16>(pModules.size()));
        for( const auto& rpModule: pModules )
        {
            if( !rpModule->Store( r ) )
            {
                return false;
            }
        }
        return true;
    }

    bool StarBASIC::GetUNOConstant( const OUString& rName, css::uno::Any& aOut )
    {
        bool bRes = false;
        SbUnoObject* pGlobs = dynamic_cast<SbUnoObject*>( Find( rName, SbxClassType::DontCare ) );
        if ( pGlobs )
        {
            aOut = pGlobs->getUnoAny();
            bRes = true;
        }
        return bRes;
    }

    Reference< frame::XModel > StarBASIC::GetModelFromBasic( SbxObject* pBasic )
    {
        OSL_PRECOND( pBasic != nullptr, "getModelFromBasic: illegal call!" );
        if ( !pBasic )
        {
            return nullptr;
        }
        // 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 OUString sThisComponent( "ThisComponent");
        SbxVariable* pThisComponent = nullptr;

        SbxObject* pLookup = pBasic->GetParent();
        while ( pLookup && !pThisComponent )
        {
            pThisComponent = pLookup->Find( sThisComponent, SbxClassType::Object );
            pLookup = pLookup->GetParent();
        }
        if ( !pThisComponent )
        {
            SAL_WARN("basic", "Failed to get ThisComponent");
                // the application Basic, at the latest, should have this variable
            return nullptr;
        }

        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 nullptr;
        }

        return xModel;
    }

    void StarBASIC::DetachAllDocBasicItems()
    {
        std::unordered_map< const StarBASIC *, DocBasicItemRef >& rItems = GaDocBasicItems::get();
        for (auto const& item : rItems)
        {
            DocBasicItemRef xItem = item.second;
            xItem->setDisposed(true);
        }
    }

    // #118116 Implementation Collection object

    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;
    SbxInfoRef BasicCollection::xItemInfo;

    BasicCollection::BasicCollection( const OUString& rClass )
                 : SbxObject( rClass )
    {
        if( !nCountHash )
        {
            nCountHash  = MakeHashCode( pCountStr );
            nAddHash    = MakeHashCode( pAddStr );
            nItemHash   = MakeHashCode( pItemStr );
            nRemoveHash = MakeHashCode( pRemoveStr );
        }
        Initialize();

    }

    BasicCollection::~BasicCollection()
    {}

    void BasicCollection::Clear()
    {
        SbxObject::Clear();
        Initialize();
    }

    void BasicCollection::Initialize()
    {
        xItemArray = new SbxArray();
        SetType( SbxOBJECT );
        SetFlag( SbxFlagBits::Fixed );
        ResetFlag( SbxFlagBits::Write );
        SbxVariable* p;
        p = Make( pCountStr, SbxClassType::Property, SbxINTEGER );
        p->ResetFlag( SbxFlagBits::Write );
        p->SetFlag( SbxFlagBits::DontStore );
        p = Make( pAddStr, SbxClassType::Method, SbxEMPTY );
        p->SetFlag( SbxFlagBits::DontStore );
        p = Make( pItemStr, SbxClassType::Method, SbxVARIANT );
        p->SetFlag( SbxFlagBits::DontStore );
        p = Make( pRemoveStr, SbxClassType::Method, SbxEMPTY );
        p->SetFlag( SbxFlagBits::DontStore );
        if ( !xAddInfo.is() )
        {
            xAddInfo = new SbxInfo;
            xAddInfo->AddParam(  "Item", SbxVARIANT );
            xAddInfo->AddParam(  "Key", SbxVARIANT, SbxFlagBits::Read | SbxFlagBits::Optional );
            xAddInfo->AddParam(  "Before", SbxVARIANT, SbxFlagBits::Read | SbxFlagBits::Optional );
            xAddInfo->AddParam(  "After", SbxVARIANT, SbxFlagBits::Read | SbxFlagBits::Optional );
        }
        if ( !xItemInfo.is() )
        {
            xItemInfo = new SbxInfo;
            xItemInfo->AddParam(  "Index", SbxVARIANT, SbxFlagBits::Read | SbxFlagBits::Optional);
        }
    }

    void BasicCollection::Notify( SfxBroadcaster& rCst, const SfxHint& rHint )
    {
        const SbxHint* p = dynamic_cast<const SbxHint*>(&rHint);
        if( p )
        {
            const SfxHintId nId = p->GetId();
            bool bRead  = nId == SfxHintId::BasicDataWanted;
            bool bWrite = nId == SfxHintId::BasicDataChanged;
            bool bRequestInfo = nId == SfxHintId::BasicInfoWanted;
            SbxVariable* pVar = p->GetVar();
            SbxArray* pArg = pVar->GetParameters();
            OUString aVarName( pVar->GetName() );
            if( bRead || bWrite )
            {
                if( pVar->GetHashCode() == nCountHash
                      && aVarName.equalsIgnoreAsciiCase( pCountStr ) )
                {
                    pVar->PutLong( xItemArray->Count32() );
                }
                else if( pVar->GetHashCode() == nAddHash
                      && aVarName.equalsIgnoreAsciiCase( pAddStr ) )
                {
                    CollAdd( pArg );
                }
                else if( pVar->GetHashCode() == nItemHash
                      && aVarName.equalsIgnoreAsciiCase( pItemStr ) )
                {
                    CollItem( pArg );
                }
                else if( pVar->GetHashCode() == nRemoveHash
                      && aVarName.equalsIgnoreAsciiCase( pRemoveStr ) )
                {
                    CollRemove( pArg );
                }
                else
                {
                    SbxObject::Notify( rCst, rHint );
                }
                return;
            }
            else if ( bRequestInfo )
            {
                if( pVar->GetHashCode() == nAddHash
                      && aVarName.equalsIgnoreAsciiCase( pAddStr ) )
                {
                    pVar->SetInfo( xAddInfo.get() );
                }
                else if( pVar->GetHashCode() == nItemHash
                      && aVarName.equalsIgnoreAsciiCase( pItemStr ) )
                {
                    pVar->SetInfo( xItemInfo.get() );
                }
            }
        }
        SbxObject::Notify( rCst, rHint );
    }

    sal_Int32 BasicCollection::implGetIndex( SbxVariable const * pIndexVar )
    {
        sal_Int32 nIndex = -1;
        if( pIndexVar->GetType() == SbxSTRING )
        {
            nIndex = implGetIndexForName( pIndexVar->GetOUString() );
        }
        else
        {
            nIndex = pIndexVar->GetLong() - 1;
        }
        return nIndex;
    }

    sal_Int32 BasicCollection::implGetIndexForName( const OUString& rName )
    {
        sal_Int32 nIndex = -1;
        sal_Int32 nCount = xItemArray->Count32();
        sal_Int32 nNameHash = MakeHashCode( rName );
        for( sal_Int32 i = 0 ; i < nCount ; i++ )
        {
            SbxVariable* pVar = xItemArray->Get32( i );
            if( pVar->GetHashCode() == nNameHash &&
                pVar->GetName().equalsIgnoreAsciiCase( rName ) )
            {
                nIndex = i;
                break;
            }
        }
        return nIndex;
    }

    void BasicCollection::CollAdd( SbxArray* pPar_ )
    {
        sal_uInt16 nCount = pPar_->Count();
        if( nCount < 2 || nCount > 5 )
        {
            SetError( ERRCODE_BASIC_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( ERRCODE_BASIC_BAD_ARGUMENT );
                        return;
                    }
                    SbxVariable* pAfter = pPar_->Get(4);
                    sal_Int32 nAfterIndex = implGetIndex( pAfter );
                    if( nAfterIndex == -1 )
                    {
                        SetError( ERRCODE_BASIC_BAD_ARGUMENT );
                        return;
                    }
                    nNextIndex = nAfterIndex + 1;
                }
                else // if( nCount == 4 )
                {
                    sal_Int32 nBeforeIndex = implGetIndex( pBefore );
                    if( nBeforeIndex == -1 )
                    {
                        SetError( ERRCODE_BASIC_BAD_ARGUMENT );
                        return;
                    }
                    nNextIndex = nBeforeIndex;
                }
            }

            auto pNewItem = tools::make_ref<SbxVariable>( *pItem );
            if( nCount >= 3 )
            {
                SbxVariable* pKey = pPar_->Get(2);
                if( !( pKey->IsErr() || ( pKey->GetType() == SbxEMPTY ) ) )
                {
                    if( pKey->GetType() != SbxSTRING )
                    {
                        SetError( ERRCODE_BASIC_BAD_ARGUMENT );
                        return;
                    }
                    OUString aKey = pKey->GetOUString();
                    if( implGetIndexForName( aKey ) != -1 )
                    {
                        SetError( ERRCODE_BASIC_BAD_ARGUMENT );
                        return;
                    }
                    pNewItem->SetName( aKey );
                }
            }
            pNewItem->SetFlag( SbxFlagBits::ReadWrite );
            xItemArray->Insert32( pNewItem.get(), nNextIndex );
        }
        else
        {
            SetError( ERRCODE_BASIC_BAD_ARGUMENT );
            return;
        }
    }

    void BasicCollection::CollItem( SbxArray* pPar_ )
    {
        if( pPar_->Count() != 2 )
        {
            SetError( ERRCODE_BASIC_WRONG_ARGS );
            return;
        }
        SbxVariable* pRes = nullptr;
        SbxVariable* p = pPar_->Get( 1 );
        sal_Int32 nIndex = implGetIndex( p );
        if( nIndex >= 0 && nIndex < static_cast<sal_Int32>(xItemArray->Count32()) )
        {
            pRes = xItemArray->Get32( nIndex );
        }
        if( !pRes )
        {
            SetError( ERRCODE_BASIC_BAD_ARGUMENT );
        }
        else
        {
            *(pPar_->Get(0)) = *pRes;
        }
    }

    void BasicCollection::CollRemove( SbxArray* pPar_ )
    {
        if( pPar_ == nullptr || pPar_->Count() != 2 )
        {
            SetError( ERRCODE_BASIC_WRONG_ARGS );
            return;
        }

        SbxVariable* p = pPar_->Get( 1 );
        sal_Int32 nIndex = implGetIndex( p );
        if( nIndex >= 0 && nIndex < static_cast<sal_Int32>(xItemArray->Count32()) )
        {
            xItemArray->Remove( nIndex );

            // Correct for stack if necessary
            SbiInstance* pInst = GetSbData()->pInst;
            SbiRuntime* pRT = pInst ? pInst->pRun : nullptr;
            if( pRT )
            {
                SbiForStack* pStack = pRT->FindForStackItemForCollection( this );
                if( pStack != nullptr )
                {
                    if( pStack->nCurCollectionIndex >= nIndex )
                    {
                        --pStack->nCurCollectionIndex;
                    }
                }
            }
        }
        else
        {
            SetError( ERRCODE_BASIC_BAD_ARGUMENT );
        }
    }

    /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

↑ V678 An object is used as an argument to its own method. Consider checking the first actual argument of the 'PutObject' function.