xref: /aoo41x/main/basic/source/sbx/sbxint.cxx (revision e1f63238)
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 
ImpRound(double d)30 double ImpRound( double d )
31 {
32 	return d + ( d < 0 ? -0.5 : 0.5 );
33 }
34 
ImpGetInteger(const SbxValues * p)35 sal_Int16 ImpGetInteger( const SbxValues* p )
36 {
37 	SbxValues aTmp;
38 	sal_Int16 nRes;
39 start:
40 	switch( +p->eType )
41 	{
42 		case SbxNULL:
43 			SbxBase::SetError( SbxERR_CONVERSION );
44 		case SbxEMPTY:
45 			nRes = 0; break;
46 		case SbxCHAR:
47 			nRes = p->nChar; break;
48 		case SbxBYTE:
49 			nRes = p->nByte; break;
50 		case SbxINTEGER:
51 		case SbxBOOL:
52 			nRes = p->nInteger; break;
53 		case SbxERROR:
54 		case SbxUSHORT:
55 			if( p->nUShort > (sal_uInt16) SbxMAXINT )
56 			{
57 				SbxBase::SetError( SbxERR_OVERFLOW ); nRes = SbxMAXINT;
58 			}
59 			else
60 				nRes = (sal_Int16) p->nUShort;
61 			break;
62 		case SbxLONG:
63 			if( p->nLong > SbxMAXINT )
64 			{
65 				SbxBase::SetError( SbxERR_OVERFLOW ); nRes = SbxMAXINT;
66 			}
67 			else if( p->nLong < SbxMININT )
68 			{
69 				SbxBase::SetError( SbxERR_OVERFLOW ); nRes = SbxMININT;
70 			}
71 			else
72 				nRes = (sal_Int16) p->nLong;
73 			break;
74 		case SbxULONG:
75 			if( p->nULong > SbxMAXINT )
76 			{
77 				SbxBase::SetError( SbxERR_OVERFLOW ); nRes = SbxMAXINT;
78 			}
79 			else
80 				nRes = (sal_Int16) p->nULong;
81 			break;
82 		case SbxSINGLE:
83 			if( p->nSingle > SbxMAXINT )
84 			{
85 				SbxBase::SetError( SbxERR_OVERFLOW ); nRes = SbxMAXINT;
86 			}
87 			else if( p->nSingle < SbxMININT )
88 			{
89 				SbxBase::SetError( SbxERR_OVERFLOW ); nRes = SbxMININT;
90 			}
91 			else
92 				nRes = (sal_Int16) ImpRound( p->nSingle );
93 			break;
94 		case SbxSALINT64:
95 			if( p->nInt64 > SbxMAXINT )
96 			{
97 				SbxBase::SetError( SbxERR_OVERFLOW ); nRes = SbxMAXINT;
98 			}
99 			else if( p->nInt64 < SbxMININT )
100 			{
101 				SbxBase::SetError( SbxERR_OVERFLOW ); nRes = SbxMININT;
102 			}
103 			else
104 				nRes = (sal_Int16) p->nInt64;
105 			break;
106 		case SbxSALUINT64:
107 			if( p->uInt64 > SbxMAXINT )
108 			{
109 				SbxBase::SetError( SbxERR_OVERFLOW ); nRes = SbxMAXINT;
110 			}
111 			else
112 				nRes = (sal_Int16) p->uInt64;
113 			break;
114 		case SbxDATE:
115 		case SbxDOUBLE:
116 		case SbxLONG64:
117 		case SbxULONG64:
118 		case SbxCURRENCY:
119 		case SbxDECIMAL:
120 		case SbxBYREF | SbxDECIMAL:
121 			{
122 			double dVal;
123 			if( p->eType ==	SbxCURRENCY )
124 				dVal = ImpCurrencyToDouble( p->nLong64 );
125 			else if( p->eType == SbxLONG64 )
126 				dVal = ImpINT64ToDouble( p->nLong64 );
127 			else if( p->eType == SbxULONG64 )
128 				dVal = ImpUINT64ToDouble( p->nULong64 );
129 			else if( p->eType == SbxDECIMAL )
130 			{
131 				dVal = 0.0;
132 				if( p->pDecimal )
133 					p->pDecimal->getDouble( dVal );
134 			}
135 			else
136 				dVal = p->nDouble;
137 
138 			if( dVal > SbxMAXINT )
139 			{
140 				SbxBase::SetError( SbxERR_OVERFLOW ); nRes = SbxMAXINT;
141 			}
142 			else if( dVal < SbxMININT )
143 			{
144 				SbxBase::SetError( SbxERR_OVERFLOW ); nRes = SbxMININT;
145 			}
146 			else
147 				nRes = (sal_Int16) ImpRound( dVal );
148 			break;
149 			}
150 		case SbxLPSTR:
151 		case SbxSTRING:
152 		case SbxBYREF | SbxSTRING:
153 			if( !p->pOUString )
154 				nRes = 0;
155 			else
156 			{
157 				double d;
158 				SbxDataType t;
159 				if( ImpScan( *p->pOUString, d, t, NULL ) != SbxERR_OK )
160 					nRes = 0;
161 				else if( d > SbxMAXINT )
162 				{
163 					SbxBase::SetError( SbxERR_OVERFLOW ); nRes = SbxMAXINT;
164 				}
165 				else if( d < SbxMININT )
166 				{
167 					SbxBase::SetError( SbxERR_OVERFLOW ); nRes = SbxMININT;
168 				}
169 				else
170 					nRes = (sal_Int16) ImpRound( d );
171 			}
172 			break;
173 		case SbxOBJECT:
174 		{
175 			SbxValue* pVal = PTR_CAST(SbxValue,p->pObj);
176 			if( pVal )
177 				nRes = pVal->GetInteger();
178 			else
179 			{
180 				SbxBase::SetError( SbxERR_NO_OBJECT ); nRes = 0;
181 			}
182 			break;
183 		}
184 
185 		case SbxBYREF | SbxCHAR:
186 			nRes = *p->pChar; break;
187 		case SbxBYREF | SbxBYTE:
188 			nRes = *p->pByte; break;
189 		case SbxBYREF | SbxINTEGER:
190 		case SbxBYREF | SbxBOOL:
191 			nRes = *p->pInteger; break;
192 
193 		// ab hier muss getestet werden
194 		case SbxBYREF | SbxLONG:
195 			aTmp.nLong = *p->pLong; goto ref;
196 		case SbxBYREF | SbxULONG:
197 			aTmp.nULong = *p->pULong; goto ref;
198 		case SbxBYREF | SbxERROR:
199 		case SbxBYREF | SbxUSHORT:
200 			aTmp.nUShort = *p->pUShort; goto ref;
201 		case SbxBYREF | SbxSINGLE:
202 			aTmp.nSingle = *p->pSingle; goto ref;
203 		case SbxBYREF | SbxDATE:
204 		case SbxBYREF | SbxDOUBLE:
205 			aTmp.nDouble = *p->pDouble; goto ref;
206 		case SbxBYREF | SbxULONG64:
207 			aTmp.nULong64 = *p->pULong64; goto ref;
208 		case SbxBYREF | SbxLONG64:
209 		case SbxBYREF | SbxCURRENCY:
210 			aTmp.nLong64 = *p->pLong64; goto ref;
211 		case SbxBYREF | SbxSALINT64:
212 			aTmp.nInt64 = *p->pnInt64; goto ref;
213 		case SbxBYREF | SbxSALUINT64:
214 			aTmp.uInt64 = *p->puInt64; goto ref;
215 		ref:
216 			aTmp.eType = SbxDataType( p->eType & 0x0FFF );
217 			p = &aTmp; goto start;
218 
219 		default:
220 			SbxBase::SetError( SbxERR_CONVERSION ); nRes = 0;
221 	}
222 	return nRes;
223 }
224 
ImpPutInteger(SbxValues * p,sal_Int16 n)225 void ImpPutInteger( SbxValues* p, sal_Int16 n )
226 {
227 	SbxValues aTmp;
228 start:
229 	switch( +p->eType )
230 	{
231 		// hier muss getestet werden
232 		case SbxCHAR:
233 			aTmp.pChar = &p->nChar; goto direct;
234 		case SbxBYTE:
235 			aTmp.pByte = &p->nByte; goto direct;
236 		case SbxULONG:
237 			aTmp.pULong = &p->nULong; goto direct;
238 		case SbxERROR:
239 		case SbxUSHORT:
240 			aTmp.pUShort = &p->nUShort; goto direct;
241 		case SbxSALUINT64:
242 			aTmp.puInt64 = &p->uInt64; goto direct;
243 		direct:
244 			aTmp.eType = SbxDataType( p->eType | SbxBYREF );
245 			p = &aTmp; goto start;
246 
247 		// ab hier nicht mehr
248 		case SbxINTEGER:
249 		case SbxBOOL:
250 			p->nInteger = n; break;
251 		case SbxLONG:
252 			p->nLong = n; break;
253 		case SbxSINGLE:
254 			p->nSingle = n; break;
255 		case SbxDATE:
256 		case SbxDOUBLE:
257 			p->nDouble = n; break;
258 		case SbxSALINT64:
259 			p->nInt64 = n; break;
260 		case SbxULONG64:
261 			p->nULong64 = ImpDoubleToUINT64( (double)n ); break;
262 		case SbxLONG64:
263 			p->nLong64 = ImpDoubleToINT64( (double)n ); break;
264 		case SbxCURRENCY:
265 			p->nLong64 = ImpDoubleToCurrency( (double)n ); break;
266 		case SbxDECIMAL:
267 		case SbxBYREF | SbxDECIMAL:
268 			ImpCreateDecimal( p )->setInt( n );
269 			break;
270 
271 		case SbxLPSTR:
272 		case SbxSTRING:
273 		case SbxBYREF | SbxSTRING:
274 			if( !p->pOUString )
275 				p->pOUString = new ::rtl::OUString;
276 			ImpCvtNum( (double) n, 0, *p->pOUString );
277 			break;
278 		case SbxOBJECT:
279 		{
280 			SbxValue* pVal = PTR_CAST(SbxValue,p->pObj);
281 			if( pVal )
282 				pVal->PutInteger( n );
283 			else
284 				SbxBase::SetError( SbxERR_NO_OBJECT );
285 			break;
286 		}
287 		case SbxBYREF | SbxCHAR:
288 			if( n < SbxMINCHAR )
289 			{
290 				SbxBase::SetError( SbxERR_OVERFLOW ); n = SbxMINCHAR;
291 			}
292 			*p->pChar = (char) n; break;
293 		case SbxBYREF | SbxBYTE:
294 			if( n > SbxMAXBYTE )
295 			{
296 				SbxBase::SetError( SbxERR_OVERFLOW ); n = SbxMAXBYTE;
297 			}
298 			else if( n < 0 )
299 			{
300 				SbxBase::SetError( SbxERR_OVERFLOW ); n = 0;
301 			}
302 			*p->pByte = (sal_uInt8) n; break;
303 		case SbxBYREF | SbxINTEGER:
304 		case SbxBYREF | SbxBOOL:
305 			*p->pInteger = n; break;
306 		case SbxBYREF | SbxERROR:
307 		case SbxBYREF | SbxUSHORT:
308 			if( n < 0 )
309 			{
310 				SbxBase::SetError( SbxERR_OVERFLOW ); n = 0;
311 			}
312 			*p->pUShort = (sal_uInt16) n; break;
313 		case SbxBYREF | SbxLONG:
314 			*p->pLong = (sal_Int32) n; break;
315 		case SbxBYREF | SbxULONG:
316 			if( n < 0 )
317 			{
318 				SbxBase::SetError( SbxERR_OVERFLOW ); n = 0;
319 			}
320 			*p->pULong = (sal_uInt32) n; break;
321 		case SbxBYREF | SbxSALINT64:
322 			*p->pnInt64 = n; break;
323 		case SbxBYREF | SbxSALUINT64:
324 	        if( n < 0 )
325             {
326 		        SbxBase::SetError( SbxERR_OVERFLOW ); *p->puInt64 = 0;
327             }
328             else
329 			    *p->puInt64 = n;
330             break;
331 		case SbxBYREF | SbxSINGLE:
332 			*p->pSingle = (float) n; break;
333 		case SbxBYREF | SbxDATE:
334 		case SbxBYREF | SbxDOUBLE:
335 			*p->pDouble = (double) n; break;
336 		case SbxBYREF | SbxULONG64:
337 			*p->pULong64 = ImpDoubleToUINT64( (double)n ); break;
338 		case SbxBYREF | SbxLONG64:
339 			*p->pLong64 = ImpDoubleToINT64( (double)n ); break;
340 		case SbxBYREF | SbxCURRENCY:
341 			*p->pLong64 = ImpDoubleToCurrency( (double)n ); break;
342 
343 		default:
344 			SbxBase::SetError( SbxERR_CONVERSION );
345 	}
346 }
347 
348 
349 // sal_Int64 / hyper
350 
ImpDoubleToSalInt64(double d)351 sal_Int64 ImpDoubleToSalInt64( double d )
352 {
353     sal_Int64 nRes;
354 	if( d > SbxMAXSALINT64 )
355 	{
356 		SbxBase::SetError( SbxERR_OVERFLOW ); nRes = SbxMAXSALINT64;
357 	}
358 	else if( d < SbxMINSALINT64 )
359 	{
360 		SbxBase::SetError( SbxERR_OVERFLOW ); nRes = SbxMINSALINT64;
361 	}
362 	else
363 		nRes = (sal_Int64) ImpRound( d );
364     return nRes;
365 }
366 
ImpDoubleToSalUInt64(double d)367 sal_uInt64 ImpDoubleToSalUInt64( double d )
368 {
369     sal_uInt64 nRes;
370 	if( d > SbxMAXSALUINT64 )
371 	{
372 		SbxBase::SetError( SbxERR_OVERFLOW ); nRes = SbxMAXSALUINT64;
373 	}
374 	else if( d < 0.0 )
375 	{
376 		SbxBase::SetError( SbxERR_OVERFLOW ); nRes = 0;
377 	}
378 	else
379 		nRes = (sal_uInt64) ImpRound( d );
380     return nRes;
381 }
382 
ImpSalUInt64ToDouble(sal_uInt64 n)383 double ImpSalUInt64ToDouble( sal_uInt64 n )
384 {
385     double d = 0.0;
386     if( n > SbxMAXSALINT64 )
387         SbxBase::SetError( SbxERR_CONVERSION );
388     else
389 	    d = (double)(sal_Int64) n;
390     return d;
391 }
392 
393 
ImpGetInt64(const SbxValues * p)394 sal_Int64 ImpGetInt64( const SbxValues* p )
395 {
396 	SbxValues aTmp;
397 	sal_Int64 nRes;
398 start:
399 	switch( +p->eType )
400 	{
401 		case SbxNULL:
402 			SbxBase::SetError( SbxERR_CONVERSION );
403 		case SbxEMPTY:
404 			nRes = 0; break;
405 		case SbxCHAR:
406 			nRes = p->nChar; break;
407 		case SbxBYTE:
408 			nRes = p->nByte; break;
409 		case SbxINTEGER:
410 		case SbxBOOL:
411 			nRes = p->nInteger; break;
412 		case SbxERROR:
413 		case SbxUSHORT:
414 			nRes = p->nUShort; break;
415 		case SbxLONG:
416 			nRes = p->nLong; break;
417 		case SbxULONG:
418 			nRes = (sal_Int64) p->nULong; break;
419 		case SbxSINGLE:
420             nRes = ImpDoubleToSalInt64( (double)p->nSingle );
421 			break;
422 		case SbxDATE:
423 		case SbxDOUBLE:
424 		case SbxLONG64:
425 		case SbxULONG64:
426 		case SbxCURRENCY:
427 			{
428 			double dVal;
429 			if( p->eType ==	SbxCURRENCY )
430 				dVal = ImpCurrencyToDouble( p->nLong64 );
431 			else if( p->eType == SbxLONG64 )
432 				dVal = ImpINT64ToDouble( p->nLong64 );
433 			else if( p->eType == SbxULONG64 )
434 				dVal = ImpUINT64ToDouble( p->nULong64 );
435 			else
436 				dVal = p->nDouble;
437 
438             nRes = ImpDoubleToSalInt64( dVal );
439 			break;
440 			}
441         case SbxSALINT64:
442 		    nRes = p->nInt64; break;
443 		case SbxSALUINT64:
444 			if( p->uInt64 > SbxMAXSALINT64 )
445 			{
446 				SbxBase::SetError( SbxERR_OVERFLOW ); nRes = SbxMAXSALINT64;
447 			}
448 			else
449 				nRes = (sal_Int64) p->uInt64;
450 			break;
451 
452 		case SbxBYREF | SbxSTRING:
453 		case SbxSTRING:
454 		case SbxLPSTR:
455 			if( !p->pOUString )
456 				nRes = 0;
457 			else
458 			{
459                	::rtl::OString aOStr = ::rtl::OUStringToOString
460                     ( *p->pOUString, RTL_TEXTENCODING_ASCII_US );
461                 nRes = aOStr.toInt64();
462                 if( nRes == 0 )
463                 {
464                     // Check if really 0 or invalid conversion
465 				    double d;
466 				    SbxDataType t;
467 				    if( ImpScan( *p->pOUString, d, t, NULL ) != SbxERR_OK )
468 					    nRes = 0;
469                     else
470 					    nRes = ImpDoubleToSalInt64( d );
471                 }
472 			}
473 			break;
474 		case SbxOBJECT:
475 		{
476 			SbxValue* pVal = PTR_CAST(SbxValue,p->pObj);
477 			if( pVal )
478 				nRes = pVal->GetInt64();
479 			else
480 			{
481 				SbxBase::SetError( SbxERR_NO_OBJECT ); nRes = 0;
482 			}
483 			break;
484 		}
485 
486 		case SbxBYREF | SbxCHAR:
487 			nRes = *p->pChar; break;
488 		case SbxBYREF | SbxBYTE:
489 			nRes = *p->pByte; break;
490 		case SbxBYREF | SbxINTEGER:
491 		case SbxBYREF | SbxBOOL:
492 			nRes = *p->pInteger; break;
493 		case SbxBYREF | SbxLONG:
494 			nRes = *p->pLong; break;
495 		case SbxBYREF | SbxULONG:
496 			nRes = *p->pULong; break;
497         case SbxBYREF | SbxSALINT64:
498 		    nRes = *p->pnInt64; break;
499 
500 		// from here the values has to be checked
501 		case SbxBYREF | SbxERROR:
502 		case SbxBYREF | SbxUSHORT:
503 			aTmp.nUShort = *p->pUShort; goto ref;
504 		case SbxBYREF | SbxSINGLE:
505 			aTmp.nSingle = *p->pSingle; goto ref;
506 		case SbxBYREF | SbxDATE:
507 		case SbxBYREF | SbxDOUBLE:
508 			aTmp.nDouble = *p->pDouble; goto ref;
509 		case SbxBYREF | SbxULONG64:
510 			aTmp.nULong64 = *p->pULong64; goto ref;
511 		case SbxBYREF | SbxLONG64:
512 		case SbxBYREF | SbxCURRENCY:
513 			aTmp.nLong64 = *p->pLong64; goto ref;
514         case SbxBYREF | SbxSALUINT64:
515 			aTmp.uInt64 = *p->puInt64; goto ref;
516 		ref:
517 			aTmp.eType = SbxDataType( p->eType & 0x0FFF );
518 			p = &aTmp; goto start;
519 
520 		default:
521 			SbxBase::SetError( SbxERR_CONVERSION ); nRes = 0;
522 	}
523 	return nRes;
524 }
525 
ImpPutInt64(SbxValues * p,sal_Int64 n)526 void ImpPutInt64( SbxValues* p, sal_Int64 n )
527 {
528 	SbxValues aTmp;
529 
530 start:
531 	switch( +p->eType )
532 	{
533 		// Check neccessary
534 		case SbxCHAR:
535 			aTmp.pChar = &p->nChar; goto direct;
536 		case SbxBYTE:
537 			aTmp.pByte = &p->nByte; goto direct;
538 		case SbxINTEGER:
539 		case SbxBOOL:
540 			aTmp.pInteger = &p->nInteger; goto direct;
541 		case SbxULONG64:
542 			aTmp.pULong64 = &p->nULong64; goto direct;
543 		case SbxLONG64:
544 		case SbxCURRENCY:
545 			aTmp.pLong64 = &p->nLong64; goto direct;
546 		case SbxULONG:
547 			aTmp.pULong = &p->nULong; goto direct;
548 		case SbxERROR:
549 		case SbxUSHORT:
550 			aTmp.pUShort = &p->nUShort; goto direct;
551 		case SbxLONG:
552 			aTmp.pnInt64 = &p->nInt64; goto direct;
553 		case SbxSALUINT64:
554 			aTmp.puInt64 = &p->uInt64; goto direct;
555 
556 		direct:
557 			aTmp.eType = SbxDataType( p->eType | SbxBYREF );
558 			p = &aTmp; goto start;
559 
560 		// Check not neccessary
561         case SbxSALINT64:
562 		    p->nInt64 = n; break;
563 		case SbxSINGLE:
564 			p->nSingle = (float) n; break;
565 		case SbxDATE:
566 		case SbxDOUBLE:
567 			p->nDouble = (double) n; break;
568 
569 		case SbxBYREF | SbxSTRING:
570 		case SbxSTRING:
571 		case SbxLPSTR:
572         {
573 			if( !p->pOUString )
574 				p->pOUString = new ::rtl::OUString;
575 
576             ::rtl::OString  aOStr  = ::rtl::OString::valueOf( n );
577            	(*p->pOUString) = ::rtl::OStringToOUString
578                 ( aOStr, RTL_TEXTENCODING_ASCII_US );
579 			break;
580         }
581 		case SbxOBJECT:
582 		{
583 			SbxValue* pVal = PTR_CAST(SbxValue,p->pObj);
584 			if( pVal )
585 				pVal->PutInt64( n );
586 			else
587 				SbxBase::SetError( SbxERR_NO_OBJECT );
588 			break;
589 		}
590 		case SbxBYREF | SbxCHAR:
591 			if( n > SbxMAXCHAR )
592 			{
593 				SbxBase::SetError( SbxERR_OVERFLOW ); n = SbxMAXCHAR;
594 			}
595 			else if( n < SbxMINCHAR )
596 			{
597 				SbxBase::SetError( SbxERR_OVERFLOW ); n = SbxMINCHAR;
598 			}
599 			*p->pChar = (xub_Unicode) n; break;
600 		case SbxBYREF | SbxBYTE:
601 			if( n > SbxMAXBYTE )
602 			{
603 				SbxBase::SetError( SbxERR_OVERFLOW ); n = SbxMAXBYTE;
604 			}
605 			else if( n < 0 )
606 			{
607 				SbxBase::SetError( SbxERR_OVERFLOW ); n = 0;
608 			}
609 			*p->pByte = (sal_uInt8) n; break;
610 		case SbxBYREF | SbxINTEGER:
611 		case SbxBYREF | SbxBOOL:
612 			if( n > SbxMAXINT )
613 			{
614 				SbxBase::SetError( SbxERR_OVERFLOW ); n = SbxMAXINT;
615 			}
616 			else if( n < SbxMININT )
617 			{
618 				SbxBase::SetError( SbxERR_OVERFLOW ); n = SbxMININT;
619 			}
620 			*p->pInteger = (sal_Int16) n; break;
621 		case SbxBYREF | SbxERROR:
622 		case SbxBYREF | SbxUSHORT:
623 			if( n > SbxMAXUINT )
624 			{
625 				SbxBase::SetError( SbxERR_OVERFLOW ); n = SbxMAXUINT;
626 			}
627 			else if( n < 0 )
628 			{
629 				SbxBase::SetError( SbxERR_OVERFLOW ); n = 0;
630 			}
631 			*p->pUShort = (sal_uInt16) n; break;
632 		case SbxBYREF | SbxLONG:
633 			if( n > SbxMAXLNG )
634 			{
635 				SbxBase::SetError( SbxERR_OVERFLOW ); n = SbxMAXLNG;
636 			}
637 			else if( n < SbxMINLNG )
638 			{
639 				SbxBase::SetError( SbxERR_OVERFLOW ); n = SbxMINLNG;
640 			}
641 			*p->pLong = (sal_Int32) n; break;
642 		case SbxBYREF | SbxULONG:
643 			if( n > SbxMAXULNG )
644 			{
645 				SbxBase::SetError( SbxERR_OVERFLOW ); n = SbxMAXULNG;
646 			}
647 			else if( n < 0 )
648 			{
649 				SbxBase::SetError( SbxERR_OVERFLOW ); n = 0;
650 			}
651 			*p->pULong = (sal_uInt32) n; break;
652 		case SbxBYREF | SbxSINGLE:
653 			*p->pSingle = (float) n; break;
654 		case SbxBYREF | SbxDATE:
655 		case SbxBYREF | SbxDOUBLE:
656 			*p->pDouble = (double) n; break;
657 		case SbxBYREF | SbxCURRENCY:
658 			if( n > SbxMAXCURR )
659 			{
660 				SbxBase::SetError( SbxERR_OVERFLOW ); n = (sal_Int64) SbxMAXCURR;
661 			}
662 			else if( n < SbxMINCURR )
663 			{
664 				SbxBase::SetError( SbxERR_OVERFLOW ); n = (sal_Int64) SbxMINCURR;
665 			}
666 			*p->pLong64 = ImpDoubleToCurrency( (double)n ); break;
667 
668 		case SbxBYREF | SbxSALINT64:
669 			*p->pnInt64 = n; break;
670 		case SbxBYREF | SbxSALUINT64:
671 			if( n < 0 )
672 			{
673 				SbxBase::SetError( SbxERR_OVERFLOW ); n = 0;
674 			}
675 			*p->puInt64 = (sal_Int64) n; break;
676 
677 		default:
678 			SbxBase::SetError( SbxERR_CONVERSION );
679 	}
680 }
681 
ImpGetUInt64(const SbxValues * p)682 sal_uInt64 ImpGetUInt64( const SbxValues* p )
683 {
684 	SbxValues aTmp;
685 	sal_uInt64 nRes;
686 start:
687 	switch( +p->eType )
688 	{
689 		case SbxNULL:
690 			SbxBase::SetError( SbxERR_CONVERSION );
691 		case SbxEMPTY:
692 			nRes = 0; break;
693 		case SbxCHAR:
694 			nRes = p->nChar; break;
695 		case SbxBYTE:
696 			nRes = p->nByte; break;
697 		case SbxINTEGER:
698 		case SbxBOOL:
699 			nRes = p->nInteger; break;
700 		case SbxERROR:
701 		case SbxUSHORT:
702 			nRes = p->nUShort; break;
703 		case SbxLONG:
704 			nRes = p->nLong; break;
705 		case SbxULONG:
706 			nRes = (sal_uInt64) p->nULong; break;
707 		case SbxSINGLE:
708             nRes = ImpDoubleToSalUInt64( (double)p->nSingle );
709 			break;
710 		case SbxDATE:
711 		case SbxDOUBLE:
712 		case SbxLONG64:
713 		case SbxULONG64:
714 		case SbxCURRENCY:
715 			{
716 			double dVal;
717 			if( p->eType ==	SbxCURRENCY )
718 				dVal = ImpCurrencyToDouble( p->nLong64 );
719 			else if( p->eType == SbxLONG64 )
720 				dVal = ImpINT64ToDouble( p->nLong64 );
721 			else if( p->eType == SbxULONG64 )
722 				dVal = ImpUINT64ToDouble( p->nULong64 );
723 			else
724 				dVal = p->nDouble;
725 
726             nRes = ImpDoubleToSalUInt64( dVal );
727 			break;
728 			}
729         case SbxSALINT64:
730 			if( p->nInt64 < 0 )
731 			{
732 				SbxBase::SetError( SbxERR_OVERFLOW ); nRes = 0;
733 			}
734 			else
735 				nRes = (sal_uInt64) p->nInt64;
736 		case SbxSALUINT64:
737 		    nRes = p->uInt64; break;
738 
739 		case SbxBYREF | SbxSTRING:
740 		case SbxSTRING:
741 		case SbxLPSTR:
742 			if( !p->pOUString )
743 				nRes = 0;
744 			else
745 			{
746                	::rtl::OString aOStr = ::rtl::OUStringToOString
747                     ( *p->pOUString, RTL_TEXTENCODING_ASCII_US );
748                 sal_Int64 n64 = aOStr.toInt64();
749                 if( n64 == 0 )
750                 {
751                     // Check if really 0 or invalid conversion
752 				    double d;
753 				    SbxDataType t;
754 				    if( ImpScan( *p->pOUString, d, t, NULL ) != SbxERR_OK )
755 					    nRes = 0;
756 				    else if( d > SbxMAXSALUINT64 )
757 				    {
758 					    SbxBase::SetError( SbxERR_OVERFLOW ); nRes = SbxMAXSALUINT64;
759 				    }
760 				    else if( d < 0.0 )
761 				    {
762 					    SbxBase::SetError( SbxERR_OVERFLOW ); nRes = 0;
763 				    }
764 				    else
765 					    nRes = (sal_uInt64) ImpRound( d );
766                 }
767 			    else if( n64 < 0 )
768 			    {
769 				    SbxBase::SetError( SbxERR_OVERFLOW ); nRes = 0;
770 			    }
771                 else
772 			    {
773 				    nRes = n64;
774 			    }
775 			}
776 			break;
777 		case SbxOBJECT:
778 		{
779 			SbxValue* pVal = PTR_CAST(SbxValue,p->pObj);
780 			if( pVal )
781 				nRes = pVal->GetUInt64();
782 			else
783 			{
784 				SbxBase::SetError( SbxERR_NO_OBJECT ); nRes = 0;
785 			}
786 			break;
787 		}
788 
789 		case SbxBYREF | SbxCHAR:
790 			nRes = *p->pChar; break;
791 		case SbxBYREF | SbxBYTE:
792 			nRes = *p->pByte; break;
793 		case SbxBYREF | SbxINTEGER:
794 		case SbxBYREF | SbxBOOL:
795 			nRes = *p->pInteger; break;
796 		case SbxBYREF | SbxLONG:
797 			nRes = *p->pLong; break;
798 		case SbxBYREF | SbxULONG:
799 			nRes = *p->pULong; break;
800         case SbxBYREF | SbxSALUINT64:
801 		    nRes = *p->puInt64; break;
802 
803 		// from here the values has to be checked
804 		case SbxBYREF | SbxERROR:
805 		case SbxBYREF | SbxUSHORT:
806 			aTmp.nUShort = *p->pUShort; goto ref;
807 		case SbxBYREF | SbxSINGLE:
808 			aTmp.nSingle = *p->pSingle; goto ref;
809 		case SbxBYREF | SbxDATE:
810 		case SbxBYREF | SbxDOUBLE:
811 			aTmp.nDouble = *p->pDouble; goto ref;
812 		case SbxBYREF | SbxULONG64:
813 			aTmp.nULong64 = *p->pULong64; goto ref;
814 		case SbxBYREF | SbxLONG64:
815 		case SbxBYREF | SbxCURRENCY:
816 			aTmp.nLong64 = *p->pLong64; goto ref;
817         case SbxBYREF | SbxSALINT64:
818 			aTmp.nInt64 = *p->pnInt64; goto ref;
819 		ref:
820 			aTmp.eType = SbxDataType( p->eType & 0x0FFF );
821 			p = &aTmp; goto start;
822 
823 		default:
824 			SbxBase::SetError( SbxERR_CONVERSION ); nRes = 0;
825 	}
826 	return nRes;
827 }
828 
ImpPutUInt64(SbxValues * p,sal_uInt64 n)829 void ImpPutUInt64( SbxValues* p, sal_uInt64 n )
830 {
831 	SbxValues aTmp;
832 
833 start:
834 	switch( +p->eType )
835 	{
836 		// Check neccessary
837 		case SbxCHAR:
838 			aTmp.pChar = &p->nChar; goto direct;
839 		case SbxBYTE:
840 			aTmp.pByte = &p->nByte; goto direct;
841 		case SbxINTEGER:
842 		case SbxBOOL:
843 			aTmp.pInteger = &p->nInteger; goto direct;
844 		case SbxULONG64:
845 			aTmp.pULong64 = &p->nULong64; goto direct;
846 		case SbxLONG64:
847 		case SbxCURRENCY:
848 			aTmp.pLong64 = &p->nLong64; goto direct;
849 		case SbxULONG:
850 			aTmp.pULong = &p->nULong; goto direct;
851 		case SbxERROR:
852 		case SbxUSHORT:
853 			aTmp.pUShort = &p->nUShort; goto direct;
854 		case SbxLONG:
855 			aTmp.pnInt64 = &p->nInt64; goto direct;
856 		case SbxSALINT64:
857 			aTmp.pnInt64 = &p->nInt64; goto direct;
858 		case SbxSINGLE:
859 			aTmp.pSingle = &p->nSingle; goto direct;
860 		case SbxDATE:
861 		case SbxDOUBLE:
862 			aTmp.pDouble = &p->nDouble; goto direct;
863 
864 		direct:
865 			aTmp.eType = SbxDataType( p->eType | SbxBYREF );
866 			p = &aTmp; goto start;
867 
868 		// Check not neccessary
869         case SbxSALUINT64:
870 		    p->uInt64 = n; break;
871 
872 		case SbxBYREF | SbxSTRING:
873 		case SbxSTRING:
874 		case SbxLPSTR:
875 			if( !p->pOUString )
876 				p->pOUString = new ::rtl::OUString;
877             if( n > SbxMAXSALINT64 )
878     			SbxBase::SetError( SbxERR_CONVERSION );
879             else
880             {
881                 ::rtl::OString  aOStr  = ::rtl::OString::valueOf( (sal_Int64)n );
882            	    (*p->pOUString) = ::rtl::OStringToOUString
883                     ( aOStr, RTL_TEXTENCODING_ASCII_US );
884             }
885 			break;
886 		case SbxOBJECT:
887 		{
888 			SbxValue* pVal = PTR_CAST(SbxValue,p->pObj);
889 			if( pVal )
890 				pVal->PutUInt64( n );
891 			else
892 				SbxBase::SetError( SbxERR_NO_OBJECT );
893 			break;
894 		}
895 		case SbxBYREF | SbxCHAR:
896 			if( n > SbxMAXCHAR )
897 			{
898 				SbxBase::SetError( SbxERR_OVERFLOW ); n = SbxMAXCHAR;
899 			}
900 			*p->pChar = (xub_Unicode) n; break;
901 		case SbxBYREF | SbxBYTE:
902 			if( n > SbxMAXBYTE )
903 			{
904 				SbxBase::SetError( SbxERR_OVERFLOW ); n = SbxMAXBYTE;
905 			}
906 			*p->pByte = (sal_uInt8) n; break;
907 		case SbxBYREF | SbxINTEGER:
908 		case SbxBYREF | SbxBOOL:
909 			if( n > SbxMAXINT )
910 			{
911 				SbxBase::SetError( SbxERR_OVERFLOW ); n = SbxMAXINT;
912 			}
913 			*p->pInteger = (sal_Int16) n; break;
914 		case SbxBYREF | SbxERROR:
915 		case SbxBYREF | SbxUSHORT:
916 			if( n > SbxMAXUINT )
917 			{
918 				SbxBase::SetError( SbxERR_OVERFLOW ); n = SbxMAXUINT;
919 			}
920 			*p->pUShort = (sal_uInt16) n; break;
921 		case SbxBYREF | SbxLONG:
922 			if( n > SbxMAXLNG )
923 			{
924 				SbxBase::SetError( SbxERR_OVERFLOW ); n = SbxMAXLNG;
925 			}
926 			*p->pLong = (sal_Int32) n; break;
927 		case SbxBYREF | SbxULONG:
928 			if( n > SbxMAXULNG )
929 			{
930 				SbxBase::SetError( SbxERR_OVERFLOW ); n = SbxMAXULNG;
931 			}
932 			*p->pULong = (sal_uInt32) n; break;
933 		case SbxBYREF | SbxSINGLE:
934             *p->pDouble = (float)ImpSalUInt64ToDouble( n ); break;
935 		case SbxBYREF | SbxDATE:
936 		case SbxBYREF | SbxDOUBLE:
937             *p->pDouble = ImpSalUInt64ToDouble( n ); break;
938 		case SbxBYREF | SbxCURRENCY:
939 			if( n > SbxMAXSALINT64 || (sal_Int64)n > SbxMAXCURR )
940 			{
941 				SbxBase::SetError( SbxERR_OVERFLOW ); n = (sal_Int64) SbxMAXCURR;
942 			}
943 			*p->pLong64 = ImpDoubleToCurrency( (double)(sal_Int64) n ); break;
944 
945 		case SbxBYREF | SbxSALUINT64:
946 			*p->puInt64 = n; break;
947 		case SbxBYREF | SbxSALINT64:
948 			if( n > SbxMAXSALINT64 )
949 			{
950 				SbxBase::SetError( SbxERR_OVERFLOW ); n = 0;
951 			}
952 			*p->pnInt64 = (sal_Int64) n; break;
953 
954 		default:
955 			SbxBase::SetError( SbxERR_CONVERSION );
956 	}
957 }
958 
959 
960