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 :
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 14 : void releaseDecimalPtr( SbxDecimal*& rpDecimal )
79 : {
80 14 : 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 14 : }
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( (sal_uIntPtr)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( ::rtl::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 : 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, nLANGID, 0, &maDec );
228 : delete [] pBuffer;
229 : }
230 : else
231 : {
232 : hResult = VarDecFromStr( (OLECHAR*)pOUString->getStr(), nLANGID, 0, &maDec );
233 : }
234 : bRet = ( hResult == S_OK );
235 : return bRet;
236 : }
237 :
238 :
239 : bool SbxDecimal::getChar( sal_Unicode& rVal )
240 : {
241 : bool bRet = ( VarUI2FromDec( &maDec, &rVal ) == S_OK );
242 : return bRet;
243 : }
244 :
245 : bool SbxDecimal::getShort( sal_Int16& rVal )
246 : {
247 : bool bRet = ( VarI2FromDec( &maDec, &rVal ) == S_OK );
248 : return bRet;
249 : }
250 :
251 : bool SbxDecimal::getLong( sal_Int32& rVal )
252 : {
253 : bool bRet = ( VarI4FromDec( &maDec, &rVal ) == S_OK );
254 : return bRet;
255 : }
256 :
257 : bool SbxDecimal::getUShort( sal_uInt16& rVal )
258 : {
259 : bool bRet = ( VarUI2FromDec( &maDec, &rVal ) == S_OK );
260 : return bRet;
261 : }
262 :
263 : bool SbxDecimal::getULong( sal_uInt32& rVal )
264 : {
265 : bool bRet = ( VarUI4FromDec( &maDec, &rVal ) == S_OK );
266 : return bRet;
267 : }
268 :
269 : bool SbxDecimal::getSingle( float& rVal )
270 : {
271 : bool bRet = ( VarR4FromDec( &maDec, &rVal ) == S_OK );
272 : return bRet;
273 : }
274 :
275 : bool SbxDecimal::getDouble( double& rVal )
276 : {
277 : bool bRet = ( VarR8FromDec( &maDec, &rVal ) == S_OK );
278 : return bRet;
279 : }
280 :
281 : #else
282 : // !WIN32
283 :
284 0 : bool SbxDecimal::operator -= ( const SbxDecimal &r )
285 : {
286 : (void)r;
287 0 : return false;
288 : }
289 :
290 0 : bool SbxDecimal::operator += ( const SbxDecimal &r )
291 : {
292 : (void)r;
293 0 : return false;
294 : }
295 :
296 0 : bool SbxDecimal::operator /= ( const SbxDecimal &r )
297 : {
298 : (void)r;
299 0 : return false;
300 : }
301 :
302 0 : bool SbxDecimal::operator *= ( const SbxDecimal &r )
303 : {
304 : (void)r;
305 0 : return false;
306 : }
307 :
308 0 : bool SbxDecimal::neg( void )
309 : {
310 0 : return false;
311 : }
312 :
313 0 : bool SbxDecimal::isZero( void )
314 : {
315 0 : return false;
316 : }
317 :
318 0 : SbxDecimal::CmpResult compare( const SbxDecimal &rLeft, const SbxDecimal &rRight )
319 : {
320 : (void)rLeft;
321 : (void)rRight;
322 0 : return (SbxDecimal::CmpResult)0;
323 : }
324 :
325 0 : void SbxDecimal::setChar( sal_Unicode val ) { (void)val; }
326 0 : void SbxDecimal::setByte( sal_uInt8 val ) { (void)val; }
327 0 : void SbxDecimal::setShort( sal_Int16 val ) { (void)val; }
328 0 : void SbxDecimal::setLong( sal_Int32 val ) { (void)val; }
329 0 : void SbxDecimal::setUShort( sal_uInt16 val ) { (void)val; }
330 0 : void SbxDecimal::setULong( sal_uInt32 val ) { (void)val; }
331 0 : bool SbxDecimal::setSingle( float val ) { (void)val; return false; }
332 0 : bool SbxDecimal::setDouble( double val ) { (void)val; return false; }
333 0 : void SbxDecimal::setInt( int val ) { (void)val; }
334 0 : void SbxDecimal::setUInt( unsigned int val ) { (void)val; }
335 0 : bool SbxDecimal::setString( ::rtl::OUString* pOUString ) { (void)pOUString; return false; }
336 :
337 0 : bool SbxDecimal::getChar( sal_Unicode& rVal ) { (void)rVal; return false; }
338 0 : bool SbxDecimal::getShort( sal_Int16& rVal ) { (void)rVal; return false; }
339 0 : bool SbxDecimal::getLong( sal_Int32& rVal ) { (void)rVal; return false; }
340 0 : bool SbxDecimal::getUShort( sal_uInt16& rVal ) { (void)rVal; return false; }
341 0 : bool SbxDecimal::getULong( sal_uInt32& rVal ) { (void)rVal; return false; }
342 0 : bool SbxDecimal::getSingle( float& rVal ) { (void)rVal; return false; }
343 0 : bool SbxDecimal::getDouble( double& rVal ) { (void)rVal; return false; }
344 :
345 : #endif
346 :
347 0 : bool SbxDecimal::getString( ::rtl::OUString& rString )
348 : {
349 : #ifdef WIN32
350 : static LCID nLANGID = MAKELANGID( LANG_ENGLISH, SUBLANG_ENGLISH_US );
351 :
352 : bool bRet = false;
353 :
354 : OLECHAR sz[100];
355 : BSTR aBStr = SysAllocString( sz );
356 : if( aBStr != NULL )
357 : {
358 : HRESULT hResult = VarBstrFromDec( &maDec, nLANGID, 0, &aBStr );
359 : bRet = ( hResult == S_OK );
360 : if( bRet )
361 : {
362 : // Convert delimiter
363 : sal_Unicode cDecimalSep;
364 : sal_Unicode cThousandSep;
365 : ImpGetIntntlSep( cDecimalSep, cThousandSep );
366 :
367 : if( cDecimalSep != '.' || cThousandSep != ',' )
368 : {
369 : sal_Unicode c;
370 : int i = 0;
371 : while( (c = aBStr[i]) != 0 )
372 : {
373 : if( c == '.' )
374 : aBStr[i] = cDecimalSep;
375 : else if( c == ',' )
376 : aBStr[i] = cThousandSep;
377 : i++;
378 : }
379 : }
380 : rString = reinterpret_cast<const sal_Unicode*>(aBStr);
381 : }
382 :
383 : SysFreeString( aBStr );
384 : }
385 : return bRet;
386 : #else
387 : (void)rString;
388 0 : return false;
389 : #endif
390 : }
391 :
392 0 : SbxDecimal* ImpCreateDecimal( SbxValues* p )
393 : {
394 0 : if( !p )
395 0 : return NULL;
396 :
397 0 : SbxDecimal*& rpDecimal = p->pDecimal;
398 0 : if( rpDecimal == NULL )
399 : {
400 0 : rpDecimal = new SbxDecimal();
401 0 : rpDecimal->addRef();
402 : }
403 0 : return rpDecimal;
404 : }
405 :
406 0 : SbxDecimal* ImpGetDecimal( const SbxValues* p )
407 : {
408 0 : SbxValues aTmp;
409 : SbxDecimal* pnDecRes;
410 :
411 0 : SbxDataType eType = p->eType;
412 0 : if( eType == SbxDECIMAL && p->pDecimal )
413 : {
414 0 : pnDecRes = new SbxDecimal( *p->pDecimal );
415 0 : pnDecRes->addRef();
416 0 : return pnDecRes;
417 : }
418 0 : pnDecRes = new SbxDecimal();
419 0 : pnDecRes->addRef();
420 :
421 : start:
422 0 : switch( +eType )
423 : {
424 : case SbxNULL:
425 0 : SbxBase::SetError( SbxERR_CONVERSION );
426 : case SbxEMPTY:
427 0 : pnDecRes->setShort( 0 ); break;
428 : case SbxCHAR:
429 0 : pnDecRes->setChar( p->nChar ); break;
430 : case SbxBYTE:
431 0 : pnDecRes->setByte( p->nByte ); break;
432 : case SbxINTEGER:
433 : case SbxBOOL:
434 0 : pnDecRes->setInt( p->nInteger ); break;
435 : case SbxERROR:
436 : case SbxUSHORT:
437 0 : pnDecRes->setUShort( p->nUShort ); break;
438 : case SbxLONG:
439 0 : pnDecRes->setLong( p->nLong ); break;
440 : case SbxULONG:
441 0 : pnDecRes->setULong( p->nULong ); break;
442 : case SbxSINGLE:
443 0 : if( !pnDecRes->setSingle( p->nSingle ) )
444 0 : SbxBase::SetError( SbxERR_OVERFLOW );
445 0 : break;
446 : case SbxCURRENCY:
447 : {
448 0 : if( !pnDecRes->setDouble( ImpCurrencyToDouble( p->nInt64 ) ) )
449 0 : SbxBase::SetError( SbxERR_OVERFLOW );
450 0 : break;
451 : }
452 : case SbxSALINT64:
453 : {
454 0 : if( !pnDecRes->setDouble( (double)p->nInt64 ) )
455 0 : SbxBase::SetError( SbxERR_OVERFLOW );
456 0 : break;
457 : }
458 : case SbxSALUINT64:
459 : {
460 0 : if( !pnDecRes->setDouble( (double)p->uInt64 ) )
461 0 : SbxBase::SetError( SbxERR_OVERFLOW );
462 0 : break;
463 : }
464 : case SbxDATE:
465 : case SbxDOUBLE:
466 : {
467 0 : double dVal = p->nDouble;
468 0 : if( !pnDecRes->setDouble( dVal ) )
469 0 : SbxBase::SetError( SbxERR_OVERFLOW );
470 0 : break;
471 : }
472 : case SbxLPSTR:
473 : case SbxSTRING:
474 : case SbxBYREF | SbxSTRING:
475 0 : pnDecRes->setString( p->pOUString ); break;
476 : case SbxOBJECT:
477 : {
478 0 : SbxValue* pVal = PTR_CAST(SbxValue,p->pObj);
479 0 : if( pVal )
480 0 : pnDecRes->setDecimal( pVal->GetDecimal() );
481 : else
482 : {
483 0 : SbxBase::SetError( SbxERR_NO_OBJECT );
484 0 : pnDecRes->setShort( 0 );
485 : }
486 0 : break;
487 : }
488 :
489 : case SbxBYREF | SbxCHAR:
490 0 : pnDecRes->setChar( *p->pChar ); break;
491 : case SbxBYREF | SbxBYTE:
492 0 : pnDecRes->setByte( *p->pByte ); break;
493 : case SbxBYREF | SbxINTEGER:
494 : case SbxBYREF | SbxBOOL:
495 0 : pnDecRes->setInt( *p->pInteger ); break;
496 : case SbxBYREF | SbxLONG:
497 0 : pnDecRes->setLong( *p->pLong ); break;
498 : case SbxBYREF | SbxULONG:
499 0 : pnDecRes->setULong( *p->pULong ); break;
500 : case SbxBYREF | SbxERROR:
501 : case SbxBYREF | SbxUSHORT:
502 0 : pnDecRes->setUShort( *p->pUShort ); break;
503 :
504 : // from here on had to be tested
505 : case SbxBYREF | SbxSINGLE:
506 0 : aTmp.nSingle = *p->pSingle; goto ref;
507 : case SbxBYREF | SbxDATE:
508 : case SbxBYREF | SbxDOUBLE:
509 0 : aTmp.nDouble = *p->pDouble; goto ref;
510 : case SbxBYREF | SbxCURRENCY:
511 : case SbxBYREF | SbxSALINT64:
512 0 : aTmp.nInt64 = *p->pnInt64; goto ref;
513 : case SbxBYREF | SbxSALUINT64:
514 0 : aTmp.uInt64 = *p->puInt64; goto ref;
515 : ref:
516 0 : aTmp.eType = SbxDataType( p->eType & 0x0FFF );
517 0 : p = &aTmp; goto start;
518 :
519 : default:
520 0 : SbxBase::SetError( SbxERR_CONVERSION ); pnDecRes->setShort( 0 );
521 : }
522 0 : return pnDecRes;
523 : }
524 :
525 0 : void ImpPutDecimal( SbxValues* p, SbxDecimal* pDec )
526 : {
527 0 : if( !pDec )
528 0 : return;
529 :
530 0 : SbxValues aTmp;
531 : start:
532 0 : switch( +p->eType )
533 : {
534 : // here had to be tested
535 : case SbxCHAR:
536 0 : aTmp.pChar = &p->nChar; goto direct;
537 : case SbxBYTE:
538 0 : aTmp.pByte = &p->nByte; goto direct;
539 : case SbxULONG:
540 0 : aTmp.pULong = &p->nULong; goto direct;
541 : case SbxERROR:
542 : case SbxUSHORT:
543 0 : aTmp.pUShort = &p->nUShort; goto direct;
544 : case SbxINTEGER:
545 : case SbxBOOL:
546 0 : aTmp.pInteger = &p->nInteger; goto direct;
547 : case SbxLONG:
548 0 : aTmp.pLong = &p->nLong; goto direct;
549 : case SbxCURRENCY:
550 : case SbxSALINT64:
551 0 : aTmp.pnInt64 = &p->nInt64; goto direct;
552 : case SbxSALUINT64:
553 0 : aTmp.puInt64 = &p->uInt64; goto direct;
554 :
555 : direct:
556 0 : aTmp.eType = SbxDataType( p->eType | SbxBYREF );
557 0 : p = &aTmp; goto start;
558 :
559 : // from here on no longer
560 : case SbxDECIMAL:
561 : case SbxBYREF | SbxDECIMAL:
562 : {
563 0 : if( pDec != p->pDecimal )
564 : {
565 0 : releaseDecimalPtr( p->pDecimal );
566 0 : p->pDecimal = pDec;
567 0 : if( pDec )
568 0 : pDec->addRef();
569 : }
570 0 : break;
571 : }
572 : case SbxSINGLE:
573 : {
574 0 : float f(0.0);
575 0 : pDec->getSingle( f );
576 0 : p->nSingle = f;
577 : break;
578 : }
579 : case SbxDATE:
580 : case SbxDOUBLE:
581 : {
582 0 : double d(0.0);
583 0 : pDec->getDouble( d );
584 0 : p->nDouble = d;
585 : break;
586 : }
587 :
588 : case SbxLPSTR:
589 : case SbxSTRING:
590 : case SbxBYREF | SbxSTRING:
591 0 : if( !p->pOUString )
592 0 : p->pOUString = new ::rtl::OUString;
593 0 : pDec->getString( *p->pOUString );
594 0 : break;
595 : case SbxOBJECT:
596 : {
597 0 : SbxValue* pVal = PTR_CAST(SbxValue,p->pObj);
598 0 : if( pVal )
599 0 : pVal->PutDecimal( pDec );
600 : else
601 0 : SbxBase::SetError( SbxERR_NO_OBJECT );
602 0 : break;
603 : }
604 :
605 : case SbxBYREF | SbxCHAR:
606 0 : if( !pDec->getChar( *p->pChar ) )
607 : {
608 0 : SbxBase::SetError( SbxERR_OVERFLOW );
609 0 : *p->pChar = 0;
610 : }
611 0 : break;
612 : case SbxBYREF | SbxBYTE:
613 0 : if( !pDec->getChar( *p->pChar ) )
614 : {
615 0 : SbxBase::SetError( SbxERR_OVERFLOW );
616 0 : *p->pByte = 0;
617 : }
618 0 : break;
619 : case SbxBYREF | SbxINTEGER:
620 : case SbxBYREF | SbxBOOL:
621 0 : if( !pDec->getShort( *p->pInteger ) )
622 : {
623 0 : SbxBase::SetError( SbxERR_OVERFLOW );
624 0 : *p->pInteger = 0;
625 : }
626 0 : break;
627 : case SbxBYREF | SbxERROR:
628 : case SbxBYREF | SbxUSHORT:
629 0 : if( !pDec->getUShort( *p->pUShort ) )
630 : {
631 0 : SbxBase::SetError( SbxERR_OVERFLOW );
632 0 : *p->pUShort = 0;
633 : }
634 0 : break;
635 : case SbxBYREF | SbxLONG:
636 0 : if( !pDec->getLong( *p->pLong ) )
637 : {
638 0 : SbxBase::SetError( SbxERR_OVERFLOW );
639 0 : *p->pLong = 0;
640 : }
641 0 : break;
642 : case SbxBYREF | SbxULONG:
643 0 : if( !pDec->getULong( *p->pULong ) )
644 : {
645 0 : SbxBase::SetError( SbxERR_OVERFLOW );
646 0 : *p->pULong = 0;
647 : }
648 0 : break;
649 : case SbxBYREF | SbxCURRENCY:
650 : {
651 0 : double d(0.0);
652 0 : if( !pDec->getDouble( d ) )
653 0 : SbxBase::SetError( SbxERR_OVERFLOW );
654 0 : *p->pnInt64 = ImpDoubleToCurrency( d );
655 : }
656 0 : break;
657 : case SbxBYREF | SbxSALINT64:
658 : {
659 0 : double d(0.0);
660 0 : if( !pDec->getDouble( d ) )
661 0 : SbxBase::SetError( SbxERR_OVERFLOW );
662 : else
663 0 : *p->pnInt64 = ImpDoubleToSalInt64( d );
664 : }
665 0 : break;
666 : case SbxBYREF | SbxSALUINT64:
667 : {
668 0 : double d(0.0);
669 0 : if( !pDec->getDouble( d ) )
670 0 : SbxBase::SetError( SbxERR_OVERFLOW );
671 : else
672 0 : *p->puInt64 = ImpDoubleToSalUInt64( d );
673 : }
674 0 : break;
675 : case SbxBYREF | SbxSINGLE:
676 0 : if( !pDec->getSingle( *p->pSingle ) )
677 : {
678 0 : SbxBase::SetError( SbxERR_OVERFLOW );
679 0 : *p->pSingle = 0;
680 : }
681 0 : break;
682 : case SbxBYREF | SbxDATE:
683 : case SbxBYREF | SbxDOUBLE:
684 0 : if( !pDec->getDouble( *p->pDouble ) )
685 : {
686 0 : SbxBase::SetError( SbxERR_OVERFLOW );
687 0 : *p->pDouble = 0;
688 : }
689 0 : break;
690 : default:
691 0 : SbxBase::SetError( SbxERR_CONVERSION );
692 : }
693 : }
694 :
695 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
