basic/source/sbx/sbxbool.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 <comphelper/errcode.hxx>
  21 #include <basic/sberrors.hxx>
  22 #include "sbxconv.hxx"
  23 #include "sbxres.hxx"
  24
  25 enum SbxBOOL ImpGetBool( const SbxValues* p )
  26 {
  27     enum SbxBOOL nRes;
  28     switch( +p->eType )
  29     {
  30         case SbxNULL:
  31             SbxBase::SetError( ERRCODE_BASIC_CONVERSION );
  32             [[fallthrough]];
  33         case SbxEMPTY:
  34             nRes = SbxFALSE; break;
  35         case SbxCHAR:
  36             nRes = p->nChar ? SbxTRUE : SbxFALSE; break;
  37         case SbxBYTE:
  38             nRes = p->nByte ? SbxTRUE : SbxFALSE; break;
  39         case SbxINTEGER:
  40         case SbxBOOL:
  41             nRes = p->nInteger ? SbxTRUE : SbxFALSE; break;
  42         case SbxERROR:
  43         case SbxUSHORT:
  44             nRes = p->nUShort ? SbxTRUE : SbxFALSE; break;
  45         case SbxLONG:
  46             nRes = p->nLong ? SbxTRUE : SbxFALSE; break;
  47         case SbxULONG:
  48             nRes = p->nULong ? SbxTRUE : SbxFALSE; break;
  49         case SbxSINGLE:
  50             nRes = p->nSingle ? SbxTRUE : SbxFALSE; break;
  51         case SbxDATE:
  52         case SbxDOUBLE:
  53             nRes = p->nDouble ? SbxTRUE : SbxFALSE; break;
  54         case SbxDECIMAL:
  55         case SbxBYREF | SbxDECIMAL:
  56             {
  57             double dVal = 0.0;
  58             if( p->pDecimal )
  59                 p->pDecimal->getDouble( dVal );
  60             nRes = dVal ? SbxTRUE : SbxFALSE;
  61             }
  62             break;
  63         case SbxSALINT64:
  64         case SbxCURRENCY:
  65             nRes = p->nInt64 ? SbxTRUE : SbxFALSE; break;
  66         case SbxSALUINT64:
  67             nRes = p->uInt64 ? SbxTRUE : SbxFALSE; break;
  68         case SbxBYREF | SbxSTRING:
  69         case SbxSTRING:
  70         case SbxLPSTR:
  71             nRes = SbxFALSE;
  72             if ( p->pOUString )
  73             {
  74                 if( p->pOUString->equalsIgnoreAsciiCase( GetSbxRes( StringId::True ) ) )
  75                     nRes = SbxTRUE;
  76                 else if( !p->pOUString->equalsIgnoreAsciiCase( GetSbxRes( StringId::False ) ) )
  77                 {
  78                     // it can be convertible to a number
  79                     bool bError = true;
  80                     double n;
  81                     SbxDataType t;
  82                     sal_Int32 nLen = 0;
  83                     if( ImpScan( *p->pOUString, n, t, &nLen ) == ERRCODE_NONE )
  84                     {
  85                         if( nLen == p->pOUString->getLength() )
  86                         {
  87                             bError = false;
  88                             if( n != 0.0 )
  89                                 nRes = SbxTRUE;
  90                         }
  91                     }
  92                     if( bError )
  93                         SbxBase::SetError( ERRCODE_BASIC_CONVERSION );
  94                 }
  95             }
  96             break;
  97         case SbxOBJECT:
  98         {
  99             SbxValue* pVal = dynamic_cast<SbxValue*>( p->pObj );
 100             if( pVal )
 101                 nRes = pVal->GetBool() ? SbxTRUE : SbxFALSE;
 102             else
 103             {
 104                 SbxBase::SetError( ERRCODE_BASIC_NO_OBJECT ); nRes = SbxFALSE;
 105             }
 106             break;
 107         }
 108
 109         case SbxBYREF | SbxCHAR:
 110             nRes = *p->pChar ? SbxTRUE : SbxFALSE; break;
 111         case SbxBYREF | SbxBYTE:
 112             nRes = *p->pByte ? SbxTRUE : SbxFALSE; break;
 113         case SbxBYREF | SbxINTEGER:
 114         case SbxBYREF | SbxBOOL:
 115             nRes = *p->pInteger ? SbxTRUE : SbxFALSE; break;
 116         case SbxBYREF | SbxLONG:
 117             nRes = *p->pLong ? SbxTRUE : SbxFALSE; break;
 118         case SbxBYREF | SbxULONG:
 119             nRes = *p->pULong ? SbxTRUE : SbxFALSE; break;
 120         case SbxBYREF | SbxERROR:
 121         case SbxBYREF | SbxUSHORT:
 122             nRes = *p->pUShort ? SbxTRUE : SbxFALSE; break;
 123         case SbxBYREF | SbxSINGLE:
 124             nRes = ( *p->pSingle != 0 ) ? SbxTRUE : SbxFALSE; break;
 125         case SbxBYREF | SbxDATE:
 126         case SbxBYREF | SbxDOUBLE:
 127             nRes = ( *p->pDouble != 0 ) ? SbxTRUE : SbxFALSE; break;
 128         case SbxBYREF | SbxCURRENCY:
 129         case SbxBYREF | SbxSALINT64:
 130             nRes = ( *p->pnInt64 ) ? SbxTRUE : SbxFALSE; break;
 131         case SbxBYREF | SbxSALUINT64:
 132             nRes = ( *p->puInt64 ) ? SbxTRUE : SbxFALSE; break;
 133         default:
 134             SbxBase::SetError( ERRCODE_BASIC_CONVERSION ); nRes = SbxFALSE;
 135     }
 136     return nRes;
 137 }
 138
 139 void ImpPutBool( SbxValues* p, sal_Int16 n )
 140 {
 141     if( n )
 142         n = SbxTRUE;
 143     switch( +p->eType )
 144     {
 145         case SbxCHAR:
 146             p->nChar = static_cast<sal_Unicode>(n); break;
 147         case SbxUINT:
 148             p->nByte = static_cast<sal_uInt8>(n); break;
 149         case SbxINTEGER:
 150         case SbxBOOL:
 151             p->nInteger = n; break;
 152         case SbxLONG:
 153             p->nLong = n; break;
 154         case SbxULONG:
 155             p->nULong = static_cast<sal_uInt32>(n); break;
 156         case SbxERROR:
 157         case SbxUSHORT:
 158             p->nUShort = static_cast<sal_uInt16>(n); break;
 159         case SbxSINGLE:
 160             p->nSingle = n; break;
 161         case SbxDATE:
 162         case SbxDOUBLE:
 163             p->nDouble = n; break;
 164         case SbxCURRENCY:
 165         case SbxSALINT64:
 166             p->nInt64 = static_cast<sal_Int64>(n); break;
 167         case SbxSALUINT64:
 168             p->uInt64 = static_cast<sal_uInt64>(n); break;
 169         case SbxDECIMAL:
 170         case SbxBYREF | SbxDECIMAL:
 171             ImpCreateDecimal( p )->setInt( n );
 172             break;
 173
 174         case SbxBYREF | SbxSTRING:
 175         case SbxSTRING:
 176         case SbxLPSTR:
 177             if ( !p->pOUString )
 178                 p->pOUString = new OUString( GetSbxRes( n ? StringId::True : StringId::False ) );
 179             else
 180                 *p->pOUString = GetSbxRes( n ? StringId::True : StringId::False );
 181             break;
 182
 183         case SbxOBJECT:
 184         {
 185             SbxValue* pVal = dynamic_cast<SbxValue*>( p->pObj );
 186             if( pVal )
 187                 pVal->PutBool( n != 0 );
 188             else
 189                 SbxBase::SetError( ERRCODE_BASIC_NO_OBJECT );
 190             break;
 191         }
 192         case SbxBYREF | SbxCHAR:
 193             *p->pChar = static_cast<sal_Unicode>(n); break;
 194         case SbxBYREF | SbxBYTE:
 195             *p->pByte = static_cast<sal_uInt8>(n); break;
 196         case SbxBYREF | SbxINTEGER:
 197         case SbxBYREF | SbxBOOL:
 198             *p->pInteger = n; break;
 199         case SbxBYREF | SbxERROR:
 200         case SbxBYREF | SbxUSHORT:
 201             *p->pUShort = static_cast<sal_uInt16>(n); break;
 202         case SbxBYREF | SbxLONG:
 203             *p->pLong = n; break;
 204         case SbxBYREF | SbxULONG:
 205             *p->pULong = static_cast<sal_uInt32>(n); break;
 206         case SbxBYREF | SbxSINGLE:
 207             *p->pSingle = n; break;
 208         case SbxBYREF | SbxDATE:
 209         case SbxBYREF | SbxDOUBLE:
 210             *p->pDouble = n; break;
 211         case SbxBYREF | SbxCURRENCY:
 212         case SbxBYREF | SbxSALINT64:
 213             *p->pnInt64 = static_cast<sal_Int64>(n); break;
 214         case SbxBYREF | SbxSALUINT64:
 215             *p->puInt64 = static_cast<sal_uInt64>(n); break;
 216         default:
 217             SbxBase::SetError( ERRCODE_BASIC_CONVERSION );
 218     }
 219 }
 220
 221 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */