octave-nkf: src/ls-mat5.cc comparison

comparison src/ls-mat5.cc @ 10349:d4d13389c957

make load-save to matlab format work when using --enable-64

author	John W. Eaton <jwe@octave.org>
date	Mon, 22 Feb 2010 23:07:21 -0500
parents	57a59eae83cc
children	12884915a8e4

comparison

equal deleted inserted replaced

-:df1df5f0c236
+:d4d13389c957
 // each element before copying to DATA.  FLT_FMT specifies the format
 // of the data if we are reading floating point numbers.
 static void
 read_mat5_binary_data (std::istream& is, double *data,
-int count, bool swap, mat5_data_type type,
+octave_idx_type  count, bool swap, mat5_data_type type,
 oct_mach_info::float_format flt_fmt)
 {
 switch (type)
 {
 }
 }
 template <class T>
 void
-read_mat5_integer_data (std::istream& is, T *m, int count, bool swap,
+read_mat5_integer_data (std::istream& is, T *m, octave_idx_type count,
-mat5_data_type type)
+bool swap, mat5_data_type type)
 {
 #define READ_INTEGER_DATA(TYPE, swap, data, size, len, stream)  \
 do \
 { \
 { \
 OCTAVE_LOCAL_BUFFER (TYPE, ptr, len); \
 stream.read (reinterpret_cast<char *> (ptr), size * len); \
 if (swap) \
 swap_bytes< size > (ptr, len); \
-for (int i = 0; i < len; i++) \
+for (octave_idx_type i = 0; i < len; i++) \
 data[i] = ptr[i]; \
 } \
 } \
 while (0)
 #undef READ_INTEGER_DATA
 }
-template void read_mat5_integer_data (std::istream& is, octave_int8 *m,
+template void
-int count, bool swap,
+read_mat5_integer_data (std::istream& is, octave_int8 *m,
-mat5_data_type type);
+octave_idx_type count, bool swap,
-template void read_mat5_integer_data (std::istream& is, octave_int16 *m,
+mat5_data_type type);
-int count, bool swap,
-mat5_data_type type);
+template void
-template void read_mat5_integer_data (std::istream& is, octave_int32 *m,
+read_mat5_integer_data (std::istream& is, octave_int16 *m,
-int count, bool swap,
+octave_idx_type count, bool swap,
 mat5_data_type type);
-template void read_mat5_integer_data (std::istream& is, octave_int64 *m,
-int count, bool swap,
+template void
-mat5_data_type type);
+read_mat5_integer_data (std::istream& is, octave_int32 *m,
-template void read_mat5_integer_data (std::istream& is, octave_uint8 *m,
+octave_idx_type count, bool swap,
-int count, bool swap,
+mat5_data_type type);
-mat5_data_type type);
-template void read_mat5_integer_data (std::istream& is, octave_uint16 *m,
+template void
-int count, bool swap,
+read_mat5_integer_data (std::istream& is, octave_int64 *m,
-mat5_data_type type);
+octave_idx_type count, bool swap,
-template void read_mat5_integer_data (std::istream& is, octave_uint32 *m,
+mat5_data_type type);
-int count, bool swap,
-mat5_data_type type);
+template void
-template void read_mat5_integer_data (std::istream& is, octave_uint64 *m,
+read_mat5_integer_data (std::istream& is, octave_uint8 *m,
-int count, bool swap,
+octave_idx_type count, bool swap,
 mat5_data_type type);
-template void read_mat5_integer_data (std::istream& is, int *m,
+template void
-int count, bool swap,
+read_mat5_integer_data (std::istream& is, octave_uint16 *m,
-mat5_data_type type);
+octave_idx_type count, bool swap,
+mat5_data_type type);
+template void
+read_mat5_integer_data (std::istream& is, octave_uint32 *m,
+octave_idx_type count, bool swap,
+mat5_data_type type);
+template void
+read_mat5_integer_data (std::istream& is, octave_uint64 *m,
+octave_idx_type count, bool swap,
+mat5_data_type type);
+template void
+read_mat5_integer_data (std::istream& is, int *m,
+octave_idx_type count, bool swap,
+mat5_data_type type);
 #define OCTAVE_MAT5_INTEGER_READ(TYP) \
 { \
 TYP re (dims); \
 \
 { \
 error ("load: reading matrix data for `%s'", retval.c_str ()); \
 goto data_read_error; \
 } \
 \
-int n = re.length (); \
+octave_idx_type n = re.numel (); \
 tmp_pos = is.tellg (); \
 read_mat5_integer_data (is, re.fortran_vec (), n, swap, \
 static_cast<enum mat5_data_type> (type)); \
 \
 if (! is || error_state) \
 error ("load: reading matrix data for `%s'", \
 retval.c_str ()); \
 goto data_read_error; \
 } \
 \
-n = im.length (); \
+n = im.numel (); \
 read_mat5_binary_data (is, im.fortran_vec (), n, swap, \
 static_cast<enum mat5_data_type> (type), flt_fmt); \
 \
 if (! is || error_state) \
 { \
 goto data_read_error; \
 } \
 \
 ComplexNDArray ctmp (dims); \
 \
-for (int i = 0; i < n; i++) \
+for (octave_idx_type i = 0; i < n; i++) \
 ctmp(i) = Complex (re(i).double_value (), im(i)); \
 \
 tc = ctmp;  \
 } \
 else \
 read_mat5_binary_element (std::istream& is, const std::string& filename,
 bool swap, bool& global, octave_value& tc)
 {
 std::string retval;
-// These are initialized here instead of closer to where they are
+global = false;
-// first used to avoid errors from gcc about goto crossing
+// NOTE: these are initialized here instead of closer to where they
+// are first used to avoid errors from gcc about goto crossing
 // initialization of variable.
+bool imag;
+bool isclass = false;
+bool logicalvar;
+dim_vector dims;
+enum arrayclasstype arrayclass;
+int16_t number = *(reinterpret_cast<const int16_t *>("\x00\x01"));
+octave_idx_type nzmax;
+std::string classname;
+// MAT files always use IEEE floating point
 oct_mach_info::float_format flt_fmt = oct_mach_info::flt_fmt_unknown;
-int32_t type = 0;
-std::string classname;
-bool isclass = false;
-bool imag;
-bool logicalvar;
-enum arrayclasstype arrayclass;
-int32_t nzmax;
-int32_t flags;
-dim_vector dims;
-int32_t len;
-int32_t element_length;
-std::streampos pos;
-int16_t number;
-number = *(reinterpret_cast<const int16_t *>("\x00\x01"));
-global = false;
-// MAT files always use IEEE floating point
 if ((number == 1) ^ swap)
 flt_fmt = oct_mach_info::flt_fmt_ieee_big_endian;
 else
 flt_fmt = oct_mach_info::flt_fmt_ieee_little_endian;
 // element type and length
+int32_t type = 0;
+int32_t element_length;
 if (read_mat5_tag (is, swap, type, element_length))
 return retval;                      // EOF
 #ifdef HAVE_ZLIB
 if (type == miCOMPRESSED)
 {
-// If C++ allowed us direct access to the file descriptor of an ifstream
+// If C++ allowed us direct access to the file descriptor of an
-// in a uniform way, the code below could be vastly simplified, and
+// ifstream in a uniform way, the code below could be vastly
-// additional copies of the data in memory wouldn't be needed!!
+// simplified, and additional copies of the data in memory
+// wouldn't be needed.
 OCTAVE_LOCAL_BUFFER (char, inbuf, element_length);
 is.read (inbuf, element_length);
 // We uncompress the first 8 bytes of the header to get the buffer length
 destLen = tmp[1] + 8;
 std::string outbuf (destLen, ' ');
 // FIXME -- find a way to avoid casting away const here!
-int err = uncompress (reinterpret_cast<Bytef *> (const_cast<char *> (outbuf.c_str ())), &destLen,
+int err = uncompress (reinterpret_cast<Bytef *> (const_cast<char *> (outbuf.c_str ())),
-reinterpret_cast<Bytef *> (inbuf), element_length);
+&destLen, reinterpret_cast<Bytef *> (inbuf),
+element_length);
 if (err != Z_OK)
 error ("load: error uncompressing data element");
 else
 {
 return retval;
 }
 #endif
+std::streampos pos;
 if (type != miMATRIX)
 {
 pos = is.tellg ();
 error ("load: invalid element type = %d", type);
 goto early_read_error;
 }
 pos = is.tellg ();
 // array flags subelement
+int32_t len;
 if (read_mat5_tag (is, swap, type, len) || type != miUINT32 || len != 8)
 {
 error ("load: invalid array flags subelement");
 goto early_read_error;
 }
+int32_t flags;
 read_int (is, swap, flags);
 imag = (flags & 0x0800) != 0; // has an imaginary part?
 global = (flags & 0x0400) != 0; // global variable?
 logicalvar = (flags & 0x0200) != 0; // boolean ?
 arrayclass = static_cast<arrayclasstype> (flags & 0xff);
-read_int (is, swap, nzmax);   // max number of non-zero in sparse
+int32_t tmp_nzmax;
+read_int (is, swap, tmp_nzmax);   // max number of non-zero in sparse
+nzmax = tmp_nzmax;
 // dimensions array subelement
 if (arrayclass != MAT_FILE_WORKSPACE_CLASS)
 {
 int32_t dim_len;
 {
 case MAT_FILE_CELL_CLASS:
 {
 Cell cell_array (dims);
-int n = cell_array.length ();
+octave_idx_type n = cell_array.numel ();
-for (int i = 0; i < n; i++)
+for (octave_idx_type i = 0; i < n; i++)
 {
 octave_value tc2;
 std::string nm
 = read_mat5_binary_element (is, filename, swap, global, tc2);
 tc = cell_array;
 }
 break;
 case MAT_FILE_SPARSE_CLASS:
-#if SIZEOF_INT != SIZEOF_OCTAVE_IDX_TYPE
-warning ("load: sparse objects are not implemented");
-goto skip_ahead;
-#else
 {
-int nr = dims(0);
+octave_idx_type nr = dims(0);
-int nc = dims(1);
+octave_idx_type nc = dims(1);
 SparseMatrix sm;
 SparseComplexMatrix scm;
-int *ridx;
+octave_idx_type *ridx;
-int *cidx;
+octave_idx_type *cidx;
 double *data;
 // Setup return value
 if (imag)
 {
-scm = SparseComplexMatrix (static_cast<octave_idx_type> (nr),
+scm = SparseComplexMatrix (nr, nc, nzmax);
-static_cast<octave_idx_type> (nc),
-static_cast<octave_idx_type> (nzmax));
 ridx = scm.ridx ();
 cidx = scm.cidx ();
 data = 0;
 }
 else
 {
-sm = SparseMatrix (static_cast<octave_idx_type> (nr),
+sm = SparseMatrix (nr, nc, nzmax);
-static_cast<octave_idx_type> (nc),
-static_cast<octave_idx_type> (nzmax));
 ridx = sm.ridx ();
 cidx = sm.cidx ();
 data = sm.data ();
 }
 {
 error ("load: reading sparse matrix data for `%s'", retval.c_str ());
 goto data_read_error;
 }
-int32_t nnz = cidx[nc];
+octave_idx_type nnz = cidx[nc];
 NDArray re;
 if (imag)
 {
-re = NDArray (dim_vector (static_cast<int> (nnz)));
+re = NDArray (dim_vector (nnz));
 data = re.fortran_vec ();
 }
 tmp_pos = is.tellg ();
 read_mat5_binary_data (is, data, nnz, swap,
 error ("load: reading imaginary sparse matrix data for `%s'",
 retval.c_str ());
 goto data_read_error;
 }
-for (int i = 0; i < nnz; i++)
+for (octave_idx_type i = 0; i < nnz; i++)
 scm.xdata (i) = Complex (re (i), im (i));
 tc = scm;
 }
 else
 tc = sm;
 }
-#endif
 break;
 case MAT_FILE_FUNCTION_CLASS:
 {
 octave_value tc2;
 // variable and convert it.
 if (logicalvar)
 {
 uint8NDArray in = tc.uint8_array_value ();
-int nel = in.nelem ();
+octave_idx_type nel = in.numel ();
 boolNDArray out (dims);
-for (int i = 0; i < nel; i++)
+for (octave_idx_type i = 0; i < nel; i++)
 out (i) = in(i).bool_value ();
 tc = out;
 }
 }
 {
 error ("load: reading matrix data for `%s'", retval.c_str ());
 goto data_read_error;
 }
-int n = re.length ();
+octave_idx_type n = re.numel ();
 tmp_pos = is.tellg ();
 read_mat5_binary_data (is, re.fortran_vec (), n, swap,
 static_cast<enum mat5_data_type> (type), flt_fmt);
 if (! is || error_state)
 // MAT_FILE_DOUBLE_CLASS, so check if we have a logical
 // variable and convert it.
 boolNDArray out (dims);
-for (int i = 0; i < n; i++)
+for (octave_idx_type i = 0; i < n; i++)
 out (i) = static_cast<bool> (re (i));
 tc = out;
 }
 else if (imag)
 {
 error ("load: reading matrix data for `%s'", retval.c_str ());
 goto data_read_error;
 }
-n = im.length ();
+n = im.numel ();
 read_mat5_binary_data (is, im.fortran_vec (), n, swap,
 static_cast<enum mat5_data_type> (type), flt_fmt);
 if (! is || error_state)
 {
 goto data_read_error;
 }
 ComplexNDArray ctmp (dims);
-for (int i = 0; i < n; i++)
+for (octave_idx_type i = 0; i < n; i++)
 ctmp(i) = Complex (re(i), im(i));
 tc = ctmp;
 }
 else
 if (arrayclass == MAT_FILE_CHAR_CLASS)
 {
 if (type == miUTF16 || type == miUTF32)
 {
 bool found_big_char = false;
-for (int i = 0; i < n; i++)
+for (octave_idx_type i = 0; i < n; i++)
 {
 if (re(i) > 127) {
 re(i) = '?';
 found_big_char = true;
 }
 {
 // Search for multi-byte encoded UTF8 characters and
 // replace with 0x3F for '?'... Give the user a warning
 bool utf8_multi_byte = false;
-for (int i = 0; i < n; i++)
+for (octave_idx_type i = 0; i < n; i++)
 {
 unsigned char a = static_cast<unsigned char> (re(i));
 if (a > 0x7f)
 utf8_multi_byte = true;
 }
 if (utf8_multi_byte)
 {
 warning ("load: can not read multi-byte encoded UTF8 characters.");
 warning ("      Replacing unreadable characters with '?'.");
-for (int i = 0; i < n; i++)
+for (octave_idx_type i = 0; i < n; i++)
 {
 unsigned char a = static_cast<unsigned char> (re(i));
 if (a > 0x7f)
 re(i) = '?';
 }
 return -1;
 if (tc.is_uint8_type ())
 {
 const uint8NDArray itmp = tc.uint8_array_value();
-octave_idx_type ilen = itmp.nelem ();
+octave_idx_type ilen = itmp.numel ();
 // Why should I have to initialize outbuf as just overwrite
 std::string outbuf (ilen - 7, ' ');
 // FIXME -- find a way to avoid casting away const here
 return 0;
 }
 static int
-write_mat5_tag (std::ostream& is, int type, int bytes)
+write_mat5_tag (std::ostream& is, int type, octave_idx_type bytes)
 {
 int32_t temp;
 if (bytes > 0 && bytes <= 4)
 temp = (bytes << 16) + type;
 // write out the numeric values in M to OS,
 // preceded by the appropriate tag.
 static void
 write_mat5_array (std::ostream& os, const NDArray& m, bool save_as_floats)
 {
-int nel = m.nelem ();
-double max_val, min_val;
 save_type st = LS_DOUBLE;
-mat5_data_type mst;
-int size;
-unsigned len;
 const double *data = m.data ();
 // Have to use copy here to avoid writing over data accessed via
 // Matrix::data().
 #define MAT5_DO_WRITE(TYPE, data, count, stream) \
 do \
 { \
 OCTAVE_LOCAL_BUFFER (TYPE, ptr, count); \
-for (int i = 0; i < count; i++) \
+for (octave_idx_type i = 0; i < count; i++) \
 ptr[i] = static_cast<TYPE> (data[i]); \
 stream.write (reinterpret_cast<char *> (ptr), count * sizeof (TYPE)); \
 } \
 while (0)
 }
 else
 st = LS_FLOAT;
 }
+double max_val, min_val;
 if (m.all_integers (max_val, min_val))
 st = get_save_type (max_val, min_val);
+mat5_data_type mst;
+int size;
 switch (st)
 {
 default:
 case LS_DOUBLE:  mst = miDOUBLE; size = 8; break;
 case LS_FLOAT:   mst = miSINGLE; size = 4; break;
 case LS_CHAR:    mst = miINT8;   size = 1; break;
 case LS_SHORT:   mst = miINT16;  size = 2; break;
 case LS_INT:     mst = miINT32;  size = 4; break;
 }
-len = nel*size;
+octave_idx_type nel = m.numel ();
+octave_idx_type len = nel*size;
 write_mat5_tag (os, mst, len);
 {
 switch (st)
 {
 }
 }
 template <class T>
 void
-write_mat5_integer_data (std::ostream& os, const T *m, int size, int nel)
+write_mat5_integer_data (std::ostream& os, const T *m, int size,
+octave_idx_type nel)
 {
 mat5_data_type mst;
 unsigned len;
 switch (size)
 static char buf[9]="\x00\x00\x00\x00\x00\x00\x00\x00";
 os.write (buf, PAD (len) - len);
 }
 }
-template void write_mat5_integer_data (std::ostream& os, const octave_int8 *m,
+template void
-int size, int nel);
+write_mat5_integer_data (std::ostream& os, const octave_int8 *m,
-template void write_mat5_integer_data (std::ostream& os, const octave_int16 *m,
+int size, octave_idx_type nel);
-int size, int nel);
-template void write_mat5_integer_data (std::ostream& os, const octave_int32 *m,
+template void
-int size, int nel);
+write_mat5_integer_data (std::ostream& os, const octave_int16 *m,
-template void write_mat5_integer_data (std::ostream& os, const octave_int64 *m,
+int size, octave_idx_type nel);
-int size, int nel);
-template void write_mat5_integer_data (std::ostream& os, const octave_uint8 *m,
+template void
-int size, int nel);
+write_mat5_integer_data (std::ostream& os, const octave_int32 *m,
-template void write_mat5_integer_data (std::ostream& os, const octave_uint16 *m,
+int size, octave_idx_type nel);
-int size, int nel);
-template void write_mat5_integer_data (std::ostream& os, const octave_uint32 *m,
+template void
-int size, int nel);
+write_mat5_integer_data (std::ostream& os, const octave_int64 *m,
-template void write_mat5_integer_data (std::ostream& os, const octave_uint64 *m,
+int size, octave_idx_type nel);
-int size, int nel);
-template void write_mat5_integer_data (std::ostream& os, const int *m,
+template void
-int size, int nel);
+write_mat5_integer_data (std::ostream& os, const octave_uint8 *m,
+int size, octave_idx_type nel);
+template void
+write_mat5_integer_data (std::ostream& os, const octave_uint16 *m,
+int size, octave_idx_type nel);
+template void
+write_mat5_integer_data (std::ostream& os, const octave_uint32 *m,
+int size, octave_idx_type nel);
+template void
+write_mat5_integer_data (std::ostream& os, const octave_uint64 *m,
+int size, octave_idx_type nel);
+template void
+write_mat5_integer_data (std::ostream& os, const int *m,
+int size, octave_idx_type nel);
 // Write out cell element values in the cell array to OS, preceded by
 // the appropriate tag.
 static bool
 write_mat5_cell_array (std::ostream& os, const Cell& cell,
 bool mark_as_global, bool save_as_floats)
 {
-int nel = cell.nelem ();
+octave_idx_type nel = cell.numel ();
-for (int i = 0; i < nel; i++)
+for (octave_idx_type i = 0; i < nel; i++)
 {
 octave_value ov = cell(i);
 if (! save_mat5_binary_element (os, ov, "", mark_as_global,
 false, save_as_floats))
 return true;
 }
 int
-save_mat5_array_length (const double* val, int nel, bool save_as_floats)
+save_mat5_array_length (const double* val, octave_idx_type nel,
+bool save_as_floats)
 {
 if (nel > 0)
 {
 int size = 8;
 if (save_as_floats)
 {
 bool too_large_for_float = false;
-for (int i = 0; i < nel; i++)
+for (octave_idx_type i = 0; i < nel; i++)
 {
 double tmp = val [i];
 if (! (xisnan (tmp) || xisinf (tmp))
 && fabs (tmp) > FLT_MAX)
 else
 return 8;
 }
 int
-save_mat5_array_length (const Complex* val, int nel, bool save_as_floats)
+save_mat5_array_length (const Complex* val, octave_idx_type nel,
+bool save_as_floats)
 {
 int ret;
 OCTAVE_LOCAL_BUFFER (double, tmp, nel);
-for (int i = 1; i < nel; i++)
+for (octave_idx_type i = 1; i < nel; i++)
 tmp[i] = std::real (val[i]);
 ret = save_mat5_array_length (tmp, nel, save_as_floats);
-for (int i = 1; i < nel; i++)
+for (octave_idx_type i = 1; i < nel; i++)
 tmp[i] = std::imag (val[i]);
 ret += save_mat5_array_length (tmp, nel, save_as_floats);
 return ret;
 int
 save_mat5_element_length (const octave_value& tc, const std::string& name,
 bool save_as_floats, bool mat7_format)
 {
-int max_namelen = (mat7_format ? 63 : 31);
+size_t max_namelen = (mat7_format ? 63 : 31);
-int len = name.length ();
+size_t len = name.length ();
 std::string cname = tc.class_name ();
 int ret = 32;
 if (len > 4)
 ret += PAD (len > max_namelen ? max_namelen : len);
 if (tc.is_string ())
 {
 charNDArray chm = tc.char_array_value ();
 ret += 8;
-if (chm.nelem () > 2)
+if (chm.numel () > 2)
-ret += PAD (2 * chm.nelem ());
+ret += PAD (2 * chm.numel ());
 }
 else if (tc.is_sparse_type ())
 {
 if (tc.is_complex_type ())
 {
 SparseComplexMatrix m = tc.sparse_complex_matrix_value ();
-int nc = m.cols ();
+octave_idx_type nc = m.cols ();
-int nnz = m.nzmax ();
+octave_idx_type nnz = m.nzmax ();
 ret += 16 + PAD (nnz * sizeof (int)) + PAD ((nc + 1) * sizeof (int)) +
-save_mat5_array_length (m.data (), m.nelem (), save_as_floats);
+save_mat5_array_length (m.data (), nnz, save_as_floats);
 }
 else
 {
 SparseMatrix m = tc.sparse_matrix_value ();
-int nc = m.cols ();
+octave_idx_type nc = m.cols ();
-int nnz = m.nzmax ();
+octave_idx_type nnz = m.nzmax ();
 ret += 16 + PAD (nnz * sizeof (int)) + PAD ((nc + 1) * sizeof (int)) +
-save_mat5_array_length (m.data (), m.nelem (), save_as_floats);
+save_mat5_array_length (m.data (), nnz, save_as_floats);
 }
 }
 #define INT_LEN(nel, size) \
 { \
 ret += 8; \
-int sz = nel * size; \
+octave_idx_type sz = nel * size; \
 if (sz > 4) \
 ret += PAD (sz);  \
 }
 else if (cname == "int8")
-INT_LEN (tc.int8_array_value ().nelem (), 1)
+INT_LEN (tc.int8_array_value ().numel (), 1)
 else if (cname == "int16")
-INT_LEN (tc.int16_array_value ().nelem (), 2)
+INT_LEN (tc.int16_array_value ().numel (), 2)
 else if (cname == "int32")
-INT_LEN (tc.int32_array_value ().nelem (), 4)
+INT_LEN (tc.int32_array_value ().numel (), 4)
 else if (cname == "int64")
-INT_LEN (tc.int64_array_value ().nelem (), 8)
+INT_LEN (tc.int64_array_value ().numel (), 8)
 else if (cname == "uint8")
-INT_LEN (tc.uint8_array_value ().nelem (), 1)
+INT_LEN (tc.uint8_array_value ().numel (), 1)
 else if (cname == "uint16")
-INT_LEN (tc.uint16_array_value ().nelem (), 2)
+INT_LEN (tc.uint16_array_value ().numel (), 2)
 else if (cname == "uint32")
-INT_LEN (tc.uint32_array_value ().nelem (), 4)
+INT_LEN (tc.uint32_array_value ().numel (), 4)
 else if (cname == "uint64")
-INT_LEN (tc.uint64_array_value ().nelem (), 8)
+INT_LEN (tc.uint64_array_value ().numel (), 8)
 else if (tc.is_bool_type ())
-INT_LEN (tc.bool_array_value ().nelem (), 1)
+INT_LEN (tc.bool_array_value ().numel (), 1)
 else if (tc.is_real_scalar () || tc.is_real_matrix () || tc.is_range ())
 {
 NDArray m = tc.array_value ();
-ret += save_mat5_array_length (m.fortran_vec (), m.nelem (),
+ret += save_mat5_array_length (m.fortran_vec (), m.numel (),
 save_as_floats);
 }
 else if (tc.is_cell ())
 {
 Cell cell = tc.cell_value ();
-int nel = cell.nelem ();
+octave_idx_type nel = cell.numel ();
 for (int i = 0; i < nel; i++)
 ret += 8 +
 save_mat5_element_length (cell (i), "", save_as_floats, mat7_format);
 }
 else if (tc.is_complex_scalar () || tc.is_complex_matrix ())
 {
 ComplexNDArray m = tc.complex_array_value ();
-ret += save_mat5_array_length (m.fortran_vec (), m.nelem (),
+ret += save_mat5_array_length (m.fortran_vec (), m.numel (),
 save_as_floats);
 }
 else if (tc.is_map () || tc.is_inline_function () || tc.is_object ())
 {
 int fieldcnt = 0;
 const Octave_map m = tc.map_value ();
-int nel = m.numel ();
+octave_idx_type nel = m.numel ();
 if (tc.is_inline_function ())
 // length of "inline" is 6
 ret += 8 + PAD (6 > max_namelen ? max_namelen : 6);
 else if (tc.is_object ())
 {
-int classlen = tc.class_name (). length ();
+size_t classlen = tc.class_name (). length ();
 ret += 8 + PAD (classlen > max_namelen ? max_namelen : classlen);
 }
 for (Octave_map::const_iterator i = m.begin (); i != m.end (); i++)
 fieldcnt++;
 ret += 16 + fieldcnt * (max_namelen + 1);
-for (int j = 0; j < nel; j++)
+for (octave_idx_type j = 0; j < nel; j++)
 {
 for (Octave_map::const_iterator i = m.begin (); i != m.end (); i++)
 {
 const Cell elts = m.contents (i);
 }
 else
 ret = -1;
 return ret;
+}
+static void
+write_mat5_sparse_index_vector (std::ostream& os,
+const octave_idx_type *idx,
+octave_idx_type nel)
+{
+int tmp = sizeof (int);
+OCTAVE_LOCAL_BUFFER (int32_t, tmp_idx, nel);
+for (octave_idx_type i = 0; i < nel; i++)
+tmp_idx[i] = idx[i];
+write_mat5_integer_data (os, tmp_idx, -tmp, nel);
+}
+static void
+gripe_dim_too_large (const std::string& name)
+{
+warning ("save: skipping %s: dimension too large for MAT format",
+name.c_str ());
 }
 // save the data from TC along with the corresponding NAME on stream
 // OS in the MatLab version 5 binary format.  Return true on success.
 save_mat5_binary_element (std::ostream& os,
 const octave_value& tc, const std::string& name,
 bool mark_as_global, bool mat7_format,
 bool save_as_floats, bool compressing)
 {
-int32_t flags=0;
+int32_t flags = 0;
-int32_t nnz=0;
+int32_t nnz_32 = 0;
-std::streampos fixup, contin;
 std::string cname = tc.class_name ();
-int max_namelen = (mat7_format ? 63 : 31);
+size_t max_namelen = (mat7_format ? 63 : 31);
+dim_vector dv = tc.dims ();
+int nd = tc.ndims ();
+int dim_len = 4*nd;
+static octave_idx_type max_dim_val = std::numeric_limits<int32_t>::max ();
+for (int i = 0; i < nd; i++)
+{
+if (dv(i) > max_dim_val)
+{
+gripe_dim_too_large (name);
+goto skip_to_next;
+}
+}
+if (tc.is_sparse_type ())
+{
+octave_idx_type nnz;
+octave_idx_type nc;
+if (tc.is_complex_type ())
+{
+SparseComplexMatrix scm = tc.sparse_complex_matrix_value ();
+nnz = scm.nzmax ();
+nc = scm.cols ();
+}
+else
+{
+SparseMatrix sm = tc.sparse_matrix_value ();
+nnz = sm.nzmax ();
+nc = sm.cols ();
+}
+if (nnz > max_dim_val || nc + 1 > max_dim_val)
+{
+gripe_dim_too_large (name);
+goto skip_to_next;
+}
+nnz_32 = nnz;
+}
+else if (dv.numel () > max_dim_val)
+{
+gripe_dim_too_large (name);
+goto skip_to_next;
+}
 #ifdef HAVE_ZLIB
 if (mat7_format && !compressing)
 {
 bool ret = false;
 OCTAVE_LOCAL_BUFFER (char, out_buf, destLen);
 if (compress (reinterpret_cast<Bytef *> (out_buf), &destLen,
 reinterpret_cast<const Bytef *> (buf_str.c_str ()), srcLen) == Z_OK)
 {
-write_mat5_tag (os, miCOMPRESSED, static_cast<int> (destLen));
+write_mat5_tag (os, miCOMPRESSED,
+static_cast<octave_idx_type> (destLen));
 os.write (out_buf, destLen);
 }
 else
 {
 error ("save: error compressing data element");
 return ret;
 }
 #endif
-// element type and length
-fixup = os.tellp ();
 write_mat5_tag (os, miMATRIX, save_mat5_element_length
 (tc, name, save_as_floats, mat7_format));
 // array flags subelement
 write_mat5_tag (os, miUINT32, 8);
 else if (cname == "uint32")
 flags |= MAT_FILE_UINT32_CLASS;
 else if (cname == "uint64")
 flags |= MAT_FILE_UINT64_CLASS;
 else if (tc.is_sparse_type ())
-{
+flags |= MAT_FILE_SPARSE_CLASS;
-flags |= MAT_FILE_SPARSE_CLASS;
-if (tc.is_complex_type ())
-{
-SparseComplexMatrix scm = tc.sparse_complex_matrix_value ();
-nnz = scm.nzmax ();
-}
-else
-{
-SparseMatrix sm = tc.sparse_matrix_value ();
-nnz = sm.nzmax ();
-}
-}
 else if (tc.is_real_scalar ())
 flags |= MAT_FILE_DOUBLE_CLASS;
 else if (tc.is_real_matrix () || tc.is_range ())
 flags |= MAT_FILE_DOUBLE_CLASS;
 else if (tc.is_complex_scalar ())
 gripe_wrong_type_arg ("save", tc, false);
 goto error_cleanup;
 }
 os.write (reinterpret_cast<char *> (&flags), 4);
-os.write (reinterpret_cast<char *> (&nnz), 4);
+os.write (reinterpret_cast<char *> (&nnz_32), 4);
-{
+write_mat5_tag (os, miINT32, dim_len);
-dim_vector dv = tc.dims ();
-int nd = tc.ndims ();
+for (int i = 0; i < nd; i++)
-int dim_len = 4*nd;
+{
+int32_t n = dv(i);
-write_mat5_tag (os, miINT32, dim_len);
+os.write (reinterpret_cast<char *> (&n), 4);
+}
-for (int i = 0; i < nd; i++)
-{
+if (PAD (dim_len) > dim_len)
-int32_t n = dv(i);
+{
-os.write (reinterpret_cast<char *> (&n), 4);
+static char buf[9]="\x00\x00\x00\x00\x00\x00\x00\x00";
-}
+os.write (buf, PAD (dim_len) - dim_len);
+}
-if (PAD (dim_len) > dim_len)
-{
-static char buf[9]="\x00\x00\x00\x00\x00\x00\x00\x00";
-os.write (buf, PAD (dim_len) - dim_len);
-}
-}
 // array name subelement
 {
-int namelen = name.length ();
+size_t namelen = name.length ();
 if (namelen > max_namelen)
 namelen = max_namelen; // only 31 or 63 char names permitted in mat file
 int paddedlength = PAD (namelen);
 // data element
 if (tc.is_string ())
 {
 charNDArray chm = tc.char_array_value ();
-int nel = chm.nelem ();
+octave_idx_type nel = chm.numel ();
-int len = nel*2;
+octave_idx_type len = nel*2;
-int paddedlength = PAD (len);
+octave_idx_type paddedlength = PAD (len);
 OCTAVE_LOCAL_BUFFER (int16_t, buf, nel+3);
 write_mat5_tag (os, miUINT16, len);
 const char *s = chm.data ();
-for (int i = 0; i < nel; i++)
+for (octave_idx_type i = 0; i < nel; i++)
 buf[i] = *s++ & 0x00FF;
 os.write (reinterpret_cast<char *> (buf), len);
 if (paddedlength > len)
 else if (tc.is_sparse_type ())
 {
 if (tc.is_complex_type ())
 {
 SparseComplexMatrix m = tc.sparse_complex_matrix_value ();
-int nc = m.cols ();
+octave_idx_type nnz = m.nnz ();
+octave_idx_type nc = m.cols ();
-int tmp = sizeof (int);
+write_mat5_sparse_index_vector (os, m.ridx (), nnz);
-write_mat5_integer_data (os, m.ridx (), -tmp, nnz);
+write_mat5_sparse_index_vector (os, m.cidx (), nc + 1);
-write_mat5_integer_data (os, m.cidx (), -tmp, nc + 1);
 NDArray buf (dim_vector (nnz, 1));
-for (int i = 0; i < nnz; i++)
+for (octave_idx_type i = 0; i < nnz; i++)
 buf (i) = std::real (m.data (i));
 write_mat5_array (os, buf, save_as_floats);
-for (int i = 0; i < nnz; i++)
+for (octave_idx_type i = 0; i < nnz; i++)
 buf (i) = std::imag (m.data (i));
 write_mat5_array (os, buf, save_as_floats);
 }
 else
 {
 SparseMatrix m = tc.sparse_matrix_value ();
-int nc = m.cols ();
+octave_idx_type nnz = m.nnz ();
+octave_idx_type nc = m.cols ();
-int tmp = sizeof (int);
+write_mat5_sparse_index_vector (os, m.ridx (), nnz);
-write_mat5_integer_data (os, m.ridx (), -tmp, nnz);
+write_mat5_sparse_index_vector (os, m.cidx (), nc + 1);
-write_mat5_integer_data (os, m.cidx (), -tmp, nc + 1);
 // FIXME
 // Is there a way to easily do without this buffer
 NDArray buf (dim_vector (nnz, 1));
 }
 else if (cname == "int8")
 {
 int8NDArray m = tc.int8_array_value ();
-write_mat5_integer_data (os, m.fortran_vec (), -1, m.nelem ());
+write_mat5_integer_data (os, m.fortran_vec (), -1, m.numel ());
 }
 else if (cname == "int16")
 {
 int16NDArray m = tc.int16_array_value ();
-write_mat5_integer_data (os, m.fortran_vec (), -2, m.nelem ());
+write_mat5_integer_data (os, m.fortran_vec (), -2, m.numel ());
 }
 else if (cname == "int32")
 {
 int32NDArray m = tc.int32_array_value ();
-write_mat5_integer_data (os, m.fortran_vec (), -4, m.nelem ());
+write_mat5_integer_data (os, m.fortran_vec (), -4, m.numel ());
 }
 else if (cname == "int64")
 {
 int64NDArray m = tc.int64_array_value ();
-write_mat5_integer_data (os, m.fortran_vec (), -8, m.nelem ());
+write_mat5_integer_data (os, m.fortran_vec (), -8, m.numel ());
 }
 else if (cname == "uint8")
 {
 uint8NDArray m = tc.uint8_array_value ();
-write_mat5_integer_data (os, m.fortran_vec (), 1, m.nelem ());
+write_mat5_integer_data (os, m.fortran_vec (), 1, m.numel ());
 }
 else if (cname == "uint16")
 {
 uint16NDArray m = tc.uint16_array_value ();
-write_mat5_integer_data (os, m.fortran_vec (), 2, m.nelem ());
+write_mat5_integer_data (os, m.fortran_vec (), 2, m.numel ());
 }
 else if (cname == "uint32")
 {
 uint32NDArray m = tc.uint32_array_value ();
-write_mat5_integer_data (os, m.fortran_vec (), 4, m.nelem ());
+write_mat5_integer_data (os, m.fortran_vec (), 4, m.numel ());
 }
 else if (cname == "uint64")
 {
 uint64NDArray m = tc.uint64_array_value ();
-write_mat5_integer_data (os, m.fortran_vec (), 8, m.nelem ());
+write_mat5_integer_data (os, m.fortran_vec (), 8, m.numel ());
 }
 else if (tc.is_bool_type ())
 {
 uint8NDArray m (tc.bool_array_value ());
-write_mat5_integer_data (os, m.fortran_vec (), 1, m.nelem ());
+write_mat5_integer_data (os, m.fortran_vec (), 1, m.numel ());
 }
 else if (tc.is_real_scalar () || tc.is_real_matrix () || tc.is_range ())
 {
 NDArray m = tc.array_value ();
 else if (tc.is_map () || tc.is_inline_function() || tc.is_object ())
 {
 if (tc.is_inline_function () || tc.is_object ())
 {
 std::string classname = tc.is_object() ? tc.class_name () : "inline";
-int namelen = classname.length ();
+size_t namelen = classname.length ();
 if (namelen > max_namelen)
 namelen = max_namelen; // only 31 or 63 char names permitted
 int paddedlength = PAD (namelen);
 char buf[64];
 int32_t maxfieldnamelength = max_namelen + 1;
 octave_idx_type nf = m.nfields ();
-int fieldcnt = nf;
 write_mat5_tag (os, miINT32, 4);
 os.write (reinterpret_cast<char *> (&maxfieldnamelength), 4);
-write_mat5_tag (os, miINT8, fieldcnt*maxfieldnamelength);
+write_mat5_tag (os, miINT8, nf*maxfieldnamelength);
 // Iterating over the list of keys will preserve the order of
 // the fields.
 string_vector keys = m.keys ();
 // only 31 or 63 char names permitted
 strncpy (buf, key.c_str (), max_namelen);
 os.write (buf, max_namelen + 1);
 }
-int len = m.numel ();
+octave_idx_type len = m.numel ();
 // Create temporary copy of structure contents to avoid
 // multiple calls of the contents method.
 std::vector<const octave_value *> elts (nf);
 for (octave_idx_type i = 0; i < nf; i++)
 elts[i] = m.contents (keys(i)).data ();
-for (int j = 0; j < len; j++)
+for (octave_idx_type j = 0; j < len; j++)
 {
 // write the data of each element
 // Iterating over the list of keys will preserve the order
 // of the fields.
 }
 }
 else
 gripe_wrong_type_arg ("save", tc, false);
-contin = os.tellp ();
+skip_to_next:
 return true;
 error_cleanup:
 error ("save: error while writing `%s' to MAT file", name.c_str ());

Mercurial > hg > octave-nkf

comparison src/ls-mat5.cc @ 10349:d4d13389c957