1 : //==============================================================================
2 : // File <$/src/cpp/dev/idlc/float_value.cpp>
3 : // This file is part of YaOrb : Yet Another Object Request Broker,
4 : // Copyright (c) 2000-2003, 2006, Marc Alff.
5 : //
6 : // This program is free software; you can redistribute it and/or
7 : // modify it under the terms of the GNU General Public License
8 : // as published by the Free Software Foundation; either version 2
9 : // of the License, or (at your option) any later version.
10 : //
11 : // This program is distributed in the hope that it will be useful,
12 : // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 : // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 : // GNU General Public License for more details.
15 : //
16 : // You should have received a copy of the GNU General Public License
17 : // along with this program; if not, write to the Free Software
18 : // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
19 : //
20 : //==============================================================================
21 :
22 : #include "src/cpp/prod/tool/Assert.h"
23 :
24 : #include "src/cpp/dev/idlc/arith.h"
25 : #include "src/cpp/dev/idlc/float_value.h"
26 :
27 : typedef void (*convertFn)(IDLFloatValue*) ;
28 :
29 8 : static void nop(IDLFloatValue*)
30 : {}
31 :
32 : // Matrix, line 0 : F32_to_XXX
33 :
34 0 : static void F32_to_F64(IDLFloatValue* v)
35 : {
36 0 : double v2 = v->GetF32() ;
37 0 : v->PutF64(v2) ;
38 : }
39 :
40 0 : static void F32_to_F96(IDLFloatValue* v)
41 : {
42 : long double v2 ;
43 0 : v2 = v->GetF32() ;
44 0 : v->PutF96(v2) ;
45 : }
46 :
47 : // Matrix, line 1 : F64_to_XXX
48 :
49 0 : static void F64_to_F32(IDLFloatValue* v)
50 : {
51 0 : float v2 = v->GetF64() ;
52 0 : v->PutF32(v2) ;
53 : }
54 :
55 0 : static void F64_to_F96(IDLFloatValue* v)
56 : {
57 : long double v2 ;
58 0 : v2 = v->GetF64() ;
59 0 : v->PutF96(v2) ;
60 : }
61 :
62 : // Matrix, line 2 : F96_to_XXX
63 :
64 8 : static void F96_to_F32(IDLFloatValue* v)
65 : {
66 8 : float v2 = v->GetF96() ;
67 8 : v->PutF32(v2) ;
68 : }
69 :
70 11 : static void F96_to_F64(IDLFloatValue* v)
71 : {
72 11 : double v2 = v->GetF96() ;
73 11 : v->PutF64(v2) ;
74 : }
75 :
76 54 : static int index(IDLFloatType_e type)
77 : {
78 54 : switch(type)
79 : {
80 : case idl_float :
81 : {
82 : return 0 ;
83 : }
84 : case idl_double :
85 : {
86 : return 1 ;
87 : }
88 : case idl_long_double :
89 : {
90 : return 2 ;
91 : }
92 : }
93 :
94 : ASSERT(false) ;
95 : return 0 ;
96 : }
97 :
98 : static convertFn convertMatrix[3][3] =
99 : {
100 : {nop , F32_to_F64 , F32_to_F96},
101 : {F64_to_F32 , nop , F64_to_F96},
102 : {F96_to_F32, F96_to_F64, nop }
103 : } ;
104 :
105 39 : IDLFloatValue::IDLFloatValue()
106 : : IDLValue(idl_floatType),
107 : _type(idl_float),
108 : _value_f32(0.0),
109 : _value_f64(0.0),
110 39 : _value_f96()
111 : {
112 : }
113 :
114 27 : IDLFloatValue::IDLFloatValue(const IDLFloatValue& v)
115 : : IDLValue(idl_floatType),
116 : _type(v._type),
117 : _value_f32(v._value_f32),
118 : _value_f64(v._value_f64),
119 27 : _value_f96(v._value_f96)
120 : {
121 : }
122 :
123 0 : IDLFloatValue& IDLFloatValue::operator = (const IDLFloatValue& v)
124 : {
125 0 : _type = v._type ;
126 :
127 0 : _value_f32 = v._value_f32 ;
128 0 : _value_f64 = v._value_f64 ;
129 0 : _value_f96 = v._value_f96 ;
130 :
131 : return *this ;
132 : }
133 :
134 60 : IDLFloatValue::~IDLFloatValue()
135 60 : {}
136 :
137 0 : IDLFloatType_e IDLFloatValue::GetType(void) const
138 : {
139 : return _type ;
140 : }
141 :
142 0 : IDLType* IDLFloatValue::GetValueType(void) const
143 : {
144 0 : switch(_type)
145 : {
146 : case idl_float :
147 : {
148 0 : static IDLFloatType t(idl_float) ;
149 : return &t ;
150 : }
151 : case idl_double :
152 : {
153 0 : static IDLFloatType t(idl_double) ;
154 : return &t ;
155 : }
156 : case idl_long_double :
157 : {
158 0 : static IDLFloatType t(idl_long_double) ;
159 : return &t ;
160 : }
161 : } ;
162 :
163 : // Never executed : to please the compiler
164 : ASSERT(false) ;
165 : return NULL ;
166 : }
167 :
168 12 : void IDLFloatValue::PutF32(float v)
169 : {
170 12 : _type = idl_float ;
171 12 : _value_f32 = v ;
172 : }
173 :
174 15 : void IDLFloatValue::PutF64(double v)
175 : {
176 15 : _type = idl_double ;
177 15 : _value_f64 = v ;
178 : }
179 :
180 31 : void IDLFloatValue::PutF96(long double v)
181 : {
182 31 : _type = idl_long_double ;
183 31 : _value_f96 = v ;
184 : }
185 :
186 0 : float IDLFloatValue::GetF32(void) const
187 : {
188 : ASSERT(_type == idl_float) ;
189 : return _value_f32 ;
190 : }
191 :
192 3 : double IDLFloatValue::GetF64(void) const
193 : {
194 : ASSERT(_type == idl_double) ;
195 : return _value_f64 ;
196 : }
197 :
198 19 : long double IDLFloatValue::GetF96(void) const
199 : {
200 : ASSERT(_type == idl_long_double) ;
201 : return _value_f96 ;
202 : }
203 :
204 12 : void IDLFloatValue::print(std::ostream &str) const
205 : {
206 : char buff[80] ;
207 :
208 12 : switch(_type)
209 : {
210 : case idl_float :
211 : {
212 4 : sprintf(buff, "%f", _value_f32) ;
213 4 : break ;
214 : }
215 : case idl_double :
216 : {
217 4 : sprintf(buff, "%g", _value_f64) ;
218 4 : break ;
219 : }
220 : case idl_long_double :
221 : {
222 4 : NON_DEV("f96 print") ;
223 4 : sprintf(buff, "FIXME f96 print") ;
224 : // sprintf(buff, "%Lf", _value_f96) ;
225 : break ;
226 : }
227 : }
228 :
229 12 : str << buff ;
230 : }
231 :
232 27 : void IDLFloatValue::convert(IDLType *type)
233 : {
234 : ASSERT(type != NULL) ;
235 :
236 27 : if (type->isA() == idl_floatType)
237 : {
238 : IDLFloatType *type2 = (IDLFloatType*) type ;
239 :
240 27 : int lign = index(_type) ;
241 54 : int column = index(type2->GetType()) ;
242 : convertFn fct = convertMatrix[lign][column] ;
243 :
244 : ASSERT(fct != NULL) ;
245 27 : (*fct) (this) ;
246 : }
247 : else
248 : {
249 0 : if (type->isA() != idl_errorType)
250 : {
251 0 : typeConvertionError(type) ;
252 : }
253 : }
254 : }
255 :
256 27 : IDLValue* IDLFloatValue::copy(void)
257 : {
258 27 : return new IDLFloatValue(*this) ;
259 : }
260 :
261 3 : IDLValue* IDLFloatValue::computeAdd(const IDLValue* v)
262 : {
263 3 : IDLFloatValue *result = new IDLFloatValue() ;
264 : IDLFloatValue *v2 = NULL ;
265 : bool overflow = false ;
266 :
267 : ASSERT(v->isA() == idl_floatType) ;
268 3 : v2 = (IDLFloatValue*) v ;
269 : ASSERT(v2->GetType() == _type) ;
270 :
271 3 : switch (_type)
272 : {
273 : case idl_float :
274 : {
275 : float r ;
276 1 : overflow = add_f32(_value_f32, v2->_value_f32, & r) ;
277 1 : result->PutF32(r) ;
278 1 : break ;
279 : }
280 : case idl_double :
281 : {
282 : double r ;
283 1 : overflow = add_f64(_value_f64, v2->_value_f64, & r) ;
284 1 : result->PutF64(r) ;
285 1 : break ;
286 : }
287 : case idl_long_double :
288 : {
289 : long double r ;
290 1 : overflow = add_f96(_value_f96, v2->_value_f96, & r) ;
291 1 : result->PutF96(r) ;
292 : break ;
293 : }
294 : }
295 :
296 3 : if (overflow)
297 : {
298 0 : result->SetError() ;
299 : }
300 : return result ;
301 : }
302 :
303 3 : IDLValue* IDLFloatValue::computeSub(const IDLValue* v)
304 : {
305 3 : IDLFloatValue *result = new IDLFloatValue() ;
306 : IDLFloatValue *v2 = NULL ;
307 : bool overflow = false ;
308 :
309 : ASSERT(v->isA() == idl_floatType) ;
310 3 : v2 = (IDLFloatValue*) v ;
311 : ASSERT(v2->GetType() == _type) ;
312 :
313 3 : switch (_type)
314 : {
315 : case idl_float :
316 : {
317 : float r ;
318 1 : overflow = sub_f32(_value_f32, v2->_value_f32, & r) ;
319 1 : result->PutF32(r) ;
320 1 : break ;
321 : }
322 : case idl_double :
323 : {
324 : double r ;
325 1 : overflow = sub_f64(_value_f64, v2->_value_f64, & r) ;
326 1 : result->PutF64(r) ;
327 1 : break ;
328 : }
329 : case idl_long_double :
330 : {
331 : long double r ;
332 1 : overflow = sub_f96(_value_f96, v2->_value_f96, & r) ;
333 1 : result->PutF96(r) ;
334 : break ;
335 : }
336 : }
337 :
338 3 : if (overflow)
339 : {
340 0 : result->SetError() ;
341 : }
342 : return result ;
343 : }
344 :
345 3 : IDLValue* IDLFloatValue::computeMul(const IDLValue* v)
346 : {
347 3 : IDLFloatValue *result = new IDLFloatValue() ;
348 : IDLFloatValue *v2 = NULL ;
349 : bool overflow = false ;
350 :
351 : ASSERT(v->isA() == idl_floatType) ;
352 3 : v2 = (IDLFloatValue*) v ;
353 : ASSERT(v2->GetType() == _type) ;
354 :
355 3 : switch (_type)
356 : {
357 : case idl_float :
358 : {
359 : float r ;
360 1 : overflow = mul_f32(_value_f32, v2->_value_f32, & r) ;
361 1 : result->PutF32(r) ;
362 1 : break ;
363 : }
364 : case idl_double :
365 : {
366 : double r ;
367 1 : overflow = mul_f64(_value_f64, v2->_value_f64, & r) ;
368 1 : result->PutF64(r) ;
369 1 : break ;
370 : }
371 : case idl_long_double :
372 : {
373 : long double r ;
374 1 : overflow = mul_f96(_value_f96, v2->_value_f96, & r) ;
375 1 : result->PutF96(r) ;
376 : break ;
377 : }
378 : }
379 :
380 3 : if (overflow)
381 : {
382 0 : result->SetError() ;
383 : }
384 : return result ;
385 : }
386 :
387 3 : IDLValue* IDLFloatValue::computeDiv(const IDLValue* v)
388 : {
389 3 : IDLFloatValue *result = new IDLFloatValue() ;
390 : IDLFloatValue *v2 = NULL ;
391 : bool overflow = false ;
392 :
393 : ASSERT(v->isA() == idl_floatType) ;
394 3 : v2 = (IDLFloatValue*) v ;
395 : ASSERT(v2->GetType() == _type) ;
396 :
397 3 : switch (_type)
398 : {
399 : case idl_float :
400 : {
401 : float r ;
402 1 : overflow = div_f32(_value_f32, v2->_value_f32, & r) ;
403 1 : result->PutF32(r) ;
404 1 : break ;
405 : }
406 : case idl_double :
407 : {
408 : double r ;
409 1 : overflow = div_f64(_value_f64, v2->_value_f64, & r) ;
410 1 : result->PutF64(r) ;
411 1 : break ;
412 : }
413 : case idl_long_double :
414 : {
415 : long double r ;
416 1 : overflow = div_f96(_value_f96, v2->_value_f96, & r) ;
417 1 : result->PutF96(r) ;
418 : break ;
419 : }
420 : }
421 :
422 3 : if (overflow)
423 : {
424 0 : result->SetError() ;
425 : }
426 : return result ;
427 : }
428 :
429 0 : IDLValue* IDLFloatValue::computeMinus(void)
430 : {
431 0 : NON_DEV("IDLFloatValue") ;
432 : return NULL ;
433 63 : }
434 63 :
|
