basic/source/sbx/sbxconv.hxx

   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 #pragma once
  21
  22 #include "sbxdec.hxx"
  23 #include <basic/sberrors.hxx>
  24 #include <basic/sbx.hxx>
  25 #include <basic/sbxcore.hxx>
  26 #include <basic/sbxdef.hxx>
  27
  28 #include <o3tl/float_int_conversion.hxx>
  29 #include <o3tl/safeint.hxx>
  30 #include <rtl/math.hxx>
  31 #include <sal/types.h>
  32
  33 class SbxArray;
  34
  35 template <typename I> inline I DoubleTo(double f, I min, I max)
  36 {
  37     f = rtl::math::round(f);
  38     if (!o3tl::convertsToAtMost(f, max))
  39     {
  40         SbxBase::SetError(ERRCODE_BASIC_MATH_OVERFLOW);
  41         return max;
  42     }
  43     if (!o3tl::convertsToAtLeast(f, min))
  44     {
  45         SbxBase::SetError(ERRCODE_BASIC_MATH_OVERFLOW);
  46         return min;
  47     }
  48     return f;
  49 }
  50
  51 inline auto ImpDoubleToChar(double f) { return DoubleTo<sal_Unicode>(f, SbxMINCHAR, SbxMAXCHAR); }
  52 inline auto ImpDoubleToByte(double f) { return DoubleTo<sal_uInt8>(f, 0, SbxMAXBYTE); }
  53 inline auto ImpDoubleToUShort(double f) { return DoubleTo<sal_uInt16>(f, 0, SbxMAXUINT); }
  54 inline auto ImpDoubleToInteger(double f) { return DoubleTo<sal_Int16>(f, SbxMININT, SbxMAXINT); }
  55 inline auto ImpDoubleToULong(double f) { return DoubleTo<sal_uInt32>(f, 0, SbxMAXULNG); }
  56 inline auto ImpDoubleToLong(double f) { return DoubleTo<sal_Int32>(f, SbxMINLNG, SbxMAXLNG); }
  57 inline auto ImpDoubleToSalUInt64(double d) { return DoubleTo<sal_uInt64>(d, 0, SAL_MAX_UINT64); }
  58 inline auto ImpDoubleToSalInt64(double d)
  59 {
  60     return DoubleTo<sal_Int64>(d, SAL_MIN_INT64, SAL_MAX_INT64);
  61 }
  62
  63 // SBXSCAN.CXX
  64 extern void ImpCvtNum( double nNum, short nPrec, OUString& rRes, bool bCoreString=false );
  65 extern ErrCode ImpScan
  66     ( const OUString& rSrc, double& nVal, SbxDataType& rType, sal_uInt16* pLen,
  67       bool bOnlyIntntl );
  68 // A version that uses defaults / compatibility settings for bOnlyIntntl
  69 extern ErrCode ImpScan
  70     ( const OUString& rSrc, double& nVal, SbxDataType& rType, sal_uInt16* pLen );
  71
  72 // with advanced evaluation (International, "TRUE"/"FALSE")
  73 extern bool ImpConvStringExt( OUString& rSrc, SbxDataType eTargetType );
  74
  75 void ImpGetIntntlSep( sal_Unicode& rcDecimalSep, sal_Unicode& rcThousandSep, sal_Unicode& rcDecimalSepAlt );
  76
  77 // SBXINT.CXX
  78
  79 sal_Int16   ImpGetInteger( const SbxValues* );
  80 void        ImpPutInteger( SbxValues*, sal_Int16 );
  81
  82 sal_Int64   ImpGetInt64( const SbxValues* );
  83 void        ImpPutInt64( SbxValues*, sal_Int64 );
  84 sal_uInt64  ImpGetUInt64( const SbxValues* );
  85 void        ImpPutUInt64( SbxValues*, sal_uInt64 );
  86
  87 double      ImpSalUInt64ToDouble( sal_uInt64 n );
  88
  89 // SBXLNG.CXX
  90
  91 sal_Int32   ImpGetLong( const SbxValues* );
  92 void    ImpPutLong( SbxValues*, sal_Int32 );
  93
  94 // SBXSNG.CXX
  95
  96 float   ImpGetSingle( const SbxValues* );
  97 void    ImpPutSingle( SbxValues*, float );
  98
  99 // SBXDBL.CXX
 100
 101 double  ImpGetDouble( const SbxValues* );
 102 void    ImpPutDouble( SbxValues*, double, bool bCoreString=false );
 103
 104 // SBXCURR.CXX
 105
 106 sal_Int64   ImpGetCurrency( const SbxValues* );
 107 void        ImpPutCurrency( SbxValues*, const sal_Int64 );
 108
 109 inline  sal_Int64   ImpDoubleToCurrency( double d )
 110 {
 111     double result = d > 0 ? (d * CURRENCY_FACTOR + 0.5) : (d * CURRENCY_FACTOR - 0.5);
 112     if (result >= double(SAL_MAX_INT64)) // double(SAL_MAX_INT64) is greater than SAL_MAX_INT64
 113     {
 114         SbxBase::SetError(ERRCODE_BASIC_MATH_OVERFLOW);
 115         return SAL_MAX_INT64;
 116     }
 117     if (result < double(SAL_MIN_INT64))
 118     {
 119         SbxBase::SetError(ERRCODE_BASIC_MATH_OVERFLOW);
 120         return SAL_MIN_INT64;
 121     }
 122     return result;
 123 }
 124
 125 template <typename I>
 126     requires std::is_integral_v<I>
 127 inline sal_Int64 CurFrom(I n)
 128 {
 129     using ValidRange = o3tl::ValidRange<sal_Int64, SAL_MIN_INT64 / CURRENCY_FACTOR, SAL_MAX_INT64 / CURRENCY_FACTOR>;
 130     if (ValidRange::isAbove(n))
 131     {
 132         SbxBase::SetError(ERRCODE_BASIC_MATH_OVERFLOW);
 133         return SAL_MAX_INT64;
 134     }
 135     if (ValidRange::isBelow(n))
 136     {
 137         SbxBase::SetError(ERRCODE_BASIC_MATH_OVERFLOW);
 138         return SAL_MIN_INT64;
 139     }
 140     return n * CURRENCY_FACTOR;
 141 }
 142
 143 inline double ImpCurrencyToDouble(sal_Int64 r) { return static_cast<double>(r) / CURRENCY_FACTOR; }
 144
 145 template <typename I>
 146     requires std::is_integral_v<I>
 147 inline I CurTo(sal_Int64 cur_val)
 148 {
 149     sal_Int64 i = CurTo<sal_Int64>(cur_val);
 150     if (o3tl::ValidRange<I>::isAbove(i))
 151     {
 152         SbxBase::SetError(ERRCODE_BASIC_MATH_OVERFLOW);
 153         return std::numeric_limits<I>::max();
 154     }
 155     if (o3tl::ValidRange<I>::isBelow(i))
 156     {
 157         SbxBase::SetError(ERRCODE_BASIC_MATH_OVERFLOW);
 158         return std::numeric_limits<I>::min();
 159     }
 160     return i;
 161 }
 162
 163 template <> inline sal_Int64 CurTo<sal_Int64>(sal_Int64 cur_val)
 164 {
 165     sal_Int64 i = cur_val / CURRENCY_FACTOR;
 166     // Rounding (half-to-even)
 167     int f = cur_val % CURRENCY_FACTOR;
 168     if (i % 2 == 1)
 169     {
 170         if (f < 0)
 171             --f;
 172         else
 173             ++f;
 174     }
 175     if (f > CURRENCY_FACTOR / 2)
 176         ++i;
 177     else if (f < -CURRENCY_FACTOR / 2)
 178         --i;
 179     return i;
 180 }
 181
 182
 183 // SBXDEC.CXX
 184
 185 SbxDecimal* ImpCreateDecimal( SbxValues* p );
 186 SbxDecimal* ImpGetDecimal( const SbxValues* p );
 187 void ImpPutDecimal( SbxValues* p, SbxDecimal* pDec );
 188
 189 // SBXDATE.CXX
 190
 191 double  ImpGetDate( const SbxValues* );
 192 void    ImpPutDate( SbxValues*, double );
 193
 194 // SBXSTR.CXX
 195
 196 OUString     ImpGetString( const SbxValues* );
 197 OUString     ImpGetCoreString( const SbxValues* );
 198 void    ImpPutString( SbxValues*, const OUString* );
 199
 200 // SBXCHAR.CXX
 201
 202 sal_Unicode ImpGetChar( const SbxValues* );
 203 void        ImpPutChar( SbxValues*, sal_Unicode );
 204
 205 // SBXBYTE.CXX
 206 sal_uInt8   ImpGetByte( const SbxValues* );
 207 void    ImpPutByte( SbxValues*, sal_uInt8 );
 208
 209 // SBXUINT.CXX
 210
 211 sal_uInt16  ImpGetUShort( const SbxValues* );
 212 void    ImpPutUShort( SbxValues*, sal_uInt16 );
 213
 214 // SBXULNG.CXX
 215
 216 sal_uInt32  ImpGetULong( const SbxValues* );
 217 void    ImpPutULong( SbxValues*, sal_uInt32 );
 218
 219 // SBXBOOL.CXX
 220
 221 enum SbxBOOL ImpGetBool( const SbxValues* );
 222 void    ImpPutBool( SbxValues*, sal_Int16 );
 223
 224 // ByteArray <--> String
 225 SbxArray* StringToByteArray(const OUString& rStr);
 226 OUString ByteArrayToString(SbxArray* pArr);
 227
 228 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */