basic/source/sbx/sbxscan.cxx

   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 <config_features.h>
  21
  22 #include <vcl/errcode.hxx>
  23 #include <unotools/resmgr.hxx>
  24 #include "sbxconv.hxx"
  25
  26 #include <unotools/syslocale.hxx>
  27 #include <unotools/charclass.hxx>
  28
  29 #include <vcl/svapp.hxx>
  30 #include <vcl/settings.hxx>
  31
  32 #include <math.h>
  33
  34 #include <sbxbase.hxx>
  35 #include <sbintern.hxx>
  36 #include <basic/sbxform.hxx>
  37
  38 #include <date.hxx>
  39 #include <runtime.hxx>
  40 #include <strings.hrc>
  41
  42 #include <rtl/character.hxx>
  43 #include <sal/log.hxx>
  44 #include <svl/zforlist.hxx>
  45
  46
  47 void ImpGetIntntlSep( sal_Unicode& rcDecimalSep, sal_Unicode& rcThousandSep, sal_Unicode& rcDecimalSepAlt )
  48 {
  49     SvtSysLocale aSysLocale;
  50     const LocaleDataWrapper& rData = aSysLocale.GetLocaleData();
  51     rcDecimalSep = rData.getNumDecimalSep()[0];
  52     rcThousandSep = rData.getNumThousandSep()[0];
  53     rcDecimalSepAlt = rData.getNumDecimalSepAlt().toChar();
  54 }
  55
  56
  57 /** NOTE: slightly differs from strchr() in that it does not consider the
  58     terminating NULL character to be part of the string and returns bool
  59     instead of pointer, if character is 0 returns false.
  60  */
  61 static bool ImpStrChr( const sal_Unicode* p, sal_Unicode c )
  62 {
  63     if (!c)
  64         return false;
  65     while (*p)
  66     {
  67         if (*p++ == c)
  68             return true;
  69     }
  70     return false;
  71 }
  72
  73
  74 // scanning a string according to BASIC-conventions
  75 // but exponent may also be a D, so data type is SbxDOUBLE
  76 // conversion error if data type is fixed and it doesn't fit
  77
  78 ErrCode ImpScan( const OUString& rWSrc, double& nVal, SbxDataType& rType,
  79                   sal_uInt16* pLen, bool bOnlyIntntl )
  80 {
  81     sal_Unicode cIntntlDecSep, cIntntlGrpSep, cIntntlDecSepAlt;
  82     sal_Unicode cNonIntntlDecSep = '.';
  83     if( bOnlyIntntl )
  84     {
  85         ImpGetIntntlSep( cIntntlDecSep, cIntntlGrpSep, cIntntlDecSepAlt );
  86         cNonIntntlDecSep = cIntntlDecSep;
  87         // Ensure that the decimal separator alternative is really one.
  88         if (cIntntlDecSepAlt && cIntntlDecSepAlt == cNonIntntlDecSep)
  89             cIntntlDecSepAlt = 0;
  90     }
  91     else
  92     {
  93         cIntntlDecSep = cNonIntntlDecSep;
  94         cIntntlGrpSep = 0;  // no group separator accepted in non-i18n
  95         cIntntlDecSepAlt = 0;
  96     }
  97
  98     const sal_Unicode* const pStart = rWSrc.getStr();
  99     const sal_Unicode* p = pStart;
 100     OUStringBuffer aBuf( rWSrc.getLength());
 101     bool bRes = true;
 102     bool bMinus = false;
 103     nVal = 0;
 104     SbxDataType eScanType = SbxSINGLE;
 105     while( *p == ' ' || *p == '\t' )
 106         p++;
 107     if( *p == '-' )
 108     {
 109         p++;
 110         bMinus = true;
 111     }
 112     if( rtl::isAsciiDigit( *p ) || ((*p == cNonIntntlDecSep || *p == cIntntlDecSep ||
 113                     (cIntntlDecSep && *p == cIntntlGrpSep) || (cIntntlDecSepAlt && *p == cIntntlDecSepAlt)) &&
 114                 rtl::isAsciiDigit( *(p+1) )))
 115     {
 116         // tdf#118442: Whitespace and minus are skipped; store the position to calculate index
 117         const sal_Unicode* const pDigitsStart = p;
 118         short exp = 0;
 119         short decsep = 0;
 120         short ndig = 0;
 121         short ncdig = 0;    // number of digits after decimal point
 122         OUStringBuffer aSearchStr("0123456789DEde");
 123         aSearchStr.append(cNonIntntlDecSep);
 124         if( cIntntlDecSep != cNonIntntlDecSep )
 125             aSearchStr.append(cIntntlDecSep);
 126         if( cIntntlDecSepAlt && cIntntlDecSepAlt != cNonIntntlDecSep )
 127             aSearchStr.append(cIntntlDecSepAlt);
 128         if( bOnlyIntntl )
 129             aSearchStr.append(cIntntlGrpSep);
 130         const sal_Unicode* const pSearchStr = aSearchStr.getStr();
 131         const sal_Unicode pDdEe[] = { 'D', 'd', 'E', 'e', 0 };
 132         while( ImpStrChr( pSearchStr, *p ) )
 133         {
 134             aBuf.append( *p );
 135             if( bOnlyIntntl && *p == cIntntlGrpSep )
 136             {
 137                 p++;
 138                 continue;
 139             }
 140             if( *p == cNonIntntlDecSep || *p == cIntntlDecSep || (cIntntlDecSepAlt && *p == cIntntlDecSepAlt) )
 141             {
 142                 // Use the separator that is passed to stringToDouble()
 143                 aBuf[p - pDigitsStart] = cIntntlDecSep;
 144                 p++;
 145                 if( ++decsep > 1 )
 146                     continue;
 147             }
 148             else if( ImpStrChr( pDdEe, *p ) )
 149             {
 150                 if( ++exp > 1 )
 151                 {
 152                     p++;
 153                     continue;
 154                 }
 155                 if( *p == 'D' || *p == 'd' )
 156                     eScanType = SbxDOUBLE;
 157                 aBuf[p - pDigitsStart] = 'E';
 158                 p++;
 159                 if (*p == '+')
 160                     ++p;
 161                 else if (*p == '-')
 162                 {
 163                     aBuf.append('-');
 164                     ++p;
 165                 }
 166             }
 167             else
 168             {
 169                 p++;
 170                 if( decsep && !exp )
 171                     ncdig++;
 172             }
 173             if( !exp )
 174                 ndig++;
 175         }
 176
 177         if( decsep > 1 || exp > 1 )
 178             bRes = false;
 179
 180         OUString aBufStr( aBuf.makeStringAndClear());
 181         rtl_math_ConversionStatus eStatus = rtl_math_ConversionStatus_Ok;
 182         sal_Int32 nParseEnd = 0;
 183         nVal = rtl::math::stringToDouble( aBufStr, cIntntlDecSep, cIntntlGrpSep, &eStatus, &nParseEnd );
 184         if( eStatus != rtl_math_ConversionStatus_Ok || nParseEnd != aBufStr.getLength() )
 185             bRes = false;
 186
 187         if( !decsep && !exp )
 188         {
 189             if( nVal >= SbxMININT && nVal <= SbxMAXINT )
 190                 eScanType = SbxINTEGER;
 191             else if( nVal >= SbxMINLNG && nVal <= SbxMAXLNG )
 192                 eScanType = SbxLONG;
 193         }
 194
 195         ndig = ndig - decsep;
 196         // too many numbers for SINGLE?
 197         if( ndig > 15 || ncdig > 6 )
 198             eScanType = SbxDOUBLE;
 199
 200         // type detection?
 201         const sal_Unicode pTypes[] = { '%', '!', '&', '#', 0 };
 202         if( ImpStrChr( pTypes, *p ) )
 203             p++;
 204     }
 205     // hex/octal number? read in and convert:
 206     else if( *p == '&' )
 207     {
 208         p++;
 209         eScanType = SbxLONG;
 210         OUString aCmp( "0123456789ABCDEFabcdef" );
 211         char base = 16;
 212         char ndig = 8;
 213         switch( *p++ )
 214         {
 215             case 'O':
 216             case 'o':
 217                 aCmp = "01234567";
 218                 base = 8;
 219                 ndig = 11;
 220                 break;
 221             case 'H':
 222             case 'h':
 223                 break;
 224             default :
 225                 bRes = false;
 226         }
 227         const sal_Unicode* const pCmp = aCmp.getStr();
 228         while( rtl::isAsciiAlphanumeric( *p ) )    /* XXX: really munge all alnum also when error? */
 229         {
 230             sal_Unicode ch = *p;
 231             if( ImpStrChr( pCmp, ch ) )
 232             {
 233                 if (ch > 0x60)
 234                     ch -= 0x20;     // convert ASCII lower to upper case
 235                 aBuf.append( ch );
 236             }
 237             else
 238                 bRes = false;
 239             p++;
 240         }
 241         OUString aBufStr( aBuf.makeStringAndClear());
 242         sal_Int32 l = 0;
 243         for( const sal_Unicode* q = aBufStr.getStr(); bRes && *q; q++ )
 244         {
 245             int i = *q - '0';
 246             if( i > 9 )
 247                 i -= 7;     // 'A'-'0' = 17 => 10, ...
 248             l = ( l * base ) + i;
 249             if( !ndig-- )
 250                 bRes = false;
 251         }
 252         if( *p == '&' )
 253             p++;
 254         nVal = static_cast<double>(l);
 255         if( l >= SbxMININT && l <= SbxMAXINT )
 256             eScanType = SbxINTEGER;
 257     }
 258 #if HAVE_FEATURE_SCRIPTING
 259     else if ( SbiRuntime::isVBAEnabled() )
 260     {
 261         SAL_WARN("basic", "Reporting error converting");
 262         return ERRCODE_BASIC_CONVERSION;
 263     }
 264 #endif
 265     if( pLen )
 266         *pLen = static_cast<sal_uInt16>( p - pStart );
 267     if( !bRes )
 268         return ERRCODE_BASIC_CONVERSION;
 269     if( bMinus )
 270         nVal = -nVal;
 271     rType = eScanType;
 272     return ERRCODE_NONE;
 273 }
 274
 275 // port for CDbl in the Basic
 276 ErrCode SbxValue::ScanNumIntnl( const OUString& rSrc, double& nVal, bool bSingle )
 277 {
 278     SbxDataType t;
 279     sal_uInt16 nLen = 0;
 280     ErrCode nRetError = ImpScan( rSrc, nVal, t, &nLen,
 281         /*bOnlyIntntl*/true );
 282     // read completely?
 283     if( nRetError == ERRCODE_NONE && nLen != rSrc.getLength() )
 284     {
 285         nRetError = ERRCODE_BASIC_CONVERSION;
 286     }
 287     if( bSingle )
 288     {
 289         SbxValues aValues( nVal );
 290         nVal = static_cast<double>(ImpGetSingle( &aValues ));    // here error at overflow
 291     }
 292     return nRetError;
 293 }
 294
 295
 296 static const double roundArray[] = {
 297     5.0e+0, 0.5e+0, 0.5e-1, 0.5e-2, 0.5e-3, 0.5e-4, 0.5e-5, 0.5e-6, 0.5e-7,
 298     0.5e-8, 0.5e-9, 0.5e-10,0.5e-11,0.5e-12,0.5e-13,0.5e-14,0.5e-15 };
 299
 300 /*
 301 |*
 302 |*  void myftoa( double, char *, short, short, bool, bool )
 303 |*
 304 |*  description:        conversion double --> ASCII
 305 |*  parameters:         double              the number
 306 |*                      char *              target buffer
 307 |*                      short               number of positions after decimal point
 308 |*                      short               range of the exponent ( 0=no E )
 309 |*                      bool                true: with 1000-separators
 310 |*                      bool                true: output without formatting
 311 |*
 312  */
 313
 314 static void myftoa( double nNum, char * pBuf, short nPrec, short nExpWidth,
 315                     sal_Unicode cForceThousandSep )
 316 {
 317
 318     short nExp = 0;
 319     short nDig = nPrec + 1;
 320     short nDec;                         // number of positions before decimal point
 321     int i;
 322
 323     sal_Unicode cDecimalSep, cThousandSep, cDecimalSepAlt;
 324     ImpGetIntntlSep( cDecimalSep, cThousandSep, cDecimalSepAlt );
 325     if( cForceThousandSep )
 326         cThousandSep = cForceThousandSep;
 327
 328     // compute exponent
 329     nExp = 0;
 330     if( nNum > 0.0 )
 331     {
 332         while( nNum <   1.0 )
 333         {
 334             nNum *= 10.0;
 335             nExp--;
 336         }
 337         while( nNum >= 10.0 )
 338         {
 339             nNum /= 10.0;
 340             nExp++;
 341         }
 342     }
 343     if( !nPrec )
 344         nDig = nExp + 1;
 345
 346     // round number
 347     if( (nNum += roundArray [std::min<short>( nDig, 16 )] ) >= 10.0 )
 348     {
 349         nNum = 1.0;
 350         ++nExp;
 351         if( !nExpWidth ) ++nDig;
 352     }
 353
 354     // determine positions before decimal point
 355     if( !nExpWidth )
 356     {
 357         if( nExp < 0 )
 358         {
 359             // #41691: also a 0 at bFix
 360             *pBuf++ = '0';
 361             if( nPrec ) *pBuf++ = static_cast<char>(cDecimalSep);
 362             i = -nExp - 1;
 363             if( nDig <= 0 ) i = nPrec;
 364             while( i-- )    *pBuf++ = '0';
 365             nDec = 0;
 366         }
 367         else
 368             nDec = nExp+1;
 369     }
 370     else
 371         nDec = 1;
 372
 373     // output number
 374     if( nDig > 0 )
 375     {
 376         int digit;
 377         for( i = 0 ; ; ++i )
 378         {
 379             if( i < 16 )
 380             {
 381                 digit = static_cast<int>(nNum);
 382                 *pBuf++ = sal::static_int_cast< char >(digit + '0');
 383                 nNum =( nNum - digit ) * 10.0;
 384             } else
 385                 *pBuf++ = '0';
 386             if( --nDig == 0 ) break;
 387             if( nDec )
 388             {
 389                 nDec--;
 390                 if( !nDec )
 391                     *pBuf++ = static_cast<char>(cDecimalSep);
 392             }
 393         }
 394     }
 395
 396     // output exponent
 397     if( nExpWidth )
 398     {
 399         if( nExpWidth < 3 ) nExpWidth = 3;
 400         nExpWidth -= 2;
 401         *pBuf++ = 'E';
 402         if ( nExp < 0 )
 403         {
 404             nExp = -nExp;
 405             *pBuf++ = '-';
 406         }
 407         else
 408             *pBuf++ = '+';
 409         while( nExpWidth > 3 )
 410         {
 411             *pBuf++ = '0';
 412             nExpWidth--;
 413         }
 414         if( nExp >= 100 || nExpWidth == 3 )
 415         {
 416             *pBuf++ = sal::static_int_cast< char >(nExp/100 + '0');
 417             nExp %= 100;
 418         }
 419         if( nExp/10 || nExpWidth >= 2 )
 420             *pBuf++ = sal::static_int_cast< char >(nExp/10 + '0');
 421         *pBuf++ = sal::static_int_cast< char >(nExp%10 + '0');
 422     }
 423     *pBuf = 0;
 424 }
 425
 426 // The number is prepared unformattedly with the given number of
 427 // NK-positions. A leading minus is added if applicable.
 428 // This routine is public because it's also used by the Put-functions
 429 // in the class SbxImpSTRING.
 430
 431 void ImpCvtNum( double nNum, short nPrec, OUString& rRes, bool bCoreString )
 432 {
 433     char *q;
 434     char cBuf[ 40 ], *p = cBuf;
 435
 436     sal_Unicode cDecimalSep, cThousandSep, cDecimalSepAlt;
 437     ImpGetIntntlSep( cDecimalSep, cThousandSep, cDecimalSepAlt );
 438     if( bCoreString )
 439         cDecimalSep = '.';
 440
 441     if( nNum < 0.0 ) {
 442         nNum = -nNum;
 443         *p++ = '-';
 444     }
 445     double dMaxNumWithoutExp = (nPrec == 6) ? 1E6 : 1E14;
 446     myftoa( nNum, p, nPrec,( nNum &&( nNum < 1E-1 || nNum >= dMaxNumWithoutExp ) ) ? 4:0,
 447         cDecimalSep );
 448     // remove trailing zeros
 449     for( p = cBuf; *p &&( *p != 'E' ); p++ ) {}
 450     q = p; p--;
 451     while( nPrec && *p == '0' )
 452     {
 453         nPrec--;
 454         p--;
 455     }
 456     if( *p == cDecimalSep ) p--;
 457     while( *q ) *++p = *q++;
 458     *++p = 0;
 459     rRes = OUString::createFromAscii( cBuf );
 460 }
 461
 462 bool ImpConvStringExt( OUString& rSrc, SbxDataType eTargetType )
 463 {
 464     bool bChanged = false;
 465     OUString aNewString;
 466
 467     // only special cases are handled, nothing on default
 468     switch( eTargetType )
 469     {
 470         // consider international for floating point
 471         case SbxSINGLE:
 472         case SbxDOUBLE:
 473         case SbxCURRENCY:
 474         {
 475             sal_Unicode cDecimalSep, cThousandSep, cDecimalSepAlt;
 476             ImpGetIntntlSep( cDecimalSep, cThousandSep, cDecimalSepAlt );
 477             aNewString = rSrc;
 478
 479             if( cDecimalSep != '.' || (cDecimalSepAlt && cDecimalSepAlt != '.') )
 480             {
 481                 sal_Int32 nPos = aNewString.indexOf( cDecimalSep );
 482                 if( nPos == -1 && cDecimalSepAlt )
 483                     nPos = aNewString.indexOf( cDecimalSepAlt );
 484                 if( nPos != -1 )
 485                 {
 486                     sal_Unicode* pStr = const_cast<sal_Unicode*>(aNewString.getStr());
 487                     pStr[nPos] = '.';
 488                     bChanged = true;
 489                 }
 490             }
 491             break;
 492         }
 493
 494         // check as string in case of sal_Bool sal_True and sal_False
 495         case SbxBOOL:
 496         {
 497             if( rSrc.equalsIgnoreAsciiCase("true") )
 498             {
 499                 aNewString = OUString::number( SbxTRUE );
 500                 bChanged = true;
 501             }
 502             else if( rSrc.equalsIgnoreAsciiCase("false") )
 503             {
 504                 aNewString = OUString::number( SbxFALSE );
 505                 bChanged = true;
 506             }
 507             break;
 508         }
 509         default: break;
 510     }
 511
 512     if( bChanged )
 513         rSrc = aNewString;
 514     return bChanged;
 515 }
 516
 517
 518 // formatted number output
 519 // the return value is the number of characters used
 520 // from the format
 521
 522 static sal_uInt16 printfmtstr( const OUString& rStr, OUString& rRes, const OUString& rFmt )
 523 {
 524     OUStringBuffer aTemp;
 525     const sal_Unicode* pStr = rStr.getStr();
 526     const sal_Unicode* pFmtStart = rFmt.getStr();
 527     const sal_Unicode* pFmt = pFmtStart;
 528
 529     switch( *pFmt )
 530     {
 531     case '!':
 532         aTemp.append(*pStr++);
 533         pFmt++;
 534         break;
 535     case '\\':
 536         do
 537         {
 538             aTemp.append( *pStr ? *pStr++ : u' ');
 539             pFmt++;
 540         }
 541         while( *pFmt && *pFmt != '\\' );
 542         aTemp.append(*pStr ? *pStr++ : u' ');
 543         pFmt++; break;
 544     case '&':
 545         aTemp = rStr;
 546         pFmt++; break;
 547     default:
 548         aTemp = rStr;
 549         break;
 550     }
 551     rRes = aTemp.makeStringAndClear();
 552     return static_cast<sal_uInt16>( pFmt - pFmtStart );
 553 }
 554
 555
 556 bool SbxValue::Scan( const OUString& rSrc, sal_uInt16* pLen )
 557 {
 558     ErrCode eRes = ERRCODE_NONE;
 559     if( !CanWrite() )
 560     {
 561         eRes = ERRCODE_BASIC_PROP_READONLY;
 562     }
 563     else
 564     {
 565         double n;
 566         SbxDataType t;
 567         eRes = ImpScan( rSrc, n, t, pLen, false );
 568         if( eRes == ERRCODE_NONE )
 569         {
 570             if( !IsFixed() )
 571             {
 572                 SetType( t );
 573             }
 574             PutDouble( n );
 575         }
 576     }
 577     if( eRes )
 578     {
 579         SetError( eRes );
 580         return false;
 581     }
 582     else
 583     {
 584         return true;
 585     }
 586 }
 587
 588 std::locale BasResLocale()
 589 {
 590     return Translate::Create("sb");
 591 }
 592
 593 OUString BasResId(const char *pId)
 594 {
 595     return Translate::get(pId, BasResLocale());
 596 }
 597
 598 namespace
 599 {
 600
 601 enum class VbaFormatType
 602 {
 603     Offset,      // standard number format
 604     UserDefined, // user defined number format
 605     Null
 606 };
 607
 608 struct VbaFormatInfo
 609 {
 610     VbaFormatType meType;
 611     OUStringLiteral mpVbaFormat; // Format string in vba
 612     NfIndexTableOffset meOffset; // SvNumberFormatter format index, if meType = VbaFormatType::Offset
 613     const char* mpOOoFormat;     // if meType = VbaFormatType::UserDefined
 614 };
 615
 616 #if HAVE_FEATURE_SCRIPTING
 617 const VbaFormatInfo pFormatInfoTable[] =
 618 {
 619     { VbaFormatType::Offset,      OUStringLiteral("Long Date"),   NF_DATE_SYSTEM_LONG,    nullptr },
 620     { VbaFormatType::UserDefined, OUStringLiteral("Medium Date"), NF_NUMBER_STANDARD,     "DD-MMM-YY" },
 621     { VbaFormatType::Offset,      OUStringLiteral("Short Date"),  NF_DATE_SYSTEM_SHORT,   nullptr },
 622     { VbaFormatType::UserDefined, OUStringLiteral("Long Time"),   NF_NUMBER_STANDARD,     "H:MM:SS AM/PM" },
 623     { VbaFormatType::Offset,      OUStringLiteral("Medium Time"), NF_TIME_HHMMAMPM,       nullptr },
 624     { VbaFormatType::Offset,      OUStringLiteral("Short Time"),  NF_TIME_HHMM,           nullptr },
 625     { VbaFormatType::Offset,      OUStringLiteral("ddddd"),       NF_DATE_SYSTEM_SHORT,   nullptr },
 626     { VbaFormatType::Offset,      OUStringLiteral("dddddd"),      NF_DATE_SYSTEM_LONG,    nullptr },
 627     { VbaFormatType::UserDefined, OUStringLiteral("ttttt"),       NF_NUMBER_STANDARD,     "H:MM:SS AM/PM" },
 628     { VbaFormatType::Offset,      OUStringLiteral("ww"),          NF_DATE_WW,             nullptr },
 629     { VbaFormatType::Null,        OUStringLiteral(""),            NF_INDEX_TABLE_ENTRIES, nullptr }
 630 };
 631
 632 const VbaFormatInfo* getFormatInfo( const OUString& rFmt )
 633 {
 634     const VbaFormatInfo* pInfo = pFormatInfoTable;
 635     while( pInfo->meType != VbaFormatType::Null )
 636     {
 637         if( rFmt.equalsIgnoreAsciiCase( pInfo->mpVbaFormat ) )
 638             break;
 639         ++pInfo;
 640     }
 641     return pInfo;
 642 }
 643 #endif
 644
 645 } // namespace
 646
 647 #if HAVE_FEATURE_SCRIPTING
 648 #define VBAFORMAT_GENERALDATE       "General Date"
 649 #define VBAFORMAT_C                 "c"
 650 #define VBAFORMAT_N                 "n"
 651 #define VBAFORMAT_NN                "nn"
 652 #define VBAFORMAT_W                 "w"
 653 #define VBAFORMAT_Y                 "y"
 654 #define VBAFORMAT_LOWERCASE         "<"
 655 #define VBAFORMAT_UPPERCASE         ">"
 656 #endif
 657
 658 void SbxValue::Format( OUString& rRes, const OUString* pFmt ) const
 659 {
 660     short nComma = 0;
 661     double d = 0;
 662
 663     // pflin, It is better to use SvNumberFormatter to handle the date/time/number format.
 664     // the SvNumberFormatter output is mostly compatible with
 665     // VBA output besides the OOo-basic output
 666 #if HAVE_FEATURE_SCRIPTING
 667     if( pFmt && !SbxBasicFormater::isBasicFormat( *pFmt ) )
 668     {
 669         OUString aStr = GetOUString();
 670
 671         SvtSysLocale aSysLocale;
 672         const CharClass& rCharClass = aSysLocale.GetCharClass();
 673
 674         if( pFmt->equalsIgnoreAsciiCase( VBAFORMAT_LOWERCASE ) )
 675         {
 676             rRes = rCharClass.lowercase( aStr );
 677             return;
 678         }
 679         if( pFmt->equalsIgnoreAsciiCase( VBAFORMAT_UPPERCASE ) )
 680         {
 681             rRes = rCharClass.uppercase( aStr );
 682             return;
 683         }
 684
 685         LanguageType eLangType = Application::GetSettings().GetLanguageTag().getLanguageType();
 686         std::shared_ptr<SvNumberFormatter> pFormatter;
 687         if (GetSbData()->pInst)
 688         {
 689             pFormatter = GetSbData()->pInst->GetNumberFormatter();
 690         }
 691         else
 692         {
 693             sal_uInt32 n;   // Dummy
 694             pFormatter = SbiInstance::PrepareNumberFormatter( n, n, n );
 695         }
 696
 697         // Passing an index of a locale switches IsNumberFormat() to use that
 698         // locale in case the formatter wasn't default created with it.
 699         sal_uInt32 nIndex = pFormatter->GetStandardIndex( eLangType);
 700         double nNumber;
 701         Color* pCol;
 702
 703         bool bSuccess = pFormatter->IsNumberFormat( aStr, nIndex, nNumber );
 704
 705         // number format, use SvNumberFormatter to handle it.
 706         if( bSuccess )
 707         {
 708             sal_Int32 nCheckPos = 0;
 709             SvNumFormatType nType;
 710             OUString aFmtStr = *pFmt;
 711             const VbaFormatInfo* pInfo = getFormatInfo( aFmtStr );
 712             if( pInfo->meType != VbaFormatType::Null )
 713             {
 714                 if( pInfo->meType == VbaFormatType::Offset )
 715                 {
 716                     nIndex = pFormatter->GetFormatIndex( pInfo->meOffset, eLangType );
 717                 }
 718                 else
 719                 {
 720                     aFmtStr = OUString::createFromAscii(pInfo->mpOOoFormat);
 721                     pFormatter->PutandConvertEntry( aFmtStr, nCheckPos, nType, nIndex, LANGUAGE_ENGLISH, eLangType, true);
 722                 }
 723                 pFormatter->GetOutputString( nNumber, nIndex, rRes, &pCol );
 724             }
 725             else if( aFmtStr.equalsIgnoreAsciiCase( VBAFORMAT_GENERALDATE )
 726                     || aFmtStr.equalsIgnoreAsciiCase( VBAFORMAT_C ))
 727             {
 728                 if( nNumber <=-1.0 || nNumber >= 1.0 )
 729                 {
 730                     // short date
 731                     nIndex = pFormatter->GetFormatIndex( NF_DATE_SYSTEM_SHORT, eLangType );
 732                     pFormatter->GetOutputString( nNumber, nIndex, rRes, &pCol );
 733
 734                     // long time
 735                     if( floor( nNumber ) != nNumber )
 736                     {
 737                         aFmtStr = "H:MM:SS AM/PM";
 738                         pFormatter->PutandConvertEntry( aFmtStr, nCheckPos, nType, nIndex, LANGUAGE_ENGLISH, eLangType, true);
 739                         OUString aTime;
 740                         pFormatter->GetOutputString( nNumber, nIndex, aTime, &pCol );
 741                         rRes += " " + aTime;
 742                     }
 743                 }
 744                 else
 745                 {
 746                     // long time only
 747                     aFmtStr = "H:MM:SS AM/PM";
 748                     pFormatter->PutandConvertEntry( aFmtStr, nCheckPos, nType, nIndex, LANGUAGE_ENGLISH, eLangType, true);
 749                     pFormatter->GetOutputString( nNumber, nIndex, rRes, &pCol );
 750                 }
 751             }
 752             else if( aFmtStr.equalsIgnoreAsciiCase( VBAFORMAT_N ) ||
 753                      aFmtStr.equalsIgnoreAsciiCase( VBAFORMAT_NN ))
 754             {
 755                 sal_Int32 nMin = implGetMinute( nNumber );
 756                 if( nMin < 10 && aFmtStr.equalsIgnoreAsciiCase( VBAFORMAT_NN ))
 757                 {
 758                     // Minute in two digits
 759                      sal_Unicode aBuf[2];
 760                      aBuf[0] = '0';
 761                      aBuf[1] = '0' + nMin;
 762                      rRes = OUString(aBuf, SAL_N_ELEMENTS(aBuf));
 763                 }
 764                 else
 765                 {
 766                     rRes = OUString::number(nMin);
 767                 }
 768             }
 769             else if( aFmtStr.equalsIgnoreAsciiCase( VBAFORMAT_W ))
 770             {
 771                 sal_Int32 nWeekDay = implGetWeekDay( nNumber );
 772                 rRes = OUString::number(nWeekDay);
 773             }
 774             else if( aFmtStr.equalsIgnoreAsciiCase( VBAFORMAT_Y ))
 775             {
 776                 sal_Int16 nYear = implGetDateYear( nNumber );
 777                 double dBaseDate;
 778                 implDateSerial( nYear, 1, 1, true, SbDateCorrection::None, dBaseDate );
 779                 sal_Int32 nYear32 = 1 + sal_Int32( nNumber - dBaseDate );
 780                 rRes = OUString::number(nYear32);
 781             }
 782             else
 783             {
 784                 pFormatter->PutandConvertEntry( aFmtStr, nCheckPos, nType, nIndex, LANGUAGE_ENGLISH, eLangType, true);
 785                 pFormatter->GetOutputString( nNumber, nIndex, rRes, &pCol );
 786             }
 787
 788             return;
 789         }
 790     }
 791 #endif
 792
 793     SbxDataType eType = GetType();
 794     switch( eType )
 795     {
 796     case SbxCHAR:
 797     case SbxBYTE:
 798     case SbxINTEGER:
 799     case SbxUSHORT:
 800     case SbxLONG:
 801     case SbxULONG:
 802     case SbxINT:
 803     case SbxUINT:
 804     case SbxNULL:       // #45929 NULL with a little cheating
 805         nComma = 0;     goto cvt;
 806     case SbxSINGLE:
 807         nComma = 6;     goto cvt;
 808     case SbxDOUBLE:
 809         nComma = 14;
 810
 811     cvt:
 812         if( eType != SbxNULL )
 813         {
 814             d = GetDouble();
 815         }
 816         // #45355 another point to jump in for isnumeric-String
 817     cvt2:
 818         if( pFmt )
 819         {
 820             SbxAppData& rAppData = GetSbxData_Impl();
 821
 822             LanguageType eLangType = Application::GetSettings().GetLanguageTag().getLanguageType();
 823             if( rAppData.pBasicFormater )
 824             {
 825                 if( rAppData.eBasicFormaterLangType != eLangType )
 826                 {
 827                     rAppData.pBasicFormater.reset();
 828                 }
 829             }
 830             rAppData.eBasicFormaterLangType = eLangType;
 831
 832
 833             if( !rAppData.pBasicFormater )
 834             {
 835                 SvtSysLocale aSysLocale;
 836                 const LocaleDataWrapper& rData = aSysLocale.GetLocaleData();
 837                 sal_Unicode cComma = rData.getNumDecimalSep()[0];
 838                 sal_Unicode c1000  = rData.getNumThousandSep()[0];
 839                 const OUString& aCurrencyStrg = rData.getCurrSymbol();
 840
 841                 // initialize the Basic-formater help object:
 842                 // get resources for predefined output
 843                 // of the Format()-command, e. g. for "On/Off"
 844                 OUString aOnStrg = BasResId(STR_BASICKEY_FORMAT_ON);
 845                 OUString aOffStrg = BasResId(STR_BASICKEY_FORMAT_OFF);
 846                 OUString aYesStrg = BasResId(STR_BASICKEY_FORMAT_YES);
 847                 OUString aNoStrg = BasResId(STR_BASICKEY_FORMAT_NO);
 848                 OUString aTrueStrg = BasResId(STR_BASICKEY_FORMAT_TRUE);
 849                 OUString aFalseStrg = BasResId(STR_BASICKEY_FORMAT_FALSE);
 850                 OUString aCurrencyFormatStrg = BasResId(STR_BASICKEY_FORMAT_CURRENCY);
 851
 852                 rAppData.pBasicFormater = std::make_unique<SbxBasicFormater>(
 853                                                                 cComma,c1000,aOnStrg,aOffStrg,
 854                                                                 aYesStrg,aNoStrg,aTrueStrg,aFalseStrg,
 855                                                                 aCurrencyStrg,aCurrencyFormatStrg );
 856             }
 857             // Remark: For performance reasons there's only ONE BasicFormater-
 858             //    object created and 'stored', so that the expensive resource-
 859             //    loading is saved (for country-specific predefined outputs,
 860             //    e. g. "On/Off") and the continuous string-creation
 861             //    operations, too.
 862             // BUT: therefore this code is NOT multithreading capable!
 863
 864             // here are problems with ;;;Null because this method is only
 865             // called, if SbxValue is a number!!!
 866             // in addition rAppData.pBasicFormater->BasicFormatNull( *pFmt ); could be called!
 867             if( eType != SbxNULL )
 868             {
 869                 rRes = rAppData.pBasicFormater->BasicFormat( d ,*pFmt );
 870             }
 871             else
 872             {
 873                 rRes = SbxBasicFormater::BasicFormatNull( *pFmt );
 874             }
 875
 876         }
 877         else
 878             ImpCvtNum( GetDouble(), nComma, rRes );
 879         break;
 880     case SbxSTRING:
 881         if( pFmt )
 882         {
 883             // #45355 converting if numeric
 884             if( IsNumericRTL() )
 885             {
 886                 ScanNumIntnl( GetOUString(), d );
 887                 goto cvt2;
 888             }
 889             else
 890             {
 891                 printfmtstr( GetOUString(), rRes, *pFmt );
 892             }
 893         }
 894         else
 895         {
 896             rRes = GetOUString();
 897         }
 898         break;
 899     default:
 900         rRes = GetOUString();
 901     }
 902 }
 903
 904
 905 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */