xref: /AOO41X/main/basic/source/sbx/sbxdec.cxx (revision e8c8fa4bdcac50a8fe6c60960dd164b285c48c7e) 
1 /**************************************************************
2  *
3  * Licensed to the Apache Software Foundation (ASF) under one
4  * or more contributor license agreements.  See the NOTICE file
5  * distributed with this work for additional information
6  * regarding copyright ownership.  The ASF licenses this file
7  * to you under the Apache License, Version 2.0 (the
8  * "License"); you may not use this file except in compliance
9  * with the License.  You may obtain a copy of the License at
10  *
11  *   http://www.apache.org/licenses/LICENSE-2.0
12  *
13  * Unless required by applicable law or agreed to in writing,
14  * software distributed under the License is distributed on an
15  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16  * KIND, either express or implied.  See the License for the
17  * specific language governing permissions and limitations
18  * under the License.
19  *
20  *************************************************************/
21 
22 
23 
24 // MARKER(update_precomp.py): autogen include statement, do not remove
25 #include "precompiled_basic.hxx"
26 #include <tools/errcode.hxx>
27 
28 #include <basic/sbx.hxx>
29 #include "sbxconv.hxx"
30 
31 #include <com/sun/star/bridge/oleautomation/Decimal.hpp>
32 
33 
34 // int GnDecCounter = 0;
35 
36 // Implementation SbxDecimal
37 SbxDecimal::SbxDecimal( void )
38 {
39 	setInt( 0 );
40 	mnRefCount = 0;
41 	// GnDecCounter++;
42 }
43 
44 SbxDecimal::SbxDecimal( const SbxDecimal& rDec )
45 {
46 #ifdef WIN32
47 	maDec = rDec.maDec;
48 #else
49     (void)rDec;
50 #endif
51 	mnRefCount = 0;
52 	// GnDecCounter++;
53 }
54 
55 SbxDecimal::SbxDecimal
56 	( const com::sun::star::bridge::oleautomation::Decimal& rAutomationDec )
57 {
58 #ifdef WIN32
59 	maDec.scale = rAutomationDec.Scale;
60 	maDec.sign  = rAutomationDec.Sign;
61 	maDec.Lo32 = rAutomationDec.LowValue;
62 	maDec.Mid32 = rAutomationDec.MiddleValue;
63 	maDec.Hi32 = rAutomationDec.HighValue;
64 #else
65     (void)rAutomationDec;
66 #endif
67 	mnRefCount = 0;
68 	// GnDecCounter++;
69 }
70 
71 void SbxDecimal::fillAutomationDecimal
72 	( com::sun::star::bridge::oleautomation::Decimal& rAutomationDec )
73 {
74 #ifdef WIN32
75 	rAutomationDec.Scale = maDec.scale;
76 	rAutomationDec.Sign = maDec.sign;
77 	rAutomationDec.LowValue = maDec.Lo32;
78 	rAutomationDec.MiddleValue = maDec.Mid32;
79 	rAutomationDec.HighValue = maDec.Hi32;
80 #else
81     (void)rAutomationDec;
82 #endif
83 }
84 
85 SbxDecimal::~SbxDecimal()
86 {
87 	// GnDecCounter--;
88 }
89 
90 void releaseDecimalPtr( SbxDecimal*& rpDecimal )
91 {
92 	if( rpDecimal )
93 	{
94 		rpDecimal->mnRefCount--;
95 		if( rpDecimal->mnRefCount == 0 )
96 		{
97 			delete rpDecimal;
98 			rpDecimal = NULL;
99 		}
100 	}
101 }
102 
103 #ifdef WIN32
104 
105 bool SbxDecimal::operator -= ( const SbxDecimal &r )
106 {
107 	HRESULT hResult = VarDecSub( &maDec, (LPDECIMAL)&r.maDec, &maDec );
108 	bool bRet = ( hResult == S_OK );
109 	return bRet;
110 }
111 
112 bool SbxDecimal::operator += ( const SbxDecimal &r )
113 {
114 	HRESULT hResult = VarDecAdd( &maDec, (LPDECIMAL)&r.maDec, &maDec );
115 	bool bRet = ( hResult == S_OK );
116 	return bRet;
117 }
118 
119 bool SbxDecimal::operator /= ( const SbxDecimal &r )
120 {
121 	HRESULT hResult = VarDecDiv( &maDec, (LPDECIMAL)&r.maDec, &maDec );
122 	bool bRet = ( hResult == S_OK );
123 	return bRet;
124 }
125 
126 bool SbxDecimal::operator *= ( const SbxDecimal &r )
127 {
128 	HRESULT hResult = VarDecMul( &maDec, (LPDECIMAL)&r.maDec, &maDec );
129 	bool bRet = ( hResult == S_OK );
130 	return bRet;
131 }
132 
133 bool SbxDecimal::neg( void )
134 {
135 	HRESULT hResult = VarDecNeg( &maDec, &maDec );
136 	bool bRet = ( hResult == S_OK );
137 	return bRet;
138 }
139 
140 bool SbxDecimal::isZero( void )
141 {
142 	SbxDecimal aZeroDec;
143 	aZeroDec.setLong( 0 );
144 	bool bZero = ( EQ == compare( *this, aZeroDec ) );
145 	return bZero;
146 }
147 
148 SbxDecimal::CmpResult compare( const SbxDecimal &rLeft, const SbxDecimal &rRight )
149 {
150 	HRESULT hResult = VarDecCmp( (LPDECIMAL)&rLeft.maDec, (LPDECIMAL)&rRight.maDec );
151 	SbxDecimal::CmpResult eRes = (SbxDecimal::CmpResult)hResult;
152 	return eRes;
153 }
154 
155 void SbxDecimal::setChar( sal_Unicode val )
156 {
157 	VarDecFromUI2( (sal_uInt16)val, &maDec );
158 }
159 
160 void SbxDecimal::setByte( sal_uInt8 val )
161 {
162 	VarDecFromUI1( (sal_uInt8)val, &maDec );
163 }
164 
165 void SbxDecimal::setShort( sal_Int16 val )
166 {
167 	VarDecFromI2( (short)val, &maDec );
168 }
169 
170 void SbxDecimal::setLong( sal_Int32 val )
171 {
172 	VarDecFromI4( (long)val, &maDec );
173 }
174 
175 void SbxDecimal::setUShort( sal_uInt16 val )
176 {
177 	VarDecFromUI2( (sal_uInt16)val, &maDec );
178 }
179 
180 void SbxDecimal::setULong( sal_uInt32 val )
181 {
182 	VarDecFromUI4( (sal_uIntPtr)val, &maDec );
183 }
184 
185 bool SbxDecimal::setSingle( float val )
186 {
187 	bool bRet = ( VarDecFromR4( val, &maDec ) == S_OK );
188 	return bRet;
189 }
190 
191 bool SbxDecimal::setDouble( double val )
192 {
193 	bool bRet = ( VarDecFromR8( val, &maDec ) == S_OK );
194 	return bRet;
195 }
196 
197 void SbxDecimal::setInt( int val )
198 {
199 	setLong( (sal_Int32)val );
200 }
201 
202 void SbxDecimal::setUInt( unsigned int val )
203 {
204 	setULong( (sal_uInt32)val );
205 }
206 
207 // sbxscan.cxx
208 void ImpGetIntntlSep( sal_Unicode& rcDecimalSep, sal_Unicode& rcThousandSep );
209 
210 bool SbxDecimal::setString( ::rtl::OUString* pOUString )
211 {
212 	static LCID nLANGID = MAKELANGID( LANG_ENGLISH, SUBLANG_ENGLISH_US );
213 
214 	// Convert delimiter
215 	sal_Unicode cDecimalSep;
216 	sal_Unicode cThousandSep;
217 	ImpGetIntntlSep( cDecimalSep, cThousandSep );
218 
219 	bool bRet = false;
220 	HRESULT hResult;
221 	if( cDecimalSep != '.' || cThousandSep != ',' )
222 	{
223 		int nLen = pOUString->getLength();
224 		sal_Unicode* pBuffer = new sal_Unicode[nLen +  1];
225 		pBuffer[nLen] = 0;
226 
227 		const sal_Unicode* pSrc = pOUString->getStr();
228 		int i;
229 		for( i = 0 ; i < nLen ; ++i )
230 			pBuffer[i] = pSrc[i];
231 
232 		sal_Unicode c;
233 		i = 0;
234 		while( (c = pBuffer[i]) != 0 )
235 		{
236 			if( c == cDecimalSep )
237 				pBuffer[i] = '.';
238 			else if( c == cThousandSep )
239 				pBuffer[i] = ',';
240 			i++;
241 		}
242 		hResult = VarDecFromStr( (OLECHAR*)pBuffer, nLANGID, 0, &maDec );
243 		delete pBuffer;
244 	}
245 	else
246 	{
247 		hResult = VarDecFromStr( (OLECHAR*)pOUString->getStr(), nLANGID, 0, &maDec );
248 	}
249 	bRet = ( hResult == S_OK );
250 	return bRet;
251 }
252 
253 
254 bool SbxDecimal::getChar( sal_Unicode& rVal )
255 {
256 	bool bRet = ( VarUI2FromDec( &maDec, &rVal ) == S_OK );
257 	return bRet;
258 }
259 
260 bool SbxDecimal::getByte( sal_uInt8& rVal )
261 {
262 	bool bRet = ( VarUI1FromDec( &maDec, &rVal ) == S_OK );
263 	return bRet;
264 }
265 
266 bool SbxDecimal::getShort( sal_Int16& rVal )
267 {
268 	bool bRet = ( VarI2FromDec( &maDec, &rVal ) == S_OK );
269 	return bRet;
270 }
271 
272 bool SbxDecimal::getLong( sal_Int32& rVal )
273 {
274 	bool bRet = ( VarI4FromDec( &maDec, &rVal ) == S_OK );
275 	return bRet;
276 }
277 
278 bool SbxDecimal::getUShort( sal_uInt16& rVal )
279 {
280 	bool bRet = ( VarUI2FromDec( &maDec, &rVal ) == S_OK );
281 	return bRet;
282 }
283 
284 bool SbxDecimal::getULong( sal_uInt32& rVal )
285 {
286 	bool bRet = ( VarUI4FromDec( &maDec, &rVal ) == S_OK );
287 	return bRet;
288 }
289 
290 bool SbxDecimal::getSingle( float& rVal )
291 {
292 	bool bRet = ( VarR4FromDec( &maDec, &rVal ) == S_OK );
293 	return bRet;
294 }
295 
296 bool SbxDecimal::getDouble( double& rVal )
297 {
298 	bool bRet = ( VarR8FromDec( &maDec, &rVal ) == S_OK );
299 	return bRet;
300 }
301 
302 bool SbxDecimal::getInt( int& rVal )
303 {
304 	sal_Int32 TmpVal;
305 	bool bRet = getLong( TmpVal );
306 	rVal = TmpVal;
307 	return bRet;
308 }
309 
310 bool SbxDecimal::getUInt( unsigned int& rVal )
311 {
312 	sal_uInt32 TmpVal;
313 	bool bRet = getULong( TmpVal );
314 	rVal = TmpVal;
315 	return bRet;
316 }
317 
318 #else
319 // !WIN32
320 
321 bool SbxDecimal::operator -= ( const SbxDecimal &r )
322 {
323     (void)r;
324 	return false;
325 }
326 
327 bool SbxDecimal::operator += ( const SbxDecimal &r )
328 {
329     (void)r;
330 	return false;
331 }
332 
333 bool SbxDecimal::operator /= ( const SbxDecimal &r )
334 {
335     (void)r;
336 	return false;
337 }
338 
339 bool SbxDecimal::operator *= ( const SbxDecimal &r )
340 {
341     (void)r;
342 	return false;
343 }
344 
345 bool SbxDecimal::neg( void )
346 {
347 	return false;
348 }
349 
350 bool SbxDecimal::isZero( void )
351 {
352 	return false;
353 }
354 
355 SbxDecimal::CmpResult compare( const SbxDecimal &rLeft, const SbxDecimal &rRight )
356 {
357     (void)rLeft;
358     (void)rRight;
359 	return (SbxDecimal::CmpResult)0;
360 }
361 
362 void SbxDecimal::setChar( sal_Unicode val )		{ (void)val; }
363 void SbxDecimal::setByte( sal_uInt8 val )			{ (void)val; }
364 void SbxDecimal::setShort( sal_Int16 val )			{ (void)val; }
365 void SbxDecimal::setLong( sal_Int32 val )			{ (void)val; }
366 void SbxDecimal::setUShort( sal_uInt16 val )		{ (void)val; }
367 void SbxDecimal::setULong( sal_uInt32 val )			{ (void)val; }
368 bool SbxDecimal::setSingle( float val )			{ (void)val; return false; }
369 bool SbxDecimal::setDouble( double val )		{ (void)val; return false; }
370 void SbxDecimal::setInt( int val )				{ (void)val; }
371 void SbxDecimal::setUInt( unsigned int val )	{ (void)val; }
372 bool SbxDecimal::setString( ::rtl::OUString* pOUString )	{ (void)pOUString;  return false; }
373 
374 bool SbxDecimal::getChar( sal_Unicode& rVal )	{ (void)rVal; return false; }
375 bool SbxDecimal::getByte( sal_uInt8& rVal )			{ (void)rVal; return false; }
376 bool SbxDecimal::getShort( sal_Int16& rVal )		{ (void)rVal; return false; }
377 bool SbxDecimal::getLong( sal_Int32& rVal )			{ (void)rVal; return false; }
378 bool SbxDecimal::getUShort( sal_uInt16& rVal )		{ (void)rVal; return false; }
379 bool SbxDecimal::getULong( sal_uInt32& rVal )		{ (void)rVal; return false; }
380 bool SbxDecimal::getSingle( float& rVal )		{ (void)rVal; return false; }
381 bool SbxDecimal::getDouble( double& rVal )		{ (void)rVal; return false; }
382 bool SbxDecimal::getInt( int& rVal )			{ (void)rVal; return false; }
383 bool SbxDecimal::getUInt( unsigned int& rVal )	{ (void)rVal; return false; }
384 
385 #endif
386 
387 bool SbxDecimal::getString( ::rtl::OUString& rString )
388 {
389 #ifdef WIN32
390 	static LCID nLANGID = MAKELANGID( LANG_ENGLISH, SUBLANG_ENGLISH_US );
391 
392 	bool bRet = false;
393 
394 	OLECHAR sz[100];
395 	BSTR aBStr = SysAllocString( sz );
396 	if( aBStr != NULL )
397 	{
398 		HRESULT hResult = VarBstrFromDec( &maDec, nLANGID, 0, &aBStr );
399 		bRet = ( hResult == S_OK );
400 		if( bRet )
401 		{
402 			// Convert delimiter
403 			sal_Unicode cDecimalSep;
404 			sal_Unicode cThousandSep;
405 			ImpGetIntntlSep( cDecimalSep, cThousandSep );
406 
407 			if( cDecimalSep != '.' || cThousandSep != ',' )
408 			{
409 				sal_Unicode c;
410 				int i = 0;
411 				while( (c = aBStr[i]) != 0 )
412 				{
413 					if( c == '.' )
414 						aBStr[i] = cDecimalSep;
415 					else if( c == ',' )
416 						aBStr[i] = cThousandSep;
417 					i++;
418 				}
419 			}
420 			rString = reinterpret_cast<const sal_Unicode*>(aBStr);
421 		}
422 
423 		SysFreeString( aBStr );
424 	}
425 	return bRet;
426 #else
427     (void)rString;
428 	return false;
429 #endif
430 }
431 
432 SbxDecimal* ImpCreateDecimal( SbxValues* p )
433 {
434 #ifdef WIN32
435 	if( !p )
436 		return NULL;
437 
438 	SbxDecimal*& rpDecimal = p->pDecimal;
439 	if( rpDecimal == NULL )
440 	{
441 		rpDecimal = new SbxDecimal();
442 		rpDecimal->addRef();
443 	}
444 	return rpDecimal;
445 #else
446     (void)p;
447 	return NULL;
448 #endif
449 }
450 
451 SbxDecimal* ImpGetDecimal( const SbxValues* p )
452 {
453 #ifdef WIN32
454 	SbxValues aTmp;
455 	SbxDecimal* pnDecRes;
456 
457 	SbxDataType eType = p->eType;
458 	if( eType == SbxDECIMAL && p->pDecimal )
459 	{
460 		pnDecRes = new SbxDecimal( *p->pDecimal );
461 		pnDecRes->addRef();
462 		return pnDecRes;
463 	}
464 	pnDecRes = new SbxDecimal();
465 	pnDecRes->addRef();
466 
467 start:
468 	switch( +eType )
469 	{
470 		case SbxNULL:
471 			SbxBase::SetError( SbxERR_CONVERSION );
472 		case SbxEMPTY:
473 			pnDecRes->setShort( 0 ); break;
474 		case SbxCHAR:
475 			pnDecRes->setChar( p->nChar ); break;
476 		case SbxBYTE:
477 			pnDecRes->setByte( p->nByte ); break;
478 		case SbxINTEGER:
479 		case SbxBOOL:
480 			pnDecRes->setInt( p->nInteger ); break;
481 		case SbxERROR:
482 		case SbxUSHORT:
483 			pnDecRes->setUShort( p->nUShort ); break;
484 		case SbxLONG:
485 			pnDecRes->setLong( p->nLong ); break;
486 		case SbxULONG:
487 			pnDecRes->setULong( p->nULong ); break;
488 		case SbxSINGLE:
489 			if( !pnDecRes->setSingle( p->nSingle ) )
490 				SbxBase::SetError( SbxERR_OVERFLOW );
491 			break;
492 		case SbxSALINT64:
493 			{
494 				double d = (double)p->nInt64;
495 				pnDecRes->setDouble( d );
496 				break;
497 			}
498 		case SbxSALUINT64:
499 			{
500 				double d = ImpSalUInt64ToDouble( p->uInt64 );
501 				pnDecRes->setDouble( d );
502 				break;
503 			}
504 		case SbxDATE:
505 		case SbxDOUBLE:
506 		case SbxLONG64:
507 		case SbxULONG64:
508 		case SbxCURRENCY:
509 			{
510 			double dVal;
511 			if( p->eType ==	SbxCURRENCY )
512 				dVal = ImpCurrencyToDouble( p->nLong64 );
513 			else if( p->eType == SbxLONG64 )
514 				dVal = ImpINT64ToDouble( p->nLong64 );
515 			else if( p->eType == SbxULONG64 )
516 				dVal = ImpUINT64ToDouble( p->nULong64 );
517 			else
518 				dVal = p->nDouble;
519 
520 			if( !pnDecRes->setDouble( dVal ) )
521 				SbxBase::SetError( SbxERR_OVERFLOW );
522 			break;
523 			}
524 		case SbxLPSTR:
525 		case SbxSTRING:
526 		case SbxBYREF | SbxSTRING:
527 			pnDecRes->setString( p->pOUString ); break;
528 		case SbxOBJECT:
529 		{
530 			SbxValue* pVal = PTR_CAST(SbxValue,p->pObj);
531 			if( pVal )
532 				pnDecRes->setDecimal( pVal->GetDecimal() );
533 			else
534 			{
535 				SbxBase::SetError( SbxERR_NO_OBJECT );
536 				pnDecRes->setShort( 0 );
537 			}
538 			break;
539 		}
540 
541 		case SbxBYREF | SbxCHAR:
542 			pnDecRes->setChar( *p->pChar ); break;
543 		case SbxBYREF | SbxBYTE:
544 			pnDecRes->setByte( *p->pByte ); break;
545 		case SbxBYREF | SbxINTEGER:
546 		case SbxBYREF | SbxBOOL:
547 			pnDecRes->setInt( *p->pInteger ); break;
548 		case SbxBYREF | SbxLONG:
549 			pnDecRes->setLong( *p->pLong ); break;
550 		case SbxBYREF | SbxULONG:
551 			pnDecRes->setULong( *p->pULong ); break;
552 		case SbxBYREF | SbxERROR:
553 		case SbxBYREF | SbxUSHORT:
554 			pnDecRes->setUShort( *p->pUShort ); break;
555 
556 		// ab hier muss getestet werden
557 		case SbxBYREF | SbxSINGLE:
558 			aTmp.nSingle = *p->pSingle; goto ref;
559 		case SbxBYREF | SbxDATE:
560 		case SbxBYREF | SbxDOUBLE:
561 			aTmp.nDouble = *p->pDouble; goto ref;
562 		case SbxBYREF | SbxULONG64:
563 			aTmp.nULong64 = *p->pULong64; goto ref;
564 		case SbxBYREF | SbxLONG64:
565 		case SbxBYREF | SbxCURRENCY:
566 			aTmp.nLong64 = *p->pLong64; goto ref;
567 		case SbxBYREF | SbxSALINT64:
568 			aTmp.nInt64 = *p->pnInt64; goto ref;
569 		case SbxBYREF | SbxSALUINT64:
570 			aTmp.uInt64 = *p->puInt64; goto ref;
571 		ref:
572 			aTmp.eType = SbxDataType( p->eType & 0x0FFF );
573 			p = &aTmp; goto start;
574 
575 		default:
576 			SbxBase::SetError( SbxERR_CONVERSION ); pnDecRes->setShort( 0 );
577 	}
578 	return pnDecRes;
579 #else
580     (void)p;
581     return NULL;
582 #endif
583 }
584 
585 
586 void ImpPutDecimal( SbxValues* p, SbxDecimal* pDec )
587 {
588 #ifdef WIN32
589 	if( !pDec )
590 		return;
591 
592 	SbxValues aTmp;
593 start:
594 	switch( +p->eType )
595 	{
596 		// hier muss getestet werden
597 		case SbxCHAR:
598 			aTmp.pChar = &p->nChar; goto direct;
599 		case SbxBYTE:
600 			aTmp.pByte = &p->nByte; goto direct;
601 		case SbxULONG:
602 			aTmp.pULong = &p->nULong; goto direct;
603 		case SbxERROR:
604 		case SbxUSHORT:
605 			aTmp.pUShort = &p->nUShort; goto direct;
606 		case SbxSALUINT64:
607 			aTmp.puInt64 = &p->uInt64; goto direct;
608 		case SbxINTEGER:
609 		case SbxBOOL:
610 			aTmp.pInteger = &p->nInteger; goto direct;
611 		case SbxLONG:
612 			aTmp.pLong = &p->nLong; goto direct;
613 		case SbxSALINT64:
614 			aTmp.pnInt64 = &p->nInt64; goto direct;
615 		case SbxCURRENCY:
616 			aTmp.pLong64 = &p->nLong64; goto direct;
617 		direct:
618 			aTmp.eType = SbxDataType( p->eType | SbxBYREF );
619 			p = &aTmp; goto start;
620 
621 		// ab hier nicht mehr
622 		case SbxDECIMAL:
623 		case SbxBYREF | SbxDECIMAL:
624 		{
625 			if( pDec != p->pDecimal )
626 			{
627 				releaseDecimalPtr( p->pDecimal );
628 				// if( p->pDecimal )
629 					// p->pDecimal->ReleaseRef();
630 				p->pDecimal = pDec;
631 				if( pDec )
632 					pDec->addRef();
633 			}
634 			break;
635 		}
636 		case SbxSINGLE:
637 		{
638 			float f;
639 			pDec->getSingle( f );
640 			p->nSingle = f;
641 			break;
642 		}
643 		case SbxDATE:
644 		case SbxDOUBLE:
645 		{
646 			double d;
647 			pDec->getDouble( d );
648 			p->nDouble = d;
649 			break;
650 		}
651 		case SbxULONG64:
652 		{
653 			double d;
654 			pDec->getDouble( d );
655 			p->nULong64 = ImpDoubleToUINT64( d );
656 			break;
657 		}
658 		case SbxLONG64:
659 		{
660 			double d;
661 			pDec->getDouble( d );
662 			p->nLong64 = ImpDoubleToINT64( d );
663 			break;
664 		}
665 
666 		case SbxLPSTR:
667 		case SbxSTRING:
668 		case SbxBYREF | SbxSTRING:
669 			if( !p->pOUString )
670 				p->pOUString = new ::rtl::OUString;
671 			// ImpCvtNum( (double) n, 0, *p->pString );
672 			pDec->getString( *p->pOUString );
673 			break;
674 		case SbxOBJECT:
675 		{
676 			SbxValue* pVal = PTR_CAST(SbxValue,p->pObj);
677 			if( pVal )
678 				pVal->PutDecimal( pDec );
679 			else
680 				SbxBase::SetError( SbxERR_NO_OBJECT );
681 			break;
682 		}
683 
684 		case SbxBYREF | SbxCHAR:
685 			if( !pDec->getChar( *p->pChar ) )
686 			{
687 				SbxBase::SetError( SbxERR_OVERFLOW );
688 				*p->pChar = 0;
689 			}
690 			break;
691 		case SbxBYREF | SbxBYTE:
692 			if( !pDec->getChar( *p->pChar ) )
693 			{
694 				SbxBase::SetError( SbxERR_OVERFLOW );
695 				*p->pByte = 0;
696 			}
697 			break;
698 		case SbxBYREF | SbxINTEGER:
699 		case SbxBYREF | SbxBOOL:
700 			if( !pDec->getShort( *p->pInteger ) )
701 			{
702 				SbxBase::SetError( SbxERR_OVERFLOW );
703 				*p->pInteger = 0;
704 			}
705 			break;
706 			// *p->pInteger = n; break;
707 		case SbxBYREF | SbxERROR:
708 		case SbxBYREF | SbxUSHORT:
709 			if( !pDec->getUShort( *p->pUShort ) )
710 			{
711 				SbxBase::SetError( SbxERR_OVERFLOW );
712 				*p->pUShort = 0;
713 			}
714 			break;
715 		case SbxBYREF | SbxLONG:
716 			if( !pDec->getLong( *p->pLong ) )
717 			{
718 				SbxBase::SetError( SbxERR_OVERFLOW );
719 				*p->pLong = 0;
720 			}
721 			break;
722 		case SbxBYREF | SbxULONG:
723 			if( !pDec->getULong( *p->pULong ) )
724 			{
725 				SbxBase::SetError( SbxERR_OVERFLOW );
726 				*p->pULong = 0;
727 			}
728 			break;
729 		case SbxBYREF | SbxSALINT64:
730 			{
731 			double d;
732 			if( !pDec->getDouble( d ) )
733 				SbxBase::SetError( SbxERR_OVERFLOW );
734 			else
735 				*p->pnInt64 = ImpDoubleToSalInt64( d );
736 			break;
737 			}
738 		case SbxBYREF | SbxSALUINT64:
739 			{
740 			double d;
741 			if( !pDec->getDouble( d ) )
742 				SbxBase::SetError( SbxERR_OVERFLOW );
743 			else
744 				*p->puInt64 = ImpDoubleToSalUInt64( d );
745 			break;
746 			}
747 		case SbxBYREF | SbxSINGLE:
748 			if( !pDec->getSingle( *p->pSingle ) )
749 			{
750 				SbxBase::SetError( SbxERR_OVERFLOW );
751 				*p->pSingle = 0;
752 			}
753 			break;
754 			// *p->pSingle = (float) n; break;
755 		case SbxBYREF | SbxDATE:
756 		case SbxBYREF | SbxDOUBLE:
757 			if( !pDec->getDouble( *p->pDouble ) )
758 			{
759 				SbxBase::SetError( SbxERR_OVERFLOW );
760 				*p->pDouble = 0;
761 			}
762 			break;
763 		case SbxBYREF | SbxULONG64:
764 		{
765 			double d;
766 			pDec->getDouble( d );
767 			*p->pULong64 = ImpDoubleToUINT64( d );
768 			break;
769 		}
770 		case SbxBYREF | SbxLONG64:
771 		{
772 			double d;
773 			pDec->getDouble( d );
774 			*p->pLong64 = ImpDoubleToINT64( d );
775 			break;
776 		}
777 		case SbxBYREF | SbxCURRENCY:
778 		{
779 			double d;
780 			pDec->getDouble( d );
781 			*p->pLong64 = ImpDoubleToCurrency( d );
782 			break;
783 		}
784 
785 		default:
786 			SbxBase::SetError( SbxERR_CONVERSION );
787 	}
788 #else
789     (void)p;
790     (void)pDec;
791 #endif
792 }
793 
794