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