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