/**************************************************************
 *
 * 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"

#define _TLBIGINT_INT64
#include <tools/bigint.hxx>
#include <tools/stream.hxx>

#include <basic/sbx.hxx>
#include "sbxconv.hxx"
#include <math.h>
#include "runtime.hxx"
// AB 29.10.99 Unicode
#ifndef _USE_NO_NAMESPACE
using namespace rtl;
#endif


TYPEINIT1(SbxValue,SbxBase)

/////////////////////////// SbxINT64 /////////////////////////////////////
SbxINT64 &SbxINT64::operator -= ( const SbxINT64 &r )
{
	BigInt b( *this );
	b -= BigInt( r );
	b.INT64( this );
	return *this;
}
SbxINT64 &SbxINT64::operator += ( const SbxINT64 &r )
{
	BigInt b( *this );
	b += BigInt( r );
	b.INT64( this );
	return *this;
}
SbxINT64 &SbxINT64::operator *= ( const SbxINT64 &r )
{
	BigInt b( *this );
	b *= BigInt( r );
	b.INT64( this );
	return *this;
}
SbxINT64 &SbxINT64::operator %= ( const SbxINT64 &r )
{
	BigInt b( *this );
	b %= BigInt( r );
	b.INT64( this );
	return *this;
}
SbxINT64 &SbxINT64::operator /= ( const SbxINT64 &r )
{
	BigInt b( *this );
	b /= BigInt( r );
	b.INT64( this );
	return *this;
}
SbxINT64 &SbxINT64::operator &= ( const SbxINT64 &r )
{
	nHigh &= r.nHigh;
	nLow  &= r.nLow;
	return *this;
}
SbxINT64 &SbxINT64::operator |= ( const SbxINT64 &r )
{
	nHigh |= r.nHigh;
	nLow  |= r.nLow;
	return *this;
}
SbxINT64 &SbxINT64::operator ^= ( const SbxINT64 &r )
{
	nHigh ^= r.nHigh;
	nLow  ^= r.nLow;
	return *this;
}

SbxINT64 operator - ( const SbxINT64 &l, const SbxINT64 &r )
{
	SbxINT64 a(l);
	a -= r;
	return a;
}
SbxINT64 operator + ( const SbxINT64 &l, const SbxINT64 &r )
{
	SbxINT64 a(l);
	a += r;
	return a;
}
SbxINT64 operator / ( const SbxINT64 &l, const SbxINT64 &r )
{
	SbxINT64 a(l);
	a /= r;
	return a;
}
SbxINT64 operator % ( const SbxINT64 &l, const SbxINT64 &r )
{
	SbxINT64 a(l);
	a %= r;
	return a;
}
SbxINT64 operator * ( const SbxINT64 &l, const SbxINT64 &r )
{
	SbxINT64 a(l);
	a *= r;
	return a;
}
SbxINT64 operator & ( const SbxINT64 &l, const SbxINT64 &r )
{
	SbxINT64 a;
	a.nHigh = r.nHigh & l.nHigh;
	a.nLow  = r.nLow  & l.nLow;
	return a;
}
SbxINT64 operator | ( const SbxINT64 &l, const SbxINT64 &r )
{
	SbxINT64 a;
	a.nHigh = r.nHigh | l.nHigh;
	a.nLow  = r.nLow  | l.nLow;
	return a;
}
SbxINT64 operator ^ ( const SbxINT64 &r, const SbxINT64 &l )
{
	SbxINT64 a;
	a.nHigh = r.nHigh ^ l.nHigh;
	a.nLow  = r.nLow  ^ l.nLow;
	return a;
}

SbxINT64 operator - ( const SbxINT64 &r )
{
	SbxINT64 a( r );
	a.CHS();
	return a;
}
SbxINT64 operator ~ ( const SbxINT64 &r )
{
	SbxINT64 a;
	a.nHigh = ~r.nHigh;
	a.nLow  = ~r.nLow;
	return a;
}

SbxUINT64 &SbxUINT64::operator %= ( const SbxUINT64 &r )
{
	BigInt b( *this );
	b %= BigInt( r );
	b.UINT64( this );
	return *this;
}
SbxUINT64 &SbxUINT64::operator /= ( const SbxUINT64 &r )
{
	BigInt b( *this );
	b /= BigInt( r );
	b.UINT64( this );
	return *this;
}
/////////////////////////// Fehlerbehandlung /////////////////////////////

#ifdef _USED
// NOCH NACHZUBAUEN!

// Das Default-Handling setzt nur den Fehlercode.

#ifndef WNT
#if defined ( UNX )
int matherr( struct exception* p )
#else
int matherr( struct _exception* p )
#endif
{
	switch( p->type )
	{
#if defined ( UNX )
		case OVERFLOW: SbxBase::SetError( SbxERR_OVERFLOW ); break;
#else
		case _OVERFLOW: SbxBase::SetError( SbxERR_OVERFLOW ); break;
#endif
		default:		SbxBase::SetError( SbxERR_NOTIMP ); break;
	}
	return sal_True;
}
#endif

#endif // _USED


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

SbxValue::SbxValue() : SbxBase()
{
	aData.eType = SbxEMPTY;
}

SbxValue::SbxValue( SbxDataType t, void* p ) : SbxBase()
{
	int n = t & 0x0FFF;
	if( p )
		n |= SbxBYREF;
	if( n == SbxVARIANT )
		n = SbxEMPTY;
	else
		SetFlag( SBX_FIXED );
	if( p )
	switch( t & 0x0FFF )
	{
		case SbxINTEGER:	n |= SbxBYREF; aData.pInteger = (sal_Int16*) p; break;
		case SbxULONG64:	n |= SbxBYREF; aData.pULong64 = (SbxUINT64*) p; break;
		case SbxLONG64:
		case SbxCURRENCY:	n |= SbxBYREF; aData.pLong64 = (SbxINT64*) p; break;
		case SbxLONG:		n |= SbxBYREF; aData.pLong = (sal_Int32*) p; break;
		case SbxSINGLE:		n |= SbxBYREF; aData.pSingle = (float*) p; break;
		case SbxDATE:
		case SbxDOUBLE:		n |= SbxBYREF; aData.pDouble = (double*) p; break;
        case SbxSTRING:		n |= SbxBYREF; aData.pOUString = (::rtl::OUString*) p; break;
		case SbxERROR:
		case SbxUSHORT:
		case SbxBOOL:		n |= SbxBYREF; aData.pUShort = (sal_uInt16*) p; break;
		case SbxULONG:		n |= SbxBYREF; aData.pULong = (sal_uInt32*) p; break;
		case SbxCHAR:		n |= SbxBYREF; aData.pChar = (xub_Unicode*) p; break;
		case SbxBYTE:		n |= SbxBYREF; aData.pByte = (sal_uInt8*) p; break;
		case SbxINT:		n |= SbxBYREF; aData.pInt = (int*) p; break;
		case SbxOBJECT:
			aData.pObj = (SbxBase*) p;
			if( p )
				aData.pObj->AddRef();
			break;
		case SbxDECIMAL:
			aData.pDecimal = (SbxDecimal*) p;
			if( p )
				aData.pDecimal->addRef();
			break;
		default:
			DBG_ASSERT( sal_False, "Indication of an invalid pointer" );
			n = SbxNULL;
	}
	else
		memset( &aData, 0, sizeof( SbxValues ) );
	aData.eType = SbxDataType( n );
}

SbxValue::SbxValue( const SbxValue& r )
    : SvRefBase( r ), SbxBase( r )
{
	if( !r.CanRead() )
	{
		SetError( SbxERR_PROP_WRITEONLY );
		if( !IsFixed() )
			aData.eType = SbxNULL;
	}
	else
	{
		((SbxValue*) &r)->Broadcast( SBX_HINT_DATAWANTED );
		aData = r.aData;
		// Pointer kopieren, Referenzen inkrementieren
		switch( aData.eType )
		{
			case SbxSTRING:
				if( aData.pOUString )
					aData.pOUString = new ::rtl::OUString( *aData.pOUString );
				break;
			case SbxOBJECT:
				if( aData.pObj )
					aData.pObj->AddRef();
				break;
			case SbxDECIMAL:
				if( aData.pDecimal )
					aData.pDecimal->addRef();
				break;
			default: break;
		}
	}
}

SbxValue& SbxValue::operator=( const SbxValue& r )
{
	if( &r != this )
	{
		if( !CanWrite() )
			SetError( SbxERR_PROP_READONLY );
		else
		{
			// string -> byte array
			if( IsFixed() && (aData.eType == SbxOBJECT)
				&& aData.pObj && ( aData.pObj->GetType() == (SbxARRAY | SbxBYTE) )
				&& (r.aData.eType == SbxSTRING) )
			{
				::rtl::OUString aStr = r.GetString();
				SbxArray* pArr = StringToByteArray(aStr);
				PutObject(pArr);
				return *this;
			}
			// byte array -> string
			if( r.IsFixed() && (r.aData.eType == SbxOBJECT)
				&& r.aData.pObj && ( r.aData.pObj->GetType() == (SbxARRAY | SbxBYTE) )
				&& (aData.eType == SbxSTRING) )
			{
				SbxBase* pObj = r.GetObject();
				SbxArray* pArr = PTR_CAST(SbxArray, pObj);
				if( pArr )
				{
					::rtl::OUString aStr = ByteArrayToString( pArr );
					PutString(aStr);
					return *this;
				}
			}
			// Den Inhalt der Variablen auslesen
			SbxValues aNew;
			if( IsFixed() )
				// fest: dann muss der Typ stimmen
				aNew.eType = aData.eType;
			else if( r.IsFixed() )
				// Quelle fest: Typ uebernehmen
				aNew.eType = SbxDataType( r.aData.eType & 0x0FFF );
			else
				// beides Variant: dann isses egal
				aNew.eType = SbxVARIANT;
			if( r.Get( aNew ) )
				Put( aNew );
		}
	}
	return *this;
}

SbxValue::~SbxValue()
{
#ifndef C50
	Broadcast( SBX_HINT_DYING );
	SetFlag( SBX_WRITE );
	SbxValue::Clear();
#else
	// Provisorischer Fix fuer Solaris 5.0 Compiler Bug
	// bei Nutzung virtueller Vererbung. Virtuelle Calls
	// im Destruktor vermeiden. Statt Clear() zu rufen
	// moegliche Objekt-Referenzen direkt freigeben.
	if( aData.eType == SbxOBJECT )
	{
		if( aData.pObj && aData.pObj != this )
		{
			HACK(nicht bei Parent-Prop - sonst CyclicRef)
			SbxVariable *pThisVar = PTR_CAST(SbxVariable, this);
			sal_Bool bParentProp = pThisVar && 5345 ==
			( (sal_Int16) ( pThisVar->GetUserData() & 0xFFFF ) );
			if ( !bParentProp )
				aData.pObj->ReleaseRef();
		}
	}
	else if( aData.eType == SbxDECIMAL )
	{
		releaseDecimalPtr( aData.pDecimal );
	}
#endif
}

void SbxValue::Clear()
{
	switch( aData.eType )
	{
		case SbxNULL:
		case SbxEMPTY:
		case SbxVOID:
			break;
		case SbxSTRING:
			delete aData.pOUString; aData.pOUString = NULL;
			break;
		case SbxOBJECT:
			if( aData.pObj )
			{
				if( aData.pObj != this )
				{
					HACK(nicht bei Parent-Prop - sonst CyclicRef)
					SbxVariable *pThisVar = PTR_CAST(SbxVariable, this);
					sal_Bool bParentProp = pThisVar && 5345 ==
					( (sal_Int16) ( pThisVar->GetUserData() & 0xFFFF ) );
					if ( !bParentProp )
						aData.pObj->ReleaseRef();
				}
				aData.pObj = NULL;
			}
			break;
		case SbxDECIMAL:
			if( aData.eType == SbxDECIMAL )
				releaseDecimalPtr( aData.pDecimal );
			break;
		case SbxDATAOBJECT:
			aData.pData = NULL; break;
		default:
		{
			SbxValues aEmpty;
			memset( &aEmpty, 0, sizeof( SbxValues ) );
			aEmpty.eType = GetType();
			Put( aEmpty );
		}
	}
}

// Dummy

void SbxValue::Broadcast( sal_uIntPtr )
{}

//////////////////////////// Daten auslesen //////////////////////////////

// Ermitteln der "richtigen" Variablen. Falls es ein Objekt ist, wird
// entweder das Objekt selbst oder dessen Default-Property angesprochen.
// Falls die Variable eine Variable oder ein Objekt enthaelt, wird
// dieses angesprochen.

SbxValue* SbxValue::TheRealValue() const
{
	return TheRealValue( sal_True );
}

// #55226 Zusaetzliche Info transportieren
bool handleToStringForCOMObjects( SbxObject* pObj, SbxValue* pVal );	// sbunoobj.cxx

SbxValue* SbxValue::TheRealValue( sal_Bool bObjInObjError ) const
{
	SbxValue* p = (SbxValue*) this;
	for( ;; )
	{
		SbxDataType t = SbxDataType( p->aData.eType & 0x0FFF );
		if( t == SbxOBJECT )
		{
			// Der Block enthaelt ein Objekt oder eine Variable
			SbxObject* pObj = PTR_CAST(SbxObject,p->aData.pObj);
			if( pObj )
			{
				// Hat das Objekt eine Default-Property?
				SbxVariable* pDflt = pObj->GetDfltProperty();

				// Falls dies ein Objekt ist und sich selbst enthaelt,
				// koennen wir nicht darauf zugreifen
				// #55226# Die alte Bedingung, um einen Fehler zu setzen,
				// ist nicht richtig, da z.B. eine ganz normale Variant-
				// Variable mit Objekt davon betroffen sein kann, wenn ein
				// anderer Wert zugewiesen werden soll. Daher mit Flag.
				if( bObjInObjError && !pDflt &&
					((SbxValue*) pObj)->aData.eType == SbxOBJECT &&
					((SbxValue*) pObj)->aData.pObj == pObj )
				{
					bool bSuccess = handleToStringForCOMObjects( pObj, p );
					if( !bSuccess )
					{
						SetError( SbxERR_BAD_PROP_VALUE );
						p = NULL;
					}
				}
				else if( pDflt )
					p = pDflt;
				/* ALT:
				else
					p = pDflt ? pDflt : (SbxVariable*) pObj;
				*/
				break;
			}
			// Haben wir ein Array?
			SbxArray* pArray = PTR_CAST(SbxArray,p->aData.pObj);
			if( pArray )
			{
				// Ggf. Parameter holen
				SbxArray* pPar = NULL;
				SbxVariable* pVar = PTR_CAST(SbxVariable,p);
				if( pVar )
					pPar = pVar->GetParameters();
				if( pPar )
				{
					// Haben wir ein dimensioniertes Array?
					SbxDimArray* pDimArray = PTR_CAST(SbxDimArray,p->aData.pObj);
					if( pDimArray )
						p = pDimArray->Get( pPar );
					else
						p = pArray->Get( pPar->Get( 1 )->GetInteger() );
					break;
				}
			}
			// Sonst einen SbxValue annehmen
			SbxValue* pVal = PTR_CAST(SbxValue,p->aData.pObj);
			if( pVal )
				p = pVal;
			else
				break;
		}
		else
			break;
	}
	return p;
}

sal_Bool SbxValue::Get( SbxValues& rRes ) const
{
	sal_Bool bRes = sal_False;
	SbxError eOld = GetError();
	if( eOld != SbxERR_OK )
		ResetError();
	if( !CanRead() )
	{
		SetError( SbxERR_PROP_WRITEONLY );
		rRes.pObj = NULL;
	}
	else
	{
		// Falls nach einem Objekt oder einem VARIANT gefragt wird, nicht
		// die wahren Werte suchen
		SbxValue* p = (SbxValue*) this;
		if( rRes.eType != SbxOBJECT && rRes.eType != SbxVARIANT )
			p = TheRealValue();
		if( p )
		{
			p->Broadcast( SBX_HINT_DATAWANTED );
			switch( rRes.eType )
			{
				case SbxEMPTY:
				case SbxVOID:
				case SbxNULL:	 break;
				case SbxVARIANT: rRes = p->aData; break;
				case SbxINTEGER: rRes.nInteger = ImpGetInteger( &p->aData ); break;
				case SbxLONG:	 rRes.nLong = ImpGetLong( &p->aData ); break;
				case SbxSALINT64:	rRes.nInt64 = ImpGetInt64( &p->aData ); break;
				case SbxSALUINT64:	rRes.uInt64 = ImpGetUInt64( &p->aData ); break;
				case SbxSINGLE:	 rRes.nSingle = ImpGetSingle( &p->aData ); break;
				case SbxDOUBLE:	 rRes.nDouble = ImpGetDouble( &p->aData ); break;
				case SbxCURRENCY:rRes.nLong64 = ImpGetCurrency( &p->aData ); break;
				case SbxDECIMAL: rRes.pDecimal = ImpGetDecimal( &p->aData ); break;
				case SbxDATE:	 rRes.nDouble = ImpGetDate( &p->aData ); break;
				case SbxBOOL:
                    rRes.nUShort = sal::static_int_cast< sal_uInt16 >(
                        ImpGetBool( &p->aData ) );
                    break;
				case SbxCHAR:	 rRes.nChar = ImpGetChar( &p->aData ); break;
				case SbxBYTE:	 rRes.nByte = ImpGetByte( &p->aData ); break;
				case SbxUSHORT:	 rRes.nUShort = ImpGetUShort( &p->aData ); break;
				case SbxULONG:	 rRes.nULong = ImpGetULong( &p->aData ); break;
				case SbxLPSTR:
				case SbxSTRING:	 p->aPic = ImpGetString( &p->aData );
								 rRes.pOUString = &p->aPic; break;
				case SbxCoreSTRING:	p->aPic = ImpGetCoreString( &p->aData );
									rRes.pOUString = &p->aPic; break;
				case SbxINT:
#if SAL_TYPES_SIZEOFINT == 2
					rRes.nInt = (int) ImpGetInteger( &p->aData );
#else
					rRes.nInt = (int) ImpGetLong( &p->aData );
#endif
					break;
				case SbxUINT:
#if SAL_TYPES_SIZEOFINT == 2
					rRes.nUInt = (int) ImpGetUShort( &p->aData );
#else
					rRes.nUInt = (int) ImpGetULong( &p->aData );
#endif
					break;
				case SbxOBJECT:
					if( p->aData.eType == SbxOBJECT )
						rRes.pObj = p->aData.pObj;
					else
					{
						SetError( SbxERR_NO_OBJECT );
						rRes.pObj = NULL;
					}
					break;
				default:
					if( p->aData.eType == rRes.eType )
						rRes = p->aData;
					else
					{
						SetError( SbxERR_CONVERSION );
						rRes.pObj = NULL;
					}
			}
		}
		else
		{
			// Objekt enthielt sich selbst
			SbxDataType eTemp = rRes.eType;
			memset( &rRes, 0, sizeof( SbxValues ) );
			rRes.eType = eTemp;
		}
	}
	if( !IsError() )
	{
		bRes = sal_True;
		if( eOld != SbxERR_OK )
			SetError( eOld );
	}
	return bRes;
}

sal_Bool SbxValue::GetNoBroadcast( SbxValues& rRes )
{
	sal_uInt16 nFlags_ = GetFlags();
	SetFlag( SBX_NO_BROADCAST );
	sal_Bool bRes = Get( rRes );
	SetFlags( nFlags_ );
	return bRes;
}

const XubString& SbxValue::GetString() const
{
	SbxValues aRes;
	aRes.eType = SbxSTRING;
	if( Get( aRes ) )
		((SbxValue*) this)->aToolString = *aRes.pOUString;
	else
		((SbxValue*) this)->aToolString.Erase();

    return aToolString;
}

const XubString& SbxValue::GetCoreString() const
{
	SbxValues aRes;
	aRes.eType = SbxCoreSTRING;
	if( Get( aRes ) )
		((SbxValue*) this)->aToolString = *aRes.pOUString;
	else
		((SbxValue*) this)->aToolString.Erase();

    return aToolString;
}

::rtl::OUString SbxValue::GetOUString() const
{
    ::rtl::OUString aResult;
    SbxValues aRes;
    aRes.eType = SbxSTRING;
    if( Get( aRes ) )
        aResult = *aRes.pOUString;

    return aResult;
}

sal_Bool SbxValue::HasObject() const
{
	ErrCode eErr = GetError();
	SbxValues aRes;
	aRes.eType = SbxOBJECT;
	Get( aRes );
	SetError( eErr );
	return 0 != aRes.pObj;
}

sal_Bool SbxValue::GetBool() const
{
	SbxValues aRes;
	aRes.eType = SbxBOOL;
	Get( aRes );
	return sal_Bool( aRes.nUShort != 0 );
}

#define GET( g, e, t, m ) \
t SbxValue::g() const { SbxValues aRes(e); Get( aRes ); return aRes.m; }

GET( GetByte,     SbxBYTE,       sal_uInt8,             nByte )
GET( GetChar,     SbxCHAR,       xub_Unicode,           nChar )
GET( GetCurrency, SbxCURRENCY,   SbxINT64,         nLong64 )
GET( GetDate,     SbxDATE,       double,           nDouble )
GET( GetData,     SbxDATAOBJECT, void*,            pData )
GET( GetDouble,   SbxDOUBLE,     double,           nDouble )
GET( GetErr,      SbxERROR,      sal_uInt16,           nUShort )
GET( GetInt,      SbxINT,        int,              nInt )
GET( GetInteger,  SbxINTEGER,    sal_Int16,            nInteger )
GET( GetLong,     SbxLONG,       sal_Int32,            nLong )
GET( GetLong64,   SbxLONG64,     SbxINT64,         nLong64 )
GET( GetObject,   SbxOBJECT,     SbxBase*,         pObj )
GET( GetSingle,   SbxSINGLE,     float,            nSingle )
GET( GetULong,    SbxULONG,      sal_uInt32,           nULong )
GET( GetULong64,  SbxULONG64,    SbxUINT64,        nULong64 )
GET( GetUShort,   SbxUSHORT,     sal_uInt16,           nUShort )
GET( GetInt64,    SbxSALINT64,   sal_Int64,        nInt64 )
GET( GetUInt64,   SbxSALUINT64,  sal_uInt64,       uInt64 )
GET( GetDecimal,  SbxDECIMAL,    SbxDecimal*,      pDecimal )


//////////////////////////// Daten schreiben /////////////////////////////

sal_Bool SbxValue::Put( const SbxValues& rVal )
{
	sal_Bool bRes = sal_False;
	SbxError eOld = GetError();
	if( eOld != SbxERR_OK )
		ResetError();
	if( !CanWrite() )
		SetError( SbxERR_PROP_READONLY );
	else if( rVal.eType & 0xF000 )
		SetError( SbxERR_NOTIMP );
	else
	{
		// Falls nach einem Objekt gefragt wird, nicht
		// die wahren Werte suchen
		SbxValue* p = this;
		if( rVal.eType != SbxOBJECT )
			p = TheRealValue( sal_False );	// #55226 Hier keinen Fehler erlauben
		if( p )
		{
			if( !p->CanWrite() )
				SetError( SbxERR_PROP_READONLY );
			else if( p->IsFixed() || p->SetType( (SbxDataType) ( rVal.eType & 0x0FFF ) ) )
			  switch( rVal.eType & 0x0FFF )
			{
				case SbxEMPTY:
				case SbxVOID:
				case SbxNULL:		break;
				case SbxINTEGER:	ImpPutInteger( &p->aData, rVal.nInteger ); break;
				case SbxLONG:		ImpPutLong( &p->aData, rVal.nLong ); break;
				case SbxSALINT64:	ImpPutInt64( &p->aData, rVal.nInt64 ); break;
				case SbxSALUINT64:	ImpPutUInt64( &p->aData, rVal.uInt64 ); break;
				case SbxSINGLE:		ImpPutSingle( &p->aData, rVal.nSingle ); break;
				case SbxDOUBLE:		ImpPutDouble( &p->aData, rVal.nDouble ); break;
				case SbxCURRENCY:	ImpPutCurrency( &p->aData, rVal.nLong64 ); break;
				case SbxDECIMAL:	ImpPutDecimal( &p->aData, rVal.pDecimal ); break;
				case SbxDATE:		ImpPutDate( &p->aData, rVal.nDouble ); break;
				case SbxBOOL:		ImpPutBool( &p->aData, rVal.nInteger ); break;
				case SbxCHAR:		ImpPutChar( &p->aData, rVal.nChar ); break;
				case SbxBYTE:		ImpPutByte( &p->aData, rVal.nByte ); break;
				case SbxUSHORT:		ImpPutUShort( &p->aData, rVal.nUShort ); break;
				case SbxULONG:		ImpPutULong( &p->aData, rVal.nULong ); break;
				case SbxLPSTR:
				case SbxSTRING:		ImpPutString( &p->aData, rVal.pOUString ); break;
				case SbxINT:
#if SAL_TYPES_SIZEOFINT == 2
					ImpPutInteger( &p->aData, (sal_Int16) rVal.nInt );
#else
					ImpPutLong( &p->aData, (sal_Int32) rVal.nInt );
#endif
					break;
				case SbxUINT:
#if SAL_TYPES_SIZEOFINT == 2
					ImpPutUShort( &p->aData, (sal_uInt16) rVal.nUInt );
#else
					ImpPutULong( &p->aData, (sal_uInt32) rVal.nUInt );
#endif
					break;
				case SbxOBJECT:
					if( !p->IsFixed() || p->aData.eType == SbxOBJECT )
					{
						// ist schon drin
						if( p->aData.eType == SbxOBJECT && p->aData.pObj == rVal.pObj )
							break;

						// Nur den Werteteil loeschen!
						p->SbxValue::Clear();

						// eingentliche Zuweisung
						p->aData.pObj = rVal.pObj;

						// ggf. Ref-Count mitzaehlen
						if( p->aData.pObj && p->aData.pObj != p )
						{
							if ( p != this )
                            {
								DBG_ERROR( "TheRealValue" );
                            }
							HACK(nicht bei Parent-Prop - sonst CyclicRef)
							SbxVariable *pThisVar = PTR_CAST(SbxVariable, this);
							sal_Bool bParentProp = pThisVar && 5345 ==
									( (sal_Int16) ( pThisVar->GetUserData() & 0xFFFF ) );
							if ( !bParentProp )
								p->aData.pObj->AddRef();
						}
					}
					else
						SetError( SbxERR_CONVERSION );
					break;
				default:
					if( p->aData.eType == rVal.eType )
						p->aData = rVal;
					else
					{
						SetError( SbxERR_CONVERSION );
						if( !p->IsFixed() )
							p->aData.eType = SbxNULL;
					}
			}
			if( !IsError() )
			{
				p->SetModified( sal_True );
				p->Broadcast( SBX_HINT_DATACHANGED );
				if( eOld != SbxERR_OK )
					SetError( eOld );
				bRes = sal_True;
			}
		}
	}
	return bRes;
}

// AB, 28.3.96:
// Methode, um bei speziellen Typen eine Vorbehandlung des Strings
// durchzufuehren. Insbesondere erforderlich fuer BASIC-IDE, damit
// die Ausgaben im Watch-Fenster mit PutStringExt zurueckgeschrieben
// werden koennen, wenn Floats mit ',' als Dezimaltrenner oder BOOLs
// explizit mit "TRUE" oder "FALSE" angegeben werden.
// Implementierung in ImpConvStringExt (SBXSCAN.CXX)
sal_Bool SbxValue::PutStringExt( const ::rtl::OUString& r )
{
	// Kopieren, bei Unicode gleich konvertieren
	::rtl::OUString aStr( r );

	// Eigenen Typ bestimmen (nicht wie in Put() mit TheRealValue(),
	// Objekte werden sowieso nicht behandelt)
	SbxDataType eTargetType = SbxDataType( aData.eType & 0x0FFF );

	// Source-Value basteln
	SbxValues aRes;
	aRes.eType = SbxSTRING;

	// Nur, wenn wirklich was konvertiert wurde, Kopie nehmen,
	// sonst Original (Unicode bleibt erhalten)
	sal_Bool bRet;
	if( ImpConvStringExt( aStr, eTargetType ) )
		aRes.pOUString = (::rtl::OUString*)&aStr;
	else
		aRes.pOUString = (::rtl::OUString*)&r;

	// #34939: Bei Strings. die eine Zahl enthalten und wenn this einen
	// Num-Typ hat, Fixed-Flag setzen, damit der Typ nicht veraendert wird
	sal_uInt16 nFlags_ = GetFlags();
	if( ( eTargetType >= SbxINTEGER && eTargetType <= SbxCURRENCY ) ||
		( eTargetType >= SbxCHAR && eTargetType <= SbxUINT ) ||
		eTargetType == SbxBOOL )
	{
		SbxValue aVal;
		aVal.Put( aRes );
		if( aVal.IsNumeric() )
			SetFlag( SBX_FIXED );
	}

	Put( aRes );
	bRet = sal_Bool( !IsError() );

	// Falls das mit dem FIXED einen Error gegeben hat, zuruecksetzen
	// (UI-Aktion sollte keinen Error ergeben, sondern nur scheitern)
	if( !bRet )
		ResetError();

	SetFlags( nFlags_ );
	return bRet;
}

sal_Bool SbxValue::PutString( const xub_Unicode* p )
{
	::rtl::OUString aVal( p );
	SbxValues aRes;
	aRes.eType = SbxSTRING;
	aRes.pOUString = &aVal;
	Put( aRes );
	return sal_Bool( !IsError() );
}

sal_Bool SbxValue::PutBool( sal_Bool b )
{
	SbxValues aRes;
	aRes.eType = SbxBOOL;
	aRes.nUShort = sal::static_int_cast< sal_uInt16 >(b ? SbxTRUE : SbxFALSE);
	Put( aRes );
	return sal_Bool( !IsError() );
}

sal_Bool SbxValue::PutEmpty()
{
	sal_Bool bRet = SetType( SbxEMPTY );
		SetModified( sal_True );
	return bRet;
}

sal_Bool SbxValue::PutNull()
{
	sal_Bool bRet = SetType( SbxNULL );
	if( bRet )
		SetModified( sal_True );
	return bRet;
}


// Special decimal methods
sal_Bool SbxValue::PutDecimal( com::sun::star::bridge::oleautomation::Decimal& rAutomationDec )
{
	SbxValue::Clear();
	aData.pDecimal = new SbxDecimal( rAutomationDec );
	aData.pDecimal->addRef();
	aData.eType = SbxDECIMAL;
	return sal_True;
}

sal_Bool SbxValue::fillAutomationDecimal
	( com::sun::star::bridge::oleautomation::Decimal& rAutomationDec )
{
	SbxDecimal* pDecimal = GetDecimal();
	if( pDecimal != NULL )
	{
		pDecimal->fillAutomationDecimal( rAutomationDec );
		return sal_True;
	}
	return sal_False;
}


sal_Bool SbxValue::PutpChar( const xub_Unicode* p )
{
	::rtl::OUString aVal( p );
	SbxValues aRes;
	aRes.eType = SbxLPSTR;
	aRes.pOUString = &aVal;
	Put( aRes );
	return sal_Bool( !IsError() );
}

sal_Bool SbxValue::PutString( const ::rtl::OUString& r )
{
	SbxValues aRes;
	aRes.eType = SbxSTRING;
	aRes.pOUString = (::rtl::OUString*) &r;
	Put( aRes );
	return sal_Bool( !IsError() );
}


#define PUT( p, e, t, m ) \
sal_Bool SbxValue::p( t n ) \
{ SbxValues aRes(e); aRes.m = n; Put( aRes ); return sal_Bool( !IsError() ); }

PUT( PutByte,     SbxBYTE,       sal_uInt8,             nByte )
PUT( PutChar,     SbxCHAR,       xub_Unicode,      nChar )
PUT( PutCurrency, SbxCURRENCY,   const SbxINT64&,  nLong64 )
PUT( PutDate,     SbxDATE,       double,           nDouble )
PUT( PutData,     SbxDATAOBJECT, void*,            pData )
PUT( PutDouble,   SbxDOUBLE,     double,           nDouble )
PUT( PutErr,      SbxERROR,      sal_uInt16,           nUShort )
PUT( PutInt,      SbxINT,        int,              nInt )
PUT( PutInteger,  SbxINTEGER,    sal_Int16,            nInteger )
PUT( PutLong,     SbxLONG,       sal_Int32,            nLong )
PUT( PutLong64,   SbxLONG64,     const SbxINT64&,  nLong64 )
PUT( PutObject,   SbxOBJECT,     SbxBase*,         pObj )
PUT( PutSingle,   SbxSINGLE,     float,            nSingle )
PUT( PutULong,    SbxULONG,      sal_uInt32,           nULong )
PUT( PutULong64,  SbxULONG64,    const SbxUINT64&, nULong64 )
PUT( PutUShort,   SbxUSHORT,     sal_uInt16,           nUShort )
PUT( PutInt64,    SbxSALINT64,   sal_Int64,        nInt64 )
PUT( PutUInt64,   SbxSALUINT64,  sal_uInt64,       uInt64 )
PUT( PutDecimal,  SbxDECIMAL,    SbxDecimal*,      pDecimal )


////////////////////////// Setzen des Datentyps ///////////////////////////

sal_Bool SbxValue::IsFixed() const
{
	return ( (GetFlags() & SBX_FIXED) | (aData.eType & SbxBYREF) ) != 0;
}

// Eine Variable ist numerisch, wenn sie EMPTY oder wirklich numerisch ist
// oder einen vollstaendig konvertierbaren String enthaelt

// #41692, fuer RTL und Basic-Core getrennt implementieren
sal_Bool SbxValue::IsNumeric() const
{
	return ImpIsNumeric( /*bOnlyIntntl*/sal_False );
}

sal_Bool SbxValue::IsNumericRTL() const
{
	return ImpIsNumeric( /*bOnlyIntntl*/sal_True );
}

sal_Bool SbxValue::ImpIsNumeric( sal_Bool bOnlyIntntl ) const
{

	if( !CanRead() )
	{
		SetError( SbxERR_PROP_WRITEONLY ); return sal_False;
	}
	// Downcast pruefen!!!
	if( this->ISA(SbxVariable) )
		((SbxVariable*)this)->Broadcast( SBX_HINT_DATAWANTED );
	SbxDataType t = GetType();
	if( t == SbxSTRING )
	{
		if( aData.pOUString )
		{
			::rtl::OUString s( *aData.pOUString );
			double n;
			SbxDataType t2;
			sal_uInt16 nLen = 0;
			if( ImpScan( s, n, t2, &nLen, /*bAllowIntntl*/sal_False, bOnlyIntntl ) == SbxERR_OK )
				return sal_Bool( nLen == s.getLength() );
		}
		return sal_False;
	}
	else
		return sal_Bool( t == SbxEMPTY
			|| ( t >= SbxINTEGER && t <= SbxCURRENCY )
			|| ( t >= SbxCHAR && t <= SbxUINT ) );
}

SbxClassType SbxValue::GetClass() const
{
	return SbxCLASS_VALUE;
}

SbxDataType SbxValue::GetType() const
{
	return SbxDataType( aData.eType & 0x0FFF );
}

SbxDataType SbxValue::GetFullType() const
{
	return aData.eType;
}

sal_Bool SbxValue::SetType( SbxDataType t )
{
	DBG_ASSERT( !( t & 0xF000 ), "Setzen von BYREF|ARRAY verboten!" );
	if( ( t == SbxEMPTY && aData.eType == SbxVOID )
	 || ( aData.eType == SbxEMPTY && t == SbxVOID ) )
		return sal_True;
	if( ( t & 0x0FFF ) == SbxVARIANT )
	{
		// Versuch, den Datentyp auf Variant zu setzen
		ResetFlag( SBX_FIXED );
		if( IsFixed() )
		{
			SetError( SbxERR_CONVERSION ); return sal_False;
		}
		t = SbxEMPTY;
	}
	if( ( t & 0x0FFF ) != ( aData.eType & 0x0FFF ) )
	{
		if( !CanWrite() || IsFixed() )
		{
			SetError( SbxERR_CONVERSION ); return sal_False;
		}
		else
		{
			// Eventuelle Objekte freigeben
			switch( aData.eType )
			{
				case SbxSTRING:
					delete aData.pOUString;
					break;
				case SbxOBJECT:
					if( aData.pObj && aData.pObj != this )
					{
						HACK(nicht bei Parent-Prop - sonst CyclicRef)
						SbxVariable *pThisVar = PTR_CAST(SbxVariable, this);
						sal_uInt16 nSlotId = pThisVar
									? ( (sal_Int16) ( pThisVar->GetUserData() & 0xFFFF ) )
									: 0;
						DBG_ASSERT( nSlotId != 5345 || pThisVar->GetName() == UniString::CreateFromAscii( "Parent" ),
									"SID_PARENTOBJECT heisst nicht 'Parent'" );
						sal_Bool bParentProp = 5345 == nSlotId;
						if ( !bParentProp )
							aData.pObj->ReleaseRef();
					}
					break;
				default: break;
			}
			// Das klappt immer, da auch die Float-Repraesentationen 0 sind.
			memset( &aData, 0, sizeof( SbxValues ) );
			aData.eType = t;
		}
	}
	return sal_True;
}

sal_Bool SbxValue::Convert( SbxDataType eTo )
{
	eTo = SbxDataType( eTo & 0x0FFF );
	if( ( aData.eType & 0x0FFF ) == eTo )
		return sal_True;
	if( !CanWrite() )
		return sal_False;
	if( eTo == SbxVARIANT )
	{
		// Versuch, den Datentyp auf Variant zu setzen
		ResetFlag( SBX_FIXED );
		if( IsFixed() )
		{
			SetError( SbxERR_CONVERSION ); return sal_False;
		}
		else
			return sal_True;
	}
	// Convert from Null geht niemals. Einmal Null, immer Null!
	if( aData.eType == SbxNULL )
	{
		SetError( SbxERR_CONVERSION ); return sal_False;
	}

	// Konversion der Daten:
	SbxValues aNew;
	aNew.eType = eTo;
	if( Get( aNew ) )
	{
		// Der Datentyp konnte konvertiert werden. Bei Fixed-Elementen
		// ist hier Ende, da die Daten nicht uebernommen zu werden brauchen
		if( !IsFixed() )
		{
			SetType( eTo );
			Put( aNew );
			SetModified( sal_True );
		}
		Broadcast( SBX_HINT_CONVERTED );
		return sal_True;
	}
	else
		return sal_False;
}
////////////////////////////////// Rechnen /////////////////////////////////

sal_Bool SbxValue::Compute( SbxOperator eOp, const SbxValue& rOp )
{
	bool bVBAInterop =  SbiRuntime::isVBAEnabled();

	SbxDataType eThisType = GetType();
	SbxDataType eOpType = rOp.GetType();
	SbxError eOld = GetError();
	if( eOld != SbxERR_OK )
		ResetError();
	if( !CanWrite() )
		SetError( SbxERR_PROP_READONLY );
	else if( !rOp.CanRead() )
		SetError( SbxERR_PROP_WRITEONLY );
	// Sonderregel 1: Ist ein Operand Null, ist das Ergebnis Null
	else if( eThisType == SbxNULL || eOpType == SbxNULL )
		SetType( SbxNULL );
	// Sonderregel 2: Ist ein Operand Empty, ist das Ergebnis der 2. Operand
	else if( eThisType == SbxEMPTY
	&& !bVBAInterop
	)
		*this = rOp;
	// 13.2.96: Nicht schon vor Get auf SbxEMPTY pruefen
	else
	{
		SbxValues aL, aR;
		bool bDecimal = false;
		if( bVBAInterop && ( ( eThisType == SbxSTRING && eOpType != SbxSTRING ) ||
			 ( eThisType != SbxSTRING && eOpType == SbxSTRING ) ) &&
			 ( eOp == SbxMUL || eOp == SbxDIV || eOp == SbxPLUS || eOp == SbxMINUS ) )
		{
			goto Lbl_OpIsDouble;
		}
		else if( eThisType == SbxSTRING || eOp == SbxCAT || ( bVBAInterop && ( eOpType == SbxSTRING ) && (  eOp == SbxPLUS ) ) )
		{
			if( eOp == SbxCAT || eOp == SbxPLUS )
			{
				// AB 5.11.1999, OUString beruecksichtigen
				aL.eType = aR.eType = SbxSTRING;
				rOp.Get( aR );
				// AB 8.12.1999, #70399: Hier wieder GetType() rufen, Get() kann Typ aendern!
				if( rOp.GetType() == SbxEMPTY )
					goto Lbl_OpIsEmpty;
				Get( aL );

				// #30576: Erstmal testen, ob Wandlung geklappt hat
				if( aL.pOUString != NULL && aR.pOUString != NULL )
				{
					*aL.pOUString += *aR.pOUString;
				}
				// Nicht einmal Left OK?
				else if( aL.pOUString == NULL )
				{
					aL.pOUString = new ::rtl::OUString();
				}
				Put( aL );
			}
			else
				SetError( SbxERR_CONVERSION );
		}
		else if( eOpType == SbxSTRING && rOp.IsFixed() )
		{	// Numerisch: rechts darf kein String stehen
			SetError( SbxERR_CONVERSION );
		}
		else if( ( eOp >= SbxIDIV && eOp <= SbxNOT ) || eOp == SbxMOD )
		{
			if( GetType() == eOpType )
			{
				if( GetType() == SbxULONG64
					|| GetType() == SbxLONG64
					|| GetType() == SbxCURRENCY
					|| GetType() == SbxULONG )
					aL.eType = aR.eType = GetType();
//				else if( GetType() == SbxDouble || GetType() == SbxSingle )
//					aL.eType = aR.eType = SbxLONG64;
				else
					aL.eType = aR.eType = SbxLONG;
			}
			else if( GetType() == SbxCURRENCY || eOpType == SbxCURRENCY
					 || GetType() == SbxULONG64 || eOpType == SbxULONG64
					 || GetType() == SbxLONG64 || eOpType == SbxLONG64 )
				aL.eType = aR.eType = SbxLONG64;
//			else if( GetType() == SbxDouble || rOP.GetType() == SbxDouble
//			         || GetType() == SbxSingle || rOP.GetType() == SbxSingle )
//				aL.eType = aR.eType = SbxLONG64;
			else
				aL.eType = aR.eType = SbxLONG;

			if( rOp.Get( aR ) )
			{
				if( rOp.GetType() == SbxEMPTY )
				{
					if ( !bVBAInterop || ( bVBAInterop && ( eOp != SbxNOT  ) ) )
						goto Lbl_OpIsEmpty;
				}
				if( Get( aL ) ) switch( eOp )
				{
					case SbxIDIV:
						if( aL.eType == SbxCURRENCY )
							aL.eType = SbxLONG64;
						if( aL.eType == SbxLONG64 )
							if( !aR.nLong64 ) SetError( SbxERR_ZERODIV );
							else aL.nLong64 /= aR.nLong64;
						else if( aL.eType == SbxULONG64 )
							if( !aR.nULong64 ) SetError( SbxERR_ZERODIV );
							else aL.nULong64 /= aR.nULong64;
						else if( aL.eType == SbxLONG )
							if( !aR.nLong ) SetError( SbxERR_ZERODIV );
							else aL.nLong /= aR.nLong;
						else
							if( !aR.nULong ) SetError( SbxERR_ZERODIV );
							else aL.nULong /= aR.nULong;
						break;
					case SbxMOD:
						if( aL.eType == SbxCURRENCY )
							aL.eType = SbxLONG64;
						if( aL.eType == SbxLONG64 )
							if( !aR.nLong64 ) SetError( SbxERR_ZERODIV );
							else aL.nLong64 %= aR.nLong64;
						else if( aL.eType == SbxULONG64 )
							if( !aR.nULong64 ) SetError( SbxERR_ZERODIV );
							else aL.nULong64 %= aR.nULong64;
						else if( aL.eType == SbxLONG )
							if( !aR.nLong ) SetError( SbxERR_ZERODIV );
							else aL.nLong %= aR.nLong;
						else
							if( !aR.nULong ) SetError( SbxERR_ZERODIV );
							else aL.nULong %= aR.nULong;
						break;
					case SbxAND:
						if( aL.eType != SbxLONG && aL.eType != SbxULONG )
							aL.nLong64 &= aR.nLong64;
						else
							aL.nLong &= aR.nLong;
						break;
					case SbxOR:
						if( aL.eType != SbxLONG && aL.eType != SbxULONG )
							aL.nLong64 |= aR.nLong64;
						else
							aL.nLong |= aR.nLong;
						break;
					case SbxXOR:
						if( aL.eType != SbxLONG && aL.eType != SbxULONG )
							aL.nLong64 ^= aR.nLong64;
						else
							aL.nLong ^= aR.nLong;
						break;
					case SbxEQV:
						if( aL.eType != SbxLONG && aL.eType != SbxULONG )
							aL.nLong64 = (aL.nLong64 & aR.nLong64) | (~aL.nLong64 & ~aR.nLong64);
						else
							aL.nLong = (aL.nLong & aR.nLong) | (~aL.nLong & ~aR.nLong);
						break;
					case SbxIMP:
						if( aL.eType != SbxLONG && aL.eType != SbxULONG )
							aL.nLong64 = ~aL.nLong64 | aR.nLong64;
						else
							aL.nLong = ~aL.nLong | aR.nLong;
						break;
					case SbxNOT:
						if( aL.eType != SbxLONG && aL.eType != SbxULONG )
							aL.nLong64 = ~aL.nLong64;
						else
							aL.nLong = ~aL.nLong;
						break;
					default: break;
				}
			}
		}
		else if( ( GetType() == SbxDECIMAL || rOp.GetType() == SbxDECIMAL ) &&
			     ( eOp == SbxMUL || eOp == SbxDIV || eOp == SbxPLUS || eOp == SbxMINUS || eOp == SbxNEG ) )
		{
			aL.eType = aR.eType = SbxDECIMAL;
			bDecimal = true;
			if( rOp.Get( aR ) )
			{
				if( rOp.GetType() == SbxEMPTY )
				{
					releaseDecimalPtr( aL.pDecimal );
					goto Lbl_OpIsEmpty;
				}
				if( Get( aL ) )
				{
					if( aL.pDecimal && aR.pDecimal )
					{
						bool bOk = true;
						switch( eOp )
						{
							case SbxMUL:
								bOk = ( *(aL.pDecimal) *= *(aR.pDecimal) );
								break;
							case SbxDIV:
								if( aR.pDecimal->isZero() )
									SetError( SbxERR_ZERODIV );
								else
									bOk = ( *(aL.pDecimal) /= *(aR.pDecimal) );
								break;
							case SbxPLUS:
								bOk = ( *(aL.pDecimal) += *(aR.pDecimal) );
								break;
							case SbxMINUS:
								bOk = ( *(aL.pDecimal) -= *(aR.pDecimal) );
								break;
							case SbxNEG:
								bOk = ( aL.pDecimal->neg() );
								break;
							default:
								SetError( SbxERR_NOTIMP );
						}
						if( !bOk )
							SetError( SbxERR_OVERFLOW );
					}
					else
					{
						SetError( SbxERR_CONVERSION );
					}
				}
			}
		}
		else if( GetType() == SbxCURRENCY || rOp.GetType() == SbxCURRENCY )
		{
			aL.eType = SbxCURRENCY;
			aR.eType = SbxCURRENCY;

			if( rOp.Get( aR ) )
			{
				static BigInt n10K( 10000 );

				if( rOp.GetType() == SbxEMPTY )
					goto Lbl_OpIsEmpty;

				if( Get( aL ) ) switch( eOp )
				{
					case SbxMUL:
					{
						// #i20704 Implement directly
						BigInt b1( aL.nLong64 );
						BigInt b2( aR.nLong64 );
						b1 *= b2;
						b1 /= n10K;
						double d = double( b1 ) / 10000.0;
						if( d > SbxMAXCURR || d < SbxMINCURR )
							SetError( SbxERR_OVERFLOW );
						else
							b1.INT64( &aL.nLong64 );
						break;
					}
					case SbxDIV:
						if( !aR.nLong64 )
						{
							SetError( SbxERR_ZERODIV );
						}
						else
						{
							// #i20704 Implement directly
							BigInt b1( aL.nLong64 );
							BigInt b2( aR.nLong64 );
							b1 *= n10K;
							b1 /= b2;
							double d = double( b1 ) / 10000.0;
							if( d > SbxMAXCURR || d < SbxMINCURR )
								SetError( SbxERR_OVERFLOW );
							else
								b1.INT64( &aL.nLong64 );
						}
						break;
					case SbxPLUS:
						aL.nLong64 += aR.nLong64; break;
					case SbxMINUS:
						aL.nLong64 -= aR.nLong64; break;
					case SbxNEG:
						aL.nLong64 = -aL.nLong64; break;
					default:
						SetError( SbxERR_NOTIMP );
				}
			}
		}
		else
Lbl_OpIsDouble:
		{	// Andere Operatoren
			aL.eType = aR.eType = SbxDOUBLE;
			if( rOp.Get( aR ) )
			{
				if( rOp.GetType() == SbxEMPTY )
				{
					if ( !bVBAInterop || ( bVBAInterop && ( eOp != SbxNEG ) ) )
						goto Lbl_OpIsEmpty;
				}
				if( Get( aL ) )
				{
					switch( eOp )
					{
						case SbxEXP:
							aL.nDouble = pow( aL.nDouble, aR.nDouble );
							break;
						case SbxMUL:
							aL.nDouble *= aR.nDouble; break;
						case SbxDIV:
							if( !aR.nDouble ) SetError( SbxERR_ZERODIV );
							else aL.nDouble /= aR.nDouble; break;
						case SbxPLUS:
							aL.nDouble += aR.nDouble; break;
						case SbxMINUS:
							aL.nDouble -= aR.nDouble; break;
						case SbxNEG:
							aL.nDouble = -aL.nDouble; break;
						default:
							SetError( SbxERR_NOTIMP );
					}

					// #45465 Date braucht bei + eine Spezial-Behandlung
					if( eOp == SbxPLUS && (GetType() == SbxDATE || rOp.GetType() == SbxDATE ) )
						aL.eType = SbxDATE;
				}
			}

		}
		if( !IsError() )
			Put( aL );
		if( bDecimal )
		{
			releaseDecimalPtr( aL.pDecimal );
			releaseDecimalPtr( aR.pDecimal );
		}
	}
Lbl_OpIsEmpty:

	sal_Bool bRes = sal_Bool( !IsError() );
	if( bRes && eOld != SbxERR_OK )
		SetError( eOld );
	return bRes;
}

// Die Vergleichs-Routine liefert sal_True oder sal_False.

sal_Bool SbxValue::Compare( SbxOperator eOp, const SbxValue& rOp ) const
{
	bool bVBAInterop =  SbiRuntime::isVBAEnabled();

	sal_Bool bRes = sal_False;
	SbxError eOld = GetError();
	if( eOld != SbxERR_OK )
		ResetError();
	if( !CanRead() || !rOp.CanRead() )
		SetError( SbxERR_PROP_WRITEONLY );
	else if( GetType() == SbxNULL && rOp.GetType() == SbxNULL && !bVBAInterop )
    {
		bRes = sal_True;
    }
	else if( GetType() == SbxEMPTY && rOp.GetType() == SbxEMPTY )
		bRes = !bVBAInterop ? sal_True : ( eOp == SbxEQ ? sal_True : sal_False );
	// Sonderregel 1: Ist ein Operand Null, ist das Ergebnis FALSE
	else if( GetType() == SbxNULL || rOp.GetType() == SbxNULL )
		bRes = sal_False;
	// Sonderregel 2: Wenn beide Variant sind und einer ist numerisch,
	// und der andere ein String, ist num < str
	else if( !IsFixed() && !rOp.IsFixed()
	 && ( rOp.GetType() == SbxSTRING && GetType() != SbxSTRING && IsNumeric() ) && !bVBAInterop
	)
		bRes = sal_Bool( eOp == SbxLT || eOp == SbxLE || eOp == SbxNE );
	else if( !IsFixed() && !rOp.IsFixed()
	 && ( GetType() == SbxSTRING && rOp.GetType() != SbxSTRING && rOp.IsNumeric() )
&& !bVBAInterop
	)
		bRes = sal_Bool( eOp == SbxGT || eOp == SbxGE || eOp == SbxNE );
	else
	{
		SbxValues aL, aR;
		// Wenn einer der Operanden ein String ist,
		// findet ein Stringvergleich statt
		if( GetType() == SbxSTRING || rOp.GetType() == SbxSTRING )
		{
			aL.eType = aR.eType = SbxSTRING;
			if( Get( aL ) && rOp.Get( aR ) ) switch( eOp )
			{
				case SbxEQ:
					bRes = sal_Bool( *aL.pOUString == *aR.pOUString ); break;
				case SbxNE:
					bRes = sal_Bool( *aL.pOUString != *aR.pOUString ); break;
				case SbxLT:
					bRes = sal_Bool( *aL.pOUString <  *aR.pOUString ); break;
				case SbxGT:
					bRes = sal_Bool( *aL.pOUString >  *aR.pOUString ); break;
				case SbxLE:
					bRes = sal_Bool( *aL.pOUString <= *aR.pOUString ); break;
				case SbxGE:
					bRes = sal_Bool( *aL.pOUString >= *aR.pOUString ); break;
				default:
					SetError( SbxERR_NOTIMP );
			}
		}
		// AB 19.12.95: Wenn SbxSINGLE beteiligt, auf SINGLE konvertieren,
		//				sonst gibt es numerische Fehler
		else if( GetType() == SbxSINGLE || rOp.GetType() == SbxSINGLE )
		{
			aL.eType = aR.eType = SbxSINGLE;
			if( Get( aL ) && rOp.Get( aR ) )
			  switch( eOp )
			{
				case SbxEQ:
					bRes = sal_Bool( aL.nSingle == aR.nSingle ); break;
				case SbxNE:
					bRes = sal_Bool( aL.nSingle != aR.nSingle ); break;
				case SbxLT:
					bRes = sal_Bool( aL.nSingle <  aR.nSingle ); break;
				case SbxGT:
					bRes = sal_Bool( aL.nSingle >  aR.nSingle ); break;
				case SbxLE:
					bRes = sal_Bool( aL.nSingle <= aR.nSingle ); break;
				case SbxGE:
					bRes = sal_Bool( aL.nSingle >= aR.nSingle ); break;
				default:
					SetError( SbxERR_NOTIMP );
			}
		}
		else if( GetType() == SbxDECIMAL && rOp.GetType() == SbxDECIMAL )
		{
			aL.eType = aR.eType = SbxDECIMAL;
			Get( aL );
			rOp.Get( aR );
			if( aL.pDecimal && aR.pDecimal )
			{
				SbxDecimal::CmpResult eRes = compare( *aL.pDecimal, *aR.pDecimal );
				switch( eOp )
				{
					case SbxEQ:
						bRes = sal_Bool( eRes == SbxDecimal::EQ ); break;
					case SbxNE:
						bRes = sal_Bool( eRes != SbxDecimal::EQ ); break;
					case SbxLT:
						bRes = sal_Bool( eRes == SbxDecimal::LT ); break;
					case SbxGT:
						bRes = sal_Bool( eRes == SbxDecimal::GT ); break;
					case SbxLE:
						bRes = sal_Bool( eRes != SbxDecimal::GT ); break;
					case SbxGE:
						bRes = sal_Bool( eRes != SbxDecimal::LT ); break;
					default:
						SetError( SbxERR_NOTIMP );
				}
			}
			else
			{
				SetError( SbxERR_CONVERSION );
			}
			releaseDecimalPtr( aL.pDecimal );
			releaseDecimalPtr( aR.pDecimal );
		}
		// Alles andere auf SbxDOUBLE-Basis vergleichen
		else
		{
			aL.eType = aR.eType = SbxDOUBLE;
			//if( Get( aL ) && rOp.Get( aR ) )
			bool bGetL = Get( aL );
			bool bGetR = rOp.Get( aR );
			if( bGetL && bGetR )
			  switch( eOp )
			{
				case SbxEQ:
					bRes = sal_Bool( aL.nDouble == aR.nDouble ); break;
				case SbxNE:
					bRes = sal_Bool( aL.nDouble != aR.nDouble ); break;
				case SbxLT:
					bRes = sal_Bool( aL.nDouble <  aR.nDouble ); break;
				case SbxGT:
					bRes = sal_Bool( aL.nDouble >  aR.nDouble ); break;
				case SbxLE:
					bRes = sal_Bool( aL.nDouble <= aR.nDouble ); break;
				case SbxGE:
					bRes = sal_Bool( aL.nDouble >= aR.nDouble ); break;
				default:
					SetError( SbxERR_NOTIMP );
			}
			// at least one value was got
			// if this is VBA then a conversion error for one
			// side will yield a false result of an equality test
			else if ( bGetR || bGetL )
			{
				if ( bVBAInterop && eOp == SbxEQ && GetError() == SbxERR_CONVERSION )
				{
					ResetError();
					bRes = sal_False;
				}
			}
		}
	}
	if( eOld != SbxERR_OK )
		SetError( eOld );
	return bRes;
}

///////////////////////////// Lesen/Schreiben ////////////////////////////

sal_Bool SbxValue::LoadData( SvStream& r, sal_uInt16 )
{
	SbxValue::Clear();
	sal_uInt16 nType;
	r >> nType;
	aData.eType = SbxDataType( nType );
	switch( nType )
	{
		case SbxBOOL:
		case SbxINTEGER:
			r >> aData.nInteger; break;
		case SbxLONG:
			r >> aData.nLong; break;
		case SbxSINGLE:
		{
			// Floats als ASCII
			XubString aVal;
			r.ReadByteString( aVal, RTL_TEXTENCODING_ASCII_US );
			double d;
			SbxDataType t;
			if( ImpScan( aVal, d, t, NULL ) != SbxERR_OK || t == SbxDOUBLE )
			{
				aData.nSingle = 0.0F;
				return sal_False;
			}
			aData.nSingle = (float) d;
			break;
		}
		case SbxDATE:
		case SbxDOUBLE:
		{
			// Floats als ASCII
			XubString aVal;
			r.ReadByteString( aVal, RTL_TEXTENCODING_ASCII_US );
			SbxDataType t;
			if( ImpScan( aVal, aData.nDouble, t, NULL ) != SbxERR_OK )
			{
				aData.nDouble = 0.0;
				return sal_False;
			}
			break;
		}
		case SbxULONG64:
		{
			r >> aData.nULong64.nHigh >> aData.nULong64.nLow;
			break;
		}
		case SbxLONG64:
		case SbxCURRENCY:
		{
			r >> aData.nLong64.nHigh >> aData.nLong64.nLow;
			break;
		}
		case SbxSTRING:
		{
			XubString aVal;
			r.ReadByteString( aVal, RTL_TEXTENCODING_ASCII_US );
			if( aVal.Len() )
				aData.pOUString = new ::rtl::OUString( aVal );
			else
				aData.pOUString = NULL; // JSM 22.09.1995
			break;
		}
		case SbxERROR:
		case SbxUSHORT:
			r >> aData.nUShort; break;
		case SbxOBJECT:
		{
			sal_uInt8 nMode;
			r >> nMode;
			switch( nMode )
			{
				case 0:
					aData.pObj = NULL;
					break;
				case 1:
					aData.pObj = SbxBase::Load( r );
					return sal_Bool( aData.pObj != NULL );
				case 2:
					aData.pObj = this;
					break;
			}
			break;
		}
		case SbxCHAR:
		{
			char c;
			r >> c;
			aData.nChar = c;
			break;
		}
		case SbxBYTE:
			r >> aData.nByte; break;
		case SbxULONG:
			r >> aData.nULong; break;
		case SbxINT:
		{
			sal_uInt8 n;
			r >> n;
			// Passt der Int auf diesem System?
			if( n > SAL_TYPES_SIZEOFINT )
				r >> aData.nLong, aData.eType = SbxLONG;
			else
				r >> aData.nInt;
			break;
		}
		case SbxUINT:
		{
			sal_uInt8 n;
			r >> n;
			// Passt der UInt auf diesem System?
			if( n > SAL_TYPES_SIZEOFINT )
				r >> aData.nULong, aData.eType = SbxULONG;
			else
				r >> (sal_uInt32&)aData.nUInt;
			break;
		}
		case SbxEMPTY:
		case SbxNULL:
		case SbxVOID:
			break;
		case SbxDATAOBJECT:
			r >> aData.nLong;
			break;
		// #78919 For backwards compatibility
		case SbxWSTRING:
		case SbxWCHAR:
			break;
		default:
			memset (&aData,0,sizeof(aData));
			ResetFlag(SBX_FIXED);
			aData.eType = SbxNULL;
			DBG_ASSERT( sal_False, "Unsupported data type loaded" );
			return sal_False;
	}
	return sal_True;
}

sal_Bool SbxValue::StoreData( SvStream& r ) const
{
	sal_uInt16 nType = sal::static_int_cast< sal_uInt16 >(aData.eType);
	r << nType;
	switch( nType & 0x0FFF )
	{
		case SbxBOOL:
		case SbxINTEGER:
			r << aData.nInteger; break;
		case SbxLONG:
			r << aData.nLong; break;
		case SbxDATE:
			// #49935: Als double speichern, sonst Fehler beim Einlesen
			((SbxValue*)this)->aData.eType = (SbxDataType)( ( nType & 0xF000 ) | SbxDOUBLE );
			r.WriteByteString( GetCoreString(), RTL_TEXTENCODING_ASCII_US );
			((SbxValue*)this)->aData.eType = (SbxDataType)nType;
			break;
		case SbxSINGLE:
		case SbxDOUBLE:
			r.WriteByteString( GetCoreString(), RTL_TEXTENCODING_ASCII_US );
			break;
		case SbxULONG64:
		{
			r << aData.nULong64.nHigh << aData.nULong64.nLow;
			break;
		}
		case SbxLONG64:
		case SbxCURRENCY:
		{
			r << aData.nLong64.nHigh << aData.nLong64.nLow;
			break;
		}
		case SbxSTRING:
			if( aData.pOUString )
			{
				r.WriteByteString( *aData.pOUString, RTL_TEXTENCODING_ASCII_US );
			}
			else
			{
				String aEmpty;
				r.WriteByteString( aEmpty, RTL_TEXTENCODING_ASCII_US );
			}
			break;
		case SbxERROR:
		case SbxUSHORT:
			r << aData.nUShort; break;
		case SbxOBJECT:
			// sich selbst als Objektptr speichern geht nicht!
			if( aData.pObj )
			{
				if( PTR_CAST(SbxValue,aData.pObj) != this )
				{
					r << (sal_uInt8) 1;
					return aData.pObj->Store( r );
				}
				else
					r << (sal_uInt8) 2;
			}
			else
				r << (sal_uInt8) 0;
			break;
		case SbxCHAR:
		{
			char c = sal::static_int_cast< char >(aData.nChar);
			r << c;
			break;
		}
		case SbxBYTE:
			r << aData.nByte; break;
		case SbxULONG:
			r << aData.nULong; break;
		case SbxINT:
		{
			sal_uInt8 n = SAL_TYPES_SIZEOFINT;
			r << n << (sal_Int32)aData.nInt;
			break;
		}
		case SbxUINT:
		{
			sal_uInt8 n = SAL_TYPES_SIZEOFINT;
			r << n << (sal_uInt32)aData.nUInt;
			break;
		}
		case SbxEMPTY:
		case SbxNULL:
		case SbxVOID:
			break;
		case SbxDATAOBJECT:
			r << aData.nLong;
			break;
		// #78919 For backwards compatibility
		case SbxWSTRING:
		case SbxWCHAR:
			break;
		default:
			DBG_ASSERT( sal_False, "Save an unsupported data type" );
			return sal_False;
	}
	return sal_True;
}