Branch data 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 : 202 : void releaseDecimalPtr( SbxDecimal*& rpDecimal )
79 : : {
80 [ - + ]: 202 : 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 : 202 : }
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: */
|
