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 <vcl/svapp.hxx>
21 #include <vcl/settings.hxx>
22 #include <svl/zforlist.hxx>
23 #include <tools/color.hxx>
24 #include <i18nlangtag/lang.h>
25 #include <basic/sberrors.hxx>
26 #include "sbxconv.hxx"
27 #include <runtime.hxx>
28 #include <sbintern.hxx>
29 #include <math.h>
30 #include <memory>
31 #include <config_features.h>
32
33
ImpGetDate(const SbxValues * p)34 double ImpGetDate( const SbxValues* p )
35 {
36 double nRes;
37 SbxValue* pVal;
38
39 switch( +p->eType )
40 {
41 case SbxNULL:
42 SbxBase::SetError( ERRCODE_BASIC_CONVERSION );
43 [[fallthrough]];
44 case SbxEMPTY:
45 nRes = 0;
46 break;
47 case SbxCHAR:
48 nRes = p->nChar;
49 break;
50 case SbxBYTE:
51 nRes = p->nByte;
52 break;
53 case SbxINTEGER:
54 case SbxBOOL:
55 nRes = p->nInteger;
56 break;
57 case SbxERROR:
58 case SbxUSHORT:
59 nRes = p->nUShort;
60 break;
61 case SbxLONG:
62 nRes = static_cast<double>(p->nLong);
63 break;
64 case SbxULONG:
65 nRes = static_cast<double>(p->nULong);
66 break;
67 case SbxSINGLE:
68 nRes = p->nSingle;
69 break;
70 case SbxDATE:
71 case SbxDOUBLE:
72 nRes = p->nDouble;
73 break;
74 case SbxCURRENCY:
75 nRes = ImpCurrencyToDouble( p->nInt64 );
76 break;
77 case SbxSALINT64:
78 nRes = static_cast< double >(p->nInt64);
79 break;
80 case SbxSALUINT64:
81 nRes = ImpSalUInt64ToDouble( p->uInt64 );
82 break;
83 case SbxDECIMAL:
84 case SbxBYREF | SbxDECIMAL:
85 if( p->pDecimal )
86 {
87 p->pDecimal->getDouble( nRes );
88 }
89 else
90 {
91 nRes = 0.0;
92 }
93 break;
94 case SbxBYREF | SbxSTRING:
95 case SbxSTRING:
96 case SbxLPSTR:
97 #if HAVE_FEATURE_SCRIPTING
98 if( !p->pOUString )
99 {
100 nRes = 0;
101 }
102 else
103 {
104 LanguageType eLangType = Application::GetSettings().GetLanguageTag().getLanguageType();
105 std::shared_ptr<SvNumberFormatter> pFormatter;
106 if (GetSbData()->pInst)
107 {
108 pFormatter = GetSbData()->pInst->GetNumberFormatter();
109 }
110 else
111 {
112 sal_uInt32 nDummy;
113 pFormatter = SbiInstance::PrepareNumberFormatter( nDummy, nDummy, nDummy );
114 }
115
116 sal_uInt32 nIndex;
117 sal_Int32 nCheckPos = 0;
118 SvNumFormatType nType = SvNumFormatType::DEFINED | SvNumFormatType::DATE | SvNumFormatType::TIME | SvNumFormatType::CURRENCY
119 | SvNumFormatType::NUMBER | SvNumFormatType::SCIENTIFIC | SvNumFormatType::FRACTION;
120
121 // Default templates of the formatter have only two-digit
122 // date. Therefore register an own format.
123
124 // HACK, because the number formatter in PutandConvertEntry replace the wildcard
125 // for month, day, year not according to the configuration.
126 // Problem: Print Year(Date) under Engl. OS
127 // quod vide basic/source/runtime/runtime.cxx
128
129 SvtSysLocale aSysLocale;
130 DateOrder eDate = aSysLocale.GetLocaleData().getDateOrder();
131 OUString aDateStr;
132 switch( eDate )
133 {
134 default:
135 case DateOrder::MDY: aDateStr = "MM/DD/YYYY"; break;
136 case DateOrder::DMY: aDateStr = "DD/MM/YYYY"; break;
137 case DateOrder::YMD: aDateStr = "YYYY/MM/DD"; break;
138 }
139
140 OUString aStr = aDateStr + " HH:MM:SS";
141
142 pFormatter->PutandConvertEntry( aStr, nCheckPos, nType,
143 nIndex, LANGUAGE_ENGLISH_US, eLangType, true);
144 bool bSuccess = pFormatter->IsNumberFormat( *p->pOUString, nIndex, nRes );
145 if ( bSuccess )
146 {
147 SvNumFormatType nType_ = pFormatter->GetType( nIndex );
148 if(!(nType_ & ( SvNumFormatType::DATETIME | SvNumFormatType::DATE |
149 SvNumFormatType::TIME | SvNumFormatType::DEFINED )))
150 {
151 bSuccess = false;
152 }
153 }
154
155 if ( !bSuccess )
156 {
157 SbxBase::SetError( ERRCODE_BASIC_CONVERSION ); nRes = 0;
158 }
159 }
160 #else
161 nRes = 0;
162 #endif
163 break;
164 case SbxOBJECT:
165 pVal = dynamic_cast<SbxValue*>( p->pObj );
166 if( pVal )
167 {
168 nRes = pVal->GetDate();
169 }
170 else
171 {
172 SbxBase::SetError( ERRCODE_BASIC_NO_OBJECT ); nRes = 0;
173 }
174 break;
175 case SbxBYREF | SbxCHAR:
176 nRes = *p->pChar;
177 break;
178 case SbxBYREF | SbxBYTE:
179 nRes = *p->pByte;
180 break;
181 case SbxBYREF | SbxINTEGER:
182 case SbxBYREF | SbxBOOL:
183 nRes = *p->pInteger;
184 break;
185 case SbxBYREF | SbxLONG:
186 nRes = *p->pLong;
187 break;
188 case SbxBYREF | SbxULONG:
189 nRes = *p->pULong;
190 break;
191 case SbxBYREF | SbxERROR:
192 case SbxBYREF | SbxUSHORT:
193 nRes = *p->pUShort;
194 break;
195 case SbxBYREF | SbxSINGLE:
196 nRes = *p->pSingle;
197 break;
198 case SbxBYREF | SbxDATE:
199 case SbxBYREF | SbxDOUBLE:
200 nRes = *p->pDouble;
201 break;
202 case SbxBYREF | SbxCURRENCY:
203 nRes = ImpCurrencyToDouble( *p->pnInt64 );
204 break;
205 case SbxBYREF | SbxSALINT64:
206 nRes = static_cast< double >(*p->pnInt64);
207 break;
208 case SbxBYREF | SbxSALUINT64:
209 nRes = ImpSalUInt64ToDouble( *p->puInt64 );
210 break;
211 default:
212 SbxBase::SetError( ERRCODE_BASIC_CONVERSION ); nRes = 0;
213 break;
214 }
215 return nRes;
216 }
217
ImpPutDate(SbxValues * p,double n)218 void ImpPutDate( SbxValues* p, double n )
219 {
220 SbxValues aTmp;
221 SbxDecimal* pDec;
222 SbxValue* pVal;
223
224 start:
225 switch( +p->eType )
226 {
227 case SbxDATE:
228 case SbxDOUBLE:
229 p->nDouble = n;
230 break;
231 // from here will be tested
232 case SbxCHAR:
233 aTmp.pChar = &p->nChar;
234 goto direct;
235 case SbxBYTE:
236 aTmp.pByte = &p->nByte;
237 goto direct;
238 case SbxINTEGER:
239 case SbxBOOL:
240 aTmp.pInteger = &p->nInteger;
241 goto direct;
242 case SbxLONG:
243 aTmp.pLong = &p->nLong;
244 goto direct;
245 case SbxULONG:
246 aTmp.pULong = &p->nULong;
247 goto direct;
248 case SbxERROR:
249 case SbxUSHORT:
250 aTmp.pUShort = &p->nUShort;
251 goto direct;
252 case SbxSINGLE:
253 aTmp.pSingle = &p->nSingle;
254 goto direct;
255 case SbxCURRENCY:
256 case SbxSALINT64:
257 aTmp.pnInt64 = &p->nInt64;
258 goto direct;
259 case SbxSALUINT64:
260 aTmp.puInt64 = &p->uInt64;
261 goto direct;
262 case SbxDECIMAL:
263 case SbxBYREF | SbxDECIMAL:
264 pDec = ImpCreateDecimal( p );
265 if( !pDec->setDouble( n ) )
266 {
267 SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW );
268 }
269 break;
270 direct:
271 aTmp.eType = SbxDataType( p->eType | SbxBYREF );
272 p = &aTmp; goto start;
273
274 case SbxBYREF | SbxSTRING:
275 case SbxSTRING:
276 case SbxLPSTR:
277 {
278 #if HAVE_FEATURE_SCRIPTING
279 if( !p->pOUString )
280 {
281 p->pOUString = new OUString;
282 }
283 Color* pColor;
284
285 LanguageType eLangType = Application::GetSettings().GetLanguageTag().getLanguageType();
286 std::shared_ptr<SvNumberFormatter> pFormatter;
287 if (GetSbData()->pInst)
288 {
289 pFormatter = GetSbData()->pInst->GetNumberFormatter();
290 }
291 else
292 {
293 sal_uInt32 nDummy;
294 pFormatter = SbiInstance::PrepareNumberFormatter( nDummy, nDummy, nDummy );
295 }
296
297 sal_uInt32 nIndex;
298 sal_Int32 nCheckPos = 0;
299 SvNumFormatType nType;
300
301 SvtSysLocale aSysLocale;
302 DateOrder eDate = aSysLocale.GetLocaleData().getDateOrder();
303 OUString aStr;
304 // if the whole-number part is 0, we want no year!
305 if( n <= -1.0 || n >= 1.0 )
306 {
307 // Time only if != 00:00:00
308 if( rtl::math::approxEqual(floor( n ), n) )
309 {
310 switch( eDate )
311 {
312 default:
313 case DateOrder::MDY: aStr = "MM/DD/YYYY"; break;
314 case DateOrder::DMY: aStr = "DD/MM/YYYY"; break;
315 case DateOrder::YMD: aStr = "YYYY/MM/DD"; break;
316 }
317 }
318 else
319 {
320 switch( eDate )
321 {
322 default:
323 case DateOrder::MDY: aStr = "MM/DD/YYYY HH:MM:SS"; break;
324 case DateOrder::DMY: aStr = "DD/MM/YYYY HH:MM:SS"; break;
325 case DateOrder::YMD: aStr = "YYYY/MM/DD HH:MM:SS"; break;
326 }
327 }
328 }
329 else
330 {
331 aStr = "HH:MM:SS";
332 }
333 pFormatter->PutandConvertEntry( aStr,
334 nCheckPos,
335 nType,
336 nIndex,
337 LANGUAGE_ENGLISH_US,
338 eLangType, true);
339 pFormatter->GetOutputString( n, nIndex, *p->pOUString, &pColor );
340 #endif
341 break;
342 }
343 case SbxOBJECT:
344 pVal = dynamic_cast<SbxValue*>( p->pObj );
345 if( pVal )
346 {
347 pVal->PutDate( n );
348 }
349 else
350 {
351 SbxBase::SetError( ERRCODE_BASIC_NO_OBJECT );
352 }
353 break;
354 case SbxBYREF | SbxCHAR:
355 if( n > SbxMAXCHAR )
356 {
357 SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = SbxMAXCHAR;
358 }
359 else if( n < SbxMINCHAR )
360 {
361 SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = SbxMINCHAR;
362 }
363 *p->pChar = static_cast<sal_Unicode>(n);
364 break;
365 case SbxBYREF | SbxBYTE:
366 if( n > SbxMAXBYTE )
367 {
368 SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = SbxMAXBYTE;
369 }
370 else if( n < 0 )
371 {
372 SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = 0;
373 }
374 *p->pByte = static_cast<sal_uInt8>(n);
375 break;
376 case SbxBYREF | SbxINTEGER:
377 case SbxBYREF | SbxBOOL:
378 if( n > SbxMAXINT )
379 {
380 SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = SbxMAXINT;
381 }
382 else if( n < SbxMININT )
383 {
384 SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = SbxMININT;
385 }
386 *p->pInteger = static_cast<sal_Int16>(n);
387 break;
388 case SbxBYREF | SbxERROR:
389 case SbxBYREF | SbxUSHORT:
390 if( n > SbxMAXUINT )
391 {
392 SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = SbxMAXUINT;
393 }
394 else if( n < 0 )
395 {
396 SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = 0;
397 }
398 *p->pUShort = static_cast<sal_uInt16>(n);
399 break;
400 case SbxBYREF | SbxLONG:
401 if( n > SbxMAXLNG )
402 {
403 SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = SbxMAXLNG;
404 }
405 else if( n < SbxMINLNG )
406 {
407 SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = SbxMINLNG;
408 }
409 *p->pLong = static_cast<sal_Int32>(n);
410 break;
411 case SbxBYREF | SbxULONG:
412 if( n > SbxMAXULNG )
413 {
414 SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = SbxMAXULNG;
415 }
416 else if( n < 0 )
417 {
418 SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = 0;
419 }
420 *p->pULong = static_cast<sal_uInt32>(n);
421 break;
422 case SbxBYREF | SbxSINGLE:
423 if( n > SbxMAXSNG )
424 {
425 SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = SbxMAXSNG;
426 }
427 else if( n < SbxMINSNG )
428 {
429 SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = SbxMINSNG;
430 }
431 *p->pSingle = static_cast<float>(n);
432 break;
433 case SbxBYREF | SbxSALINT64:
434 *p->pnInt64 = ImpDoubleToSalInt64( n );
435 break;
436 case SbxBYREF | SbxSALUINT64:
437 *p->puInt64 = ImpDoubleToSalUInt64( n );
438 break;
439 case SbxBYREF | SbxDATE:
440 case SbxBYREF | SbxDOUBLE:
441 *p->pDouble = n;
442 break;
443 case SbxBYREF | SbxCURRENCY:
444 if( n > SbxMAXCURR )
445 {
446 SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = SbxMAXCURR;
447 }
448 else if( n < SbxMINCURR )
449 {
450 SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = SbxMINCURR;
451 }
452 *p->pnInt64 = ImpDoubleToCurrency( n );
453 break;
454 default:
455 SbxBase::SetError( ERRCODE_BASIC_CONVERSION );
456 break;
457 }
458 }
459
460 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
461