xref: /aoo4110/main/basic/source/sbx/sbxuint.cxx (revision b1cdbd2c)
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 
ImpGetUShort(const SbxValues * p)30 sal_uInt16 ImpGetUShort( const SbxValues* p )
31 {
32 	SbxValues aTmp;
33 	sal_uInt16 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 > SbxMAXUINT )
61 			{
62 				SbxBase::SetError( SbxERR_OVERFLOW ); nRes = SbxMAXUINT;
63 			}
64 			else if( p->nLong < 0 )
65 			{
66 				SbxBase::SetError( SbxERR_OVERFLOW ); nRes = 0;
67 			}
68 			else
69 				nRes = (sal_uInt16) p->nLong;
70 			break;
71 		case SbxULONG:
72 			if( p->nULong > SbxMAXUINT )
73 			{
74 				SbxBase::SetError( SbxERR_OVERFLOW ); nRes = SbxMAXUINT;
75 			}
76 			else
77 				nRes = (sal_uInt16) p->nULong;
78 			break;
79 		case SbxSALINT64:
80 			if( p->nInt64 > SbxMAXUINT )
81 			{
82 				SbxBase::SetError( SbxERR_OVERFLOW ); nRes = SbxMAXUINT;
83 			}
84 			else if( p->nInt64 < 0 )
85 			{
86 				SbxBase::SetError( SbxERR_OVERFLOW ); nRes = 0;
87 			}
88 			else
89 				nRes = (sal_uInt16) p->nInt64;
90 			break;
91 		case SbxSALUINT64:
92 			if( p->uInt64 > SbxMAXUINT )
93 			{
94 				SbxBase::SetError( SbxERR_OVERFLOW ); nRes = SbxMAXUINT;
95 			}
96 			else
97 				nRes = (sal_uInt16) p->uInt64;
98 			break;
99 		case SbxSINGLE:
100 			if( p->nSingle > SbxMAXUINT )
101 			{
102 				SbxBase::SetError( SbxERR_OVERFLOW ); nRes = SbxMAXUINT;
103 			}
104 			else if( p->nSingle < 0 )
105 			{
106 				SbxBase::SetError( SbxERR_OVERFLOW ); nRes = 0;
107 			}
108 			else
109 				nRes = (sal_uInt16) ( p->nSingle + 0.5 );
110 			break;
111 		case SbxDATE:
112 		case SbxDOUBLE:
113 		case SbxLONG64:
114 		case SbxULONG64:
115 		case SbxCURRENCY:
116 		case SbxDECIMAL:
117 		case SbxBYREF | SbxDECIMAL:
118 			{
119 			double dVal;
120 			if( p->eType ==	SbxCURRENCY )
121 				dVal = ImpCurrencyToDouble( p->nLong64 );
122 			else if( p->eType == SbxLONG64 )
123 				dVal = ImpINT64ToDouble( p->nLong64 );
124 			else if( p->eType == SbxULONG64 )
125 				dVal = ImpUINT64ToDouble( p->nULong64 );
126 			else if( p->eType == SbxDECIMAL )
127 			{
128 				dVal = 0.0;
129 				if( p->pDecimal )
130 					p->pDecimal->getDouble( dVal );
131 			}
132 			else
133 				dVal = p->nDouble;
134 
135 			if( dVal > SbxMAXUINT )
136 			{
137 				SbxBase::SetError( SbxERR_OVERFLOW ); nRes = SbxMAXUINT;
138 			}
139 			else if( dVal < 0 )
140 			{
141 				SbxBase::SetError( SbxERR_OVERFLOW ); nRes = 0;
142 			}
143 			else
144 				nRes = (sal_uInt16) ( dVal + 0.5 );
145 			break;
146 			}
147 		case SbxBYREF | SbxSTRING:
148 		case SbxSTRING:
149 		case SbxLPSTR:
150 			if( !p->pOUString )
151 				nRes = 0;
152 			else
153 			{
154 				double d;
155 				SbxDataType t;
156 				if( ImpScan( *p->pOUString, d, t, NULL ) != SbxERR_OK )
157 					nRes = 0;
158 				else if( d > SbxMAXUINT )
159 				{
160 					SbxBase::SetError( SbxERR_OVERFLOW ); nRes = SbxMAXUINT;
161 				}
162 				else if( d < 0 )
163 				{
164 					SbxBase::SetError( SbxERR_OVERFLOW ); nRes = 0;
165 				}
166 				else
167 					nRes = (sal_uInt16) ( d + 0.5 );
168 			}
169 			break;
170 		case SbxOBJECT:
171 		{
172 			SbxValue* pVal = PTR_CAST(SbxValue,p->pObj);
173 			if( pVal )
174 				nRes = pVal->GetUShort();
175 			else
176 			{
177 				SbxBase::SetError( SbxERR_NO_OBJECT ); nRes = 0;
178 			}
179 			break;
180 		}
181 
182 		case SbxBYREF | SbxBYTE:
183 			nRes = *p->pByte; break;
184 		case SbxBYREF | SbxERROR:
185 		case SbxBYREF | SbxUSHORT:
186 			nRes = *p->pUShort; break;
187 
188 		// ab hier wird getestet
189 		case SbxBYREF | SbxCHAR:
190 			aTmp.nChar = *p->pChar; goto ref;
191 		case SbxBYREF | SbxINTEGER:
192 		case SbxBYREF | SbxBOOL:
193 			aTmp.nInteger = *p->pInteger; goto ref;
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 | SbxSINGLE:
199 			aTmp.nSingle = *p->pSingle; goto ref;
200 		case SbxBYREF | SbxDATE:
201 		case SbxBYREF | SbxDOUBLE:
202 			aTmp.nDouble = *p->pDouble; goto ref;
203 		case SbxBYREF | SbxULONG64:
204 			aTmp.nULong64 = *p->pULong64; goto ref;
205 		case SbxBYREF | SbxLONG64:
206 		case SbxBYREF | SbxCURRENCY:
207 			aTmp.nLong64 = *p->pLong64; goto ref;
208 		case SbxBYREF | SbxSALINT64:
209 			aTmp.nInt64 = *p->pnInt64; goto ref;
210 		case SbxBYREF | SbxSALUINT64:
211 			aTmp.uInt64 = *p->puInt64; goto ref;
212 		ref:
213 			aTmp.eType = SbxDataType( p->eType & 0x0FFF );
214 			p = &aTmp; goto start;
215 
216 		default:
217 			SbxBase::SetError( SbxERR_CONVERSION ); nRes = 0;
218 	}
219 	return nRes;
220 }
221 
ImpPutUShort(SbxValues * p,sal_uInt16 n)222 void ImpPutUShort( SbxValues* p, sal_uInt16 n )
223 {
224 	SbxValues aTmp;
225 
226 start:
227 	switch( +p->eType )
228 	{
229 		case SbxERROR:
230 		case SbxUSHORT:
231 			p->nUShort = n; break;
232 		case SbxLONG:
233 			p->nLong = n; break;
234 		case SbxULONG:
235 			p->nULong = n; break;
236 		case SbxSINGLE:
237 			p->nSingle = n; break;
238 		case SbxDATE:
239 		case SbxDOUBLE:
240 			p->nDouble = n; break;
241 		case SbxSALINT64:
242 			p->nInt64 = n; break;
243 		case SbxSALUINT64:
244 			p->uInt64 = n; break;
245 		case SbxULONG64:
246 			p->nULong64 = ImpDoubleToUINT64( (double)n ); break;
247 		case SbxLONG64:
248 			p->nLong64 = ImpDoubleToINT64( (double)n ); break;
249 		case SbxCURRENCY:
250 			p->nLong64 = ImpDoubleToCurrency( (double)n ); break;
251 		case SbxDECIMAL:
252 		case SbxBYREF | SbxDECIMAL:
253 			ImpCreateDecimal( p )->setUInt( n );
254 			break;
255 
256 		// Tests ab hier
257 		case SbxCHAR:
258 			aTmp.pChar = &p->nChar; goto direct;
259 		case SbxBYTE:
260 			aTmp.pByte = &p->nByte; goto direct;
261 		case SbxINTEGER:
262 		case SbxBOOL:
263 			aTmp.pInteger = &p->nInteger;
264 		direct:
265 			aTmp.eType = SbxDataType( p->eType | SbxBYREF );
266 			p = &aTmp; goto start;
267 
268 		case SbxBYREF | SbxSTRING:
269 		case SbxSTRING:
270 		case SbxLPSTR:
271 			if( !p->pOUString )
272 				p->pOUString = new ::rtl::OUString;
273 			ImpCvtNum( (double) n, 0, *p->pOUString );
274 			break;
275 		case SbxOBJECT:
276 		{
277 			SbxValue* pVal = PTR_CAST(SbxValue,p->pObj);
278 			if( pVal )
279 				pVal->PutUShort( n );
280 			else
281 				SbxBase::SetError( SbxERR_NO_OBJECT );
282 			break;
283 		}
284 
285 		case SbxBYREF | SbxCHAR:
286 			*p->pChar = (xub_Unicode) n; break;
287 		case SbxBYREF | SbxBYTE:
288 			if( n > SbxMAXBYTE )
289 			{
290 				SbxBase::SetError( SbxERR_OVERFLOW ); n = SbxMAXBYTE;
291 			}
292 			*p->pByte = (sal_uInt8) n; break;
293 		case SbxBYREF | SbxINTEGER:
294 		case SbxBYREF | SbxBOOL:
295 			if( n > SbxMAXINT )
296 			{
297 				SbxBase::SetError( SbxERR_OVERFLOW ); n = SbxMAXINT;
298 			}
299 			*p->pInteger = (sal_Int16) n; break;
300 		case SbxBYREF | SbxERROR:
301 		case SbxBYREF | SbxUSHORT:
302 			*p->pUShort = n; break;
303 		case SbxBYREF | SbxLONG:
304 			*p->pLong = n; break;
305 		case SbxBYREF | SbxULONG:
306 			*p->pULong = n; break;
307 		case SbxBYREF | SbxSINGLE:
308 			*p->pSingle = n; break;
309 		case SbxBYREF | SbxDATE:
310 		case SbxBYREF | SbxDOUBLE:
311 			*p->pDouble = n; break;
312 		case SbxBYREF | SbxSALINT64:
313 			*p->pnInt64 = n; break;
314 		case SbxBYREF | SbxSALUINT64:
315 			*p->puInt64 = n; break;
316 		case SbxBYREF | SbxULONG64:
317 			*p->pULong64 = ImpDoubleToUINT64( (double)n ); break;
318 		case SbxBYREF | SbxLONG64:
319 			*p->pLong64 = ImpDoubleToINT64( (double)n ); break;
320 		case SbxBYREF | SbxCURRENCY:
321 			*p->pLong64 = ImpDoubleToCurrency( (double)n ); break;
322 
323 		default:
324 			SbxBase::SetError( SbxERR_CONVERSION );
325 	}
326 }
327 
328