/* -*- 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 <config_features.h>

#include <tools/stream.hxx>

#include <svl/SfxBroadcaster.hxx>

#include <basic/sbx.hxx>

#include <runtime.hxx>

#include "sbxres.hxx"

#include "sbxconv.hxx"

#include <sbunoobj.hxx>

#include <rtl/ustrbuf.hxx>

#include <sal/log.hxx>

#include <global.hxx>

#include <unotools/transliterationwrapper.hxx>

#include <com/sun/star/uno/XInterface.hpp>

#include <utility>

#include <filefmt.hxx>

using namespace com::sun::star::uno;

// SbxVariable

SbxVariable::SbxVariable()

{

}

Unexecuted instantiation: SbxVariable::SbxVariable()

Unexecuted instantiation: SbxVariable::SbxVariable()

SbxVariable::SbxVariable( const SbxVariable& r )

    : SvRefBase( r ),

      SbxValue( r ),

      m_aDeclareClassName( r.m_aDeclareClassName ),

      m_xComListener( r.m_xComListener),

      mpPar( r.mpPar ),

      pInfo( r.pInfo )

{

#if HAVE_FEATURE_SCRIPTING

    if( r.m_xComListener.is() )

    {

        registerComListenerVariableForBasic( this, r.m_pComListenerParentBasic );

    }

#endif

    if( r.CanRead() )

    {

        pParent = r.pParent;

        nUserData = r.nUserData;

        maName = r.maName;

        nHash = r.nHash;

    }

}

Unexecuted instantiation: SbxVariable::SbxVariable(SbxVariable const&)

Unexecuted instantiation: SbxVariable::SbxVariable(SbxVariable const&)

SbxEnsureParentVariable::SbxEnsureParentVariable(const SbxVariable& r)

    : SbxVariable(r)

    , xParent(const_cast<SbxVariable&>(r).GetParent())

{

    assert(GetParent() == xParent.get());

}

Unexecuted instantiation: SbxEnsureParentVariable::SbxEnsureParentVariable(SbxVariable const&)

Unexecuted instantiation: SbxEnsureParentVariable::SbxEnsureParentVariable(SbxVariable const&)

void SbxEnsureParentVariable::SetParent(SbxObject* p)

{

    assert(GetParent() == xParent.get());

    SbxVariable::SetParent(p);

    xParent = SbxObjectRef(p);

    assert(GetParent() == xParent.get());

}

SbxVariable::SbxVariable( SbxDataType t ) : SbxValue( t )

{

}

Unexecuted instantiation: SbxVariable::SbxVariable(SbxDataType)

Unexecuted instantiation: SbxVariable::SbxVariable(SbxDataType)

SbxVariable::~SbxVariable()

{

#if HAVE_FEATURE_SCRIPTING

    if( IsSet( SbxFlagBits::DimAsNew ))

    {

        removeDimAsNewRecoverItem( this );

    }

#endif

    mpBroadcaster.reset();

}

// Broadcasting

SfxBroadcaster& SbxVariable::GetBroadcaster()

{

    if( !mpBroadcaster )

    {

        mpBroadcaster.reset( new SfxBroadcaster );

    }

    return *mpBroadcaster;

}

SbxArray* SbxVariable::GetParameters() const

{

    return mpPar.get();

}

// Perhaps some day one could cut the parameter 0.

// Then the copying will be dropped...

void SbxVariable::Broadcast( SfxHintId nHintId )

{

    if( !mpBroadcaster || IsSet( SbxFlagBits::NoBroadcast ) )

        return;

    // Because the method could be called from outside, check the

    // rights here again

    if( nHintId == SfxHintId::BasicDataWanted )

    {

        if( !CanRead() )

        {

            return;

        }

    }

    if( nHintId == SfxHintId::BasicDataChanged )

    {

        if( !CanWrite() )

        {

            return;

        }

    }

    //fdo#86843 Add a ref during the following block to guard against

    //getting deleted before completing this method

    SbxVariableRef aBroadcastGuard(this);

    // Avoid further broadcasting

    std::unique_ptr<SfxBroadcaster> pSave = std::move(mpBroadcaster);

    SbxFlagBits nSaveFlags = GetFlags();

    SetFlag( SbxFlagBits::ReadWrite );

    if( mpPar.is() )

    {

        // Register this as element 0, but don't change over the parent!

        mpPar->GetRef(0) = this;

    }

    pSave->Broadcast( SbxHint( nHintId, this ) );

    mpBroadcaster = std::move(pSave);

    SetFlags( nSaveFlags );

}

SbxInfo* SbxVariable::GetInfo()

{

    if( !pInfo.is() )

    {

        Broadcast( SfxHintId::BasicInfoWanted );

        if( pInfo.is() )

        {

            SetModified( true );

        }

    }

    return pInfo.get();

}

void SbxVariable::SetInfo( SbxInfo* p )

{

    pInfo = p;

}

void SbxVariable::SetParameters( SbxArray* p )

{

    mpPar = p;

}

// Name of the variables

// static

OUString SbxVariable::NameToCaseInsensitiveName(const OUString& rName)

{

    return SbGlobal::GetTransliteration().transliterate(rName, 0, rName.getLength());

}

void SbxVariable::SetName( const OUString& rName )

{

    maName = rName;

    nHash = MakeHashCode( rName );

    maNameCI.clear();

}

const OUString& SbxVariable::GetName( SbxNameType t ) const

{

    static const char cSuffixes[] = "  %&!#@ $";

    if( t == SbxNameType::NONE )

    {

        return maName;

    }

    if (t == SbxNameType::CaseInsensitive)

    {

        if (maNameCI.isEmpty() && !maName.isEmpty())

            maNameCI = NameToCaseInsensitiveName(maName);

        return maNameCI;

    }

    // Request parameter-information (not for objects)

    const_cast<SbxVariable*>(this)->GetInfo();

    // Append nothing, if it is a simple property (no empty brackets)

    if (!pInfo.is() || (pInfo->m_Params.empty() && GetClass() == SbxClassType::Property))

    {

        return maName;

    }

    OUStringBuffer aTmp( maName );

    if( t == SbxNameType::ShortTypes )

    {

        sal_Unicode cType = ' ';

        // short type? Then fetch it, possible this is 0.

        SbxDataType et = GetType();

        if( et <= SbxSTRING )

        {

            assert(et >= 0 && size_t(et) < std::size(cSuffixes) - 1);

            cType = cSuffixes[ et ];

        }

        if( cType != ' ' )

        {

            aTmp.append(cType);

        }

    }

    aTmp.append("(");

    bool first = true;

    for (auto const& i : pInfo->m_Params)

    {

        int nt = i->eType & 0x0FFF;

        if (!first)

        {

            aTmp.append(",");

        }

        first = false;

        if( i->nFlags & SbxFlagBits::Optional )

        {

            aTmp.append( GetSbxRes( StringId::Optional ) );

        }

        if( i->eType & SbxBYREF )

        {

            aTmp.append( GetSbxRes( StringId::ByRef ) );

        }

        aTmp.append( i->aName );

        sal_Unicode cType = ' ';

        // short type? Then fetch it, possible this is 0.

        if( t == SbxNameType::ShortTypes )

        {

            if( nt <= SbxSTRING )

            {

                cType = cSuffixes[ nt ];

            }

        }

        if( cType != ' ' )

        {

            aTmp.append(cType);

            if( i->eType & SbxARRAY )

            {

                aTmp.append("()");

            }

        }

        else

        {

            if( i->eType & SbxARRAY )

            {

                aTmp.append("()");

            }

            // long type?

            aTmp.append(GetSbxRes( StringId::As ));

            if( nt < 32 )

            {

                aTmp.append(GetSbxRes( static_cast<StringId>( static_cast<int>( StringId::Types ) + nt ) ));

            }

            else

            {

                aTmp.append(GetSbxRes( StringId::Any ));

            }

        }

    }

    aTmp.append(")");

    const_cast<SbxVariable*>(this)->aToolString = aTmp.makeStringAndClear();

    return aToolString;

}

// Operators

SbxVariable& SbxVariable::operator=( const SbxVariable& r )

{

    if (this != &r)

    {

        SbxValue::operator=( r );

        // tdf#144353 - copy information about a missing parameter. See SbiRuntime::SetIsMissing.

        // We cannot unconditionally assign the data about a variable because we would overwrite

        // the information about parameters (name, type, flags, and ids). For instance, in the case

        // where a method will be initialized with a literal.

        if (!pInfo)

            pInfo = r.pInfo;

        m_aDeclareClassName = r.m_aDeclareClassName;

        m_xComListener = r.m_xComListener;

        m_pComListenerParentBasic = r.m_pComListenerParentBasic;

#if HAVE_FEATURE_SCRIPTING

        if( m_xComListener.is() )

        {

            registerComListenerVariableForBasic( this, m_pComListenerParentBasic );

        }

#endif

    }

    return *this;

}

// Conversion

SbxDataType SbxVariable::GetType() const

{

    if( aData.eType == SbxOBJECT )

    {

        return aData.pObj ? aData.pObj->GetType() : SbxOBJECT;

    }

    else if( aData.eType == SbxVARIANT )

    {

        return aData.pObj ? aData.pObj->GetType() : SbxVARIANT;

    }

    else

    {

        return aData.eType;

    }

}

SbxClassType SbxVariable::GetClass() const

{

    return SbxClassType::Variable;

}

void SbxVariable::SetModified( bool b )

{

    if( IsSet( SbxFlagBits::NoModify ) )

    {

        return;

    }

    SbxBase::SetModified( b );

    if( pParent && pParent != this ) //??? HotFix: Recursion out here MM

    {

        pParent->SetModified( b );

    }

}

void SbxVariable::SetParent( SbxObject* p )

{

#ifdef DBG_UTIL

    // Will the parent of a SbxObject be set?

    if (p && dynamic_cast<SbxObject*>(this))

    {

        // then this had to be a child of the new parent

        bool bFound = false;

        SbxArray *pChildren = p->GetObjects();

        if ( pChildren )

        {

            for (sal_uInt32 nIdx = 0; !bFound && nIdx < pChildren->Count(); ++nIdx)

            {

                bFound = (this == pChildren->Get(nIdx));

            }

        }

        SAL_INFO_IF(

            !bFound, "basic.sbx",

            "dangling: [" << GetName() << "].SetParent([" << p->GetName()

                << "])");

    }

#endif

    pParent = p;

}

const OUString& SbxVariable::GetDeclareClassName() const

{

    return m_aDeclareClassName;

}

void SbxVariable::SetDeclareClassName( const OUString& rDeclareClassName )

{

    m_aDeclareClassName = rDeclareClassName;

}

void SbxVariable::SetComListener( const css::uno::Reference< css::uno::XInterface >& xComListener,

                                  StarBASIC* pParentBasic )

{

    m_xComListener = xComListener;

    m_pComListenerParentBasic = pParentBasic;

#if HAVE_FEATURE_SCRIPTING

    registerComListenerVariableForBasic( this, pParentBasic );

#endif

}

void SbxVariable::ClearComListener()

{

    m_xComListener.clear();

}

// Loading/Saving

bool SbxVariable::LoadData( SvStream& rStrm, sal_uInt16 nVer )

{

    sal_uInt8 cMark;

    rStrm.ReadUChar( cMark );

    if( cMark == 0xFF )

    {

        if( !SbxValue::LoadData( rStrm, nVer ) )

        {

            return false;

        }

        maName = read_uInt16_lenPrefixed_uInt8s_ToOUString(rStrm,

                                                                RTL_TEXTENCODING_ASCII_US);

        sal_uInt32 nTemp;

        rStrm.ReadUInt32( nTemp );

        nUserData = nTemp;

    }

    else

    {

        sal_uInt16 nType;

        rStrm.SeekRel( -1 );

        rStrm.ReadUInt16( nType );

        maName = read_uInt16_lenPrefixed_uInt8s_ToOUString(rStrm,

                                                                RTL_TEXTENCODING_ASCII_US);

        sal_uInt32 nTemp;

        rStrm.ReadUInt32( nTemp );

        nUserData = nTemp;

        // correction: old methods have instead of SbxNULL now SbxEMPTY

        if( nType == SbxNULL && GetClass() == SbxClassType::Method )

        {

            nType = SbxEMPTY;

        }

        SbxValues aTmp;

        OUString aTmpString;

        OUString aVal;

        aTmp.eType = aData.eType = static_cast<SbxDataType>(nType);

        aTmp.pOUString = &aVal;

        switch( nType )

        {

        case SbxBOOL:

        case SbxERROR:

        case SbxINTEGER:

            rStrm.ReadInt16( aTmp.nInteger ); break;

        case SbxLONG:

            rStrm.ReadInt32( aTmp.nLong ); break;

        case SbxSINGLE:

        {

            // Floats as ASCII

            aTmpString = read_uInt16_lenPrefixed_uInt8s_ToOUString(

                    rStrm, RTL_TEXTENCODING_ASCII_US);

            double d;

            SbxDataType t;

            if( ImpScan( aTmpString, d, t, nullptr ) != ERRCODE_NONE || t == SbxDOUBLE )

            {

                aTmp.nSingle = 0;

                return false;

            }

            aTmp.nSingle = static_cast<float>(d);

            break;

        }

        case SbxDATE:

        case SbxDOUBLE:

        {

            // Floats as ASCII

            aTmpString = read_uInt16_lenPrefixed_uInt8s_ToOUString(rStrm,

                                                                        RTL_TEXTENCODING_ASCII_US);

            SbxDataType t;

            if( ImpScan( aTmpString, aTmp.nDouble, t, nullptr ) != ERRCODE_NONE )

            {

                aTmp.nDouble = 0;

                return false;

            }

            break;

        }

        case SbxSTRING:

            aVal = read_uInt16_lenPrefixed_uInt8s_ToOUString(rStrm,

                                                                  RTL_TEXTENCODING_ASCII_US);

            break;

        case SbxEMPTY:

        case SbxNULL:

            break;

        default:

            aData.eType = SbxNULL;

            SAL_WARN( "basic.sbx", "Loaded a non-supported data type" );

            return false;

        }

        // putt value

        if( nType != SbxNULL && nType != SbxEMPTY && !Put( aTmp ) )

        {

            return false;

        }

    }

    rStrm.ReadUChar( cMark );

    // cMark is also a version number!

    // 1: initial version

    // 2: with nUserData

    if( cMark )

    {

        if( cMark > 2 )

        {

            return false;

        }

        pInfo = new SbxInfo;

        pInfo->LoadData( rStrm, static_cast<sal_uInt16>(cMark) );

    }

    Broadcast( SfxHintId::BasicDataChanged );

    nHash =  MakeHashCode( maName );

    SetModified( true );

    return true;

}

std::pair<bool, sal_uInt32> SbxVariable::StoreData( SvStream& rStrm ) const

{

    rStrm.WriteUChar( 0xFF );      // Marker

    bool bValStore;

    if( dynamic_cast<const SbxMethod *>(this) != nullptr )

    {

        // #50200 Avoid that objects , which during the runtime

        // as return-value are saved in the method as a value were saved

        SbxVariable* pThis = const_cast<SbxVariable*>(this);

        SbxFlagBits nSaveFlags = GetFlags();

        pThis->SetFlag( SbxFlagBits::Write );

        pThis->SbxValue::Clear();

        pThis->SetFlags( nSaveFlags );

        // So that the method will not be executed in any case!

        // CAST, to avoid const!

        pThis->SetFlag( SbxFlagBits::NoBroadcast );

        bValStore = SbxValue::StoreData( rStrm ).first;

        pThis->ResetFlag( SbxFlagBits::NoBroadcast );

    }

    else

    {

        bValStore = SbxValue::StoreData( rStrm ).first;

    }

    if( !bValStore )

    {

        return { false, 0 };

    }

    write_uInt16_lenPrefixed_uInt8s_FromOUString(rStrm, maName,

                                                      RTL_TEXTENCODING_ASCII_US);

    rStrm.WriteUInt32( nUserData );

    if( pInfo.is() )

    {

        rStrm.WriteUChar( 2 );     // Version 2: with UserData!

        pInfo->StoreData( rStrm );

    }

    else

    {

        rStrm.WriteUChar( 0 );

    }

    return { true, B_IMG_VERSION_12 };

}

// SbxInfo

SbxInfo::SbxInfo()

        :  nHelpId(0)

{}

SbxInfo::SbxInfo( OUString a, sal_uInt32 n )

       : aHelpFile(std::move( a )), nHelpId( n )

{}

SbxHint::~SbxHint() = default;

void SbxVariable::Dump( SvStream& rStrm, bool bFill )

{

    OString aBNameStr(OUStringToOString(GetName( SbxNameType::ShortTypes ), RTL_TEXTENCODING_ASCII_US));

    rStrm.WriteOString( "Variable( " )

         .WriteOString( OString::number(reinterpret_cast<sal_IntPtr>(this)) ).WriteOString( "==" )

         .WriteOString( aBNameStr );

    OString aBParentNameStr(OUStringToOString(GetParent()->GetName(), RTL_TEXTENCODING_ASCII_US));

    if ( GetParent() )

    {

        rStrm.WriteOString( " in parent '" ).WriteOString( aBParentNameStr ).WriteOString( "'" );

    }

    else

    {

        rStrm.WriteOString( " no parent" );

    }

    rStrm.WriteOString( " ) " );

    // output also the object at object-vars

    if ( GetValues_Impl().eType == SbxOBJECT &&

            GetValues_Impl().pObj &&

            GetValues_Impl().pObj != this &&

            GetValues_Impl().pObj != GetParent() )

    {

        rStrm.WriteOString( " contains " );

        static_cast<SbxObject*>(GetValues_Impl().pObj)->Dump( rStrm, bFill );

    }

    else

    {

        rStrm << endl;

    }

}

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