|
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 |
|
5307
|
19 Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA |
|
|
20 02110-1301, USA. |
|
1960
|
21 |
|
|
22 */ |
|
|
23 |
|
|
24 #ifdef HAVE_CONFIG_H |
|
|
25 #include <config.h> |
|
|
26 #endif |
|
|
27 |
|
2317
|
28 #include <cctype> |
|
|
29 |
|
3503
|
30 #include <iostream> |
|
1960
|
31 |
|
|
32 #include "byte-swap.h" |
|
|
33 #include "data-conv.h" |
|
|
34 #include "lo-error.h" |
|
|
35 |
|
4944
|
36 #if defined HAVE_LONG_LONG_INT |
|
|
37 #define FIND_SIZED_INT_TYPE(VAL, BITS, TQ, Q) \ |
|
|
38 do \ |
|
|
39 { \ |
|
|
40 int sz = BITS / CHAR_BIT; \ |
|
|
41 if (sizeof (TQ char) == sz) \ |
|
|
42 VAL = oct_data_conv::dt_ ## Q ## char; \ |
|
|
43 else if (sizeof (TQ short) == sz) \ |
|
|
44 VAL = oct_data_conv::dt_ ## Q ## short; \ |
|
|
45 else if (sizeof (TQ int) == sz) \ |
|
|
46 VAL = oct_data_conv::dt_ ## Q ## int; \ |
|
|
47 else if (sizeof (TQ long) == sz) \ |
|
|
48 VAL = oct_data_conv::dt_ ## Q ## long; \ |
|
|
49 else if (sizeof (TQ long long) == sz) \ |
|
|
50 VAL = oct_data_conv::dt_ ## Q ## longlong; \ |
|
|
51 else \ |
|
|
52 VAL = oct_data_conv::dt_unknown; \ |
|
|
53 } \ |
|
|
54 while (0) |
|
|
55 #else |
|
3359
|
56 #define FIND_SIZED_INT_TYPE(VAL, BITS, TQ, Q) \ |
|
3358
|
57 do \ |
|
|
58 { \ |
|
|
59 int sz = BITS / CHAR_BIT; \ |
|
|
60 if (sizeof (TQ char) == sz) \ |
|
|
61 VAL = oct_data_conv::dt_ ## Q ## char; \ |
|
|
62 else if (sizeof (TQ short) == sz) \ |
|
|
63 VAL = oct_data_conv::dt_ ## Q ## short; \ |
|
|
64 else if (sizeof (TQ int) == sz) \ |
|
|
65 VAL = oct_data_conv::dt_ ## Q ## int; \ |
|
|
66 else if (sizeof (TQ long) == sz) \ |
|
|
67 VAL = oct_data_conv::dt_ ## Q ## long; \ |
|
|
68 else \ |
|
|
69 VAL = oct_data_conv::dt_unknown; \ |
|
|
70 } \ |
|
|
71 while (0) |
|
4944
|
72 #endif |
|
3358
|
73 |
|
3359
|
74 #define FIND_SIZED_FLOAT_TYPE(VAL, BITS) \ |
|
3358
|
75 do \ |
|
|
76 { \ |
|
|
77 int sz = BITS / CHAR_BIT; \ |
|
|
78 if (sizeof (float) == sz) \ |
|
|
79 VAL = oct_data_conv::dt_float; \ |
|
|
80 else if (sizeof (double) == sz) \ |
|
|
81 VAL = oct_data_conv::dt_double; \ |
|
|
82 else \ |
|
|
83 VAL = oct_data_conv::dt_unknown; \ |
|
|
84 } \ |
|
|
85 while (0) |
|
|
86 |
|
|
87 // I'm not sure it is worth the trouble, but let's use a lookup table |
|
|
88 // for the types that are supposed to be a specific number of bits |
|
|
89 // wide. Given the macros above, this should work as long as CHAR_BIT |
|
|
90 // is a multiple of 8 and there are types with the right sizes. |
|
|
91 // |
|
|
92 // The sized data type lookup table has the following format: |
|
|
93 // |
|
|
94 // bits |
|
|
95 // +----+----+----+----+ |
|
|
96 // | 8 | 16 | 32 | 64 | |
|
|
97 // +----+----+----+----+ |
|
|
98 // signed integer | | | | | |
|
|
99 // +----+----+----+----+ |
|
|
100 // unsigned integer | | | | | |
|
|
101 // +----+----+----+----+ |
|
|
102 // floating point | | | | | |
|
|
103 // +----+----+----+----+ |
|
|
104 // |
|
|
105 // So, the 0,3 element is supposed to contain the oct_data_conv enum |
|
|
106 // value corresponding to the correct native data type for a signed |
|
|
107 // 32-bit integer. |
|
|
108 |
|
|
109 static void |
|
|
110 init_sized_type_lookup_table (oct_data_conv::data_type table[3][4]) |
|
|
111 { |
|
|
112 int bits = 8; |
|
|
113 |
|
|
114 for (int i = 0; i < 4; i++) |
|
|
115 { |
|
3359
|
116 FIND_SIZED_INT_TYPE (table[0][i], bits, , ); |
|
3358
|
117 |
|
3359
|
118 FIND_SIZED_INT_TYPE (table[1][i], bits, unsigned, u); |
|
3358
|
119 |
|
3359
|
120 FIND_SIZED_FLOAT_TYPE (table[2][i], bits); |
|
3358
|
121 |
|
|
122 bits *= 2; |
|
|
123 } |
|
|
124 } |
|
|
125 |
|
4944
|
126 static std::string |
|
|
127 strip_spaces (const std::string& str) |
|
|
128 { |
|
|
129 int n = str.length (); |
|
|
130 |
|
|
131 int k = 0; |
|
|
132 |
|
|
133 std::string s (n, ' '); |
|
|
134 |
|
|
135 for (int i = 0; i < n; i++) |
|
|
136 if (! isspace (str[i])) |
|
|
137 s[k++] = tolower (str[i]); |
|
|
138 |
|
|
139 s.resize (k); |
|
|
140 |
|
|
141 return s; |
|
|
142 } |
|
|
143 |
|
|
144 #define GET_SIZED_INT_TYPE(T, U) \ |
|
|
145 do \ |
|
|
146 { \ |
|
|
147 switch (sizeof (T)) \ |
|
|
148 { \ |
|
|
149 case 1: \ |
|
|
150 retval = dt_ ## U ## int8; \ |
|
|
151 break; \ |
|
|
152 \ |
|
|
153 case 2: \ |
|
|
154 retval = dt_ ## U ## int16; \ |
|
|
155 break; \ |
|
|
156 \ |
|
|
157 case 4: \ |
|
|
158 retval = dt_ ## U ## int32; \ |
|
|
159 break; \ |
|
|
160 \ |
|
|
161 case 8: \ |
|
|
162 retval = dt_ ## U ## int64; \ |
|
|
163 break; \ |
|
|
164 \ |
|
|
165 default: \ |
|
|
166 retval = dt_unknown; \ |
|
|
167 break; \ |
|
|
168 } \ |
|
|
169 } \ |
|
|
170 while (0) |
|
|
171 |
|
2317
|
172 oct_data_conv::data_type |
|
3504
|
173 oct_data_conv::string_to_data_type (const std::string& str) |
|
2317
|
174 { |
|
|
175 data_type retval = dt_unknown; |
|
|
176 |
|
3358
|
177 static bool initialized = false; |
|
|
178 |
|
|
179 static data_type sized_type_table[3][4]; |
|
2317
|
180 |
|
3358
|
181 if (! initialized) |
|
|
182 { |
|
|
183 init_sized_type_lookup_table (sized_type_table); |
|
|
184 |
|
|
185 initialized = true; |
|
|
186 } |
|
|
187 |
|
4944
|
188 std::string s = strip_spaces (str); |
|
2317
|
189 |
|
4944
|
190 if (s == "int8" || s == "integer*1") |
|
|
191 retval = dt_int8; |
|
|
192 else if (s == "uint8") |
|
|
193 retval = dt_uint8; |
|
|
194 else if (s == "int16" || s == "integer*2") |
|
|
195 retval = dt_int16; |
|
|
196 else if (s == "uint16") |
|
|
197 retval = dt_uint16; |
|
|
198 else if (s == "int32" || s == "integer*4") |
|
|
199 retval = dt_int32; |
|
|
200 else if (s == "uint32") |
|
|
201 retval = dt_uint32; |
|
|
202 else if (s == "int64" || s == "integer*8") |
|
|
203 retval = dt_int64; |
|
|
204 else if (s == "uint64") |
|
|
205 retval = dt_uint64; |
|
|
206 else if (s == "single" || s == "float32" || s == "real*4") |
|
|
207 retval = dt_single; |
|
|
208 else if (s == "double" || s == "float64" || s == "real*8") |
|
|
209 retval = dt_double; |
|
|
210 else if (s == "char" || s == "char*1") |
|
2317
|
211 retval = dt_char; |
|
|
212 else if (s == "schar" || s == "signedchar") |
|
|
213 retval = dt_schar; |
|
|
214 else if (s == "uchar" || s == "unsignedchar") |
|
|
215 retval = dt_uchar; |
|
|
216 else if (s == "short") |
|
4944
|
217 GET_SIZED_INT_TYPE (short, ); |
|
2317
|
218 else if (s == "ushort" || s == "unsignedshort") |
|
4944
|
219 GET_SIZED_INT_TYPE (unsigned short, u); |
|
2317
|
220 else if (s == "int") |
|
4944
|
221 GET_SIZED_INT_TYPE (int, ); |
|
2317
|
222 else if (s == "uint" || s == "unsignedint") |
|
4944
|
223 GET_SIZED_INT_TYPE (unsigned int, u); |
|
2317
|
224 else if (s == "long") |
|
4944
|
225 GET_SIZED_INT_TYPE (long, ); |
|
2317
|
226 else if (s == "ulong" || s == "unsignedlong") |
|
4944
|
227 GET_SIZED_INT_TYPE (unsigned long, u); |
|
|
228 else if (s == "longlong") |
|
|
229 GET_SIZED_INT_TYPE (long long, ); |
|
|
230 else if (s == "ulonglong" || s == "unsignedlonglong") |
|
|
231 GET_SIZED_INT_TYPE (unsigned long long, u); |
|
3358
|
232 else if (s == "float") |
|
4944
|
233 { |
|
|
234 if (sizeof (float) == sizeof (double)) |
|
|
235 retval = dt_double; |
|
|
236 else |
|
|
237 retval = dt_single; |
|
|
238 } |
|
4970
|
239 else if (s == "logical") |
|
|
240 retval = dt_logical; |
|
2317
|
241 else |
|
|
242 (*current_liboctave_error_handler) ("invalid data type specified"); |
|
|
243 |
|
3358
|
244 if (retval == dt_unknown) |
|
|
245 (*current_liboctave_error_handler) |
|
|
246 ("unable to find matching native data type for %s", s.c_str ()); |
|
|
247 |
|
2317
|
248 return retval; |
|
|
249 } |
|
|
250 |
|
4944
|
251 void |
|
|
252 oct_data_conv::string_to_data_type |
|
|
253 (const std::string& str, int& block_size, |
|
|
254 oct_data_conv::data_type& input_type, |
|
|
255 oct_data_conv::data_type& output_type) |
|
|
256 { |
|
|
257 block_size = 1; |
|
|
258 input_type = dt_uchar; |
|
|
259 output_type = dt_double; |
|
|
260 |
|
|
261 bool input_is_output = false; |
|
|
262 |
|
|
263 std::string s = strip_spaces (str); |
|
|
264 |
|
|
265 size_t pos = 0; |
|
|
266 |
|
|
267 if (s[0] == '*') |
|
|
268 input_is_output = true; |
|
|
269 else |
|
|
270 { |
|
|
271 size_t len = s.length (); |
|
|
272 |
|
|
273 while (pos < len && isdigit (s[pos])) |
|
|
274 pos++; |
|
|
275 |
|
|
276 if (pos > 0) |
|
|
277 { |
|
|
278 if (s[pos] == '*') |
|
|
279 { |
|
|
280 block_size = atoi (s.c_str ()); |
|
|
281 s = s.substr (pos+1); |
|
|
282 } |
|
|
283 else |
|
|
284 { |
|
|
285 (*current_liboctave_error_handler) |
|
|
286 ("invalid repeat count in `%s'", str.c_str ()); |
|
|
287 |
|
|
288 return; |
|
|
289 } |
|
|
290 } |
|
|
291 } |
|
|
292 |
|
|
293 pos = s.find ('='); |
|
|
294 |
|
|
295 if (pos != std::string::npos) |
|
|
296 { |
|
|
297 if (s[pos+1] == '>') |
|
|
298 { |
|
|
299 if (input_is_output) |
|
|
300 { |
|
|
301 input_is_output = false; |
|
|
302 |
|
|
303 (*current_liboctave_warning_handler) |
|
|
304 ("warning: ignoring leading * in fread precision"); |
|
|
305 } |
|
|
306 |
|
|
307 input_type = string_to_data_type (s.substr (0, pos)); |
|
|
308 output_type = string_to_data_type (s.substr (pos+2)); |
|
|
309 } |
|
|
310 else |
|
|
311 (*current_liboctave_error_handler) |
|
|
312 ("fread: invalid precision specified"); |
|
|
313 } |
|
|
314 else |
|
|
315 { |
|
|
316 input_type = string_to_data_type (s); |
|
|
317 |
|
|
318 if (input_is_output) |
|
|
319 output_type = input_type; |
|
|
320 } |
|
|
321 } |
|
|
322 |
|
|
323 void |
|
|
324 oct_data_conv::string_to_data_type |
|
|
325 (const std::string& str, int& block_size, |
|
|
326 oct_data_conv::data_type& output_type) |
|
|
327 { |
|
|
328 block_size = 1; |
|
|
329 output_type = dt_double; |
|
|
330 |
|
|
331 std::string s = strip_spaces (str); |
|
|
332 |
|
|
333 size_t pos = 0; |
|
|
334 |
|
|
335 size_t len = s.length (); |
|
|
336 |
|
|
337 while (pos < len && isdigit (s[pos])) |
|
|
338 pos++; |
|
|
339 |
|
|
340 if (pos > 0) |
|
|
341 { |
|
|
342 if (s[pos] == '*') |
|
|
343 { |
|
|
344 block_size = atoi (s.c_str ()); |
|
|
345 s = s.substr (pos+1); |
|
|
346 } |
|
|
347 else |
|
|
348 { |
|
|
349 (*current_liboctave_error_handler) |
|
|
350 ("invalid repeat count in `%s'", str.c_str ()); |
|
|
351 |
|
|
352 return; |
|
|
353 } |
|
|
354 } |
|
|
355 |
|
|
356 output_type = string_to_data_type (s); |
|
|
357 } |
|
|
358 |
|
|
359 std::string |
|
|
360 oct_data_conv::data_type_as_string (oct_data_conv::data_type dt) |
|
|
361 { |
|
|
362 std::string retval; |
|
|
363 |
|
|
364 switch (dt) |
|
|
365 { |
|
|
366 case oct_data_conv::dt_int8: |
|
|
367 retval = "int8"; |
|
|
368 break; |
|
|
369 |
|
|
370 case oct_data_conv::dt_uint8: |
|
|
371 retval = "uint8"; |
|
|
372 break; |
|
|
373 |
|
|
374 case oct_data_conv::dt_int16: |
|
|
375 retval = "int16"; |
|
|
376 break; |
|
|
377 |
|
|
378 case oct_data_conv::dt_uint16: |
|
|
379 retval = "uint16"; |
|
|
380 break; |
|
|
381 |
|
|
382 case oct_data_conv::dt_int32: |
|
|
383 retval = "int32"; |
|
|
384 break; |
|
|
385 |
|
|
386 case oct_data_conv::dt_uint32: |
|
|
387 retval = "uint32"; |
|
|
388 break; |
|
|
389 |
|
|
390 case oct_data_conv::dt_int64: |
|
|
391 retval = "int64"; |
|
|
392 break; |
|
|
393 |
|
|
394 case oct_data_conv::dt_uint64: |
|
|
395 retval = "uint64"; |
|
|
396 break; |
|
|
397 |
|
|
398 case oct_data_conv::dt_single: |
|
|
399 retval = "single"; |
|
|
400 break; |
|
|
401 |
|
|
402 case oct_data_conv::dt_double: |
|
|
403 retval = "double"; |
|
|
404 break; |
|
|
405 |
|
|
406 case oct_data_conv::dt_char: |
|
|
407 retval = "char"; |
|
|
408 break; |
|
|
409 |
|
|
410 case oct_data_conv::dt_schar: |
|
|
411 retval = "signed char"; |
|
|
412 break; |
|
|
413 |
|
|
414 case oct_data_conv::dt_uchar: |
|
|
415 retval = "usigned char"; |
|
|
416 break; |
|
|
417 |
|
|
418 case oct_data_conv::dt_short: |
|
|
419 retval = "short"; |
|
|
420 break; |
|
|
421 |
|
|
422 case oct_data_conv::dt_ushort: |
|
|
423 retval = "unsigned short"; |
|
|
424 break; |
|
|
425 |
|
|
426 case oct_data_conv::dt_int: |
|
|
427 retval = "int"; |
|
|
428 break; |
|
|
429 |
|
|
430 case oct_data_conv::dt_uint: |
|
|
431 retval = "usigned int"; |
|
|
432 break; |
|
|
433 |
|
|
434 case oct_data_conv::dt_long: |
|
|
435 retval = "long"; |
|
|
436 break; |
|
|
437 |
|
|
438 case oct_data_conv::dt_ulong: |
|
|
439 retval = "usigned long"; |
|
|
440 break; |
|
|
441 |
|
|
442 case oct_data_conv::dt_longlong: |
|
|
443 retval = "long long"; |
|
|
444 break; |
|
|
445 |
|
|
446 case oct_data_conv::dt_ulonglong: |
|
|
447 retval = "unsigned long long"; |
|
|
448 break; |
|
|
449 |
|
|
450 case oct_data_conv::dt_float: |
|
|
451 retval = "float"; |
|
|
452 break; |
|
|
453 |
|
4970
|
454 case oct_data_conv::dt_logical: |
|
|
455 retval = "logical"; |
|
|
456 break; |
|
|
457 |
|
4944
|
458 case oct_data_conv::dt_unknown: |
|
|
459 default: |
|
|
460 retval = "unknown"; |
|
|
461 break; |
|
|
462 } |
|
|
463 |
|
|
464 return retval; |
|
|
465 } |
|
1960
|
466 |
|
3359
|
467 #define LS_DO_READ(TYPE, swap, data, size, len, stream) \ |
|
1960
|
468 do \ |
|
|
469 { \ |
|
3867
|
470 if (len > 0) \ |
|
|
471 { \ |
|
|
472 volatile TYPE *ptr = X_CAST (volatile TYPE *, data); \ |
|
|
473 stream.read (X_CAST (char *, ptr), size * len); \ |
|
|
474 if (swap) \ |
|
4944
|
475 swap_bytes< size > (ptr, len); \ |
|
3867
|
476 TYPE tmp = ptr[0]; \ |
|
|
477 for (int i = len - 1; i > 0; i--) \ |
|
|
478 data[i] = ptr[i]; \ |
|
|
479 data[0] = tmp; \ |
|
|
480 } \ |
|
1960
|
481 } \ |
|
|
482 while (0) |
|
|
483 |
|
|
484 // Have to use copy here to avoid writing over data accessed via |
|
|
485 // Matrix::data(). |
|
|
486 |
|
3359
|
487 #define LS_DO_WRITE(TYPE, data, size, len, stream) \ |
|
1960
|
488 do \ |
|
|
489 { \ |
|
3867
|
490 if (len > 0) \ |
|
|
491 { \ |
|
|
492 char tmp_type = static_cast<char> (type); \ |
|
|
493 stream.write (&tmp_type, 1); \ |
|
|
494 TYPE *ptr = new TYPE [len]; \ |
|
|
495 for (int i = 0; i < len; i++) \ |
|
|
496 ptr[i] = X_CAST (TYPE, data[i]); \ |
|
|
497 stream.write (X_CAST (char *, ptr), size * len); \ |
|
|
498 delete [] ptr ; \ |
|
|
499 } \ |
|
1960
|
500 } \ |
|
|
501 while (0) |
|
|
502 |
|
|
503 // Loading variables from files. |
|
|
504 |
|
|
505 static void |
|
|
506 gripe_unrecognized_float_fmt (void) |
|
|
507 { |
|
|
508 (*current_liboctave_error_handler) |
|
|
509 ("unrecognized floating point format requested"); |
|
|
510 } |
|
|
511 |
|
|
512 static void |
|
|
513 gripe_data_conversion (const char *from, const char *to) |
|
|
514 { |
|
|
515 (*current_liboctave_error_handler) |
|
|
516 ("unable to convert from %s to %s format", from, to); |
|
|
517 } |
|
|
518 |
|
|
519 // But first, some data conversion routines. |
|
|
520 |
|
|
521 // Currently, we only handle conversions for the IEEE types. To fix |
|
|
522 // that, make more of the following routines work. |
|
|
523 |
|
|
524 // XXX FIXME XXX -- assumes sizeof (Complex) == 8 |
|
|
525 // XXX FIXME XXX -- assumes sizeof (double) == 8 |
|
|
526 // XXX FIXME XXX -- assumes sizeof (float) == 4 |
|
|
527 |
|
|
528 static void |
|
4944
|
529 IEEE_big_double_to_IEEE_little_double (void *d, int len) |
|
1960
|
530 { |
|
4944
|
531 swap_bytes<8> (d, len); |
|
1960
|
532 } |
|
|
533 |
|
|
534 static void |
|
4944
|
535 VAX_D_double_to_IEEE_little_double (void * /* d */, int /* len */) |
|
1960
|
536 { |
|
|
537 gripe_data_conversion ("VAX D float", "IEEE little endian format"); |
|
|
538 } |
|
|
539 |
|
|
540 static void |
|
4944
|
541 VAX_G_double_to_IEEE_little_double (void * /* d */, int /* len */) |
|
1960
|
542 { |
|
|
543 gripe_data_conversion ("VAX G float", "IEEE little endian format"); |
|
|
544 } |
|
|
545 |
|
|
546 static void |
|
4944
|
547 Cray_to_IEEE_little_double (void * /* d */, int /* len */) |
|
1960
|
548 { |
|
|
549 gripe_data_conversion ("Cray", "IEEE little endian format"); |
|
|
550 } |
|
|
551 |
|
|
552 static void |
|
4944
|
553 IEEE_big_float_to_IEEE_little_float (void *d, int len) |
|
1960
|
554 { |
|
4944
|
555 swap_bytes<4> (d, len); |
|
1960
|
556 } |
|
|
557 |
|
|
558 static void |
|
4944
|
559 VAX_D_float_to_IEEE_little_float (void * /* d */, int /* len */) |
|
1960
|
560 { |
|
|
561 gripe_data_conversion ("VAX D float", "IEEE little endian format"); |
|
|
562 } |
|
|
563 |
|
|
564 static void |
|
4944
|
565 VAX_G_float_to_IEEE_little_float (void * /* d */, int /* len */) |
|
1960
|
566 { |
|
|
567 gripe_data_conversion ("VAX G float", "IEEE little endian format"); |
|
|
568 } |
|
|
569 |
|
|
570 static void |
|
4944
|
571 Cray_to_IEEE_little_float (void * /* d */, int /* len */) |
|
1960
|
572 { |
|
|
573 gripe_data_conversion ("Cray", "IEEE little endian format"); |
|
|
574 } |
|
|
575 |
|
|
576 static void |
|
4944
|
577 IEEE_little_double_to_IEEE_big_double (void *d, int len) |
|
1960
|
578 { |
|
4944
|
579 swap_bytes<8> (d, len); |
|
1960
|
580 } |
|
|
581 |
|
|
582 static void |
|
4944
|
583 VAX_D_double_to_IEEE_big_double (void * /* d */, int /* len */) |
|
1960
|
584 { |
|
|
585 gripe_data_conversion ("VAX D float", "IEEE big endian format"); |
|
|
586 } |
|
|
587 |
|
|
588 static void |
|
4944
|
589 VAX_G_double_to_IEEE_big_double (void * /* d */, int /* len */) |
|
1960
|
590 { |
|
|
591 gripe_data_conversion ("VAX G float", "IEEE big endian format"); |
|
|
592 } |
|
|
593 |
|
|
594 static void |
|
4944
|
595 Cray_to_IEEE_big_double (void * /* d */, int /* len */) |
|
1960
|
596 { |
|
|
597 gripe_data_conversion ("Cray", "IEEE big endian format"); |
|
|
598 } |
|
|
599 |
|
|
600 static void |
|
4944
|
601 IEEE_little_float_to_IEEE_big_float (void *d, int len) |
|
1960
|
602 { |
|
4944
|
603 swap_bytes<4> (d, len); |
|
1960
|
604 } |
|
|
605 |
|
|
606 static void |
|
4944
|
607 VAX_D_float_to_IEEE_big_float (void * /* d */, int /* len */) |
|
1960
|
608 { |
|
|
609 gripe_data_conversion ("VAX D float", "IEEE big endian format"); |
|
|
610 } |
|
|
611 |
|
|
612 static void |
|
4944
|
613 VAX_G_float_to_IEEE_big_float (void * /* d */, int /* len */) |
|
1960
|
614 { |
|
|
615 gripe_data_conversion ("VAX G float", "IEEE big endian format"); |
|
|
616 } |
|
|
617 |
|
|
618 static void |
|
4944
|
619 Cray_to_IEEE_big_float (void * /* d */, int /* len */) |
|
1960
|
620 { |
|
|
621 gripe_data_conversion ("Cray", "IEEE big endian format"); |
|
|
622 } |
|
|
623 |
|
|
624 static void |
|
4944
|
625 IEEE_little_double_to_VAX_D_double (void * /* d */, int /* len */) |
|
1960
|
626 { |
|
|
627 gripe_data_conversion ("IEEE little endian", "VAX D"); |
|
|
628 } |
|
|
629 |
|
|
630 static void |
|
4944
|
631 IEEE_big_double_to_VAX_D_double (void * /* d */, int /* len */) |
|
1960
|
632 { |
|
|
633 gripe_data_conversion ("IEEE big endian", "VAX D"); |
|
|
634 } |
|
|
635 |
|
|
636 static void |
|
4944
|
637 VAX_G_double_to_VAX_D_double (void * /* d */, int /* len */) |
|
1960
|
638 { |
|
|
639 gripe_data_conversion ("VAX G float", "VAX D"); |
|
|
640 } |
|
|
641 |
|
|
642 static void |
|
4944
|
643 Cray_to_VAX_D_double (void * /* d */, int /* len */) |
|
1960
|
644 { |
|
|
645 gripe_data_conversion ("Cray", "VAX D"); |
|
|
646 } |
|
|
647 |
|
|
648 static void |
|
4944
|
649 IEEE_little_float_to_VAX_D_float (void * /* d */, int /* len */) |
|
1960
|
650 { |
|
|
651 gripe_data_conversion ("IEEE little endian", "VAX D"); |
|
|
652 } |
|
|
653 |
|
|
654 static void |
|
4944
|
655 IEEE_big_float_to_VAX_D_float (void * /* d */, int /* len */) |
|
1960
|
656 { |
|
|
657 gripe_data_conversion ("IEEE big endian", "VAX D"); |
|
|
658 } |
|
|
659 |
|
|
660 static void |
|
4944
|
661 VAX_G_float_to_VAX_D_float (void * /* d */, int /* len */) |
|
1960
|
662 { |
|
|
663 gripe_data_conversion ("VAX G float", "VAX D"); |
|
|
664 } |
|
|
665 |
|
|
666 static void |
|
4944
|
667 Cray_to_VAX_D_float (void * /* d */, int /* len */) |
|
1960
|
668 { |
|
|
669 gripe_data_conversion ("Cray", "VAX D"); |
|
|
670 } |
|
|
671 |
|
|
672 static void |
|
4944
|
673 IEEE_little_double_to_VAX_G_double (void * /* d */, int /* len */) |
|
1960
|
674 { |
|
|
675 gripe_data_conversion ("IEEE little endian", "VAX G"); |
|
|
676 } |
|
|
677 |
|
|
678 static void |
|
4944
|
679 IEEE_big_double_to_VAX_G_double (void * /* d */, int /* len */) |
|
1960
|
680 { |
|
|
681 gripe_data_conversion ("IEEE big endian", "VAX G"); |
|
|
682 } |
|
|
683 |
|
|
684 static void |
|
4944
|
685 VAX_D_double_to_VAX_G_double (void * /* d */, int /* len */) |
|
1960
|
686 { |
|
|
687 gripe_data_conversion ("VAX D float", "VAX G"); |
|
|
688 } |
|
|
689 |
|
|
690 static void |
|
4944
|
691 Cray_to_VAX_G_double (void * /* d */, int /* len */) |
|
1960
|
692 { |
|
|
693 gripe_data_conversion ("VAX G float", "VAX G"); |
|
|
694 } |
|
|
695 |
|
|
696 static void |
|
4944
|
697 IEEE_little_float_to_VAX_G_float (void * /* d */, int /* len */) |
|
1960
|
698 { |
|
|
699 gripe_data_conversion ("IEEE little endian", "VAX G"); |
|
|
700 } |
|
|
701 |
|
|
702 static void |
|
4944
|
703 IEEE_big_float_to_VAX_G_float (void * /* d */, int /* len */) |
|
1960
|
704 { |
|
|
705 gripe_data_conversion ("IEEE big endian", "VAX G"); |
|
|
706 } |
|
|
707 |
|
|
708 static void |
|
4944
|
709 VAX_D_float_to_VAX_G_float (void * /* d */, int /* len */) |
|
1960
|
710 { |
|
|
711 gripe_data_conversion ("VAX D float", "VAX G"); |
|
|
712 } |
|
|
713 |
|
|
714 static void |
|
4944
|
715 Cray_to_VAX_G_float (void * /* d */, int /* len */) |
|
1960
|
716 { |
|
|
717 gripe_data_conversion ("VAX G float", "VAX G"); |
|
|
718 } |
|
|
719 |
|
|
720 void |
|
4944
|
721 do_double_format_conversion (void *data, int len, |
|
|
722 oct_mach_info::float_format from_fmt, |
|
|
723 oct_mach_info::float_format to_fmt) |
|
1960
|
724 { |
|
4944
|
725 switch (to_fmt) |
|
1960
|
726 { |
|
4574
|
727 case oct_mach_info::flt_fmt_ieee_little_endian: |
|
4944
|
728 switch (from_fmt) |
|
1960
|
729 { |
|
4574
|
730 case oct_mach_info::flt_fmt_ieee_little_endian: |
|
1960
|
731 break; |
|
|
732 |
|
4574
|
733 case oct_mach_info::flt_fmt_ieee_big_endian: |
|
1960
|
734 IEEE_big_double_to_IEEE_little_double (data, len); |
|
|
735 break; |
|
|
736 |
|
4574
|
737 case oct_mach_info::flt_fmt_vax_d: |
|
1960
|
738 VAX_D_double_to_IEEE_little_double (data, len); |
|
|
739 break; |
|
|
740 |
|
4574
|
741 case oct_mach_info::flt_fmt_vax_g: |
|
1960
|
742 VAX_G_double_to_IEEE_little_double (data, len); |
|
|
743 break; |
|
|
744 |
|
4574
|
745 case oct_mach_info::flt_fmt_cray: |
|
1960
|
746 Cray_to_IEEE_little_double (data, len); |
|
|
747 break; |
|
|
748 |
|
|
749 default: |
|
|
750 gripe_unrecognized_float_fmt (); |
|
|
751 break; |
|
|
752 } |
|
|
753 break; |
|
|
754 |
|
4574
|
755 case oct_mach_info::flt_fmt_ieee_big_endian: |
|
4944
|
756 switch (from_fmt) |
|
1960
|
757 { |
|
4574
|
758 case oct_mach_info::flt_fmt_ieee_little_endian: |
|
1960
|
759 IEEE_little_double_to_IEEE_big_double (data, len); |
|
|
760 break; |
|
|
761 |
|
4574
|
762 case oct_mach_info::flt_fmt_ieee_big_endian: |
|
1960
|
763 break; |
|
|
764 |
|
4574
|
765 case oct_mach_info::flt_fmt_vax_d: |
|
1960
|
766 VAX_D_double_to_IEEE_big_double (data, len); |
|
|
767 break; |
|
|
768 |
|
4574
|
769 case oct_mach_info::flt_fmt_vax_g: |
|
1960
|
770 VAX_G_double_to_IEEE_big_double (data, len); |
|
|
771 break; |
|
|
772 |
|
4574
|
773 case oct_mach_info::flt_fmt_cray: |
|
1960
|
774 Cray_to_IEEE_big_double (data, len); |
|
|
775 break; |
|
|
776 |
|
|
777 default: |
|
|
778 gripe_unrecognized_float_fmt (); |
|
|
779 break; |
|
|
780 } |
|
|
781 break; |
|
|
782 |
|
4574
|
783 case oct_mach_info::flt_fmt_vax_d: |
|
4944
|
784 switch (from_fmt) |
|
1960
|
785 { |
|
4574
|
786 case oct_mach_info::flt_fmt_ieee_little_endian: |
|
1960
|
787 IEEE_little_double_to_VAX_D_double (data, len); |
|
|
788 break; |
|
|
789 |
|
4574
|
790 case oct_mach_info::flt_fmt_ieee_big_endian: |
|
1960
|
791 IEEE_big_double_to_VAX_D_double (data, len); |
|
|
792 break; |
|
|
793 |
|
4574
|
794 case oct_mach_info::flt_fmt_vax_d: |
|
1960
|
795 break; |
|
|
796 |
|
4574
|
797 case oct_mach_info::flt_fmt_vax_g: |
|
1960
|
798 VAX_G_double_to_VAX_D_double (data, len); |
|
|
799 break; |
|
|
800 |
|
4574
|
801 case oct_mach_info::flt_fmt_cray: |
|
1960
|
802 Cray_to_VAX_D_double (data, len); |
|
|
803 break; |
|
|
804 |
|
|
805 default: |
|
|
806 gripe_unrecognized_float_fmt (); |
|
|
807 break; |
|
|
808 } |
|
|
809 break; |
|
|
810 |
|
4574
|
811 case oct_mach_info::flt_fmt_vax_g: |
|
4944
|
812 switch (from_fmt) |
|
1960
|
813 { |
|
4574
|
814 case oct_mach_info::flt_fmt_ieee_little_endian: |
|
1960
|
815 IEEE_little_double_to_VAX_G_double (data, len); |
|
|
816 break; |
|
|
817 |
|
4574
|
818 case oct_mach_info::flt_fmt_ieee_big_endian: |
|
1960
|
819 IEEE_big_double_to_VAX_G_double (data, len); |
|
|
820 break; |
|
|
821 |
|
4574
|
822 case oct_mach_info::flt_fmt_vax_d: |
|
1960
|
823 VAX_D_double_to_VAX_G_double (data, len); |
|
|
824 break; |
|
|
825 |
|
4574
|
826 case oct_mach_info::flt_fmt_vax_g: |
|
1960
|
827 break; |
|
|
828 |
|
4574
|
829 case oct_mach_info::flt_fmt_cray: |
|
1960
|
830 Cray_to_VAX_G_double (data, len); |
|
|
831 break; |
|
|
832 |
|
|
833 default: |
|
|
834 gripe_unrecognized_float_fmt (); |
|
|
835 break; |
|
|
836 } |
|
|
837 break; |
|
|
838 |
|
|
839 default: |
|
|
840 (*current_liboctave_error_handler) |
|
|
841 ("impossible state reached in file `%s' at line %d", |
|
|
842 __FILE__, __LINE__); |
|
|
843 break; |
|
|
844 } |
|
|
845 } |
|
|
846 |
|
|
847 void |
|
4944
|
848 do_float_format_conversion (void *data, int len, |
|
|
849 oct_mach_info::float_format from_fmt, |
|
|
850 oct_mach_info::float_format to_fmt) |
|
1960
|
851 { |
|
4944
|
852 switch (to_fmt) |
|
1960
|
853 { |
|
4574
|
854 case oct_mach_info::flt_fmt_ieee_little_endian: |
|
4944
|
855 switch (from_fmt) |
|
1960
|
856 { |
|
4574
|
857 case oct_mach_info::flt_fmt_ieee_little_endian: |
|
1960
|
858 break; |
|
|
859 |
|
4574
|
860 case oct_mach_info::flt_fmt_ieee_big_endian: |
|
1960
|
861 IEEE_big_float_to_IEEE_little_float (data, len); |
|
|
862 break; |
|
|
863 |
|
4574
|
864 case oct_mach_info::flt_fmt_vax_d: |
|
1960
|
865 VAX_D_float_to_IEEE_little_float (data, len); |
|
|
866 break; |
|
|
867 |
|
4574
|
868 case oct_mach_info::flt_fmt_vax_g: |
|
1960
|
869 VAX_G_float_to_IEEE_little_float (data, len); |
|
|
870 break; |
|
|
871 |
|
4574
|
872 case oct_mach_info::flt_fmt_cray: |
|
1960
|
873 Cray_to_IEEE_little_float (data, len); |
|
|
874 break; |
|
|
875 |
|
|
876 default: |
|
|
877 gripe_unrecognized_float_fmt (); |
|
|
878 break; |
|
|
879 } |
|
|
880 break; |
|
|
881 |
|
4574
|
882 case oct_mach_info::flt_fmt_ieee_big_endian: |
|
4944
|
883 switch (from_fmt) |
|
1960
|
884 { |
|
4574
|
885 case oct_mach_info::flt_fmt_ieee_little_endian: |
|
1960
|
886 IEEE_little_float_to_IEEE_big_float (data, len); |
|
|
887 break; |
|
|
888 |
|
4574
|
889 case oct_mach_info::flt_fmt_ieee_big_endian: |
|
1960
|
890 break; |
|
|
891 |
|
4574
|
892 case oct_mach_info::flt_fmt_vax_d: |
|
1960
|
893 VAX_D_float_to_IEEE_big_float (data, len); |
|
|
894 break; |
|
|
895 |
|
4574
|
896 case oct_mach_info::flt_fmt_vax_g: |
|
1960
|
897 VAX_G_float_to_IEEE_big_float (data, len); |
|
|
898 break; |
|
|
899 |
|
4574
|
900 case oct_mach_info::flt_fmt_cray: |
|
1960
|
901 Cray_to_IEEE_big_float (data, len); |
|
|
902 break; |
|
|
903 |
|
|
904 default: |
|
|
905 gripe_unrecognized_float_fmt (); |
|
|
906 break; |
|
|
907 } |
|
|
908 break; |
|
|
909 |
|
4574
|
910 case oct_mach_info::flt_fmt_vax_d: |
|
4944
|
911 switch (from_fmt) |
|
1960
|
912 { |
|
4574
|
913 case oct_mach_info::flt_fmt_ieee_little_endian: |
|
1960
|
914 IEEE_little_float_to_VAX_D_float (data, len); |
|
|
915 break; |
|
|
916 |
|
4574
|
917 case oct_mach_info::flt_fmt_ieee_big_endian: |
|
1960
|
918 IEEE_big_float_to_VAX_D_float (data, len); |
|
|
919 break; |
|
|
920 |
|
4574
|
921 case oct_mach_info::flt_fmt_vax_d: |
|
1960
|
922 break; |
|
|
923 |
|
4574
|
924 case oct_mach_info::flt_fmt_vax_g: |
|
1960
|
925 VAX_G_float_to_VAX_D_float (data, len); |
|
|
926 break; |
|
|
927 |
|
4574
|
928 case oct_mach_info::flt_fmt_cray: |
|
1960
|
929 Cray_to_VAX_D_float (data, len); |
|
|
930 break; |
|
|
931 |
|
|
932 default: |
|
|
933 gripe_unrecognized_float_fmt (); |
|
|
934 break; |
|
|
935 } |
|
|
936 break; |
|
|
937 |
|
4574
|
938 case oct_mach_info::flt_fmt_vax_g: |
|
4944
|
939 switch (from_fmt) |
|
1960
|
940 { |
|
4574
|
941 case oct_mach_info::flt_fmt_ieee_little_endian: |
|
1960
|
942 IEEE_little_float_to_VAX_G_float (data, len); |
|
|
943 break; |
|
|
944 |
|
4574
|
945 case oct_mach_info::flt_fmt_ieee_big_endian: |
|
1960
|
946 IEEE_big_float_to_VAX_G_float (data, len); |
|
|
947 break; |
|
|
948 |
|
4574
|
949 case oct_mach_info::flt_fmt_vax_d: |
|
1960
|
950 VAX_D_float_to_VAX_G_float (data, len); |
|
|
951 break; |
|
|
952 |
|
4574
|
953 case oct_mach_info::flt_fmt_vax_g: |
|
1960
|
954 break; |
|
|
955 |
|
4574
|
956 case oct_mach_info::flt_fmt_cray: |
|
1960
|
957 Cray_to_VAX_G_float (data, len); |
|
|
958 break; |
|
|
959 |
|
|
960 default: |
|
|
961 gripe_unrecognized_float_fmt (); |
|
|
962 break; |
|
|
963 } |
|
|
964 break; |
|
|
965 |
|
|
966 default: |
|
|
967 (*current_liboctave_error_handler) |
|
|
968 ("impossible state reached in file `%s' at line %d", |
|
|
969 __FILE__, __LINE__); |
|
|
970 break; |
|
|
971 } |
|
|
972 } |
|
|
973 |
|
|
974 void |
|
4944
|
975 do_float_format_conversion (void *data, size_t sz, int len, |
|
|
976 oct_mach_info::float_format from_fmt, |
|
|
977 oct_mach_info::float_format to_fmt) |
|
|
978 { |
|
|
979 switch (sz) |
|
|
980 { |
|
|
981 case sizeof (float): |
|
|
982 do_float_format_conversion (data, len, from_fmt, to_fmt); |
|
|
983 break; |
|
|
984 |
|
|
985 case sizeof (double): |
|
|
986 do_double_format_conversion (data, len, from_fmt, to_fmt); |
|
|
987 break; |
|
|
988 |
|
|
989 default: |
|
|
990 (*current_liboctave_error_handler) |
|
|
991 ("impossible state reached in file `%s' at line %d", |
|
|
992 __FILE__, __LINE__); |
|
|
993 break; |
|
|
994 } |
|
|
995 } |
|
|
996 |
|
|
997 |
|
|
998 void |
|
3504
|
999 read_doubles (std::istream& is, double *data, save_type type, int len, |
|
4944
|
1000 bool swap, oct_mach_info::float_format fmt) |
|
1960
|
1001 { |
|
|
1002 switch (type) |
|
|
1003 { |
|
|
1004 case LS_U_CHAR: |
|
|
1005 LS_DO_READ (unsigned char, swap, data, 1, len, is); |
|
|
1006 break; |
|
|
1007 |
|
|
1008 case LS_U_SHORT: |
|
|
1009 LS_DO_READ (unsigned TWO_BYTE_INT, swap, data, 2, len, is); |
|
|
1010 break; |
|
|
1011 |
|
|
1012 case LS_U_INT: |
|
|
1013 LS_DO_READ (unsigned FOUR_BYTE_INT, swap, data, 4, len, is); |
|
|
1014 break; |
|
|
1015 |
|
|
1016 case LS_CHAR: |
|
|
1017 LS_DO_READ (signed char, swap, data, 1, len, is); |
|
|
1018 break; |
|
|
1019 |
|
|
1020 case LS_SHORT: |
|
|
1021 LS_DO_READ (TWO_BYTE_INT, swap, data, 2, len, is); |
|
|
1022 break; |
|
|
1023 |
|
|
1024 case LS_INT: |
|
|
1025 LS_DO_READ (FOUR_BYTE_INT, swap, data, 4, len, is); |
|
|
1026 break; |
|
|
1027 |
|
|
1028 case LS_FLOAT: |
|
|
1029 { |
|
3145
|
1030 volatile float *ptr = X_CAST (float *, data); |
|
3518
|
1031 is.read (X_CAST (char *, data), 4 * len); |
|
4944
|
1032 do_float_format_conversion (data, len, fmt); |
|
1960
|
1033 float tmp = ptr[0]; |
|
|
1034 for (int i = len - 1; i > 0; i--) |
|
|
1035 data[i] = ptr[i]; |
|
|
1036 data[0] = tmp; |
|
|
1037 } |
|
|
1038 break; |
|
|
1039 |
|
3359
|
1040 case LS_DOUBLE: // No conversion necessary. |
|
3518
|
1041 is.read (X_CAST (char *, data), 8 * len); |
|
1960
|
1042 do_double_format_conversion (data, len, fmt); |
|
|
1043 break; |
|
|
1044 |
|
|
1045 default: |
|
3504
|
1046 is.clear (std::ios::failbit|is.rdstate ()); |
|
1960
|
1047 break; |
|
|
1048 } |
|
|
1049 } |
|
|
1050 |
|
|
1051 void |
|
3504
|
1052 write_doubles (std::ostream& os, const double *data, save_type type, int len) |
|
1960
|
1053 { |
|
|
1054 switch (type) |
|
|
1055 { |
|
|
1056 case LS_U_CHAR: |
|
|
1057 LS_DO_WRITE (unsigned char, data, 1, len, os); |
|
|
1058 break; |
|
|
1059 |
|
|
1060 case LS_U_SHORT: |
|
|
1061 LS_DO_WRITE (unsigned TWO_BYTE_INT, data, 2, len, os); |
|
|
1062 break; |
|
|
1063 |
|
|
1064 case LS_U_INT: |
|
|
1065 LS_DO_WRITE (unsigned FOUR_BYTE_INT, data, 4, len, os); |
|
|
1066 break; |
|
|
1067 |
|
|
1068 case LS_CHAR: |
|
|
1069 LS_DO_WRITE (signed char, data, 1, len, os); |
|
|
1070 break; |
|
|
1071 |
|
|
1072 case LS_SHORT: |
|
|
1073 LS_DO_WRITE (TWO_BYTE_INT, data, 2, len, os); |
|
|
1074 break; |
|
|
1075 |
|
|
1076 case LS_INT: |
|
|
1077 LS_DO_WRITE (FOUR_BYTE_INT, data, 4, len, os); |
|
|
1078 break; |
|
|
1079 |
|
|
1080 case LS_FLOAT: |
|
|
1081 LS_DO_WRITE (float, data, 4, len, os); |
|
|
1082 break; |
|
|
1083 |
|
3359
|
1084 case LS_DOUBLE: // No conversion necessary. |
|
1960
|
1085 { |
|
3145
|
1086 char tmp_type = X_CAST (char, type); |
|
1960
|
1087 os.write (&tmp_type, 1); |
|
3518
|
1088 os.write (X_CAST (char *, data), 8 * len); |
|
1960
|
1089 } |
|
|
1090 break; |
|
|
1091 |
|
|
1092 default: |
|
|
1093 (*current_liboctave_error_handler) |
|
|
1094 ("unrecognized data format requested"); |
|
|
1095 break; |
|
|
1096 } |
|
|
1097 } |
|
|
1098 |
|
|
1099 /* |
|
|
1100 ;;; Local Variables: *** |
|
|
1101 ;;; mode: C++ *** |
|
|
1102 ;;; End: *** |
|
|
1103 */ |
