Mercurial > octave-nkf

comparison liboctave/data-conv.cc @ 4944:44046bbaa52c

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
[project @ 2004-08-31 05:30:46 by jwe]
author jwe
date Tue, 31 Aug 2004 05:30:47 +0000
parents 6cb22b9e3942
children 25c2664861bc
comparison
equal deleted inserted replaced
4943:1a499d0c58f5 4944:44046bbaa52c
30 30
31 #include "byte-swap.h" 31 #include "byte-swap.h"
32 #include "data-conv.h" 32 #include "data-conv.h"
33 #include "lo-error.h" 33 #include "lo-error.h"
34 34
35 #if defined HAVE_LONG_LONG_INT
36 #define FIND_SIZED_INT_TYPE(VAL, BITS, TQ, Q) \
37 do \
38 { \
39 int sz = BITS / CHAR_BIT; \
40 if (sizeof (TQ char) == sz) \
41 VAL = oct_data_conv::dt_ ## Q ## char; \
42 else if (sizeof (TQ short) == sz) \
43 VAL = oct_data_conv::dt_ ## Q ## short; \
44 else if (sizeof (TQ int) == sz) \
45 VAL = oct_data_conv::dt_ ## Q ## int; \
46 else if (sizeof (TQ long) == sz) \
47 VAL = oct_data_conv::dt_ ## Q ## long; \
48 else if (sizeof (TQ long long) == sz) \
49 VAL = oct_data_conv::dt_ ## Q ## longlong; \
50 else \
51 VAL = oct_data_conv::dt_unknown; \
52 } \
53 while (0)
54 #else
35 #define FIND_SIZED_INT_TYPE(VAL, BITS, TQ, Q) \ 55 #define FIND_SIZED_INT_TYPE(VAL, BITS, TQ, Q) \
36 do \ 56 do \
37 { \ 57 { \
38 int sz = BITS / CHAR_BIT; \ 58 int sz = BITS / CHAR_BIT; \
39 if (sizeof (TQ char) == sz) \ 59 if (sizeof (TQ char) == sz) \
46 VAL = oct_data_conv::dt_ ## Q ## long; \ 66 VAL = oct_data_conv::dt_ ## Q ## long; \
47 else \ 67 else \
48 VAL = oct_data_conv::dt_unknown; \ 68 VAL = oct_data_conv::dt_unknown; \
49 } \ 69 } \
50 while (0) 70 while (0)
71 #endif
51 72
52 #define FIND_SIZED_FLOAT_TYPE(VAL, BITS) \ 73 #define FIND_SIZED_FLOAT_TYPE(VAL, BITS) \
53 do \ 74 do \
54 { \ 75 { \
55 int sz = BITS / CHAR_BIT; \ 76 int sz = BITS / CHAR_BIT; \
99 120
100 bits *= 2; 121 bits *= 2;
101 } 122 }
102 } 123 }
103 124
104 oct_data_conv::data_type 125 static std::string
105 oct_data_conv::string_to_data_type (const std::string& str) 126 strip_spaces (const std::string& str)
106 { 127 {
107 data_type retval = dt_unknown;
108
109 static bool initialized = false;
110
111 static data_type sized_type_table[3][4];
112
113 if (! initialized)
114 {
115 init_sized_type_lookup_table (sized_type_table);
116
117 initialized = true;
118 }
119
120 // XXX FIXME XXX -- finish implementing this.
121
122 int n = str.length (); 128 int n = str.length ();
123 129
124 int k = 0; 130 int k = 0;
125 131
126 std::string s (n, ' '); 132 std::string s (n, ' ');
129 if (! isspace (str[i])) 135 if (! isspace (str[i]))
130 s[k++] = tolower (str[i]); 136 s[k++] = tolower (str[i]);
131 137
132 s.resize (k); 138 s.resize (k);
133 139
134 if (s == "char") 140 return s;
141 }
142
143 #define GET_SIZED_INT_TYPE(T, U) \
144 do \
145 { \
146 switch (sizeof (T)) \
147 { \
148 case 1: \
149 retval = dt_ ## U ## int8; \
150 break; \
151 \
152 case 2: \
153 retval = dt_ ## U ## int16; \
154 break; \
155 \
156 case 4: \
157 retval = dt_ ## U ## int32; \
158 break; \
159 \
160 case 8: \
161 retval = dt_ ## U ## int64; \
162 break; \
163 \
164 default: \
165 retval = dt_unknown; \
166 break; \
167 } \
168 } \
169 while (0)
170
171 oct_data_conv::data_type
172 oct_data_conv::string_to_data_type (const std::string& str)
173 {
174 data_type retval = dt_unknown;
175
176 static bool initialized = false;
177
178 static data_type sized_type_table[3][4];
179
180 if (! initialized)
181 {
182 init_sized_type_lookup_table (sized_type_table);
183
184 initialized = true;
185 }
186
187 std::string s = strip_spaces (str);
188
189 if (s == "int8" || s == "integer*1")
190 retval = dt_int8;
191 else if (s == "uint8")
192 retval = dt_uint8;
193 else if (s == "int16" || s == "integer*2")
194 retval = dt_int16;
195 else if (s == "uint16")
196 retval = dt_uint16;
197 else if (s == "int32" || s == "integer*4")
198 retval = dt_int32;
199 else if (s == "uint32")
200 retval = dt_uint32;
201 else if (s == "int64" || s == "integer*8")
202 retval = dt_int64;
203 else if (s == "uint64")
204 retval = dt_uint64;
205 else if (s == "single" || s == "float32" || s == "real*4")
206 retval = dt_single;
207 else if (s == "double" || s == "float64" || s == "real*8")
208 retval = dt_double;
209 else if (s == "char" || s == "char*1")
135 retval = dt_char; 210 retval = dt_char;
136 else if (s == "schar" || s == "signedchar") 211 else if (s == "schar" || s == "signedchar")
137 retval = dt_schar; 212 retval = dt_schar;
138 else if (s == "uchar" || s == "unsignedchar") 213 else if (s == "uchar" || s == "unsignedchar")
139 retval = dt_uchar; 214 retval = dt_uchar;
140 else if (s == "short") 215 else if (s == "short")
141 retval = dt_short; 216 GET_SIZED_INT_TYPE (short, );
142 else if (s == "ushort" || s == "unsignedshort") 217 else if (s == "ushort" || s == "unsignedshort")
143 retval = dt_ushort; 218 GET_SIZED_INT_TYPE (unsigned short, u);
144 else if (s == "int") 219 else if (s == "int")
145 retval = dt_int; 220 GET_SIZED_INT_TYPE (int, );
146 else if (s == "uint" || s == "unsignedint") 221 else if (s == "uint" || s == "unsignedint")
147 retval = dt_uint; 222 GET_SIZED_INT_TYPE (unsigned int, u);
148 else if (s == "long") 223 else if (s == "long")
149 retval = dt_long; 224 GET_SIZED_INT_TYPE (long, );
150 else if (s == "ulong" || s == "unsignedlong") 225 else if (s == "ulong" || s == "unsignedlong")
151 retval = dt_ulong; 226 GET_SIZED_INT_TYPE (unsigned long, u);
227 else if (s == "longlong")
228 GET_SIZED_INT_TYPE (long long, );
229 else if (s == "ulonglong" || s == "unsignedlonglong")
230 GET_SIZED_INT_TYPE (unsigned long long, u);
152 else if (s == "float") 231 else if (s == "float")
153 retval = dt_float; 232 {
154 else if (s == "double") 233 if (sizeof (float) == sizeof (double))
155 retval = dt_double; 234 retval = dt_double;
156 else if (s == "int8" || s == "char*1" || s == "integer*1") 235 else
157 retval = sized_type_table[0][0]; 236 retval = dt_single;
158 else if (s == "int16" || s == "integer*2") 237 }
159 retval = sized_type_table[0][1];
160 else if (s == "int32" || s == "integer*4")
161 retval = sized_type_table[0][2];
162 else if (s == "int64" || s == "integer*8")
163 retval = sized_type_table[0][3];
164 else if (s == "uint8")
165 retval = sized_type_table[1][0];
166 else if (s == "uint16")
167 retval = sized_type_table[1][1];
168 else if (s == "uint32")
169 retval = sized_type_table[1][2];
170 else if (s == "uint64")
171 retval = sized_type_table[1][3];
172 else if (s == "float32" || s == "real*4")
173 retval = sized_type_table[2][2];
174 else if (s == "float64" || s == "real*8")
175 retval = sized_type_table[2][3];
176 else 238 else
177 (*current_liboctave_error_handler) ("invalid data type specified"); 239 (*current_liboctave_error_handler) ("invalid data type specified");
178 240
179 if (retval == dt_unknown) 241 if (retval == dt_unknown)
180 (*current_liboctave_error_handler) 242 (*current_liboctave_error_handler)
181 ("unable to find matching native data type for %s", s.c_str ()); 243 ("unable to find matching native data type for %s", s.c_str ());
182 244
183 return retval; 245 return retval;
184 } 246 }
185 247
186 #define swap_1_bytes(x, y) 248 void
249 oct_data_conv::string_to_data_type
250 (const std::string& str, int& block_size,
251 oct_data_conv::data_type& input_type,
252 oct_data_conv::data_type& output_type)
253 {
254 block_size = 1;
255 input_type = dt_uchar;
256 output_type = dt_double;
257
258 bool input_is_output = false;
259
260 std::string s = strip_spaces (str);
261
262 size_t pos = 0;
263
264 if (s[0] == '*')
265 input_is_output = true;
266 else
267 {
268 size_t len = s.length ();
269
270 while (pos < len && isdigit (s[pos]))
271 pos++;
272
273 if (pos > 0)
274 {
275 if (s[pos] == '*')
276 {
277 block_size = atoi (s.c_str ());
278 s = s.substr (pos+1);
279 }
280 else
281 {
282 (*current_liboctave_error_handler)
283 ("invalid repeat count in `%s'", str.c_str ());
284
285 return;
286 }
287 }
288 }
289
290 pos = s.find ('=');
291
292 if (pos != std::string::npos)
293 {
294 if (s[pos+1] == '>')
295 {
296 if (input_is_output)
297 {
298 input_is_output = false;
299
300 (*current_liboctave_warning_handler)
301 ("warning: ignoring leading * in fread precision");
302 }
303
304 input_type = string_to_data_type (s.substr (0, pos));
305 output_type = string_to_data_type (s.substr (pos+2));
306 }
307 else
308 (*current_liboctave_error_handler)
309 ("fread: invalid precision specified");
310 }
311 else
312 {
313 input_type = string_to_data_type (s);
314
315 if (input_is_output)
316 output_type = input_type;
317 }
318 }
319
320 void
321 oct_data_conv::string_to_data_type
322 (const std::string& str, int& block_size,
323 oct_data_conv::data_type& output_type)
324 {
325 block_size = 1;
326 output_type = dt_double;
327
328 std::string s = strip_spaces (str);
329
330 size_t pos = 0;
331
332 size_t len = s.length ();
333
334 while (pos < len && isdigit (s[pos]))
335 pos++;
336
337 if (pos > 0)
338 {
339 if (s[pos] == '*')
340 {
341 block_size = atoi (s.c_str ());
342 s = s.substr (pos+1);
343 }
344 else
345 {
346 (*current_liboctave_error_handler)
347 ("invalid repeat count in `%s'", str.c_str ());
348
349 return;
350 }
351 }
352
353 output_type = string_to_data_type (s);
354 }
355
356 std::string
357 oct_data_conv::data_type_as_string (oct_data_conv::data_type dt)
358 {
359 std::string retval;
360
361 switch (dt)
362 {
363 case oct_data_conv::dt_int8:
364 retval = "int8";
365 break;
366
367 case oct_data_conv::dt_uint8:
368 retval = "uint8";
369 break;
370
371 case oct_data_conv::dt_int16:
372 retval = "int16";
373 break;
374
375 case oct_data_conv::dt_uint16:
376 retval = "uint16";
377 break;
378
379 case oct_data_conv::dt_int32:
380 retval = "int32";
381 break;
382
383 case oct_data_conv::dt_uint32:
384 retval = "uint32";
385 break;
386
387 case oct_data_conv::dt_int64:
388 retval = "int64";
389 break;
390
391 case oct_data_conv::dt_uint64:
392 retval = "uint64";
393 break;
394
395 case oct_data_conv::dt_single:
396 retval = "single";
397 break;
398
399 case oct_data_conv::dt_double:
400 retval = "double";
401 break;
402
403 case oct_data_conv::dt_char:
404 retval = "char";
405 break;
406
407 case oct_data_conv::dt_schar:
408 retval = "signed char";
409 break;
410
411 case oct_data_conv::dt_uchar:
412 retval = "usigned char";
413 break;
414
415 case oct_data_conv::dt_short:
416 retval = "short";
417 break;
418
419 case oct_data_conv::dt_ushort:
420 retval = "unsigned short";
421 break;
422
423 case oct_data_conv::dt_int:
424 retval = "int";
425 break;
426
427 case oct_data_conv::dt_uint:
428 retval = "usigned int";
429 break;
430
431 case oct_data_conv::dt_long:
432 retval = "long";
433 break;
434
435 case oct_data_conv::dt_ulong:
436 retval = "usigned long";
437 break;
438
439 case oct_data_conv::dt_longlong:
440 retval = "long long";
441 break;
442
443 case oct_data_conv::dt_ulonglong:
444 retval = "unsigned long long";
445 break;
446
447 case oct_data_conv::dt_float:
448 retval = "float";
449 break;
450
451 case oct_data_conv::dt_unknown:
452 default:
453 retval = "unknown";
454 break;
455 }
456
457 return retval;
458 }
187 459
188 #define LS_DO_READ(TYPE, swap, data, size, len, stream) \ 460 #define LS_DO_READ(TYPE, swap, data, size, len, stream) \
189 do \ 461 do \
190 { \ 462 { \
191 if (len > 0) \ 463 if (len > 0) \
192 { \ 464 { \
193 volatile TYPE *ptr = X_CAST (volatile TYPE *, data); \ 465 volatile TYPE *ptr = X_CAST (volatile TYPE *, data); \
194 stream.read (X_CAST (char *, ptr), size * len); \ 466 stream.read (X_CAST (char *, ptr), size * len); \
195 if (swap) \ 467 if (swap) \
196 swap_ ## size ## _bytes (ptr, len); \ 468 swap_bytes< size > (ptr, len); \
197 TYPE tmp = ptr[0]; \ 469 TYPE tmp = ptr[0]; \
198 for (int i = len - 1; i > 0; i--) \ 470 for (int i = len - 1; i > 0; i--) \
199 data[i] = ptr[i]; \ 471 data[i] = ptr[i]; \
200 data[0] = tmp; \ 472 data[0] = tmp; \
201 } \ 473 } \
245 // XXX FIXME XXX -- assumes sizeof (Complex) == 8 517 // XXX FIXME XXX -- assumes sizeof (Complex) == 8
246 // XXX FIXME XXX -- assumes sizeof (double) == 8 518 // XXX FIXME XXX -- assumes sizeof (double) == 8
247 // XXX FIXME XXX -- assumes sizeof (float) == 4 519 // XXX FIXME XXX -- assumes sizeof (float) == 4
248 520
249 static void 521 static void
250 IEEE_big_double_to_IEEE_little_double (double *d, int len) 522 IEEE_big_double_to_IEEE_little_double (void *d, int len)
251 { 523 {
252 swap_8_bytes (d, len); 524 swap_bytes<8> (d, len);
253 } 525 }
254 526
255 static void 527 static void
256 VAX_D_double_to_IEEE_little_double (double * /* d */, int /* len */) 528 VAX_D_double_to_IEEE_little_double (void * /* d */, int /* len */)
257 { 529 {
258 gripe_data_conversion ("VAX D float", "IEEE little endian format"); 530 gripe_data_conversion ("VAX D float", "IEEE little endian format");
259 } 531 }
260 532
261 static void 533 static void
262 VAX_G_double_to_IEEE_little_double (double * /* d */, int /* len */) 534 VAX_G_double_to_IEEE_little_double (void * /* d */, int /* len */)
263 { 535 {
264 gripe_data_conversion ("VAX G float", "IEEE little endian format"); 536 gripe_data_conversion ("VAX G float", "IEEE little endian format");
265 } 537 }
266 538
267 static void 539 static void
268 Cray_to_IEEE_little_double (double * /* d */, int /* len */) 540 Cray_to_IEEE_little_double (void * /* d */, int /* len */)
269 { 541 {
270 gripe_data_conversion ("Cray", "IEEE little endian format"); 542 gripe_data_conversion ("Cray", "IEEE little endian format");
271 } 543 }
272 544
273 static void 545 static void
274 IEEE_big_float_to_IEEE_little_float (float *d, int len) 546 IEEE_big_float_to_IEEE_little_float (void *d, int len)
275 { 547 {
276 swap_4_bytes (d, len); 548 swap_bytes<4> (d, len);
277 } 549 }
278 550
279 static void 551 static void
280 VAX_D_float_to_IEEE_little_float (float * /* d */, int /* len */) 552 VAX_D_float_to_IEEE_little_float (void * /* d */, int /* len */)
281 { 553 {
282 gripe_data_conversion ("VAX D float", "IEEE little endian format"); 554 gripe_data_conversion ("VAX D float", "IEEE little endian format");
283 } 555 }
284 556
285 static void 557 static void
286 VAX_G_float_to_IEEE_little_float (float * /* d */, int /* len */) 558 VAX_G_float_to_IEEE_little_float (void * /* d */, int /* len */)
287 { 559 {
288 gripe_data_conversion ("VAX G float", "IEEE little endian format"); 560 gripe_data_conversion ("VAX G float", "IEEE little endian format");
289 } 561 }
290 562
291 static void 563 static void
292 Cray_to_IEEE_little_float (float * /* d */, int /* len */) 564 Cray_to_IEEE_little_float (void * /* d */, int /* len */)
293 { 565 {
294 gripe_data_conversion ("Cray", "IEEE little endian format"); 566 gripe_data_conversion ("Cray", "IEEE little endian format");
295 } 567 }
296 568
297 static void 569 static void
298 IEEE_little_double_to_IEEE_big_double (double *d, int len) 570 IEEE_little_double_to_IEEE_big_double (void *d, int len)
299 { 571 {
300 swap_8_bytes (d, len); 572 swap_bytes<8> (d, len);
301 } 573 }
302 574
303 static void 575 static void
304 VAX_D_double_to_IEEE_big_double (double * /* d */, int /* len */) 576 VAX_D_double_to_IEEE_big_double (void * /* d */, int /* len */)
305 { 577 {
306 gripe_data_conversion ("VAX D float", "IEEE big endian format"); 578 gripe_data_conversion ("VAX D float", "IEEE big endian format");
307 } 579 }
308 580
309 static void 581 static void
310 VAX_G_double_to_IEEE_big_double (double * /* d */, int /* len */) 582 VAX_G_double_to_IEEE_big_double (void * /* d */, int /* len */)
311 { 583 {
312 gripe_data_conversion ("VAX G float", "IEEE big endian format"); 584 gripe_data_conversion ("VAX G float", "IEEE big endian format");
313 } 585 }
314 586
315 static void 587 static void
316 Cray_to_IEEE_big_double (double * /* d */, int /* len */) 588 Cray_to_IEEE_big_double (void * /* d */, int /* len */)
317 { 589 {
318 gripe_data_conversion ("Cray", "IEEE big endian format"); 590 gripe_data_conversion ("Cray", "IEEE big endian format");
319 } 591 }
320 592
321 static void 593 static void
322 IEEE_little_float_to_IEEE_big_float (float *d, int len) 594 IEEE_little_float_to_IEEE_big_float (void *d, int len)
323 { 595 {
324 swap_4_bytes (d, len); 596 swap_bytes<4> (d, len);
325 } 597 }
326 598
327 static void 599 static void
328 VAX_D_float_to_IEEE_big_float (float * /* d */, int /* len */) 600 VAX_D_float_to_IEEE_big_float (void * /* d */, int /* len */)
329 { 601 {
330 gripe_data_conversion ("VAX D float", "IEEE big endian format"); 602 gripe_data_conversion ("VAX D float", "IEEE big endian format");
331 } 603 }
332 604
333 static void 605 static void
334 VAX_G_float_to_IEEE_big_float (float * /* d */, int /* len */) 606 VAX_G_float_to_IEEE_big_float (void * /* d */, int /* len */)
335 { 607 {
336 gripe_data_conversion ("VAX G float", "IEEE big endian format"); 608 gripe_data_conversion ("VAX G float", "IEEE big endian format");
337 } 609 }
338 610
339 static void 611 static void
340 Cray_to_IEEE_big_float (float * /* d */, int /* len */) 612 Cray_to_IEEE_big_float (void * /* d */, int /* len */)
341 { 613 {
342 gripe_data_conversion ("Cray", "IEEE big endian format"); 614 gripe_data_conversion ("Cray", "IEEE big endian format");
343 } 615 }
344 616
345 static void 617 static void
346 IEEE_little_double_to_VAX_D_double (double * /* d */, int /* len */) 618 IEEE_little_double_to_VAX_D_double (void * /* d */, int /* len */)
347 { 619 {
348 gripe_data_conversion ("IEEE little endian", "VAX D"); 620 gripe_data_conversion ("IEEE little endian", "VAX D");
349 } 621 }
350 622
351 static void 623 static void
352 IEEE_big_double_to_VAX_D_double (double * /* d */, int /* len */) 624 IEEE_big_double_to_VAX_D_double (void * /* d */, int /* len */)
353 { 625 {
354 gripe_data_conversion ("IEEE big endian", "VAX D"); 626 gripe_data_conversion ("IEEE big endian", "VAX D");
355 } 627 }
356 628
357 static void 629 static void
358 VAX_G_double_to_VAX_D_double (double * /* d */, int /* len */) 630 VAX_G_double_to_VAX_D_double (void * /* d */, int /* len */)
359 { 631 {
360 gripe_data_conversion ("VAX G float", "VAX D"); 632 gripe_data_conversion ("VAX G float", "VAX D");
361 } 633 }
362 634
363 static void 635 static void
364 Cray_to_VAX_D_double (double * /* d */, int /* len */) 636 Cray_to_VAX_D_double (void * /* d */, int /* len */)
365 { 637 {
366 gripe_data_conversion ("Cray", "VAX D"); 638 gripe_data_conversion ("Cray", "VAX D");
367 } 639 }
368 640
369 static void 641 static void
370 IEEE_little_float_to_VAX_D_float (float * /* d */, int /* len */) 642 IEEE_little_float_to_VAX_D_float (void * /* d */, int /* len */)
371 { 643 {
372 gripe_data_conversion ("IEEE little endian", "VAX D"); 644 gripe_data_conversion ("IEEE little endian", "VAX D");
373 } 645 }
374 646
375 static void 647 static void
376 IEEE_big_float_to_VAX_D_float (float * /* d */, int /* len */) 648 IEEE_big_float_to_VAX_D_float (void * /* d */, int /* len */)
377 { 649 {
378 gripe_data_conversion ("IEEE big endian", "VAX D"); 650 gripe_data_conversion ("IEEE big endian", "VAX D");
379 } 651 }
380 652
381 static void 653 static void
382 VAX_G_float_to_VAX_D_float (float * /* d */, int /* len */) 654 VAX_G_float_to_VAX_D_float (void * /* d */, int /* len */)
383 { 655 {
384 gripe_data_conversion ("VAX G float", "VAX D"); 656 gripe_data_conversion ("VAX G float", "VAX D");
385 } 657 }
386 658
387 static void 659 static void
388 Cray_to_VAX_D_float (float * /* d */, int /* len */) 660 Cray_to_VAX_D_float (void * /* d */, int /* len */)
389 { 661 {
390 gripe_data_conversion ("Cray", "VAX D"); 662 gripe_data_conversion ("Cray", "VAX D");
391 } 663 }
392 664
393 static void 665 static void
394 IEEE_little_double_to_VAX_G_double (double * /* d */, int /* len */) 666 IEEE_little_double_to_VAX_G_double (void * /* d */, int /* len */)
395 { 667 {
396 gripe_data_conversion ("IEEE little endian", "VAX G"); 668 gripe_data_conversion ("IEEE little endian", "VAX G");
397 } 669 }
398 670
399 static void 671 static void
400 IEEE_big_double_to_VAX_G_double (double * /* d */, int /* len */) 672 IEEE_big_double_to_VAX_G_double (void * /* d */, int /* len */)
401 { 673 {
402 gripe_data_conversion ("IEEE big endian", "VAX G"); 674 gripe_data_conversion ("IEEE big endian", "VAX G");
403 } 675 }
404 676
405 static void 677 static void
406 VAX_D_double_to_VAX_G_double (double * /* d */, int /* len */) 678 VAX_D_double_to_VAX_G_double (void * /* d */, int /* len */)
407 { 679 {
408 gripe_data_conversion ("VAX D float", "VAX G"); 680 gripe_data_conversion ("VAX D float", "VAX G");
409 } 681 }
410 682
411 static void 683 static void
412 Cray_to_VAX_G_double (double * /* d */, int /* len */) 684 Cray_to_VAX_G_double (void * /* d */, int /* len */)
413 { 685 {
414 gripe_data_conversion ("VAX G float", "VAX G"); 686 gripe_data_conversion ("VAX G float", "VAX G");
415 } 687 }
416 688
417 static void 689 static void
418 IEEE_little_float_to_VAX_G_float (float * /* d */, int /* len */) 690 IEEE_little_float_to_VAX_G_float (void * /* d */, int /* len */)
419 { 691 {
420 gripe_data_conversion ("IEEE little endian", "VAX G"); 692 gripe_data_conversion ("IEEE little endian", "VAX G");
421 } 693 }
422 694
423 static void 695 static void
424 IEEE_big_float_to_VAX_G_float (float * /* d */, int /* len */) 696 IEEE_big_float_to_VAX_G_float (void * /* d */, int /* len */)
425 { 697 {
426 gripe_data_conversion ("IEEE big endian", "VAX G"); 698 gripe_data_conversion ("IEEE big endian", "VAX G");
427 } 699 }
428 700
429 static void 701 static void
430 VAX_D_float_to_VAX_G_float (float * /* d */, int /* len */) 702 VAX_D_float_to_VAX_G_float (void * /* d */, int /* len */)
431 { 703 {
432 gripe_data_conversion ("VAX D float", "VAX G"); 704 gripe_data_conversion ("VAX D float", "VAX G");
433 } 705 }
434 706
435 static void 707 static void
436 Cray_to_VAX_G_float (float * /* d */, int /* len */) 708 Cray_to_VAX_G_float (void * /* d */, int /* len */)
437 { 709 {
438 gripe_data_conversion ("VAX G float", "VAX G"); 710 gripe_data_conversion ("VAX G float", "VAX G");
439 } 711 }
440 712
441 void 713 void
442 do_double_format_conversion (double *data, int len, 714 do_double_format_conversion (void *data, int len,
443 oct_mach_info::float_format fmt) 715 oct_mach_info::float_format from_fmt,
444 { 716 oct_mach_info::float_format to_fmt)
445 switch (oct_mach_info::native_float_format ()) 717 {
718 switch (to_fmt)
446 { 719 {
447 case oct_mach_info::flt_fmt_ieee_little_endian: 720 case oct_mach_info::flt_fmt_ieee_little_endian:
448 switch (fmt) 721 switch (from_fmt)
449 { 722 {
450 case oct_mach_info::flt_fmt_ieee_little_endian: 723 case oct_mach_info::flt_fmt_ieee_little_endian:
451 break; 724 break;
452 725
453 case oct_mach_info::flt_fmt_ieee_big_endian: 726 case oct_mach_info::flt_fmt_ieee_big_endian:
471 break; 744 break;
472 } 745 }
473 break; 746 break;
474 747
475 case oct_mach_info::flt_fmt_ieee_big_endian: 748 case oct_mach_info::flt_fmt_ieee_big_endian:
476 switch (fmt) 749 switch (from_fmt)
477 { 750 {
478 case oct_mach_info::flt_fmt_ieee_little_endian: 751 case oct_mach_info::flt_fmt_ieee_little_endian:
479 IEEE_little_double_to_IEEE_big_double (data, len); 752 IEEE_little_double_to_IEEE_big_double (data, len);
480 break; 753 break;
481 754
499 break; 772 break;
500 } 773 }
501 break; 774 break;
502 775
503 case oct_mach_info::flt_fmt_vax_d: 776 case oct_mach_info::flt_fmt_vax_d:
504 switch (fmt) 777 switch (from_fmt)
505 { 778 {
506 case oct_mach_info::flt_fmt_ieee_little_endian: 779 case oct_mach_info::flt_fmt_ieee_little_endian:
507 IEEE_little_double_to_VAX_D_double (data, len); 780 IEEE_little_double_to_VAX_D_double (data, len);
508 break; 781 break;
509 782
527 break; 800 break;
528 } 801 }
529 break; 802 break;
530 803
531 case oct_mach_info::flt_fmt_vax_g: 804 case oct_mach_info::flt_fmt_vax_g:
532 switch (fmt) 805 switch (from_fmt)
533 { 806 {
534 case oct_mach_info::flt_fmt_ieee_little_endian: 807 case oct_mach_info::flt_fmt_ieee_little_endian:
535 IEEE_little_double_to_VAX_G_double (data, len); 808 IEEE_little_double_to_VAX_G_double (data, len);
536 break; 809 break;
537 810
563 break; 836 break;
564 } 837 }
565 } 838 }
566 839
567 void 840 void
568 do_float_format_conversion (float *data, int len, 841 do_float_format_conversion (void *data, int len,
569 oct_mach_info::float_format fmt) 842 oct_mach_info::float_format from_fmt,
570 { 843 oct_mach_info::float_format to_fmt)
571 switch (oct_mach_info::native_float_format ()) 844 {
845 switch (to_fmt)
572 { 846 {
573 case oct_mach_info::flt_fmt_ieee_little_endian: 847 case oct_mach_info::flt_fmt_ieee_little_endian:
574 switch (fmt) 848 switch (from_fmt)
575 { 849 {
576 case oct_mach_info::flt_fmt_ieee_little_endian: 850 case oct_mach_info::flt_fmt_ieee_little_endian:
577 break; 851 break;
578 852
579 case oct_mach_info::flt_fmt_ieee_big_endian: 853 case oct_mach_info::flt_fmt_ieee_big_endian:
597 break; 871 break;
598 } 872 }
599 break; 873 break;
600 874
601 case oct_mach_info::flt_fmt_ieee_big_endian: 875 case oct_mach_info::flt_fmt_ieee_big_endian:
602 switch (fmt) 876 switch (from_fmt)
603 { 877 {
604 case oct_mach_info::flt_fmt_ieee_little_endian: 878 case oct_mach_info::flt_fmt_ieee_little_endian:
605 IEEE_little_float_to_IEEE_big_float (data, len); 879 IEEE_little_float_to_IEEE_big_float (data, len);
606 break; 880 break;
607 881
625 break; 899 break;
626 } 900 }
627 break; 901 break;
628 902
629 case oct_mach_info::flt_fmt_vax_d: 903 case oct_mach_info::flt_fmt_vax_d:
630 switch (fmt) 904 switch (from_fmt)
631 { 905 {
632 case oct_mach_info::flt_fmt_ieee_little_endian: 906 case oct_mach_info::flt_fmt_ieee_little_endian:
633 IEEE_little_float_to_VAX_D_float (data, len); 907 IEEE_little_float_to_VAX_D_float (data, len);
634 break; 908 break;
635 909
653 break; 927 break;
654 } 928 }
655 break; 929 break;
656 930
657 case oct_mach_info::flt_fmt_vax_g: 931 case oct_mach_info::flt_fmt_vax_g:
658 switch (fmt) 932 switch (from_fmt)
659 { 933 {
660 case oct_mach_info::flt_fmt_ieee_little_endian: 934 case oct_mach_info::flt_fmt_ieee_little_endian:
661 IEEE_little_float_to_VAX_G_float (data, len); 935 IEEE_little_float_to_VAX_G_float (data, len);
662 break; 936 break;
663 937
689 break; 963 break;
690 } 964 }
691 } 965 }
692 966
693 void 967 void
968 do_float_format_conversion (void *data, size_t sz, int len,
969 oct_mach_info::float_format from_fmt,
970 oct_mach_info::float_format to_fmt)
971 {
972 switch (sz)
973 {
974 case sizeof (float):
975 do_float_format_conversion (data, len, from_fmt, to_fmt);
976 break;
977
978 case sizeof (double):
979 do_double_format_conversion (data, len, from_fmt, to_fmt);
980 break;
981
982 default:
983 (*current_liboctave_error_handler)
984 ("impossible state reached in file `%s' at line %d",
985 __FILE__, __LINE__);
986 break;
987 }
988 }
989
990
991 void
694 read_doubles (std::istream& is, double *data, save_type type, int len, 992 read_doubles (std::istream& is, double *data, save_type type, int len,
695 int swap, oct_mach_info::float_format fmt) 993 bool swap, oct_mach_info::float_format fmt)
696 { 994 {
697 switch (type) 995 switch (type)
698 { 996 {
699 case LS_U_CHAR: 997 case LS_U_CHAR:
700 LS_DO_READ (unsigned char, swap, data, 1, len, is); 998 LS_DO_READ (unsigned char, swap, data, 1, len, is);
722 1020
723 case LS_FLOAT: 1021 case LS_FLOAT:
724 { 1022 {
725 volatile float *ptr = X_CAST (float *, data); 1023 volatile float *ptr = X_CAST (float *, data);
726 is.read (X_CAST (char *, data), 4 * len); 1024 is.read (X_CAST (char *, data), 4 * len);
727 do_float_format_conversion (X_CAST (float *, data), len, fmt); 1025 do_float_format_conversion (data, len, fmt);
728 float tmp = ptr[0]; 1026 float tmp = ptr[0];
729 for (int i = len - 1; i > 0; i--) 1027 for (int i = len - 1; i > 0; i--)
730 data[i] = ptr[i]; 1028 data[i] = ptr[i];
731 data[0] = tmp; 1029 data[0] = tmp;
732 } 1030 }