xref: /trunk/main/basic/source/sbx/sbxvar.cxx (revision e1f63238)

/**************************************************************
 *
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 *
 *************************************************************/



// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_basic.hxx"


#include <tools/stream.hxx>
#include "svl/brdcst.hxx"

#include <basic/sbx.hxx>
#include <basic/sbxbase.hxx>
#include "sbxres.hxx"
#include "sbxconv.hxx"
#include <math.h>
#include <ctype.h>

#include "com/sun/star/uno/XInterface.hpp"
using namespace com::sun::star::uno;

///////////////////////////// SbxVariable //////////////////////////////

TYPEINIT1(SbxVariable,SbxValue)
TYPEINIT1(SbxHint,SfxSimpleHint)

extern sal_uInt32 nVarCreator;			// in SBXBASE.CXX, fuer LoadData()
#ifdef DBG_UTIL
static sal_uIntPtr nVar = 0;
#endif

///////////////////////////// SbxVariableImpl ////////////////////////////

class SbxVariableImpl
{
	friend class SbxVariable;
	String						m_aDeclareClassName;
	Reference< XInterface >		m_xComListener;
	StarBASIC*					m_pComListenerParentBasic;

	SbxVariableImpl( void )
		: m_pComListenerParentBasic( NULL )
	{}
	SbxVariableImpl( const SbxVariableImpl& r )
		: m_aDeclareClassName( r.m_aDeclareClassName )
		, m_xComListener( r.m_xComListener )
		, m_pComListenerParentBasic( r.m_pComListenerParentBasic )
	{
    }
};


///////////////////////////// Konstruktoren //////////////////////////////

SbxVariable::SbxVariable() : SbxValue()
{
	mpSbxVariableImpl = NULL;
	pCst = NULL;
	pParent = NULL;
	nUserData = 0;
	nHash = 0;
#ifdef DBG_UTIL
	DbgOutf( "SbxVariable::Ctor %lx=%ld", (void*)this, ++nVar );
	GetSbxData_Impl()->aVars.Insert( this, LIST_APPEND );
#endif
}

void registerComListenerVariableForBasic( SbxVariable* pVar, StarBASIC* pBasic );

SbxVariable::SbxVariable( const SbxVariable& r )
		   : SvRefBase( r ), SbxValue( r ), mpPar( r.mpPar ), pInfo( r.pInfo )
{
	mpSbxVariableImpl = NULL;
	if( r.mpSbxVariableImpl != NULL )
	{
		mpSbxVariableImpl = new SbxVariableImpl( *r.mpSbxVariableImpl );
		if( mpSbxVariableImpl->m_xComListener.is() )
			registerComListenerVariableForBasic( this, mpSbxVariableImpl->m_pComListenerParentBasic );
	}
	pCst = NULL;
	if( r.CanRead() )
	{
		pParent = r.pParent;
		nUserData = r.nUserData;
		maName = r.maName;
		nHash = r.nHash;
	}
	else
	{
		pParent = NULL;
		nUserData = 0;
		nHash = 0;
	}
#ifdef DBG_UTIL
	static sal_Char const aCellsStr[] = "Cells";
	if ( maName.EqualsAscii( aCellsStr ) )
		maName.AssignAscii( aCellsStr, sizeof( aCellsStr )-1 );
	DbgOutf( "SbxVariable::Ctor %lx=%ld", (void*)this, ++nVar );
	GetSbxData_Impl()->aVars.Insert( this, LIST_APPEND );
#endif
}

SbxVariable::SbxVariable( SbxDataType t, void* p ) : SbxValue( t, p )
{
	mpSbxVariableImpl = NULL;
	pCst = NULL;
	pParent = NULL;
	nUserData = 0;
	nHash = 0;
#ifdef DBG_UTIL
	DbgOutf( "SbxVariable::Ctor %lx=%ld", (void*)this, ++nVar );
	GetSbxData_Impl()->aVars.Insert( this, LIST_APPEND );
#endif
}

void removeDimAsNewRecoverItem( SbxVariable* pVar );

SbxVariable::~SbxVariable()
{
#ifdef DBG_UTIL
	ByteString aBStr( (const UniString&)maName, RTL_TEXTENCODING_ASCII_US );
	DbgOutf( "SbxVariable::Dtor %lx (%s)", (void*)this, aBStr.GetBuffer() );
	static sal_Char const aCellsStr[] = "Cells";
	if ( maName.EqualsAscii( aCellsStr ) )
		maName.AssignAscii( aCellsStr, sizeof( aCellsStr )-1 );
	GetSbxData_Impl()->aVars.Remove( this );
#endif
	if( IsSet( SBX_DIM_AS_NEW ))
		removeDimAsNewRecoverItem( this );
	delete mpSbxVariableImpl;
	delete pCst;
}

////////////////////////////// Broadcasting //////////////////////////////

SfxBroadcaster& SbxVariable::GetBroadcaster()
{
	if( !pCst )
		pCst = new SfxBroadcaster;
	return *pCst;
}

// Eines Tages kann man vielleicht den Parameter 0 schleifen,
// dann entfaellt die Kopiererei...

void SbxVariable::Broadcast( sal_uIntPtr nHintId )
{
	if( pCst && !IsSet( SBX_NO_BROADCAST ) && StaticIsEnabledBroadcasting() )
	{
		// Da die Methode von aussen aufrufbar ist, hier noch einmal
		// die Berechtigung testen
		if( nHintId & SBX_HINT_DATAWANTED )
			if( !CanRead() )
				return;
		if( nHintId & SBX_HINT_DATACHANGED )
			if( !CanWrite() )
				return;
		// Weitere Broadcasts verhindern
		SfxBroadcaster* pSave = pCst;
		pCst = NULL;
		sal_uInt16 nSaveFlags = GetFlags();
		SetFlag( SBX_READWRITE );
		if( mpPar.Is() )
			// this, als Element 0 eintragen, aber den Parent nicht umsetzen!
			mpPar->GetRef( 0 ) = this;
		pSave->Broadcast( SbxHint( nHintId, this ) );
		delete pCst; // wer weiss schon, auf welche Gedanken mancher kommt?
		pCst = pSave;
		SetFlags( nSaveFlags );
	}
}

SbxInfo* SbxVariable::GetInfo()
{
	if( !pInfo )
	{
		Broadcast( SBX_HINT_INFOWANTED );
		if( pInfo.Is() )
			SetModified( sal_True );
	}
	return pInfo;
}

void SbxVariable::SetInfo( SbxInfo* p )
{
	pInfo = p;
}

void SbxVariable::SetParameters( SbxArray* p )
{
	mpPar = p;
}


/////////////////////////// Name der Variablen ///////////////////////////

void SbxVariable::SetName( const XubString& rName )
{
	maName = rName;
	nHash = MakeHashCode( rName );
}

const XubString& SbxVariable::GetName( SbxNameType t ) const
{
	static char cSuffixes[] = "  %&!#@ $";
	if( t == SbxNAME_NONE )
		return maName;
	// Parameter-Infos anfordern (nicht fuer Objekte)
	((SbxVariable*)this)->GetInfo();
	// Nix anfuegen, wenn einfache Property (keine leeren Klammern)
	if( !pInfo
	 || ( !pInfo->aParams.Count() && GetClass() == SbxCLASS_PROPERTY ) )
		return maName;
	xub_Unicode cType = ' ';
	XubString aTmp( maName );
	// Kurzer Typ? Dann holen, evtl. ist dieser 0.
	SbxDataType et = GetType();
	if( t == SbxNAME_SHORT_TYPES )
	{
		if( et <= SbxSTRING )
			cType = cSuffixes[ et ];
		if( cType != ' ' )
			aTmp += cType;
	}
	aTmp += '(';
	for( sal_uInt16 i = 0; i < pInfo->aParams.Count(); i++ )
	{
		const SbxParamInfo* q = pInfo->aParams.GetObject( i );
		int nt = q->eType & 0x0FFF;
		if( i )
			aTmp += ',';
		if( q->nFlags & SBX_OPTIONAL )
			aTmp += String( SbxRes( STRING_OPTIONAL ) );
		if( q->eType & SbxBYREF )
			aTmp += String( SbxRes( STRING_BYREF ) );
		aTmp += q->aName;
		cType = ' ';
		// Kurzer Typ? Dann holen, evtl. ist dieser 0.
		if( t == SbxNAME_SHORT_TYPES )
		{
			if( nt <= SbxSTRING )
				cType = cSuffixes[ nt ];
		}
		if( cType != ' ' )
		{
			aTmp += cType;
			if( q->eType & SbxARRAY )
				aTmp.AppendAscii( "()" );
		}
		else
		{
			if( q->eType & SbxARRAY )
				aTmp.AppendAscii( "()" );
			// langer Typ?
			if( t != SbxNAME_SHORT )
			{
				aTmp += String( SbxRes( STRING_AS ) );
				if( nt < 32 )
					aTmp += String( SbxRes(
                        sal::static_int_cast< sal_uInt16 >( STRING_TYPES + nt ) ) );
				else
					aTmp += String( SbxRes( STRING_ANY ) );
			}
		}
	}
	aTmp += ')';
	// Langer Typ? Dann holen
	if( t == SbxNAME_LONG_TYPES && et != SbxEMPTY )
	{
		aTmp += String( SbxRes( STRING_AS ) );
		if( et < 32 )
			aTmp += String( SbxRes(
                sal::static_int_cast< sal_uInt16 >( STRING_TYPES + et ) ) );
		else
			aTmp += String( SbxRes( STRING_ANY ) );
	}
	((SbxVariable*) this)->aToolString = aTmp;
	return aToolString;
}

// Einen simplen Hashcode erzeugen: Es werden die ersten 6 Zeichen gewertet.

sal_uInt16 SbxVariable::MakeHashCode( const XubString& rName )
{
	sal_uInt16 n = 0;
	sal_uInt16 nLen = rName.Len();
	if( nLen > 6 )
		nLen = 6;
	const xub_Unicode* p = rName.GetBuffer();
	while( nLen-- )
	{
		sal_uInt8 c = (sal_uInt8)*p;
		p++;
		// Falls wir ein Schweinezeichen haben, abbrechen!!
		if( c >= 0x80 )
			return 0;
		n = sal::static_int_cast< sal_uInt16 >( ( n << 3 ) + toupper( c ) );
	}
	return n;
}

////////////////////////////// Operatoren ////////////////////////////////

SbxVariable& SbxVariable::operator=( const SbxVariable& r )
{
	SbxValue::operator=( r );
	delete mpSbxVariableImpl;
	if( r.mpSbxVariableImpl != NULL )
    {
		mpSbxVariableImpl = new SbxVariableImpl( *r.mpSbxVariableImpl );
		if( mpSbxVariableImpl->m_xComListener.is() )
			registerComListenerVariableForBasic( this, mpSbxVariableImpl->m_pComListenerParentBasic );
    }
	else
		mpSbxVariableImpl = NULL;
	return *this;
}

//////////////////////////////// Konversion ////////////////////////////////

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

void SbxVariable::SetModified( sal_Bool b )
{
	if( IsSet( SBX_NO_MODIFY ) )
		return;
	SbxBase::SetModified( b );
	if( pParent && pParent != this ) //??? HotFix: Rekursion raus MM
		pParent->SetModified( b );
}

void SbxVariable::SetParent( SbxObject* p )
{
#ifdef DBG_UTIL
	// wird der Parent eines SbxObjects gesetzt?
	if ( p && ISA(SbxObject) )
	{
		// dann mu\s dieses auch Child vom neuen Parent sein
		sal_Bool bFound = sal_False;
		SbxArray *pChilds = p->GetObjects();
		if ( pChilds )
		{
			for ( sal_uInt16 nIdx = 0; !bFound && nIdx < pChilds->Count(); ++nIdx )
				bFound = ( this == pChilds->Get(nIdx) );
		}
		if ( !bFound )
		{
			String aMsg = String::CreateFromAscii( "dangling: [" );
			aMsg += GetName();
			aMsg.AppendAscii( "].SetParent([" );
			aMsg += p->GetName();
			aMsg.AppendAscii( "])" );
			ByteString aBStr( (const UniString&)aMsg, RTL_TEXTENCODING_ASCII_US );
			DbgOut( aBStr.GetBuffer(), DBG_OUT_WARNING, __FILE__, __LINE__);
		}
	}
#endif

	pParent = p;
}

SbxVariableImpl* SbxVariable::getImpl( void )
{
	if( mpSbxVariableImpl == NULL )
		mpSbxVariableImpl = new SbxVariableImpl();
	return mpSbxVariableImpl;
}

const String& SbxVariable::GetDeclareClassName( void )
{
	SbxVariableImpl* pImpl = getImpl();
	return pImpl->m_aDeclareClassName;
}

void SbxVariable::SetDeclareClassName( const String& rDeclareClassName )
{
	SbxVariableImpl* pImpl = getImpl();
	pImpl->m_aDeclareClassName = rDeclareClassName;
}

void SbxVariable::SetComListener( ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface > xComListener,
								  StarBASIC* pParentBasic )
{
	SbxVariableImpl* pImpl = getImpl();
	pImpl->m_xComListener = xComListener;
	pImpl->m_pComListenerParentBasic = pParentBasic;
	registerComListenerVariableForBasic( this, pParentBasic );
}

void SbxVariable::ClearComListener( void )
{
	SbxVariableImpl* pImpl = getImpl();
	pImpl->m_xComListener.clear();
}


////////////////////////////// Laden/Speichern /////////////////////////////

sal_Bool SbxVariable::LoadData( SvStream& rStrm, sal_uInt16 nVer )
{
	sal_uInt16 nType;
	sal_uInt8 cMark;
	rStrm >> cMark;
	if( cMark == 0xFF )
	{
		if( !SbxValue::LoadData( rStrm, nVer ) )
			return sal_False;
		rStrm.ReadByteString( maName, RTL_TEXTENCODING_ASCII_US );
		sal_uInt32 nTemp;
		rStrm >> nTemp;
		nUserData = nTemp;
	}
	else
	{
		rStrm.SeekRel( -1L );
		rStrm >> nType;
		rStrm.ReadByteString( maName, RTL_TEXTENCODING_ASCII_US );
		sal_uInt32 nTemp;
		rStrm >> nTemp;
		nUserData = nTemp;
		// Korrektur: Alte Methoden haben statt SbxNULL jetzt SbxEMPTY
		if( nType == SbxNULL && GetClass() == SbxCLASS_METHOD )
			nType = SbxEMPTY;
		SbxValues aTmp;
        String aTmpString;
		::rtl::OUString aVal;
		aTmp.eType = aData.eType = (SbxDataType) nType;
		aTmp.pOUString = &aVal;
		switch( nType )
		{
			case SbxBOOL:
			case SbxERROR:
			case SbxINTEGER:
				rStrm >> aTmp.nInteger; break;
			case SbxLONG:
				rStrm >> aTmp.nLong; break;
			case SbxSINGLE:
			{
				// Floats als ASCII
				rStrm.ReadByteString( aTmpString, RTL_TEXTENCODING_ASCII_US );
				double d;
				SbxDataType t;
				if( ImpScan( aTmpString, d, t, NULL ) != SbxERR_OK || t == SbxDOUBLE )
				{
					aTmp.nSingle = 0;
					return sal_False;
				}
				aTmp.nSingle = (float) d;
				break;
			}
			case SbxDATE:
			case SbxDOUBLE:
			{
				// Floats als ASCII
				rStrm.ReadByteString( aTmpString, RTL_TEXTENCODING_ASCII_US );
				SbxDataType t;
				if( ImpScan( aTmpString, aTmp.nDouble, t, NULL ) != SbxERR_OK )
				{
					aTmp.nDouble = 0;
					return sal_False;
				}
				break;
			}
			case SbxSTRING:
				rStrm.ReadByteString( aTmpString, RTL_TEXTENCODING_ASCII_US );
                aVal = aTmpString;
				break;
			case SbxEMPTY:
			case SbxNULL:
				break;
			default:
				aData.eType = SbxNULL;
				DBG_ASSERT( !this, "Nicht unterstuetzer Datentyp geladen" );
				return sal_False;
		}
		// Wert putten
		if( nType != SbxNULL && nType != SbxEMPTY && !Put( aTmp ) )
			return sal_False;
	}
	rStrm >> cMark;
	// cMark ist auch eine Versionsnummer!
	// 1: initial version
	// 2: mit nUserData
	if( cMark )
	{
		if( cMark > 2 )
			return sal_False;
		pInfo = new SbxInfo;
		pInfo->LoadData( rStrm, (sal_uInt16) cMark );
	}
	// Privatdaten nur laden, wenn es eine SbxVariable ist
	if( GetClass() == SbxCLASS_VARIABLE && !LoadPrivateData( rStrm, nVer ) )
		return sal_False;
	((SbxVariable*) this)->Broadcast( SBX_HINT_DATACHANGED );
	nHash =  MakeHashCode( maName );
	SetModified( sal_True );
	return sal_True;
}

sal_Bool SbxVariable::StoreData( SvStream& rStrm ) const
{
	rStrm << (sal_uInt8) 0xFF;		// Marker
	sal_Bool bValStore;
	if( this->IsA( TYPE(SbxMethod) ) )
	{
		// #50200 Verhindern, dass Objekte, die zur Laufzeit als Return-Wert
		// in der Methode als Value gespeichert sind, mit gespeichert werden
		SbxVariable* pThis = (SbxVariable*)this;
		sal_uInt16 nSaveFlags = GetFlags();
		pThis->SetFlag( SBX_WRITE );
		pThis->SbxValue::Clear();
		pThis->SetFlags( nSaveFlags );

		// Damit die Methode in keinem Fall ausgefuehrt wird!
		// CAST, um const zu umgehen!
		pThis->SetFlag( SBX_NO_BROADCAST );
		bValStore = SbxValue::StoreData( rStrm );
		pThis->ResetFlag( SBX_NO_BROADCAST );
	}
	else
		bValStore = SbxValue::StoreData( rStrm );
	if( !bValStore )
		return sal_False;
	// if( !SbxValue::StoreData( rStrm ) )
		// return sal_False;
	rStrm.WriteByteString( maName, RTL_TEXTENCODING_ASCII_US );
	rStrm << (sal_uInt32)nUserData;
	if( pInfo.Is() )
	{
		rStrm << (sal_uInt8) 2;		// Version 2: mit UserData!
		pInfo->StoreData( rStrm );
	}
	else
		rStrm << (sal_uInt8) 0;
	// Privatdaten nur speichern, wenn es eine SbxVariable ist
	if( GetClass() == SbxCLASS_VARIABLE )
		return StorePrivateData( rStrm );
	else
		return sal_True;
}

////////////////////////////// SbxInfo ///////////////////////////////////

SbxInfo::SbxInfo() : aHelpFile(), nHelpId( 0 ), aParams()
{}

SbxInfo::SbxInfo( const String& r, sal_uInt32 n )
	   : aHelpFile( r ), nHelpId( n ), aParams()
{}

////////////////////////////// SbxAlias //////////////////////////////////

SbxAlias::SbxAlias( const XubString& rName, SbxVariable* p )
		: SbxVariable(), xAlias( p )
{
	SetName( rName );
	SetFlags( p->GetFlags() );
	SetFlag( SBX_DONTSTORE );
	aData.eType = p->GetType();
	StartListening( p->GetBroadcaster() );
}

SbxAlias::SbxAlias( const SbxAlias& r )
		: SvRefBase( r ), SbxVariable( r ),
          SfxListener( r ), xAlias( r.xAlias )
{}

SbxAlias& SbxAlias::operator=( const SbxAlias& r )
{
	xAlias = r.xAlias;
	return *this;
}

SbxAlias::~SbxAlias()
{
	if( xAlias.Is() )
		EndListening( xAlias->GetBroadcaster() );
}

void SbxAlias::Broadcast( sal_uIntPtr nHt )
{
	if( xAlias.Is() && StaticIsEnabledBroadcasting() )
	{
		xAlias->SetParameters( GetParameters() );
		if( nHt == SBX_HINT_DATAWANTED )
			SbxVariable::operator=( *xAlias );
		else if( nHt == SBX_HINT_DATACHANGED || nHt == SBX_HINT_CONVERTED )
			*xAlias = *this;
		else if( nHt == SBX_HINT_INFOWANTED )
		{
			xAlias->Broadcast( nHt );
			pInfo = xAlias->GetInfo();
		}
	}
}

void SbxAlias::SFX_NOTIFY( SfxBroadcaster&, const TypeId&,
						   const SfxHint& rHint, const TypeId& )
{
	const SbxHint* p = PTR_CAST(SbxHint,&rHint);
	if( p && p->GetId() == SBX_HINT_DYING )
	{
		xAlias.Clear();
		// Alias loeschen?
		if( pParent )
			pParent->Remove( this );
	}
}

void SbxVariable::Dump( SvStream& rStrm, sal_Bool bFill )
{
	ByteString aBNameStr( (const UniString&)GetName( SbxNAME_SHORT_TYPES ), RTL_TEXTENCODING_ASCII_US );
	rStrm << "Variable( "
          << ByteString::CreateFromInt64( (sal_uIntPtr) this ).GetBuffer() << "=="
		  << aBNameStr.GetBuffer();
	ByteString aBParentNameStr( (const UniString&)GetParent()->GetName(), RTL_TEXTENCODING_ASCII_US );
	if ( GetParent() )
		rStrm << " in parent '" << aBParentNameStr.GetBuffer() << "'";
	else
		rStrm << " no parent";
	rStrm << " ) ";

	// bei Object-Vars auch das Object ausgeben
	if ( GetValues_Impl().eType == SbxOBJECT &&
			GetValues_Impl().pObj &&
			GetValues_Impl().pObj != this &&
			GetValues_Impl().pObj != GetParent() )
	{
		rStrm << " contains ";
		((SbxObject*) GetValues_Impl().pObj)->Dump( rStrm, bFill );
	}
	else
		rStrm << endl;
}