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 :
21 : #include <tools/errcode.hxx>
22 : #include <vcl/svapp.hxx> // for SvtSysLocale
23 :
24 : #include <basic/sbx.hxx>
25 : #include <basic/sbxvar.hxx>
26 : #include "sbxconv.hxx"
27 :
28 :
29 0 : static rtl::OUString ImpCurrencyToString( const sal_Int64 &rVal )
30 : {
31 0 : bool isNeg = ( rVal < 0 );
32 0 : sal_Int64 absVal = isNeg ? -rVal : rVal;
33 :
34 0 : sal_Unicode cDecimalSep = '.';
35 : #if MAYBEFUTURE
36 : sal_Unicode cThousandSep = ',';
37 : ImpGetIntntlSep( cDecimalSep, cThousandSep );
38 : #endif
39 :
40 0 : rtl::OUString aAbsStr = rtl::OUString::valueOf( absVal );
41 0 : rtl::OUStringBuffer aBuf;
42 :
43 0 : sal_Int32 initialLen = aAbsStr.getLength();
44 :
45 0 : bool bLessThanOne = false;
46 0 : if ( initialLen <= 4 ) // if less the 1
47 0 : bLessThanOne = true;
48 :
49 0 : sal_Int32 nCapacity = 6; // minimum e.g. 0.0000
50 :
51 0 : if ( !bLessThanOne )
52 : {
53 0 : nCapacity = initialLen + 1;
54 : #if MAYBEFUTURE
55 : if ( initialLen > 5 )
56 : {
57 : sal_Int32 nThouSeperators = ( initialLen - 5 ) / 3;
58 : nCapacity += nThouSeperators;
59 : }
60 : #endif
61 : }
62 :
63 0 : if ( isNeg )
64 0 : ++nCapacity;
65 :
66 0 : aBuf.setLength( nCapacity );
67 :
68 :
69 0 : sal_Int32 nDigitCount = 0;
70 0 : sal_Int32 nInsertIndex = nCapacity - 1;
71 0 : sal_Int32 nEndIndex = isNeg ? 1 : 0;
72 :
73 0 : for ( sal_Int32 charCpyIndex = aAbsStr.getLength() - 1; nInsertIndex >= nEndIndex; ++nDigitCount )
74 : {
75 0 : if ( nDigitCount == 4 )
76 0 : aBuf[nInsertIndex--] = cDecimalSep;
77 : #if MAYBEFUTURE
78 : if ( nDigitCount > 4 && ! ( ( nDigitCount - 4 ) % 3) )
79 : aBuf[nInsertIndex--] = cThousandSep;
80 : #endif
81 0 : if ( nDigitCount < initialLen )
82 0 : aBuf[nInsertIndex--] = aAbsStr[ charCpyIndex-- ];
83 : else
84 : // Handle leading 0's to right of decimal point
85 : // Note: in VBA the stringification is a little more complex
86 : // but more natural as only the necessary digits
87 : // to the right of the decimal places are displayed
88 : // It would be great to conditionally be able to display like that too
89 : //
90 : // Val OOo (Cur) VBA (Cur)
91 : // --- --------- ---------
92 : // 0 0.0000 0
93 : // 0.1 0.1000 0.1
94 :
95 0 : aBuf[nInsertIndex--] = (sal_Unicode)'0';
96 : }
97 0 : if ( isNeg )
98 0 : aBuf[nInsertIndex] = (sal_Unicode)'-';
99 :
100 0 : aAbsStr = aBuf.makeStringAndClear();
101 0 : return aAbsStr;
102 : }
103 :
104 :
105 0 : static sal_Int64 ImpStringToCurrency( const rtl::OUString &rStr )
106 : {
107 :
108 0 : sal_Int32 nFractDigit = 4;
109 :
110 0 : sal_Unicode cDeciPnt = sal_Unicode('.');
111 0 : sal_Unicode c1000Sep = sal_Unicode(',');
112 :
113 : #if MAYBEFUTURE
114 : sal_Unicode cLocaleDeciPnt, cLocale1000Sep;
115 : ImpGetIntntlSep( cLocaleDeciPnt, cLocale1000Sep );
116 :
117 : // score each set of separators (Locale and Basic) on total number of matches
118 : // if one set has more matches use that set
119 : // if tied use the set with the only or rightmost decimal separator match
120 : // currency is fixed pt system: usually expect the decimal pt, 1000sep may occur
121 : sal_Int32 LocaleScore = 0;
122 : sal_Int32 LocaleLastDeci = -1;
123 : sal_Int32 LOBasicScore = 0;
124 : sal_Int32 LOBasicLastDeci = -1;
125 :
126 : for( int idx=0; idx<rStr.getLength(); idx++ )
127 : {
128 : if ( *(p+idx) == cLocaleDeciPnt )
129 : {
130 : LocaleScore++;
131 : LocaleLastDeci = idx;
132 : }
133 : if ( *(p+idx) == cLocale1000Sep )
134 : LocaleScore++;
135 :
136 : if ( *(p+idx) == cDeciPnt )
137 : {
138 : LOBasicScore++;
139 : LOBasicLastDeci = idx;
140 : }
141 : if ( *(p+idx) == c1000Sep )
142 : LOBasicScore++;
143 : }
144 : if ( ( LocaleScore > LOBasicScore )
145 : ||( LocaleScore = LOBasicScore && LocaleLastDeci > LOBasicLastDeci ) )
146 : {
147 : cDeciPnt = cLocaleDeciPnt;
148 : c1000Sep = cLocale1000Sep;
149 : }
150 : #endif
151 :
152 : // lets use the existing string number conversions
153 : // there is a performance impact here ( multiple string copies )
154 : // but better I think than a home brewed string parser, if we need a parser
155 : // we should share some existing ( possibly from calc is there a currency
156 : // conversion there ? #TODO check )
157 :
158 0 : rtl::OUString sTmp( rStr.trim() );
159 0 : const sal_Unicode* p = sTmp.getStr();
160 :
161 : // normalise string number by removeing thousands & decimal point seperators
162 0 : rtl::OUStringBuffer sNormalisedNumString( sTmp.getLength() + nFractDigit );
163 :
164 0 : if ( *p == '-' || *p == '+' )
165 0 : sNormalisedNumString.append( *p );
166 :
167 0 : while ( ( *p >= '0' && *p <= '9' ) )
168 : {
169 0 : sNormalisedNumString.append( *p++ );
170 : // #TODO in vba mode set runtime error when a space ( or other )
171 : // illegal character is found
172 0 : if( *p == c1000Sep )
173 0 : p++;
174 : }
175 :
176 0 : bool bRoundUp = false;
177 :
178 0 : if( *p == cDeciPnt )
179 : {
180 0 : p++;
181 0 : while( nFractDigit && *p >= '0' && *p <= '9' )
182 : {
183 0 : sNormalisedNumString.append( *p++ );
184 0 : nFractDigit--;
185 : }
186 : // Consume trailing content
187 0 : if ( p != NULL )
188 : {
189 : // Round up if necessary
190 0 : if( *p >= '5' && *p <= '9' )
191 0 : bRoundUp = true;
192 0 : while( *p >= '0' && *p <= '9' )
193 0 : p++;
194 : }
195 :
196 : }
197 : // can we raise error here ? ( previous behaviour was more forgiving )
198 : // so... not sure that could bread existing code, lets see if anyone
199 : // complains.
200 :
201 0 : if ( p != sTmp.getStr() + sTmp.getLength() )
202 0 : SbxBase::SetError( SbxERR_CONVERSION );
203 0 : while( nFractDigit )
204 : {
205 0 : sNormalisedNumString.append( sal_Unicode('0') );
206 0 : nFractDigit--;
207 : }
208 :
209 0 : sal_Int64 result = sNormalisedNumString.makeStringAndClear().toInt64();
210 :
211 0 : if ( bRoundUp )
212 0 : ++result;
213 0 : return result;
214 : }
215 :
216 :
217 0 : sal_Int64 ImpGetCurrency( const SbxValues* p )
218 : {
219 0 : SbxValues aTmp;
220 : sal_Int64 nRes;
221 : start:
222 0 : switch( +p->eType )
223 : {
224 : case SbxERROR:
225 : case SbxNULL:
226 0 : SbxBase::SetError( SbxERR_CONVERSION );
227 0 : nRes = 0; break;
228 : case SbxEMPTY:
229 0 : nRes = 0; break;
230 : case SbxCURRENCY:
231 0 : nRes = p->nInt64; break;
232 : case SbxBYTE:
233 0 : nRes = (sal_Int64)CURRENCY_FACTOR * (sal_Int64)(p->nByte);
234 0 : break;
235 : case SbxCHAR:
236 0 : nRes = (sal_Int64)CURRENCY_FACTOR * (sal_Int64)(p->pChar);
237 0 : break;
238 : case SbxBOOL:
239 : case SbxINTEGER:
240 0 : nRes = (sal_Int64)CURRENCY_FACTOR * (sal_Int64)(p->nInteger);
241 0 : break;
242 : case SbxUSHORT:
243 0 : nRes = (sal_Int64)CURRENCY_FACTOR * (sal_Int64)(p->nUShort);
244 0 : break;
245 : case SbxLONG:
246 0 : nRes = (sal_Int64)CURRENCY_FACTOR * (sal_Int64)(p->nLong);
247 0 : break;
248 : case SbxULONG:
249 0 : nRes = (sal_Int64)CURRENCY_FACTOR * (sal_Int64)(p->nULong);
250 0 : break;
251 :
252 : case SbxSALINT64:
253 : {
254 0 : nRes = p->nInt64 * CURRENCY_FACTOR; break;
255 : #if 0
256 : // Huh, is the 'break' above intentional? That means this
257 : // is unreachable, obviously. Avoid warning by ifdeffing
258 : // this out for now. Do not delete this #if 0 block unless
259 : // you know for sure the 'break' above is intentional.
260 : if ( nRes > SbxMAXSALINT64 )
261 : {
262 : SbxBase::SetError( SbxERR_OVERFLOW ); nRes = SbxMAXSALINT64;
263 : }
264 : #endif
265 : }
266 : case SbxSALUINT64:
267 0 : nRes = p->nInt64 * CURRENCY_FACTOR; break;
268 : #if 0
269 : // As above
270 : if ( nRes > SbxMAXSALINT64 )
271 : {
272 : SbxBase::SetError( SbxERR_OVERFLOW ); nRes = SbxMAXSALINT64;
273 : }
274 : else if ( nRes < SbxMINSALINT64 )
275 : {
276 : SbxBase::SetError( SbxERR_OVERFLOW ); nRes = SbxMINSALINT64;
277 : }
278 : break;
279 : #endif
280 : //TODO: bring back SbxINT64 types here for limits -1 with flag value at SAL_MAX/MIN
281 : case SbxSINGLE:
282 0 : if( p->nSingle * CURRENCY_FACTOR + 0.5 > (float)SAL_MAX_INT64
283 : || p->nSingle * CURRENCY_FACTOR - 0.5 < (float)SAL_MIN_INT64 )
284 : {
285 0 : nRes = SAL_MAX_INT64;
286 0 : if( p->nSingle * CURRENCY_FACTOR - 0.5 < (float)SAL_MIN_INT64 )
287 0 : nRes = SAL_MIN_INT64;
288 0 : SbxBase::SetError( SbxERR_OVERFLOW );
289 0 : break;
290 : }
291 0 : nRes = ImpDoubleToCurrency( (double)p->nSingle );
292 0 : break;
293 :
294 : case SbxDATE:
295 : case SbxDOUBLE:
296 0 : if( p->nDouble * CURRENCY_FACTOR + 0.5 > (double)SAL_MAX_INT64
297 : || p->nDouble * CURRENCY_FACTOR - 0.5 < (double)SAL_MIN_INT64 )
298 : {
299 0 : nRes = SAL_MAX_INT64;
300 0 : if( p->nDouble * CURRENCY_FACTOR - 0.5 < (double)SAL_MIN_INT64 )
301 0 : nRes = SAL_MIN_INT64;
302 0 : SbxBase::SetError( SbxERR_OVERFLOW );
303 0 : break;
304 : }
305 0 : nRes = ImpDoubleToCurrency( p->nDouble );
306 0 : break;
307 :
308 : case SbxDECIMAL:
309 : case SbxBYREF | SbxDECIMAL:
310 : {
311 0 : double d = 0.0;
312 0 : if( p->pDecimal )
313 0 : p->pDecimal->getDouble( d );
314 0 : nRes = ImpDoubleToCurrency( d );
315 : break;
316 : }
317 :
318 :
319 : case SbxBYREF | SbxSTRING:
320 : case SbxSTRING:
321 : case SbxLPSTR:
322 0 : if( !p->pOUString )
323 0 : nRes=0;
324 : else
325 0 : nRes = ImpStringToCurrency( *p->pOUString );
326 0 : break;
327 : case SbxOBJECT:
328 : {
329 0 : SbxValue* pVal = PTR_CAST(SbxValue,p->pObj);
330 0 : if( pVal )
331 0 : nRes = pVal->GetCurrency();
332 : else
333 : {
334 0 : SbxBase::SetError( SbxERR_NO_OBJECT );
335 0 : nRes=0;
336 : }
337 0 : break;
338 : }
339 :
340 : case SbxBYREF | SbxCHAR:
341 0 : nRes = (sal_Int64)CURRENCY_FACTOR * (sal_Int64)(*p->pChar);
342 0 : break;
343 : case SbxBYREF | SbxBYTE:
344 0 : nRes = (sal_Int64)CURRENCY_FACTOR * (sal_Int64)(*p->pByte);
345 0 : break;
346 : case SbxBYREF | SbxBOOL:
347 : case SbxBYREF | SbxINTEGER:
348 0 : nRes = (sal_Int64)CURRENCY_FACTOR * (sal_Int64)(*p->pInteger);
349 0 : break;
350 : case SbxBYREF | SbxERROR:
351 : case SbxBYREF | SbxUSHORT:
352 0 : nRes = (sal_Int64)CURRENCY_FACTOR * (sal_Int64)(*p->pUShort);
353 0 : break;
354 :
355 : // from here on had to be tested
356 : case SbxBYREF | SbxLONG:
357 0 : aTmp.nLong = *p->pLong; goto ref;
358 : case SbxBYREF | SbxULONG:
359 0 : aTmp.nULong = *p->pULong; goto ref;
360 : case SbxBYREF | SbxSINGLE:
361 0 : aTmp.nSingle = *p->pSingle; goto ref;
362 : case SbxBYREF | SbxDATE:
363 : case SbxBYREF | SbxDOUBLE:
364 0 : aTmp.nDouble = *p->pDouble; goto ref;
365 : case SbxBYREF | SbxCURRENCY:
366 : case SbxBYREF | SbxSALINT64:
367 0 : aTmp.nInt64 = *p->pnInt64; goto ref;
368 : case SbxBYREF | SbxSALUINT64:
369 0 : aTmp.uInt64 = *p->puInt64; goto ref;
370 : ref:
371 0 : aTmp.eType = SbxDataType( p->eType & ~SbxBYREF );
372 0 : p = &aTmp; goto start;
373 :
374 : default:
375 0 : SbxBase::SetError( SbxERR_CONVERSION );
376 0 : nRes=0;
377 : }
378 0 : return nRes;
379 : }
380 :
381 :
382 0 : void ImpPutCurrency( SbxValues* p, const sal_Int64 r )
383 : {
384 0 : SbxValues aTmp;
385 : start:
386 0 : switch( +p->eType )
387 : {
388 : // Here are tests necessary
389 : case SbxCHAR:
390 0 : aTmp.pChar = &p->nChar; goto direct;
391 : case SbxBYTE:
392 0 : aTmp.pByte = &p->nByte; goto direct;
393 : case SbxINTEGER:
394 : case SbxBOOL:
395 0 : aTmp.pInteger = &p->nInteger; goto direct;
396 : case SbxLONG:
397 0 : aTmp.pLong = &p->nLong; goto direct;
398 : case SbxULONG:
399 0 : aTmp.pULong = &p->nULong; goto direct;
400 : case SbxERROR:
401 : case SbxUSHORT:
402 0 : aTmp.pUShort = &p->nUShort; goto direct;
403 : direct:
404 0 : aTmp.eType = SbxDataType( p->eType | SbxBYREF );
405 0 : p = &aTmp; goto start;
406 :
407 : // from here no longer
408 : case SbxSINGLE:
409 0 : p->nSingle = (float)( r / CURRENCY_FACTOR ); break;
410 : case SbxDATE:
411 : case SbxDOUBLE:
412 0 : p->nDouble = ImpCurrencyToDouble( r ); break;
413 : case SbxSALUINT64:
414 0 : p->uInt64 = r / CURRENCY_FACTOR; break;
415 : case SbxSALINT64:
416 0 : p->nInt64 = r / CURRENCY_FACTOR; break;
417 :
418 : case SbxCURRENCY:
419 0 : p->nInt64 = r; break;
420 :
421 : case SbxDECIMAL:
422 : case SbxBYREF | SbxDECIMAL:
423 : {
424 0 : SbxDecimal* pDec = ImpCreateDecimal( p );
425 0 : if( !pDec->setDouble( ImpCurrencyToDouble( r ) / CURRENCY_FACTOR ) )
426 0 : SbxBase::SetError( SbxERR_OVERFLOW );
427 0 : break;
428 : }
429 : case SbxBYREF | SbxSTRING:
430 : case SbxSTRING:
431 : case SbxLPSTR:
432 0 : if( !p->pOUString )
433 0 : p->pOUString = new rtl::OUString;
434 :
435 0 : *p->pOUString = ImpCurrencyToString( r );
436 0 : break;
437 : case SbxOBJECT:
438 : {
439 0 : SbxValue* pVal = PTR_CAST(SbxValue,p->pObj);
440 0 : if( pVal )
441 0 : pVal->PutCurrency( r );
442 : else
443 0 : SbxBase::SetError( SbxERR_NO_OBJECT );
444 0 : break;
445 : }
446 : case SbxBYREF | SbxCHAR:
447 : {
448 0 : sal_Int64 val = r / CURRENCY_FACTOR;
449 0 : if( val > SbxMAXCHAR )
450 : {
451 0 : SbxBase::SetError( SbxERR_OVERFLOW ); val = SbxMAXCHAR;
452 : }
453 0 : else if( val < SbxMINCHAR )
454 : {
455 0 : SbxBase::SetError( SbxERR_OVERFLOW ); val = SbxMINCHAR;
456 : }
457 0 : *p->pChar = (sal_Unicode) val; break;
458 : }
459 : case SbxBYREF | SbxBYTE:
460 : {
461 0 : sal_Int64 val = r / CURRENCY_FACTOR;
462 0 : if( val > SbxMAXBYTE )
463 : {
464 0 : SbxBase::SetError( SbxERR_OVERFLOW ); val = SbxMAXBYTE;
465 : }
466 0 : else if( val < 0 )
467 : {
468 0 : SbxBase::SetError( SbxERR_OVERFLOW ); val = 0;
469 : }
470 0 : *p->pByte = (sal_uInt8) val; break;
471 : }
472 : case SbxBYREF | SbxINTEGER:
473 : case SbxBYREF | SbxBOOL:
474 : {
475 0 : sal_Int64 val = r / CURRENCY_FACTOR;
476 0 : if( r > SbxMAXINT )
477 : {
478 0 : SbxBase::SetError( SbxERR_OVERFLOW ); val = SbxMAXINT;
479 : }
480 0 : else if( r < SbxMININT )
481 : {
482 0 : SbxBase::SetError( SbxERR_OVERFLOW ); val = SbxMININT;
483 : }
484 0 : *p->pInteger = (sal_uInt16) val; break;
485 : }
486 : case SbxBYREF | SbxERROR:
487 : case SbxBYREF | SbxUSHORT:
488 : {
489 0 : sal_Int64 val = r / CURRENCY_FACTOR;
490 0 : if( val > SbxMAXUINT )
491 : {
492 0 : SbxBase::SetError( SbxERR_OVERFLOW ); val = SbxMAXUINT;
493 : }
494 0 : else if( val < 0 )
495 : {
496 0 : SbxBase::SetError( SbxERR_OVERFLOW ); val = 0;
497 : }
498 0 : *p->pUShort = (sal_uInt16) val; break;
499 : }
500 : case SbxBYREF | SbxLONG:
501 : {
502 0 : sal_Int64 val = r / CURRENCY_FACTOR;
503 0 : if( val > SbxMAXLNG )
504 : {
505 0 : SbxBase::SetError( SbxERR_OVERFLOW ); val = SbxMAXLNG;
506 : }
507 0 : else if( val < SbxMINLNG )
508 : {
509 0 : SbxBase::SetError( SbxERR_OVERFLOW ); val = SbxMINLNG;
510 : }
511 0 : *p->pLong = (sal_Int32) val; break;
512 : }
513 : case SbxBYREF | SbxULONG:
514 : {
515 0 : sal_Int64 val = r / CURRENCY_FACTOR;
516 0 : if( val > SbxMAXULNG )
517 : {
518 0 : SbxBase::SetError( SbxERR_OVERFLOW ); val = SbxMAXULNG;
519 : }
520 0 : else if( val < 0 )
521 : {
522 0 : SbxBase::SetError( SbxERR_OVERFLOW ); val = 0;
523 : }
524 0 : *p->pULong = (sal_uInt32) val; break;
525 : }
526 : case SbxBYREF | SbxCURRENCY:
527 0 : *p->pnInt64 = r; break;
528 : case SbxBYREF | SbxSALINT64:
529 0 : *p->pnInt64 = r / CURRENCY_FACTOR; break;
530 : case SbxBYREF | SbxSALUINT64:
531 0 : *p->puInt64 = (sal_uInt64)r / CURRENCY_FACTOR; break;
532 : case SbxBYREF | SbxSINGLE:
533 0 : p->nSingle = (float)( r / CURRENCY_FACTOR ); break;
534 : case SbxBYREF | SbxDATE:
535 : case SbxBYREF | SbxDOUBLE:
536 0 : *p->pDouble = ImpCurrencyToDouble( r ); break;
537 : default:
538 0 : SbxBase::SetError( SbxERR_CONVERSION );
539 : }
540 0 : }
541 :
542 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
