Mercurial > octave-nkf

comparison liboctave/util/data-conv.cc @ 16074:821922270b66

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Fix saving binary matrices with up to 2^31 elements (Bug #38326). * liboctave/util/data-conv.cc(LS_DO_READ, LS_DO_WRITE, read_doubles, read_floats, write_doubles, write_floats): Calculate number of bytes to read/write using std::streamsize variable rather than octave_idx_type.
author Rik <rik@octave.org>
date Wed, 20 Feb 2013 14:58:39 -0800
parents 049e8bbff782
children 0b644adf4f31
comparison
equal deleted inserted replaced
16073:1c8234f0b642 16074:821922270b66
485 do \ 485 do \
486 { \ 486 { \
487 if (len > 0) \ 487 if (len > 0) \
488 { \ 488 { \
489 OCTAVE_LOCAL_BUFFER (TYPE, ptr, len); \ 489 OCTAVE_LOCAL_BUFFER (TYPE, ptr, len); \
490 stream.read (reinterpret_cast<char *> (ptr), size * len); \ 490 std::streamsize n_bytes = size * len; \
491 stream.read (reinterpret_cast<char *> (ptr), n_bytes); \
491 if (swap) \ 492 if (swap) \
492 swap_bytes< size > (ptr, len); \ 493 swap_bytes< size > (ptr, len); \
493 for (octave_idx_type i = 0; i < len; i++) \ 494 for (octave_idx_type i = 0; i < len; i++) \
494 data[i] = ptr[i]; \ 495 data[i] = ptr[i]; \
495 } \ 496 } \
507 char tmp_type = type; \ 508 char tmp_type = type; \
508 stream.write (&tmp_type, 1); \ 509 stream.write (&tmp_type, 1); \
509 OCTAVE_LOCAL_BUFFER (TYPE, ptr, len); \ 510 OCTAVE_LOCAL_BUFFER (TYPE, ptr, len); \
510 for (octave_idx_type i = 0; i < len; i++) \ 511 for (octave_idx_type i = 0; i < len; i++) \
511 ptr[i] = static_cast <TYPE> (data[i]); \ 512 ptr[i] = static_cast <TYPE> (data[i]); \
512 stream.write (reinterpret_cast<char *> (ptr), size * len); \ 513 std::streamsize n_bytes = size * len; \
514 stream.write (reinterpret_cast<char *> (ptr), n_bytes); \
513 } \ 515 } \
514 } \ 516 } \
515 while (0) 517 while (0)
516 518
517 // Loading variables from files. 519 // Loading variables from files.
1006 __FILE__, __LINE__); 1008 __FILE__, __LINE__);
1007 break; 1009 break;
1008 } 1010 }
1009 } 1011 }
1010 1012
1011
1012 void 1013 void
1013 read_doubles (std::istream& is, double *data, save_type type, 1014 read_doubles (std::istream& is, double *data, save_type type,
1014 octave_idx_type len, bool swap, 1015 octave_idx_type len, bool swap,
1015 oct_mach_info::float_format fmt) 1016 oct_mach_info::float_format fmt)
1016 { 1017 {
1041 break; 1042 break;
1042 1043
1043 case LS_FLOAT: 1044 case LS_FLOAT:
1044 { 1045 {
1045 OCTAVE_LOCAL_BUFFER (float, ptr, len); 1046 OCTAVE_LOCAL_BUFFER (float, ptr, len);
1046 is.read (reinterpret_cast<char *> (ptr), 4 * len); 1047 std::streamsize n_bytes = 4 * len;
1048 is.read (reinterpret_cast<char *> (ptr), n_bytes);
1047 do_float_format_conversion (ptr, len, fmt); 1049 do_float_format_conversion (ptr, len, fmt);
1048 for (octave_idx_type i = 0; i < len; i++) 1050 for (octave_idx_type i = 0; i < len; i++)
1049 data[i] = ptr[i]; 1051 data[i] = ptr[i];
1050 } 1052 }
1051 break; 1053 break;
1052 1054
1053 case LS_DOUBLE: // No conversion necessary. 1055 case LS_DOUBLE: // No conversion necessary.
1054 { 1056 {
1055 is.read (reinterpret_cast<char *> (data), 8 * len); 1057 std::streamsize n_bytes = 8 * static_cast<std::streamsize> (len);
1058 is.read (reinterpret_cast<char *> (data), n_bytes);
1056 do_double_format_conversion (data, len, fmt); 1059 do_double_format_conversion (data, len, fmt);
1057 1060
1058 for (int i = 0; i < len; i++) 1061 for (int i = 0; i < len; i++)
1059 data[i] = __lo_ieee_replace_old_NA (data[i]); 1062 data[i] = __lo_ieee_replace_old_NA (data[i]);
1060 } 1063 }
1096 case LS_INT: 1099 case LS_INT:
1097 LS_DO_READ (int32_t, swap, data, 4, len, is); 1100 LS_DO_READ (int32_t, swap, data, 4, len, is);
1098 break; 1101 break;
1099 1102
1100 case LS_FLOAT: // No conversion necessary. 1103 case LS_FLOAT: // No conversion necessary.
1101 is.read (reinterpret_cast<char *> (data), 4 * len); 1104 {
1102 do_float_format_conversion (data, len, fmt); 1105 std::streamsize n_bytes = 4 * len;
1106 is.read (reinterpret_cast<char *> (data), n_bytes);
1107 do_float_format_conversion (data, len, fmt);
1108 }
1103 break; 1109 break;
1104 1110
1105 case LS_DOUBLE: 1111 case LS_DOUBLE:
1106 { 1112 {
1107 OCTAVE_LOCAL_BUFFER (double, ptr, len); 1113 OCTAVE_LOCAL_BUFFER (double, ptr, len);
1108 is.read (reinterpret_cast<char *> (ptr), 8 * len); 1114 std::streamsize n_bytes = 8 * len;
1115 is.read (reinterpret_cast<char *> (ptr), n_bytes);
1109 do_double_format_conversion (ptr, len, fmt); 1116 do_double_format_conversion (ptr, len, fmt);
1110 for (octave_idx_type i = 0; i < len; i++) 1117 for (octave_idx_type i = 0; i < len; i++)
1111 data[i] = ptr[i]; 1118 data[i] = ptr[i];
1112 } 1119 }
1113 break; 1120 break;
1154 1161
1155 case LS_DOUBLE: // No conversion necessary. 1162 case LS_DOUBLE: // No conversion necessary.
1156 { 1163 {
1157 char tmp_type = static_cast<char> (type); 1164 char tmp_type = static_cast<char> (type);
1158 os.write (&tmp_type, 1); 1165 os.write (&tmp_type, 1);
1159 os.write (reinterpret_cast <const char *> (data), 8 * len); 1166 std::streamsize n_bytes = 8 * static_cast<std::streamsize> (len);
1167 os.write (reinterpret_cast <const char *> (data), n_bytes);
1160 } 1168 }
1161 break; 1169 break;
1162 1170
1163 default: 1171 default:
1164 (*current_liboctave_error_handler) 1172 (*current_liboctave_error_handler)
1199 1207
1200 case LS_FLOAT: // No conversion necessary. 1208 case LS_FLOAT: // No conversion necessary.
1201 { 1209 {
1202 char tmp_type = static_cast<char> (type); 1210 char tmp_type = static_cast<char> (type);
1203 os.write (&tmp_type, 1); 1211 os.write (&tmp_type, 1);
1204 os.write (reinterpret_cast <const char *> (data), 4 * len); 1212 std::streamsize n_bytes = 4 * len;
1213 os.write (reinterpret_cast <const char *> (data), n_bytes);
1205 } 1214 }
1206 break; 1215 break;
1207 1216
1208 case LS_DOUBLE: 1217 case LS_DOUBLE:
1209 LS_DO_WRITE (double, data, 8, len, os); 1218 LS_DO_WRITE (double, data, 8, len, os);