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