|
1960
|
1 /* |
|
|
2 |
|
2847
|
3 Copyright (C) 1996, 1997 John W. Eaton |
|
1960
|
4 |
|
|
5 This file is part of Octave. |
|
|
6 |
|
|
7 Octave is free software; you can redistribute it and/or modify it |
|
|
8 under the terms of the GNU General Public License as published by the |
|
|
9 Free Software Foundation; either version 2, or (at your option) any |
|
|
10 later version. |
|
|
11 |
|
|
12 Octave is distributed in the hope that it will be useful, but WITHOUT |
|
|
13 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
|
|
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
|
|
15 for more details. |
|
|
16 |
|
|
17 You should have received a copy of the GNU General Public License |
|
|
18 along with Octave; see the file COPYING. If not, write to the Free |
|
|
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. |
|
|
20 |
|
|
21 */ |
|
|
22 |
|
|
23 #ifdef HAVE_CONFIG_H |
|
|
24 #include <config.h> |
|
|
25 #endif |
|
|
26 |
|
2317
|
27 #include <cctype> |
|
|
28 |
|
1960
|
29 #include <iostream.h> |
|
|
30 |
|
|
31 #include "byte-swap.h" |
|
|
32 #include "data-conv.h" |
|
|
33 #include "lo-error.h" |
|
|
34 |
|
2317
|
35 oct_data_conv::data_type |
|
|
36 oct_data_conv::string_to_data_type (const string& str) |
|
|
37 { |
|
|
38 data_type retval = dt_unknown; |
|
|
39 |
|
|
40 // XXX FIXME XXX -- finish implementing this. |
|
|
41 |
|
|
42 // XXX FIXME XXX -- before checking s, need to strip spaces and downcase. |
|
|
43 |
|
|
44 int n = str.length (); |
|
|
45 |
|
|
46 int k = 0; |
|
|
47 |
|
|
48 string s (n, ' '); |
|
|
49 |
|
|
50 for (int i = 0; i < n; i++) |
|
|
51 if (! isspace (str[i])) |
|
|
52 s[k++] = tolower (str[i]); |
|
|
53 |
|
|
54 s.resize (k); |
|
|
55 |
|
|
56 if (s == "char" || s == "char*1" || s == "integer*1" || s == "int8") |
|
|
57 retval = dt_char; |
|
|
58 else if (s == "schar" || s == "signedchar") |
|
|
59 retval = dt_schar; |
|
|
60 else if (s == "uchar" || s == "unsignedchar") |
|
|
61 retval = dt_uchar; |
|
|
62 else if (s == "short") |
|
|
63 retval = dt_short; |
|
|
64 else if (s == "ushort" || s == "unsignedshort") |
|
|
65 retval = dt_ushort; |
|
|
66 else if (s == "int") |
|
|
67 retval = dt_int; |
|
|
68 else if (s == "uint" || s == "unsignedint") |
|
|
69 retval = dt_uint; |
|
|
70 else if (s == "long") |
|
|
71 retval = dt_long; |
|
|
72 else if (s == "ulong" || s == "unsignedlong") |
|
|
73 retval = dt_ulong; |
|
|
74 else if (s == "float" || s == "float32" || s == "real*4") |
|
|
75 retval = dt_float; |
|
|
76 else if (s == "double" || s == "float64" || s == "real*8") |
|
|
77 retval = dt_double; |
|
|
78 else if (s == "int16" || s == "integer*2") |
|
|
79 { |
|
|
80 if (sizeof (short) == 2) |
|
|
81 retval = dt_short; |
|
|
82 else if (sizeof (int) == 2) |
|
|
83 retval = dt_int; |
|
|
84 else |
|
|
85 (*current_liboctave_error_handler) |
|
|
86 ("unable to find matching native data type for %s", s.c_str ()); |
|
|
87 } |
|
|
88 else if (s == "int32" || s == "integer*4") |
|
|
89 { |
|
|
90 if (sizeof (int) == 4) |
|
|
91 retval = dt_int; |
|
|
92 else if (sizeof (long) == 4) |
|
|
93 retval = dt_long; |
|
|
94 else |
|
|
95 (*current_liboctave_error_handler) |
|
|
96 ("unable to find matching native data type for %s", s.c_str ()); |
|
|
97 } |
|
3238
|
98 else if (s == "uint16") |
|
|
99 { |
|
|
100 if (sizeof (unsigned short) == 2) |
|
|
101 retval = dt_ushort; |
|
|
102 else if (sizeof (unsigned int) == 2) |
|
|
103 retval = dt_uint; |
|
|
104 else |
|
|
105 (*current_liboctave_error_handler) |
|
|
106 ("unable to find matching native data type for %s", s.c_str ()); |
|
|
107 } |
|
|
108 else if (s == "uint32") |
|
|
109 { |
|
|
110 if (sizeof (unsigned int) == 4) |
|
|
111 retval = dt_uint; |
|
|
112 else if (sizeof (unsigned long) == 4) |
|
|
113 retval = dt_ulong; |
|
|
114 else |
|
|
115 (*current_liboctave_error_handler) |
|
|
116 ("unable to find matching native data type for %s", s.c_str ()); |
|
|
117 } |
|
2317
|
118 else |
|
|
119 (*current_liboctave_error_handler) ("invalid data type specified"); |
|
|
120 |
|
|
121 return retval; |
|
|
122 } |
|
|
123 |
|
1960
|
124 #define swap_1_bytes(x, y) |
|
|
125 |
|
|
126 #define LS_DO_READ(TYPE,swap,data,size,len,stream) \ |
|
|
127 do \ |
|
|
128 { \ |
|
3145
|
129 volatile TYPE *ptr = X_CAST (volatile TYPE *, data); \ |
|
|
130 stream.read (X_CAST (TYPE *, ptr), size * len); \ |
|
1960
|
131 if (swap) \ |
|
3145
|
132 swap_ ## size ## _bytes (ptr, len); \ |
|
1960
|
133 TYPE tmp = ptr[0]; \ |
|
|
134 for (int i = len - 1; i > 0; i--) \ |
|
|
135 data[i] = ptr[i]; \ |
|
|
136 data[0] = tmp; \ |
|
|
137 } \ |
|
|
138 while (0) |
|
|
139 |
|
|
140 // Have to use copy here to avoid writing over data accessed via |
|
|
141 // Matrix::data(). |
|
|
142 |
|
|
143 #define LS_DO_WRITE(TYPE,data,size,len,stream) \ |
|
|
144 do \ |
|
|
145 { \ |
|
2800
|
146 char tmp_type = static_cast<char> (type); \ |
|
1960
|
147 stream.write (&tmp_type, 1); \ |
|
|
148 TYPE *ptr = new TYPE [len]; \ |
|
|
149 for (int i = 0; i < len; i++) \ |
|
3145
|
150 ptr[i] = X_CAST (TYPE, data[i]); \ |
|
|
151 stream.write (ptr, size * len); \ |
|
1960
|
152 delete [] ptr ; \ |
|
|
153 } \ |
|
|
154 while (0) |
|
|
155 |
|
|
156 // Loading variables from files. |
|
|
157 |
|
|
158 static void |
|
|
159 gripe_unrecognized_float_fmt (void) |
|
|
160 { |
|
|
161 (*current_liboctave_error_handler) |
|
|
162 ("unrecognized floating point format requested"); |
|
|
163 } |
|
|
164 |
|
|
165 static void |
|
|
166 gripe_data_conversion (const char *from, const char *to) |
|
|
167 { |
|
|
168 (*current_liboctave_error_handler) |
|
|
169 ("unable to convert from %s to %s format", from, to); |
|
|
170 } |
|
|
171 |
|
|
172 // But first, some data conversion routines. |
|
|
173 |
|
|
174 // Currently, we only handle conversions for the IEEE types. To fix |
|
|
175 // that, make more of the following routines work. |
|
|
176 |
|
|
177 // XXX FIXME XXX -- assumes sizeof (Complex) == 8 |
|
|
178 // XXX FIXME XXX -- assumes sizeof (double) == 8 |
|
|
179 // XXX FIXME XXX -- assumes sizeof (float) == 4 |
|
|
180 |
|
|
181 static void |
|
|
182 IEEE_big_double_to_IEEE_little_double (double *d, int len) |
|
|
183 { |
|
3145
|
184 swap_8_bytes (d, len); |
|
1960
|
185 } |
|
|
186 |
|
|
187 static void |
|
|
188 VAX_D_double_to_IEEE_little_double (double * /* d */, int /* len */) |
|
|
189 { |
|
|
190 gripe_data_conversion ("VAX D float", "IEEE little endian format"); |
|
|
191 } |
|
|
192 |
|
|
193 static void |
|
|
194 VAX_G_double_to_IEEE_little_double (double * /* d */, int /* len */) |
|
|
195 { |
|
|
196 gripe_data_conversion ("VAX G float", "IEEE little endian format"); |
|
|
197 } |
|
|
198 |
|
|
199 static void |
|
|
200 Cray_to_IEEE_little_double (double * /* d */, int /* len */) |
|
|
201 { |
|
|
202 gripe_data_conversion ("Cray", "IEEE little endian format"); |
|
|
203 } |
|
|
204 |
|
|
205 static void |
|
|
206 IEEE_big_float_to_IEEE_little_float (float *d, int len) |
|
|
207 { |
|
3145
|
208 swap_4_bytes (d, len); |
|
1960
|
209 } |
|
|
210 |
|
|
211 static void |
|
|
212 VAX_D_float_to_IEEE_little_float (float * /* d */, int /* len */) |
|
|
213 { |
|
|
214 gripe_data_conversion ("VAX D float", "IEEE little endian format"); |
|
|
215 } |
|
|
216 |
|
|
217 static void |
|
|
218 VAX_G_float_to_IEEE_little_float (float * /* d */, int /* len */) |
|
|
219 { |
|
|
220 gripe_data_conversion ("VAX G float", "IEEE little endian format"); |
|
|
221 } |
|
|
222 |
|
|
223 static void |
|
|
224 Cray_to_IEEE_little_float (float * /* d */, int /* len */) |
|
|
225 { |
|
|
226 gripe_data_conversion ("Cray", "IEEE little endian format"); |
|
|
227 } |
|
|
228 |
|
|
229 static void |
|
|
230 IEEE_little_double_to_IEEE_big_double (double *d, int len) |
|
|
231 { |
|
3145
|
232 swap_8_bytes (d, len); |
|
1960
|
233 } |
|
|
234 |
|
|
235 static void |
|
|
236 VAX_D_double_to_IEEE_big_double (double * /* d */, int /* len */) |
|
|
237 { |
|
|
238 gripe_data_conversion ("VAX D float", "IEEE big endian format"); |
|
|
239 } |
|
|
240 |
|
|
241 static void |
|
|
242 VAX_G_double_to_IEEE_big_double (double * /* d */, int /* len */) |
|
|
243 { |
|
|
244 gripe_data_conversion ("VAX G float", "IEEE big endian format"); |
|
|
245 } |
|
|
246 |
|
|
247 static void |
|
|
248 Cray_to_IEEE_big_double (double * /* d */, int /* len */) |
|
|
249 { |
|
|
250 gripe_data_conversion ("Cray", "IEEE big endian format"); |
|
|
251 } |
|
|
252 |
|
|
253 static void |
|
|
254 IEEE_little_float_to_IEEE_big_float (float *d, int len) |
|
|
255 { |
|
3145
|
256 swap_4_bytes (d, len); |
|
1960
|
257 } |
|
|
258 |
|
|
259 static void |
|
|
260 VAX_D_float_to_IEEE_big_float (float * /* d */, int /* len */) |
|
|
261 { |
|
|
262 gripe_data_conversion ("VAX D float", "IEEE big endian format"); |
|
|
263 } |
|
|
264 |
|
|
265 static void |
|
|
266 VAX_G_float_to_IEEE_big_float (float * /* d */, int /* len */) |
|
|
267 { |
|
|
268 gripe_data_conversion ("VAX G float", "IEEE big endian format"); |
|
|
269 } |
|
|
270 |
|
|
271 static void |
|
|
272 Cray_to_IEEE_big_float (float * /* d */, int /* len */) |
|
|
273 { |
|
|
274 gripe_data_conversion ("Cray", "IEEE big endian format"); |
|
|
275 } |
|
|
276 |
|
|
277 static void |
|
|
278 IEEE_little_double_to_VAX_D_double (double * /* d */, int /* len */) |
|
|
279 { |
|
|
280 gripe_data_conversion ("IEEE little endian", "VAX D"); |
|
|
281 } |
|
|
282 |
|
|
283 static void |
|
|
284 IEEE_big_double_to_VAX_D_double (double * /* d */, int /* len */) |
|
|
285 { |
|
|
286 gripe_data_conversion ("IEEE big endian", "VAX D"); |
|
|
287 } |
|
|
288 |
|
|
289 static void |
|
|
290 VAX_G_double_to_VAX_D_double (double * /* d */, int /* len */) |
|
|
291 { |
|
|
292 gripe_data_conversion ("VAX G float", "VAX D"); |
|
|
293 } |
|
|
294 |
|
|
295 static void |
|
|
296 Cray_to_VAX_D_double (double * /* d */, int /* len */) |
|
|
297 { |
|
|
298 gripe_data_conversion ("Cray", "VAX D"); |
|
|
299 } |
|
|
300 |
|
|
301 static void |
|
|
302 IEEE_little_float_to_VAX_D_float (float * /* d */, int /* len */) |
|
|
303 { |
|
|
304 gripe_data_conversion ("IEEE little endian", "VAX D"); |
|
|
305 } |
|
|
306 |
|
|
307 static void |
|
|
308 IEEE_big_float_to_VAX_D_float (float * /* d */, int /* len */) |
|
|
309 { |
|
|
310 gripe_data_conversion ("IEEE big endian", "VAX D"); |
|
|
311 } |
|
|
312 |
|
|
313 static void |
|
|
314 VAX_G_float_to_VAX_D_float (float * /* d */, int /* len */) |
|
|
315 { |
|
|
316 gripe_data_conversion ("VAX G float", "VAX D"); |
|
|
317 } |
|
|
318 |
|
|
319 static void |
|
|
320 Cray_to_VAX_D_float (float * /* d */, int /* len */) |
|
|
321 { |
|
|
322 gripe_data_conversion ("Cray", "VAX D"); |
|
|
323 } |
|
|
324 |
|
|
325 static void |
|
|
326 IEEE_little_double_to_VAX_G_double (double * /* d */, int /* len */) |
|
|
327 { |
|
|
328 gripe_data_conversion ("IEEE little endian", "VAX G"); |
|
|
329 } |
|
|
330 |
|
|
331 static void |
|
|
332 IEEE_big_double_to_VAX_G_double (double * /* d */, int /* len */) |
|
|
333 { |
|
|
334 gripe_data_conversion ("IEEE big endian", "VAX G"); |
|
|
335 } |
|
|
336 |
|
|
337 static void |
|
|
338 VAX_D_double_to_VAX_G_double (double * /* d */, int /* len */) |
|
|
339 { |
|
|
340 gripe_data_conversion ("VAX D float", "VAX G"); |
|
|
341 } |
|
|
342 |
|
|
343 static void |
|
|
344 Cray_to_VAX_G_double (double * /* d */, int /* len */) |
|
|
345 { |
|
|
346 gripe_data_conversion ("VAX G float", "VAX G"); |
|
|
347 } |
|
|
348 |
|
|
349 static void |
|
|
350 IEEE_little_float_to_VAX_G_float (float * /* d */, int /* len */) |
|
|
351 { |
|
|
352 gripe_data_conversion ("IEEE little endian", "VAX G"); |
|
|
353 } |
|
|
354 |
|
|
355 static void |
|
|
356 IEEE_big_float_to_VAX_G_float (float * /* d */, int /* len */) |
|
|
357 { |
|
|
358 gripe_data_conversion ("IEEE big endian", "VAX G"); |
|
|
359 } |
|
|
360 |
|
|
361 static void |
|
|
362 VAX_D_float_to_VAX_G_float (float * /* d */, int /* len */) |
|
|
363 { |
|
|
364 gripe_data_conversion ("VAX D float", "VAX G"); |
|
|
365 } |
|
|
366 |
|
|
367 static void |
|
|
368 Cray_to_VAX_G_float (float * /* d */, int /* len */) |
|
|
369 { |
|
|
370 gripe_data_conversion ("VAX G float", "VAX G"); |
|
|
371 } |
|
|
372 |
|
|
373 void |
|
|
374 do_double_format_conversion (double *data, int len, |
|
2317
|
375 oct_mach_info::float_format fmt) |
|
1960
|
376 { |
|
2317
|
377 switch (oct_mach_info::native_float_format ()) |
|
1960
|
378 { |
|
2317
|
379 case oct_mach_info::ieee_little_endian: |
|
1960
|
380 switch (fmt) |
|
|
381 { |
|
2317
|
382 case oct_mach_info::ieee_little_endian: |
|
1960
|
383 break; |
|
|
384 |
|
2317
|
385 case oct_mach_info::ieee_big_endian: |
|
1960
|
386 IEEE_big_double_to_IEEE_little_double (data, len); |
|
|
387 break; |
|
|
388 |
|
2317
|
389 case oct_mach_info::vax_d: |
|
1960
|
390 VAX_D_double_to_IEEE_little_double (data, len); |
|
|
391 break; |
|
|
392 |
|
2317
|
393 case oct_mach_info::vax_g: |
|
1960
|
394 VAX_G_double_to_IEEE_little_double (data, len); |
|
|
395 break; |
|
|
396 |
|
2317
|
397 case oct_mach_info::cray: |
|
1960
|
398 Cray_to_IEEE_little_double (data, len); |
|
|
399 break; |
|
|
400 |
|
|
401 default: |
|
|
402 gripe_unrecognized_float_fmt (); |
|
|
403 break; |
|
|
404 } |
|
|
405 break; |
|
|
406 |
|
2317
|
407 case oct_mach_info::ieee_big_endian: |
|
1960
|
408 switch (fmt) |
|
|
409 { |
|
2317
|
410 case oct_mach_info::ieee_little_endian: |
|
1960
|
411 IEEE_little_double_to_IEEE_big_double (data, len); |
|
|
412 break; |
|
|
413 |
|
2317
|
414 case oct_mach_info::ieee_big_endian: |
|
1960
|
415 break; |
|
|
416 |
|
2317
|
417 case oct_mach_info::vax_d: |
|
1960
|
418 VAX_D_double_to_IEEE_big_double (data, len); |
|
|
419 break; |
|
|
420 |
|
2317
|
421 case oct_mach_info::vax_g: |
|
1960
|
422 VAX_G_double_to_IEEE_big_double (data, len); |
|
|
423 break; |
|
|
424 |
|
2317
|
425 case oct_mach_info::cray: |
|
1960
|
426 Cray_to_IEEE_big_double (data, len); |
|
|
427 break; |
|
|
428 |
|
|
429 default: |
|
|
430 gripe_unrecognized_float_fmt (); |
|
|
431 break; |
|
|
432 } |
|
|
433 break; |
|
|
434 |
|
2317
|
435 case oct_mach_info::vax_d: |
|
1960
|
436 switch (fmt) |
|
|
437 { |
|
2317
|
438 case oct_mach_info::ieee_little_endian: |
|
1960
|
439 IEEE_little_double_to_VAX_D_double (data, len); |
|
|
440 break; |
|
|
441 |
|
2317
|
442 case oct_mach_info::ieee_big_endian: |
|
1960
|
443 IEEE_big_double_to_VAX_D_double (data, len); |
|
|
444 break; |
|
|
445 |
|
2317
|
446 case oct_mach_info::vax_d: |
|
1960
|
447 break; |
|
|
448 |
|
2317
|
449 case oct_mach_info::vax_g: |
|
1960
|
450 VAX_G_double_to_VAX_D_double (data, len); |
|
|
451 break; |
|
|
452 |
|
2317
|
453 case oct_mach_info::cray: |
|
1960
|
454 Cray_to_VAX_D_double (data, len); |
|
|
455 break; |
|
|
456 |
|
|
457 default: |
|
|
458 gripe_unrecognized_float_fmt (); |
|
|
459 break; |
|
|
460 } |
|
|
461 break; |
|
|
462 |
|
2317
|
463 case oct_mach_info::vax_g: |
|
1960
|
464 switch (fmt) |
|
|
465 { |
|
2317
|
466 case oct_mach_info::ieee_little_endian: |
|
1960
|
467 IEEE_little_double_to_VAX_G_double (data, len); |
|
|
468 break; |
|
|
469 |
|
2317
|
470 case oct_mach_info::ieee_big_endian: |
|
1960
|
471 IEEE_big_double_to_VAX_G_double (data, len); |
|
|
472 break; |
|
|
473 |
|
2317
|
474 case oct_mach_info::vax_d: |
|
1960
|
475 VAX_D_double_to_VAX_G_double (data, len); |
|
|
476 break; |
|
|
477 |
|
2317
|
478 case oct_mach_info::vax_g: |
|
1960
|
479 break; |
|
|
480 |
|
2317
|
481 case oct_mach_info::cray: |
|
1960
|
482 Cray_to_VAX_G_double (data, len); |
|
|
483 break; |
|
|
484 |
|
|
485 default: |
|
|
486 gripe_unrecognized_float_fmt (); |
|
|
487 break; |
|
|
488 } |
|
|
489 break; |
|
|
490 |
|
|
491 default: |
|
|
492 (*current_liboctave_error_handler) |
|
|
493 ("impossible state reached in file `%s' at line %d", |
|
|
494 __FILE__, __LINE__); |
|
|
495 break; |
|
|
496 } |
|
|
497 } |
|
|
498 |
|
|
499 void |
|
|
500 do_float_format_conversion (float *data, int len, |
|
2317
|
501 oct_mach_info::float_format fmt) |
|
1960
|
502 { |
|
2317
|
503 switch (oct_mach_info::native_float_format ()) |
|
1960
|
504 { |
|
2317
|
505 case oct_mach_info::ieee_little_endian: |
|
1960
|
506 switch (fmt) |
|
|
507 { |
|
2317
|
508 case oct_mach_info::ieee_little_endian: |
|
1960
|
509 break; |
|
|
510 |
|
2317
|
511 case oct_mach_info::ieee_big_endian: |
|
1960
|
512 IEEE_big_float_to_IEEE_little_float (data, len); |
|
|
513 break; |
|
|
514 |
|
2317
|
515 case oct_mach_info::vax_d: |
|
1960
|
516 VAX_D_float_to_IEEE_little_float (data, len); |
|
|
517 break; |
|
|
518 |
|
2317
|
519 case oct_mach_info::vax_g: |
|
1960
|
520 VAX_G_float_to_IEEE_little_float (data, len); |
|
|
521 break; |
|
|
522 |
|
2317
|
523 case oct_mach_info::cray: |
|
1960
|
524 Cray_to_IEEE_little_float (data, len); |
|
|
525 break; |
|
|
526 |
|
|
527 default: |
|
|
528 gripe_unrecognized_float_fmt (); |
|
|
529 break; |
|
|
530 } |
|
|
531 break; |
|
|
532 |
|
2317
|
533 case oct_mach_info::ieee_big_endian: |
|
1960
|
534 switch (fmt) |
|
|
535 { |
|
2317
|
536 case oct_mach_info::ieee_little_endian: |
|
1960
|
537 IEEE_little_float_to_IEEE_big_float (data, len); |
|
|
538 break; |
|
|
539 |
|
2317
|
540 case oct_mach_info::ieee_big_endian: |
|
1960
|
541 break; |
|
|
542 |
|
2317
|
543 case oct_mach_info::vax_d: |
|
1960
|
544 VAX_D_float_to_IEEE_big_float (data, len); |
|
|
545 break; |
|
|
546 |
|
2317
|
547 case oct_mach_info::vax_g: |
|
1960
|
548 VAX_G_float_to_IEEE_big_float (data, len); |
|
|
549 break; |
|
|
550 |
|
2317
|
551 case oct_mach_info::cray: |
|
1960
|
552 Cray_to_IEEE_big_float (data, len); |
|
|
553 break; |
|
|
554 |
|
|
555 default: |
|
|
556 gripe_unrecognized_float_fmt (); |
|
|
557 break; |
|
|
558 } |
|
|
559 break; |
|
|
560 |
|
2317
|
561 case oct_mach_info::vax_d: |
|
1960
|
562 switch (fmt) |
|
|
563 { |
|
2317
|
564 case oct_mach_info::ieee_little_endian: |
|
1960
|
565 IEEE_little_float_to_VAX_D_float (data, len); |
|
|
566 break; |
|
|
567 |
|
2317
|
568 case oct_mach_info::ieee_big_endian: |
|
1960
|
569 IEEE_big_float_to_VAX_D_float (data, len); |
|
|
570 break; |
|
|
571 |
|
2317
|
572 case oct_mach_info::vax_d: |
|
1960
|
573 break; |
|
|
574 |
|
2317
|
575 case oct_mach_info::vax_g: |
|
1960
|
576 VAX_G_float_to_VAX_D_float (data, len); |
|
|
577 break; |
|
|
578 |
|
2317
|
579 case oct_mach_info::cray: |
|
1960
|
580 Cray_to_VAX_D_float (data, len); |
|
|
581 break; |
|
|
582 |
|
|
583 default: |
|
|
584 gripe_unrecognized_float_fmt (); |
|
|
585 break; |
|
|
586 } |
|
|
587 break; |
|
|
588 |
|
2317
|
589 case oct_mach_info::vax_g: |
|
1960
|
590 switch (fmt) |
|
|
591 { |
|
2317
|
592 case oct_mach_info::ieee_little_endian: |
|
1960
|
593 IEEE_little_float_to_VAX_G_float (data, len); |
|
|
594 break; |
|
|
595 |
|
2317
|
596 case oct_mach_info::ieee_big_endian: |
|
1960
|
597 IEEE_big_float_to_VAX_G_float (data, len); |
|
|
598 break; |
|
|
599 |
|
2317
|
600 case oct_mach_info::vax_d: |
|
1960
|
601 VAX_D_float_to_VAX_G_float (data, len); |
|
|
602 break; |
|
|
603 |
|
2317
|
604 case oct_mach_info::vax_g: |
|
1960
|
605 break; |
|
|
606 |
|
2317
|
607 case oct_mach_info::cray: |
|
1960
|
608 Cray_to_VAX_G_float (data, len); |
|
|
609 break; |
|
|
610 |
|
|
611 default: |
|
|
612 gripe_unrecognized_float_fmt (); |
|
|
613 break; |
|
|
614 } |
|
|
615 break; |
|
|
616 |
|
|
617 default: |
|
|
618 (*current_liboctave_error_handler) |
|
|
619 ("impossible state reached in file `%s' at line %d", |
|
|
620 __FILE__, __LINE__); |
|
|
621 break; |
|
|
622 } |
|
|
623 } |
|
|
624 |
|
|
625 void |
|
|
626 read_doubles (istream& is, double *data, save_type type, int len, |
|
2317
|
627 int swap, oct_mach_info::float_format fmt) |
|
1960
|
628 { |
|
|
629 switch (type) |
|
|
630 { |
|
|
631 case LS_U_CHAR: |
|
|
632 LS_DO_READ (unsigned char, swap, data, 1, len, is); |
|
|
633 break; |
|
|
634 |
|
|
635 case LS_U_SHORT: |
|
|
636 LS_DO_READ (unsigned TWO_BYTE_INT, swap, data, 2, len, is); |
|
|
637 break; |
|
|
638 |
|
|
639 case LS_U_INT: |
|
|
640 LS_DO_READ (unsigned FOUR_BYTE_INT, swap, data, 4, len, is); |
|
|
641 break; |
|
|
642 |
|
|
643 case LS_CHAR: |
|
|
644 LS_DO_READ (signed char, swap, data, 1, len, is); |
|
|
645 break; |
|
|
646 |
|
|
647 case LS_SHORT: |
|
|
648 LS_DO_READ (TWO_BYTE_INT, swap, data, 2, len, is); |
|
|
649 break; |
|
|
650 |
|
|
651 case LS_INT: |
|
|
652 LS_DO_READ (FOUR_BYTE_INT, swap, data, 4, len, is); |
|
|
653 break; |
|
|
654 |
|
|
655 case LS_FLOAT: |
|
|
656 { |
|
3145
|
657 volatile float *ptr = X_CAST (float *, data); |
|
1960
|
658 is.read (data, 4 * len); |
|
3145
|
659 do_float_format_conversion (X_CAST (float *, data), len, fmt); |
|
1960
|
660 float tmp = ptr[0]; |
|
|
661 for (int i = len - 1; i > 0; i--) |
|
|
662 data[i] = ptr[i]; |
|
|
663 data[0] = tmp; |
|
|
664 } |
|
|
665 break; |
|
|
666 |
|
|
667 case LS_DOUBLE: |
|
|
668 is.read (data, 8 * len); |
|
|
669 do_double_format_conversion (data, len, fmt); |
|
|
670 break; |
|
|
671 |
|
|
672 default: |
|
|
673 is.clear (ios::failbit|is.rdstate ()); |
|
|
674 break; |
|
|
675 } |
|
|
676 } |
|
|
677 |
|
|
678 void |
|
|
679 write_doubles (ostream& os, const double *data, save_type type, int len) |
|
|
680 { |
|
|
681 switch (type) |
|
|
682 { |
|
|
683 case LS_U_CHAR: |
|
|
684 LS_DO_WRITE (unsigned char, data, 1, len, os); |
|
|
685 break; |
|
|
686 |
|
|
687 case LS_U_SHORT: |
|
|
688 LS_DO_WRITE (unsigned TWO_BYTE_INT, data, 2, len, os); |
|
|
689 break; |
|
|
690 |
|
|
691 case LS_U_INT: |
|
|
692 LS_DO_WRITE (unsigned FOUR_BYTE_INT, data, 4, len, os); |
|
|
693 break; |
|
|
694 |
|
|
695 case LS_CHAR: |
|
|
696 LS_DO_WRITE (signed char, data, 1, len, os); |
|
|
697 break; |
|
|
698 |
|
|
699 case LS_SHORT: |
|
|
700 LS_DO_WRITE (TWO_BYTE_INT, data, 2, len, os); |
|
|
701 break; |
|
|
702 |
|
|
703 case LS_INT: |
|
|
704 LS_DO_WRITE (FOUR_BYTE_INT, data, 4, len, os); |
|
|
705 break; |
|
|
706 |
|
|
707 case LS_FLOAT: |
|
|
708 LS_DO_WRITE (float, data, 4, len, os); |
|
|
709 break; |
|
|
710 |
|
|
711 case LS_DOUBLE: |
|
|
712 { |
|
3145
|
713 char tmp_type = X_CAST (char, type); |
|
1960
|
714 os.write (&tmp_type, 1); |
|
|
715 os.write (data, 8 * len); |
|
|
716 } |
|
|
717 break; |
|
|
718 |
|
|
719 default: |
|
|
720 (*current_liboctave_error_handler) |
|
|
721 ("unrecognized data format requested"); |
|
|
722 break; |
|
|
723 } |
|
|
724 } |
|
|
725 |
|
|
726 /* |
|
|
727 ;;; Local Variables: *** |
|
|
728 ;;; mode: C++ *** |
|
|
729 ;;; End: *** |
|
|
730 */ |
