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