1 /************************************************************** 2 * 3 * Licensed to the Apache Software Foundation (ASF) under one 4 * or more contributor license agreements. See the NOTICE file 5 * distributed with this work for additional information 6 * regarding copyright ownership. The ASF licenses this file 7 * to you under the Apache License, Version 2.0 (the 8 * "License"); you may not use this file except in compliance 9 * with the License. You may obtain a copy of the License at 10 * 11 * http://www.apache.org/licenses/LICENSE-2.0 12 * 13 * Unless required by applicable law or agreed to in writing, 14 * software distributed under the License is distributed on an 15 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 16 * KIND, either express or implied. See the License for the 17 * specific language governing permissions and limitations 18 * under the License. 19 * 20 *************************************************************/ 21 22 23 24 // MARKER(update_precomp.py): autogen include statement, do not remove 25 #include "precompiled_basic.hxx" 26 #include <tools/errcode.hxx> 27 #include <basic/sbx.hxx> 28 #include "sbxconv.hxx" 29 30 sal_uInt32 ImpGetULong( const SbxValues* p ) 31 { 32 SbxValues aTmp; 33 sal_uInt32 nRes; 34 start: 35 switch( +p->eType ) 36 { 37 case SbxNULL: 38 SbxBase::SetError( SbxERR_CONVERSION ); 39 case SbxEMPTY: 40 nRes = 0; break; 41 case SbxCHAR: 42 nRes = p->nChar; 43 break; 44 case SbxBYTE: 45 nRes = p->nByte; break; 46 case SbxINTEGER: 47 case SbxBOOL: 48 if( p->nInteger < 0 ) 49 { 50 SbxBase::SetError( SbxERR_OVERFLOW ); nRes = 0; 51 } 52 else 53 nRes = p->nInteger; 54 break; 55 case SbxERROR: 56 case SbxUSHORT: 57 nRes = p->nUShort; 58 break; 59 case SbxLONG: 60 if( p->nLong < 0 ) 61 { 62 SbxBase::SetError( SbxERR_OVERFLOW ); nRes = 0; 63 } 64 else 65 nRes = p->nLong; 66 break; 67 case SbxULONG: 68 nRes = p->nULong; break; 69 case SbxSINGLE: 70 if( p->nSingle > SbxMAXULNG ) 71 { 72 SbxBase::SetError( SbxERR_OVERFLOW ); nRes = SbxMAXULNG; 73 } 74 else if( p->nSingle < 0 ) 75 { 76 SbxBase::SetError( SbxERR_OVERFLOW ); nRes = 0; 77 } 78 else 79 nRes = (sal_uInt32) ( p->nSingle + 0.5 ); 80 break; 81 case SbxDATE: 82 case SbxDOUBLE: 83 case SbxLONG64: 84 case SbxULONG64: 85 case SbxSALINT64: 86 case SbxSALUINT64: 87 case SbxCURRENCY: 88 case SbxDECIMAL: 89 case SbxBYREF | SbxDECIMAL: 90 { 91 double dVal; 92 if( p->eType == SbxCURRENCY ) 93 dVal = ImpCurrencyToDouble( p->nLong64 ); 94 else if( p->eType == SbxLONG64 ) 95 dVal = ImpINT64ToDouble( p->nLong64 ); 96 else if( p->eType == SbxULONG64 ) 97 dVal = ImpUINT64ToDouble( p->nULong64 ); 98 else if( p->eType == SbxSALINT64 ) 99 dVal = static_cast< double >(p->nInt64); 100 else if( p->eType == SbxSALUINT64 ) 101 dVal = ImpSalUInt64ToDouble( p->uInt64 ); 102 else if( p->eType == SbxDECIMAL ) 103 { 104 dVal = 0.0; 105 if( p->pDecimal ) 106 p->pDecimal->getDouble( dVal ); 107 } 108 else 109 dVal = p->nDouble; 110 111 if( dVal > SbxMAXULNG ) 112 { 113 SbxBase::SetError( SbxERR_OVERFLOW ); nRes = SbxMAXULNG; 114 } 115 else if( dVal < 0 ) 116 { 117 SbxBase::SetError( SbxERR_OVERFLOW ); nRes = 0; 118 } 119 else 120 nRes = (sal_uInt32) ( dVal + 0.5 ); 121 break; 122 } 123 case SbxBYREF | SbxSTRING: 124 case SbxSTRING: 125 case SbxLPSTR: 126 if( !p->pOUString ) 127 nRes = 0; 128 else 129 { 130 double d; 131 SbxDataType t; 132 if( ImpScan( *p->pOUString, d, t, NULL ) != SbxERR_OK ) 133 nRes = 0; 134 else if( d > SbxMAXULNG ) 135 { 136 SbxBase::SetError( SbxERR_OVERFLOW ); nRes = SbxMAXULNG; 137 } 138 else if( d < 0 ) 139 { 140 SbxBase::SetError( SbxERR_OVERFLOW ); nRes = 0; 141 } 142 else 143 nRes = (sal_uInt32) ( d + 0.5 ); 144 } 145 break; 146 case SbxOBJECT: 147 { 148 SbxValue* pVal = PTR_CAST(SbxValue,p->pObj); 149 if( pVal ) 150 nRes = pVal->GetULong(); 151 else 152 { 153 SbxBase::SetError( SbxERR_NO_OBJECT ); nRes = 0; 154 } 155 break; 156 } 157 158 case SbxBYREF | SbxBYTE: 159 nRes = *p->pByte; break; 160 case SbxBYREF | SbxERROR: 161 case SbxBYREF | SbxUSHORT: 162 nRes = *p->pUShort; break; 163 case SbxBYREF | SbxULONG: 164 nRes = *p->pULong; break; 165 166 // Tests ab hier 167 case SbxBYREF | SbxCHAR: 168 aTmp.nChar = *p->pChar; goto ref; 169 case SbxBYREF | SbxINTEGER: 170 case SbxBYREF | SbxBOOL: 171 aTmp.nInteger = *p->pInteger; goto ref; 172 case SbxBYREF | SbxLONG: 173 aTmp.nLong = *p->pLong; goto ref; 174 case SbxBYREF | SbxSINGLE: 175 aTmp.nSingle = *p->pSingle; goto ref; 176 case SbxBYREF | SbxDATE: 177 case SbxBYREF | SbxDOUBLE: 178 aTmp.nDouble = *p->pDouble; goto ref; 179 case SbxBYREF | SbxSALINT64: 180 aTmp.nInt64 = *p->pnInt64; goto ref; 181 case SbxBYREF | SbxSALUINT64: 182 aTmp.uInt64 = *p->puInt64; goto ref; 183 case SbxBYREF | SbxULONG64: 184 aTmp.nULong64 = *p->pULong64; goto ref; 185 case SbxBYREF | SbxLONG64: 186 case SbxBYREF | SbxCURRENCY: 187 aTmp.nLong64 = *p->pLong64; goto ref; 188 ref: 189 aTmp.eType = SbxDataType( p->eType & 0x0FFF ); 190 p = &aTmp; goto start; 191 192 default: 193 SbxBase::SetError( SbxERR_CONVERSION ); nRes = 0; 194 } 195 return nRes; 196 } 197 198 void ImpPutULong( SbxValues* p, sal_uInt32 n ) 199 { 200 SbxValues aTmp; 201 start: 202 switch( +p->eType ) 203 { 204 case SbxULONG: 205 p->nULong = n; break; 206 case SbxSINGLE: 207 p->nSingle = (float) n; break; 208 case SbxDATE: 209 case SbxDOUBLE: 210 p->nDouble = n; break; 211 case SbxSALINT64: 212 p->nInt64 = n; break; 213 case SbxSALUINT64: 214 p->uInt64 = n; break; 215 case SbxDECIMAL: 216 case SbxBYREF | SbxDECIMAL: 217 ImpCreateDecimal( p )->setULong( n ); 218 break; 219 220 // Tests ab hier 221 case SbxCHAR: 222 aTmp.pChar = &p->nChar; goto direct; 223 case SbxUINT: 224 aTmp.pByte = &p->nByte; goto direct; 225 case SbxINTEGER: 226 case SbxBOOL: 227 aTmp.pInteger = &p->nInteger; goto direct; 228 case SbxLONG: 229 aTmp.pLong = &p->nLong; goto direct; 230 case SbxERROR: 231 case SbxUSHORT: 232 aTmp.pUShort = &p->nUShort; goto direct; 233 case SbxULONG64: 234 aTmp.pULong64 = &p->nULong64; goto direct; 235 case SbxLONG64: 236 case SbxCURRENCY: 237 aTmp.pLong64 = &p->nLong64; goto direct; 238 direct: 239 aTmp.eType = SbxDataType( p->eType | SbxBYREF ); 240 p = &aTmp; goto start; 241 242 case SbxBYREF | SbxSTRING: 243 case SbxSTRING: 244 case SbxLPSTR: 245 if( !p->pOUString ) 246 p->pOUString = new ::rtl::OUString; 247 ImpCvtNum( (double) n, 0, *p->pOUString ); 248 break; 249 case SbxOBJECT: 250 { 251 SbxValue* pVal = PTR_CAST(SbxValue,p->pObj); 252 if( pVal ) 253 pVal->PutULong( n ); 254 else 255 SbxBase::SetError( SbxERR_NO_OBJECT ); 256 break; 257 } 258 case SbxBYREF | SbxCHAR: 259 if( n > SbxMAXCHAR ) 260 { 261 SbxBase::SetError( SbxERR_OVERFLOW ); n = SbxMAXCHAR; 262 } 263 *p->pChar = (xub_Unicode) n; break; 264 case SbxBYREF | SbxBYTE: 265 if( n > SbxMAXBYTE ) 266 { 267 SbxBase::SetError( SbxERR_OVERFLOW ); n = SbxMAXBYTE; 268 } 269 *p->pByte = (sal_uInt8) n; break; 270 case SbxBYREF | SbxINTEGER: 271 case SbxBYREF | SbxBOOL: 272 if( n > SbxMAXINT ) 273 { 274 SbxBase::SetError( SbxERR_OVERFLOW ); n = SbxMAXINT; 275 } 276 *p->pInteger = (sal_Int16) n; break; 277 case SbxBYREF | SbxERROR: 278 case SbxBYREF | SbxUSHORT: 279 if( n > SbxMAXUINT ) 280 { 281 SbxBase::SetError( SbxERR_OVERFLOW ); n = SbxMAXUINT; 282 } 283 *p->pUShort = (sal_uInt16) n; break; 284 case SbxBYREF | SbxLONG: 285 if( n > SbxMAXLNG ) 286 { 287 SbxBase::SetError( SbxERR_OVERFLOW ); n = SbxMAXLNG; 288 } 289 *p->pLong = (sal_Int32) n; break; 290 case SbxBYREF | SbxULONG: 291 *p->pULong = n; break; 292 case SbxBYREF | SbxSINGLE: 293 *p->pSingle = (float) n; break; 294 case SbxBYREF | SbxDATE: 295 case SbxBYREF | SbxDOUBLE: 296 *p->pDouble = n; break; 297 case SbxBYREF | SbxSALINT64: 298 *p->pnInt64 = n; break; 299 case SbxBYREF | SbxSALUINT64: 300 *p->puInt64 = n; break; 301 case SbxBYREF | SbxCURRENCY: 302 double d; 303 if( n > SbxMAXCURR ) 304 { 305 SbxBase::SetError( SbxERR_OVERFLOW ); d = SbxMAXCURR; 306 } 307 else 308 { 309 d = n; 310 } 311 *p->pLong64 = ImpDoubleToCurrency( n ); break; 312 313 default: 314 SbxBase::SetError( SbxERR_CONVERSION ); 315 } 316 } 317 318