LibreOffice Module basic (master) 1
sbxint.cxx
Go to the documentation of this file.
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 <sal/config.h>
21
22#include <o3tl/safeint.hxx>
23#include <comphelper/errcode.hxx>
24#include <basic/sberrors.hxx>
25#include "sbxconv.hxx"
26#include <rtlproto.hxx>
27
28#include <rtl/math.hxx>
29
30sal_Int16 ImpGetInteger( const SbxValues* p )
31{
32 SbxValues aTmp;
33 sal_Int16 nRes;
34start:
35 switch( +p->eType )
36 {
37 case SbxNULL:
38 SbxBase::SetError( ERRCODE_BASIC_CONVERSION );
39 [[fallthrough]];
40 case SbxEMPTY:
41 nRes = 0; break;
42 case SbxCHAR:
43 nRes = p->nChar; break;
44 case SbxBYTE:
45 nRes = p->nByte; break;
46 case SbxINTEGER:
47 case SbxBOOL:
48 nRes = p->nInteger; break;
49 case SbxERROR:
50 case SbxUSHORT:
51 if( p->nUShort > o3tl::make_unsigned(SbxMAXINT) )
52 {
53 SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); nRes = SbxMAXINT;
54 }
55 else
56 nRes = static_cast<sal_Int16>(p->nUShort);
57 break;
58 case SbxLONG:
59 if( p->nLong > SbxMAXINT )
60 {
61 SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); nRes = SbxMAXINT;
62 }
63 else if( p->nLong < SbxMININT )
64 {
65 SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); nRes = SbxMININT;
66 }
67 else
68 nRes = static_cast<sal_Int16>(p->nLong);
69 break;
70 case SbxULONG:
71 if( p->nULong > SbxMAXINT )
72 {
73 SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); nRes = SbxMAXINT;
74 }
75 else
76 nRes = static_cast<sal_Int16>(p->nULong);
77 break;
78 case SbxSINGLE:
79 nRes = ImpDoubleToInteger(p->nSingle);
80 break;
81 case SbxCURRENCY:
82 {
83 sal_Int64 tstVal = p->nInt64 / sal_Int64(CURRENCY_FACTOR);
84
85 if( tstVal > SbxMAXINT )
86 {
87 SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); nRes = SbxMAXINT;
88 }
89 else if( tstVal < SbxMININT )
90 {
91 SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); nRes = SbxMININT;
92 }
93 else
94 nRes = static_cast<sal_Int16>(tstVal);
95 break;
96 }
97 case SbxSALINT64:
98 if( p->nInt64 > SbxMAXINT )
99 {
100 SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); nRes = SbxMAXINT;
101 }
102 else if( p->nInt64 < SbxMININT )
103 {
104 SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); nRes = SbxMININT;
105 }
106 else
107 nRes = static_cast<sal_Int16>(p->nInt64);
108 break;
109 case SbxSALUINT64:
110 if( p->uInt64 > SbxMAXINT )
111 {
112 SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); nRes = SbxMAXINT;
113 }
114 else
115 nRes = static_cast<sal_Int16>(p->uInt64);
116 break;
117 case SbxDATE:
118 case SbxDOUBLE:
119 case SbxDECIMAL:
120 case SbxBYREF | SbxDECIMAL:
121 {
122 double dVal = 0.0;
123 if( p->eType == SbxDECIMAL )
124 {
125 if( p->pDecimal )
126 p->pDecimal->getDouble( dVal );
127 }
128 else
129 dVal = p->nDouble;
130
131 nRes = ImpDoubleToInteger(dVal);
132 break;
133 }
134 case SbxLPSTR:
135 case SbxSTRING:
136 case SbxBYREF | SbxSTRING:
137 if( !p->pOUString )
138 nRes = 0;
139 else
140 {
141 double d;
142 SbxDataType t;
143 if( ImpScan( *p->pOUString, d, t, nullptr, !LibreOffice6FloatingPointMode() ) != ERRCODE_NONE )
144 nRes = 0;
145 else
146 nRes = ImpDoubleToInteger(d);
147 }
148 break;
149 case SbxOBJECT:
150 {
151 SbxValue* pVal = dynamic_cast<SbxValue*>( p->pObj );
152 if( pVal )
153 nRes = pVal->GetInteger();
154 else
155 {
156 SbxBase::SetError( ERRCODE_BASIC_NO_OBJECT ); nRes = 0;
157 }
158 break;
159 }
160
161 case SbxBYREF | SbxCHAR:
162 nRes = *p->pChar; break;
163 case SbxBYREF | SbxBYTE:
164 nRes = *p->pByte; break;
165 case SbxBYREF | SbxINTEGER:
166 case SbxBYREF | SbxBOOL:
167 nRes = *p->pInteger; break;
168
169 // from here had to be tested
170 case SbxBYREF | SbxLONG:
171 aTmp.nLong = *p->pLong; goto ref;
172 case SbxBYREF | SbxULONG:
173 aTmp.nULong = *p->pULong; goto ref;
174 case SbxBYREF | SbxERROR:
175 case SbxBYREF | SbxUSHORT:
176 aTmp.nUShort = *p->pUShort; goto ref;
177 case SbxBYREF | SbxSINGLE:
178 aTmp.nSingle = *p->pSingle; goto ref;
179 case SbxBYREF | SbxDATE:
180 case SbxBYREF | SbxDOUBLE:
181 aTmp.nDouble = *p->pDouble; goto ref;
182 case SbxBYREF | SbxCURRENCY:
183 case SbxBYREF | SbxSALINT64:
184 aTmp.nInt64 = *p->pnInt64; goto ref;
185 case SbxBYREF | SbxSALUINT64:
186 aTmp.uInt64 = *p->puInt64; goto ref;
187 ref:
188 aTmp.eType = SbxDataType( p->eType & 0x0FFF );
189 p = &aTmp; goto start;
190
191 default:
192 SbxBase::SetError( ERRCODE_BASIC_CONVERSION ); nRes = 0;
193 }
194 return nRes;
195}
196
197void ImpPutInteger( SbxValues* p, sal_Int16 n )
198{
199 SbxValues aTmp;
200start:
201 switch( +p->eType )
202 {
203 // here had to be tested
204 case SbxCHAR:
205 aTmp.pChar = &p->nChar; goto direct;
206 case SbxBYTE:
207 aTmp.pByte = &p->nByte; goto direct;
208 case SbxULONG:
209 aTmp.pULong = &p->nULong; goto direct;
210 case SbxERROR:
211 case SbxUSHORT:
212 aTmp.pUShort = &p->nUShort; goto direct;
213 case SbxSALUINT64:
214 aTmp.puInt64 = &p->uInt64; goto direct;
215 direct:
216 aTmp.eType = SbxDataType( p->eType | SbxBYREF );
217 p = &aTmp; goto start;
218
219 // from here no tests needed
220 case SbxINTEGER:
221 case SbxBOOL:
222 p->nInteger = n; break;
223 case SbxLONG:
224 p->nLong = n; break;
225 case SbxSINGLE:
226 p->nSingle = n; break;
227 case SbxDATE:
228 case SbxDOUBLE:
229 p->nDouble = n; break;
230 case SbxCURRENCY:
231 p->nInt64 = n * CURRENCY_FACTOR; break;
232 case SbxSALINT64:
233 p->nInt64 = n; break;
234 case SbxDECIMAL:
235 case SbxBYREF | SbxDECIMAL:
236 ImpCreateDecimal( p )->setInt( n );
237 break;
238
239 case SbxLPSTR:
240 case SbxSTRING:
241 case SbxBYREF | SbxSTRING:
242 if( !p->pOUString )
243 p->pOUString = new OUString;
244 ImpCvtNum( static_cast<double>(n), 0, *p->pOUString );
245 break;
246 case SbxOBJECT:
247 {
248 SbxValue* pVal = dynamic_cast<SbxValue*>( p->pObj );
249 if( pVal )
250 pVal->PutInteger( n );
251 else
252 SbxBase::SetError( ERRCODE_BASIC_NO_OBJECT );
253 break;
254 }
255 case SbxBYREF | SbxCHAR:
256 if( n < SbxMINCHAR )
257 {
258 SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = SbxMINCHAR;
259 }
260 *p->pChar = static_cast<char>(n); break;
261 case SbxBYREF | SbxBYTE:
262 if( n > SbxMAXBYTE )
263 {
264 SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = SbxMAXBYTE;
265 }
266 else if( n < 0 )
267 {
268 SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = 0;
269 }
270 *p->pByte = static_cast<sal_uInt8>(n); break;
271 case SbxBYREF | SbxINTEGER:
272 case SbxBYREF | SbxBOOL:
273 *p->pInteger = n; break;
274 case SbxBYREF | SbxERROR:
275 case SbxBYREF | SbxUSHORT:
276 if( n < 0 )
277 {
278 SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = 0;
279 }
280 *p->pUShort = static_cast<sal_uInt16>(n); break;
281 case SbxBYREF | SbxLONG:
282 *p->pLong = static_cast<sal_Int32>(n); break;
283 case SbxBYREF | SbxULONG:
284 if( n < 0 )
285 {
286 SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = 0;
287 }
288 *p->pULong = static_cast<sal_uInt32>(n); break;
289 case SbxBYREF | SbxCURRENCY:
290 *p->pnInt64 = n * CURRENCY_FACTOR; break;
291 case SbxBYREF | SbxSALINT64:
292 *p->pnInt64 = n; break;
293 case SbxBYREF | SbxSALUINT64:
294 if( n < 0 )
295 {
296 SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW );
297 *p->puInt64 = 0;
298 }
299 else
300 *p->puInt64 = n;
301 break;
302 case SbxBYREF | SbxSINGLE:
303 *p->pSingle = static_cast<float>(n); break;
304 case SbxBYREF | SbxDATE:
305 case SbxBYREF | SbxDOUBLE:
306 *p->pDouble = static_cast<double>(n); break;
307
308 default:
309 SbxBase::SetError( ERRCODE_BASIC_CONVERSION );
310 }
311}
312
313
314// sal_Int64 / hyper
315
316double ImpSalUInt64ToDouble( sal_uInt64 n )
317{
318 double d = 0.0;
319 if( n > SAL_MAX_INT64 )
320 SbxBase::SetError( ERRCODE_BASIC_CONVERSION );
321 else
322 d = static_cast<double>(static_cast<sal_Int64>(n));
323 return d;
324}
325
326
327sal_Int64 ImpGetInt64( const SbxValues* p )
328{
329 SbxValues aTmp;
330 sal_Int64 nRes;
331start:
332 switch( +p->eType )
333 {
334 case SbxNULL:
335 SbxBase::SetError( ERRCODE_BASIC_CONVERSION );
336 [[fallthrough]];
337 case SbxEMPTY:
338 nRes = 0; break;
339 case SbxCHAR:
340 nRes = p->nChar; break;
341 case SbxBYTE:
342 nRes = p->nByte; break;
343 case SbxINTEGER:
344 case SbxBOOL:
345 nRes = p->nInteger; break;
346 case SbxERROR:
347 case SbxUSHORT:
348 nRes = static_cast<sal_Int64>(p->nUShort); break;
349 case SbxLONG:
350 nRes = static_cast<sal_Int64>(p->nLong); break;
351 case SbxULONG:
352 nRes = static_cast<sal_Int64>(p->nULong); break;
353 case SbxSINGLE:
354 nRes = ImpDoubleToSalInt64(p->nSingle);
355 break;
356 case SbxDATE:
357 case SbxDOUBLE:
358 nRes = ImpDoubleToSalInt64(p->nDouble);
359 break;
360 case SbxCURRENCY:
361 nRes = p->nInt64 / CURRENCY_FACTOR; break;
362 case SbxSALINT64:
363 nRes = p->nInt64; break;
364 case SbxSALUINT64:
365 if( p->uInt64 > SAL_MAX_INT64 )
366 {
367 SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); nRes = SAL_MAX_INT64;
368 }
369 else
370 nRes = static_cast<sal_Int64>(p->uInt64);
371 break;
372
373 case SbxBYREF | SbxSTRING:
374 case SbxSTRING:
375 case SbxLPSTR:
376 if( !p->pOUString )
377 nRes = 0;
378 else
379 {
380 nRes = p->pOUString->toInt64();
381 if( nRes == 0 )
382 {
383 // Check if really 0 or invalid conversion
384 double d;
385 SbxDataType t;
386 if( ImpScan( *p->pOUString, d, t, nullptr, !LibreOffice6FloatingPointMode() ) != ERRCODE_NONE )
387 nRes = 0;
388 else
389 nRes = ImpDoubleToSalInt64(d);
390 }
391 }
392 break;
393 case SbxOBJECT:
394 {
395 SbxValue* pVal = dynamic_cast<SbxValue*>( p->pObj );
396 if( pVal )
397 nRes = pVal->GetInt64();
398 else
399 {
400 SbxBase::SetError( ERRCODE_BASIC_NO_OBJECT ); nRes = 0;
401 }
402 break;
403 }
404
405 case SbxBYREF | SbxCHAR:
406 nRes = *p->pChar; break;
407 case SbxBYREF | SbxBYTE:
408 nRes = *p->pByte; break;
409 case SbxBYREF | SbxINTEGER:
410 case SbxBYREF | SbxBOOL:
411 nRes = *p->pInteger; break;
412 case SbxBYREF | SbxLONG:
413 nRes = *p->pLong; break;
414 case SbxBYREF | SbxULONG:
415 nRes = *p->pULong; break;
416 case SbxBYREF | SbxCURRENCY:
417 nRes = p->nInt64 / CURRENCY_FACTOR; break;
418 case SbxBYREF | SbxSALINT64:
419 nRes = *p->pnInt64; break;
420
421 // from here the values has to be checked
422 case SbxBYREF | SbxSALUINT64:
423 aTmp.uInt64 = *p->puInt64; goto ref;
424
425 case SbxBYREF | SbxERROR:
426 case SbxBYREF | SbxUSHORT:
427 aTmp.nUShort = *p->pUShort; goto ref;
428 case SbxBYREF | SbxSINGLE:
429 aTmp.nSingle = *p->pSingle; goto ref;
430 case SbxBYREF | SbxDATE:
431 case SbxBYREF | SbxDOUBLE:
432 aTmp.nDouble = *p->pDouble; goto ref;
433 ref:
434 aTmp.eType = SbxDataType( p->eType & 0x0FFF );
435 p = &aTmp; goto start;
436
437 default:
438 SbxBase::SetError( ERRCODE_BASIC_CONVERSION ); nRes = 0;
439 }
440 return nRes;
441}
442
443void ImpPutInt64( SbxValues* p, sal_Int64 n )
444{
445 SbxValues aTmp;
446
447start:
448 switch( +p->eType )
449 {
450 // Check necessary
451 case SbxCHAR:
452 aTmp.pChar = &p->nChar; goto direct;
453 case SbxBYTE:
454 aTmp.pByte = &p->nByte; goto direct;
455 case SbxINTEGER:
456 case SbxBOOL:
457 aTmp.pInteger = &p->nInteger; goto direct;
458 case SbxULONG:
459 aTmp.pULong = &p->nULong; goto direct;
460 case SbxERROR:
461 case SbxUSHORT:
462 aTmp.pUShort = &p->nUShort; goto direct;
463 case SbxLONG:
464 aTmp.pnInt64 = &p->nInt64; goto direct;
465 case SbxCURRENCY:
466 case SbxSALINT64:
467 aTmp.pnInt64 = &p->nInt64; goto direct;
468 case SbxSALUINT64:
469 aTmp.puInt64 = &p->uInt64; goto direct;
470
471 direct:
472 aTmp.eType = SbxDataType( p->eType | SbxBYREF );
473 p = &aTmp; goto start;
474
475 case SbxSINGLE:
476 p->nSingle = static_cast<float>(n); break;
477 case SbxDATE:
478 case SbxDOUBLE:
479 p->nDouble = static_cast<double>(n); break;
480
481 case SbxBYREF | SbxSTRING:
482 case SbxSTRING:
483 case SbxLPSTR:
484 {
485 if( !p->pOUString )
486 p->pOUString = new OUString;
487
488 (*p->pOUString) = OUString::number(n);
489 break;
490 }
491 case SbxOBJECT:
492 {
493 SbxValue* pVal = dynamic_cast<SbxValue*>( p->pObj );
494 if( pVal )
495 pVal->PutInt64( n );
496 else
497 SbxBase::SetError( ERRCODE_BASIC_NO_OBJECT );
498 break;
499 }
500 case SbxBYREF | SbxCHAR:
501 if( n > SbxMAXCHAR )
502 {
503 SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = SbxMAXCHAR;
504 }
505 else if( n < SbxMINCHAR )
506 {
507 SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = SbxMINCHAR;
508 }
509 *p->pChar = static_cast<sal_Unicode>(n); break;
510 case SbxBYREF | SbxBYTE:
511 if( n > SbxMAXBYTE )
512 {
513 SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = SbxMAXBYTE;
514 }
515 else if( n < 0 )
516 {
517 SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = 0;
518 }
519 *p->pByte = static_cast<sal_uInt8>(n); break;
520 case SbxBYREF | SbxINTEGER:
521 case SbxBYREF | SbxBOOL:
522 if( n > SbxMAXINT )
523 {
524 SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = SbxMAXINT;
525 }
526 else if( n < SbxMININT )
527 {
528 SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = SbxMININT;
529 }
530 *p->pInteger = static_cast<sal_Int16>(n); break;
531 case SbxBYREF | SbxERROR:
532 case SbxBYREF | SbxUSHORT:
533 if( n > SbxMAXUINT )
534 {
535 SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = SbxMAXUINT;
536 }
537 else if( n < 0 )
538 {
539 SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = 0;
540 }
541 *p->pUShort = static_cast<sal_uInt16>(n); break;
542 case SbxBYREF | SbxLONG:
543 if( n > SbxMAXLNG )
544 {
545 SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = SbxMAXLNG;
546 }
547 else if( n < SbxMINLNG )
548 {
549 SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = SbxMINLNG;
550 }
551 *p->pLong = static_cast<sal_Int32>(n); break;
552 case SbxBYREF | SbxULONG:
553 if( n > SbxMAXULNG )
554 {
555 SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = SbxMAXULNG;
556 }
557 else if( n < 0 )
558 {
559 SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = 0;
560 }
561 *p->pULong = static_cast<sal_uInt32>(n); break;
562 case SbxBYREF | SbxSINGLE:
563 *p->pSingle = static_cast<float>(n); break;
564 case SbxBYREF | SbxDATE:
565 case SbxBYREF | SbxDOUBLE:
566 *p->pDouble = static_cast<double>(n); break;
567 case SbxBYREF | SbxCURRENCY:
568 *p->pnInt64 = n * CURRENCY_FACTOR; break;
569 case SbxBYREF | SbxSALINT64:
570 *p->pnInt64 = n; break;
571 case SbxBYREF | SbxSALUINT64:
572 if( n < 0 )
573 {
574 SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = 0;
575 }
576 *p->puInt64 = n; break;
577
578 default:
579 SbxBase::SetError( ERRCODE_BASIC_CONVERSION );
580 }
581}
582
583sal_uInt64 ImpGetUInt64( const SbxValues* p )
584{
585 SbxValues aTmp;
586 sal_uInt64 nRes;
587start:
588 switch( +p->eType )
589 {
590 case SbxNULL:
591 SbxBase::SetError( ERRCODE_BASIC_CONVERSION );
592 [[fallthrough]];
593 case SbxEMPTY:
594 nRes = 0; break;
595 case SbxCHAR:
596 nRes = p->nChar; break;
597 case SbxBYTE:
598 nRes = p->nByte; break;
599 case SbxINTEGER:
600 case SbxBOOL:
601 nRes = p->nInteger; break;
602 case SbxERROR:
603 case SbxUSHORT:
604 nRes = p->nUShort; break;
605 case SbxLONG:
606 nRes = p->nLong; break;
607 case SbxULONG:
608 nRes = static_cast<sal_uInt64>(p->nULong); break;
609 case SbxSINGLE:
610 nRes = ImpDoubleToSalUInt64(p->nSingle); break;
611 case SbxDATE:
612 case SbxDOUBLE:
613 nRes = ImpDoubleToSalUInt64(p->nDouble);
614 break;
615 case SbxCURRENCY:
616 nRes = p->nInt64 * CURRENCY_FACTOR; break;
617 case SbxSALINT64:
618 if( p->nInt64 < 0 )
619 {
620 SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); nRes = 0;
621 }
622 else
623 nRes = static_cast<sal_uInt64>(p->nInt64);
624 break;
625 case SbxSALUINT64:
626 nRes = p->uInt64; break;
627
628 case SbxBYREF | SbxSTRING:
629 case SbxSTRING:
630 case SbxLPSTR:
631 if( !p->pOUString )
632 nRes = 0;
633 else
634 {
635 nRes = p->pOUString->toUInt64();
636 if( nRes == 0 )
637 {
638 // Check if really 0 or invalid conversion
639 double d;
640 SbxDataType t;
641 if( ImpScan( *p->pOUString, d, t, nullptr, !LibreOffice6FloatingPointMode() ) != ERRCODE_NONE )
642 nRes = 0;
643 else
644 nRes = ImpDoubleToSalUInt64(d);
645 }
646 }
647 break;
648 case SbxOBJECT:
649 {
650 SbxValue* pVal = dynamic_cast<SbxValue*>( p->pObj );
651 if( pVal )
652 nRes = pVal->GetUInt64();
653 else
654 {
655 SbxBase::SetError( ERRCODE_BASIC_NO_OBJECT ); nRes = 0;
656 }
657 break;
658 }
659
660 case SbxBYREF | SbxCHAR:
661 nRes = *p->pChar; break;
662 case SbxBYREF | SbxBYTE:
663 nRes = *p->pByte; break;
664 case SbxBYREF | SbxINTEGER:
665 case SbxBYREF | SbxBOOL:
666 nRes = *p->pInteger; break;
667 case SbxBYREF | SbxLONG:
668 nRes = *p->pLong; break;
669 case SbxBYREF | SbxULONG:
670 nRes = *p->pULong; break;
671 case SbxBYREF | SbxSALUINT64:
672 nRes = *p->puInt64; break;
673
674 // from here on the value has to be checked
675 case SbxBYREF | SbxERROR:
676 case SbxBYREF | SbxUSHORT:
677 aTmp.nUShort = *p->pUShort; goto ref;
678 case SbxBYREF | SbxSINGLE:
679 aTmp.nSingle = *p->pSingle; goto ref;
680 case SbxBYREF | SbxDATE:
681 case SbxBYREF | SbxDOUBLE:
682 aTmp.nDouble = *p->pDouble; goto ref;
683 case SbxBYREF | SbxCURRENCY:
684 case SbxBYREF | SbxSALINT64:
685 aTmp.nInt64 = *p->pnInt64; goto ref;
686 ref:
687 aTmp.eType = SbxDataType( p->eType & 0x0FFF );
688 p = &aTmp; goto start;
689
690 default:
691 SbxBase::SetError( ERRCODE_BASIC_CONVERSION ); nRes = 0;
692 }
693 return nRes;
694}
695
696void ImpPutUInt64( SbxValues* p, sal_uInt64 n )
697{
698 SbxValues aTmp;
699
700start:
701 switch( +p->eType )
702 {
703 // Check necessary
704 case SbxCHAR:
705 aTmp.pChar = &p->nChar; goto direct;
706 case SbxBYTE:
707 aTmp.pByte = &p->nByte; goto direct;
708 case SbxINTEGER:
709 case SbxBOOL:
710 aTmp.pInteger = &p->nInteger; goto direct;
711 case SbxULONG:
712 aTmp.pULong = &p->nULong; goto direct;
713 case SbxERROR:
714 case SbxUSHORT:
715 aTmp.pUShort = &p->nUShort; goto direct;
716 case SbxLONG:
717 aTmp.pnInt64 = &p->nInt64; goto direct;
718 case SbxCURRENCY:
719 case SbxSALINT64:
720 aTmp.pnInt64 = &p->nInt64; goto direct;
721 case SbxSINGLE:
722 aTmp.pSingle = &p->nSingle; goto direct;
723 case SbxDATE:
724 case SbxDOUBLE:
725 aTmp.pDouble = &p->nDouble; goto direct;
726
727 direct:
728 aTmp.eType = SbxDataType( p->eType | SbxBYREF );
729 p = &aTmp; goto start;
730
731 // Check not necessary
732 case SbxSALUINT64:
733 p->uInt64 = n; break;
734
735 case SbxBYREF | SbxSTRING:
736 case SbxSTRING:
737 case SbxLPSTR:
738 if( !p->pOUString )
739 p->pOUString = new OUString;
740 if( n > SAL_MAX_INT64 )
741 SbxBase::SetError( ERRCODE_BASIC_CONVERSION );
742 else
743 {
744 (*p->pOUString) = OUString::number(n);
745 }
746 break;
747 case SbxOBJECT:
748 {
749 SbxValue* pVal = dynamic_cast<SbxValue*>( p->pObj );
750 if( pVal )
751 pVal->PutUInt64( n );
752 else
753 SbxBase::SetError( ERRCODE_BASIC_NO_OBJECT );
754 break;
755 }
756 case SbxBYREF | SbxCHAR:
757 if( n > SbxMAXCHAR )
758 {
759 SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = SbxMAXCHAR;
760 }
761 *p->pChar = static_cast<sal_Unicode>(n); break;
762 case SbxBYREF | SbxBYTE:
763 if( n > SbxMAXBYTE )
764 {
765 SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = SbxMAXBYTE;
766 }
767 *p->pByte = static_cast<sal_uInt8>(n); break;
768 case SbxBYREF | SbxINTEGER:
769 case SbxBYREF | SbxBOOL:
770 if( n > SbxMAXINT )
771 {
772 SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = SbxMAXINT;
773 }
774 *p->pInteger = static_cast<sal_Int16>(n); break;
775 case SbxBYREF | SbxERROR:
776 case SbxBYREF | SbxUSHORT:
777 if( n > SbxMAXUINT )
778 {
779 SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = SbxMAXUINT;
780 }
781 *p->pUShort = static_cast<sal_uInt16>(n); break;
782 case SbxBYREF | SbxLONG:
783 if( n > SbxMAXLNG )
784 {
785 SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = SbxMAXLNG;
786 }
787 *p->pLong = static_cast<sal_Int32>(n); break;
788 case SbxBYREF | SbxULONG:
789 if( n > SbxMAXULNG )
790 {
791 SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = SbxMAXULNG;
792 }
793 *p->pULong = static_cast<sal_uInt32>(n); break;
794 case SbxBYREF | SbxSINGLE:
795 *p->pDouble = static_cast<float>(ImpSalUInt64ToDouble( n )); break;
796 case SbxBYREF | SbxDATE:
797 case SbxBYREF | SbxDOUBLE:
798
799 *p->pDouble = ImpSalUInt64ToDouble( n ); break;
800 case SbxBYREF | SbxCURRENCY:
801 if ( n > ( SAL_MAX_INT64 / CURRENCY_FACTOR ) )
802 {
803 SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW );
804 n = SAL_MAX_INT64;
805 }
806 *p->pnInt64 = static_cast<sal_Int64>( n * CURRENCY_FACTOR ); break;
807 case SbxBYREF | SbxSALUINT64:
808 *p->puInt64 = n; break;
809 case SbxBYREF | SbxSALINT64:
810 if( n > SAL_MAX_INT64 )
811 {
812 SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = 0;
813 }
814 *p->pnInt64 = static_cast<sal_Int64>(n); break;
815
816 default:
817 SbxBase::SetError( ERRCODE_BASIC_CONVERSION );
818 }
819}
820
821
822/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
t
XPropertyListType t
d
double d
SbxBase::SetError
static void SetError(ErrCode)
Definition: sbxbase.cxx:116
SbxDecimal::setInt
void setInt(int val)
Definition: sbxdec.cxx:326
SbxValue::PutInt64
bool PutInt64(sal_Int64)
SbxValue::GetUInt64
sal_uInt64 GetUInt64() const
Definition: sbxvar.hxx:144
SbxValue::PutInteger
bool PutInteger(sal_Int16)
SbxValue::GetInt64
sal_Int64 GetInt64() const
Definition: sbxvar.hxx:143
SbxValue::GetInteger
sal_Int16 GetInteger() const
Definition: sbxvar.hxx:141
SbxValue::PutUInt64
bool PutUInt64(sal_uInt64)
ERRCODE_NONE
#define ERRCODE_NONE
p
void * p
n
sal_Int64 n
o3tl::make_unsigned
constexpr std::enable_if_t< std::is_signed_v< T >, std::make_unsigned_t< T > > make_unsigned(T value)
LibreOffice6FloatingPointMode
bool LibreOffice6FloatingPointMode()
Definition: methods1.cxx:2946
ERRCODE_BASIC_NO_OBJECT
#define ERRCODE_BASIC_NO_OBJECT
Definition: sberrors.hxx:34
ERRCODE_BASIC_MATH_OVERFLOW
#define ERRCODE_BASIC_MATH_OVERFLOW
Definition: sberrors.hxx:27
ERRCODE_BASIC_CONVERSION
#define ERRCODE_BASIC_CONVERSION
Definition: sberrors.hxx:30
ImpDoubleToInteger
auto ImpDoubleToInteger(double f)
Definition: sbxconv.hxx:53
ImpDoubleToSalUInt64
auto ImpDoubleToSalUInt64(double d)
Definition: sbxconv.hxx:56
ImpScan
ErrCode ImpScan(const OUString &rSrc, double &nVal, SbxDataType &rType, sal_uInt16 *pLen, bool bOnlyIntntl)
Definition: sbxscan.cxx:71
ImpDoubleToSalInt64
auto ImpDoubleToSalInt64(double d)
Definition: sbxconv.hxx:57
ImpCreateDecimal
SbxDecimal * ImpCreateDecimal(SbxValues *p)
Definition: sbxdec.cxx:376
ImpCvtNum
void ImpCvtNum(double nNum, short nPrec, OUString &rRes, bool bCoreString=false)
Definition: sbxscan.cxx:290
SbxMAXULNG
constexpr sal_uInt32 SbxMAXULNG
Definition: sbxdef.hxx:192
SbxMAXLNG
constexpr auto SbxMAXLNG
Definition: sbxdef.hxx:190
SbxMINLNG
constexpr sal_Int32 SbxMINLNG
Definition: sbxdef.hxx:191
SbxBOOL
SbxBOOL
Definition: sbxdef.hxx:215
SbxMAXCHAR
constexpr auto SbxMAXCHAR
Definition: sbxdef.hxx:184
SbxMAXINT
constexpr auto SbxMAXINT
Definition: sbxdef.hxx:187
SbxMAXUINT
constexpr sal_uInt16 SbxMAXUINT
Definition: sbxdef.hxx:189
SbxDataType
SbxDataType
Definition: sbxdef.hxx:37
SbxOBJECT
@ SbxOBJECT
Definition: sbxdef.hxx:47
SbxSALINT64
@ SbxSALINT64
Definition: sbxdef.hxx:75
SbxLONG
@ SbxLONG
Definition: sbxdef.hxx:41
SbxSALUINT64
@ SbxSALUINT64
Definition: sbxdef.hxx:76
SbxNULL
@ SbxNULL
Definition: sbxdef.hxx:39
SbxBYTE
@ SbxBYTE
Definition: sbxdef.hxx:55
SbxEMPTY
@ SbxEMPTY
Definition: sbxdef.hxx:38
SbxDECIMAL
@ SbxDECIMAL
Definition: sbxdef.hxx:77
SbxULONG
@ SbxULONG
Definition: sbxdef.hxx:57
SbxUSHORT
@ SbxUSHORT
Definition: sbxdef.hxx:56
SbxERROR
@ SbxERROR
Definition: sbxdef.hxx:48
SbxDATE
@ SbxDATE
Definition: sbxdef.hxx:45
SbxCURRENCY
@ SbxCURRENCY
Definition: sbxdef.hxx:44
SbxLPSTR
@ SbxLPSTR
Definition: sbxdef.hxx:68
SbxSINGLE
@ SbxSINGLE
Definition: sbxdef.hxx:42
SbxBYREF
@ SbxBYREF
Definition: sbxdef.hxx:81
SbxCHAR
@ SbxCHAR
Definition: sbxdef.hxx:54
SbxSTRING
@ SbxSTRING
Definition: sbxdef.hxx:46
SbxINTEGER
@ SbxINTEGER
Definition: sbxdef.hxx:40
SbxDOUBLE
@ SbxDOUBLE
Definition: sbxdef.hxx:43
SbxMINCHAR
constexpr auto SbxMINCHAR
Definition: sbxdef.hxx:185
CURRENCY_FACTOR
constexpr auto CURRENCY_FACTOR
Definition: sbxdef.hxx:197
SbxMAXBYTE
constexpr auto SbxMAXBYTE
Definition: sbxdef.hxx:186
SbxMININT
constexpr auto SbxMININT
Definition: sbxdef.hxx:188
ImpPutInt64
void ImpPutInt64(SbxValues *p, sal_Int64 n)
Definition: sbxint.cxx:443
ImpPutUInt64
void ImpPutUInt64(SbxValues *p, sal_uInt64 n)
Definition: sbxint.cxx:696
ImpGetUInt64
sal_uInt64 ImpGetUInt64(const SbxValues *p)
Definition: sbxint.cxx:583
ImpGetInteger
sal_Int16 ImpGetInteger(const SbxValues *p)
Definition: sbxint.cxx:30
ImpSalUInt64ToDouble
double ImpSalUInt64ToDouble(sal_uInt64 n)
Definition: sbxint.cxx:316
ImpPutInteger
void ImpPutInteger(SbxValues *p, sal_Int16 n)
Definition: sbxint.cxx:197
ImpGetInt64
sal_Int64 ImpGetInt64(const SbxValues *p)
Definition: sbxint.cxx:327
SbxValues::nSingle
float nSingle
Definition: sbxvar.hxx:55
SbxValues::puInt64
sal_uInt64 * puInt64
Definition: sbxvar.hxx:69
SbxValues::nLong
sal_Int32 nLong
Definition: sbxvar.hxx:49
SbxValues::pSingle
float * pSingle
Definition: sbxvar.hxx:72
SbxValues::pByte
sal_uInt8 * pByte
Definition: sbxvar.hxx:63
SbxValues::pULong
sal_uInt32 * pULong
Definition: sbxvar.hxx:67
SbxValues::pUShort
sal_uInt16 * pUShort
Definition: sbxvar.hxx:64
SbxValues::pDouble
double * pDouble
Definition: sbxvar.hxx:73
SbxValues::nInt64
sal_Int64 nInt64
Definition: sbxvar.hxx:53
SbxValues::nDouble
double nDouble
Definition: sbxvar.hxx:56
SbxValues::nUShort
sal_uInt16 nUShort
Definition: sbxvar.hxx:45
SbxValues::uInt64
sal_uInt64 uInt64
Definition: sbxvar.hxx:52
SbxValues::pInteger
sal_Int16 * pInteger
Definition: sbxvar.hxx:66
SbxValues::eType
SbxDataType eType
Definition: sbxvar.hxx:77
SbxValues::nULong
sal_uInt32 nULong
Definition: sbxvar.hxx:48
SbxValues::pnInt64
sal_Int64 * pnInt64
Definition: sbxvar.hxx:70
SbxValues::pChar
sal_Unicode * pChar
Definition: sbxvar.hxx:65
SAL_MAX_INT64
#define SAL_MAX_INT64
sal_uInt8
unsigned char sal_uInt8
sal_Unicode
sal_uInt16 sal_Unicode
Generated on Sun Jul 30 2023 04:39:09 for LibreOffice Module basic (master) by doxygen 1.9.3