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

comparison src/ls-mat5.cc @ 11586:12df7854fa7c

strip trailing whitespace from source files

author	John W. Eaton <jwe@octave.org>
date	Thu, 20 Jan 2011 17:24:59 -0500
parents	e306683a7e97
children	4ced6b90fffb

comparison

equal deleted inserted replaced

-:1473d0cf86d2
+:12df7854fa7c
 static void
 read_mat5_binary_data (std::istream& is, double *data,
 octave_idx_type  count, bool swap, mat5_data_type type,
 oct_mach_info::float_format flt_fmt)
 {
 switch (type)
 {
 case miINT8:
 read_doubles (is, data, LS_CHAR, count, swap, flt_fmt);
 break;
 static void
 read_mat5_binary_data (std::istream& is, float *data,
 octave_idx_type  count, bool swap, mat5_data_type type,
 oct_mach_info::float_format flt_fmt)
 {
 switch (type)
 {
 case miINT8:
 read_floats (is, data, LS_CHAR, count, swap, flt_fmt);
 break;
 tc = ctmp;  \
 } \
 else \
 tc = re; \
 }
 // Read one element tag from stream IS,
 // place the type code in TYPE and the byte count in BYTES
 // return nonzero on error
 static int
 read_mat5_tag (std::istream& is, bool swap, int32_t& type, int32_t& bytes)
 {
 // We uncompress the first 8 bytes of the header to get the buffer length
 // This will fail with an error Z_MEM_ERROR
 uLongf destLen = 8;
 OCTAVE_LOCAL_BUFFER (unsigned int, tmp, 2);
 if (uncompress (reinterpret_cast<Bytef *> (tmp), &destLen,
 reinterpret_cast<Bytef *> (inbuf), element_length)
 !=  Z_MEM_ERROR)
 {
 // Why should I have to initialize outbuf as I'll just overwrite!!
 if (swap)
 swap_bytes<4> (tmp, 2);
 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, reinterpret_cast<Bytef *> (inbuf),
 msg.c_str ());
 }
 else
 {
 std::istringstream gz_is (outbuf);
 retval = read_mat5_binary_element (gz_is, filename,
 swap, global, tc);
 }
 }
 else
 error ("load: error probing size of compressed data element");
 global = (flags & 0x0400) != 0; // global variable?
 logicalvar = (flags & 0x0200) != 0; // boolean ?
 arrayclass = static_cast<arrayclasstype> (flags & 0xff);
 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;
 if (len)
 {
 if (! is.read (name, len ))
 goto data_read_error;
 is.seekg (tmp_pos + static_cast<std::streamoff> (PAD (len)));
 }
 name[len] = '\0';
 retval = name;
 data = sm.data ();
 }
 // row indices
 std::streampos tmp_pos;
 if (read_mat5_tag (is, swap, type, len))
 {
 error ("load: reading sparse row data for `%s'", retval.c_str ());
 goto data_read_error;
 }
 // imaginary data subelement
 if (imag)
 {
 NDArray im (dim_vector (static_cast<int> (nnz), 1));
 if (read_mat5_tag (is, swap, type, len))
 {
 error ("load: reading sparse matrix data for `%s'", retval.c_str ());
 goto data_read_error;
 }
 if (fpath.length() == 0)
 // We have a builtin function
 tc = make_fcn_handle (fname);
 else
 {
 std::string mroot =
 m0.contents("matlabroot")(0).string_value();
 if ((fpath.length () >= mroot.length ()) &&
 fpath.substr(0, mroot.length()) == mroot &&
 OCTAVE_EXEC_PREFIX != mroot)
 // doesn't equal octave_config_info ("exec_prefix")
 // then the function points to a version of Octave
 // or Matlab other than the running version. In that
 // case we replace with the same function in the
 // running version of Octave?
 // First check if just replacing matlabroot is enough
 std::string str = OCTAVE_EXEC_PREFIX +
 fpath.substr (mroot.length ());
 file_stat fs (str);
 if (fs.exists ())
 {
 size_t xpos
 std::string dir_name = str.substr (0, xpos);
 octave_function *fcn
 = load_fcn_from_file (str, dir_name, "", fname);
 if (fcn)
 {
 octave_value tmp (fcn);
 tc = octave_value (new octave_fcn_handle (tmp, fname));
 tc = octave_value (new octave_fcn_handle (tmp, fname));
 }
 else
 {
 warning ("load: can't find the file %s",
 fpath.c_str());
 goto skip_ahead;
 }
 }
 }
 tc = octave_value (new octave_fcn_handle (tmp, fname));
 }
 else
 {
 warning ("load: can't find the file %s",
 fpath.c_str());
 goto skip_ahead;
 }
 }
 }
 frame.add_fcn (octave_call_stack::pop);
 if (m2.nfields() > 0)
 {
 octave_value tmp;
 for (Octave_map::iterator p0 = m2.begin() ;
 p0 != m2.end(); p0++)
 {
 std::string key = m2.key(p0);
 octave_value val = m2.contents(p0)(0);
 symbol_table::varref (key, local_scope, 0) = val;
 }
 }
 int parse_status;
 octave_value anon_fcn_handle =
 eval_string (fname.substr (4), true, parse_status);
 if (parse_status == 0)
 {
 octave_fcn_handle *fh =
 anon_fcn_handle.fcn_handle_value ();
 if (fh)
 tc = new octave_fcn_handle (fh->fcn_val (), "@<anonymous>");
 else
 if (fn_len)
 {
 if (! is.read (elname, fn_len))
 goto data_read_error;
 is.seekg (tmp_pos +
 static_cast<std::streamoff> (PAD (fn_len)));
 }
 elname[fn_len] = '\0';
 {
 if (field(i) == "MCOS")
 {
 octave_value fieldtc;
 read_mat5_binary_element (is, filename, swap, global,
 fieldtc);
 if (! is || error_state)
 goto data_read_error;
 elt[i](j) = fieldtc;
 }
 if (len)
 {
 if (! is.read (name, len ))
 goto data_read_error;
 is.seekg (tmp_pos + static_cast<std::streamoff> (PAD (len)));
 }
 name[len] = '\0';
 classname = name;
 {
 for (octave_idx_type i = 0; i < n_fields; i++)
 {
 octave_value fieldtc;
 read_mat5_binary_element (is, filename, swap, global,
 fieldtc);
 elt[i](j) = fieldtc;
 }
 }
 for (octave_idx_type i = 0; i < n_fields; i++)
 {
 if (classname == "inline")
 {
 // inline is not an object in Octave but rather an
 // overload of a function handle. Special case.
 tc =
 new octave_fcn_inline (m.contents("expr")(0).string_value(),
 m.contents("args")(0).string_value());
 }
 else
 {
 cls->reconstruct_exemplar ();
 if (! cls->reconstruct_parents ())
 warning ("load: unable to reconstruct object inheritance");
 tc = cls;
 if (load_path::find_method (classname, "loadobj") !=
 std::string())
 {
 octave_value_list tmp = feval ("loadobj", tc, 1);
 if (! error_state)
 if (logicalvar)
 {
 uint8NDArray in = tc.uint8_array_value ();
 octave_idx_type nel = in.numel ();
 boolNDArray out (dims);
 for (octave_idx_type i = 0; i < nel; i++)
 out (i) = in(i).bool_value ();
 tc = out;
 }
 case MAT_FILE_SINGLE_CLASS:
 {
 FloatNDArray re (dims);
 // real data subelement
 std::streampos tmp_pos;
 if (read_mat5_tag (is, swap, type, len))
 {
 error ("load: reading matrix data for `%s'", retval.c_str ());
 goto data_read_error;
 }
 if (imag)
 {
 // imaginary data subelement
 FloatNDArray im (dims);
 if (read_mat5_tag (is, swap, type, len))
 {
 error ("load: reading matrix data for `%s'", retval.c_str ());
 goto data_read_error;
 }
 case MAT_FILE_DOUBLE_CLASS:
 default:
 {
 NDArray re (dims);
 // real data subelement
 std::streampos tmp_pos;
 if (read_mat5_tag (is, swap, type, len))
 {
 error ("load: reading matrix data for `%s'", retval.c_str ());
 goto data_read_error;
 }
 // Logical variables can either be MAT_FILE_UINT8_CLASS or
 // MAT_FILE_DOUBLE_CLASS, so check if we have a logical
 // variable and convert it.
 boolNDArray out (dims);
 for (octave_idx_type i = 0; i < n; i++)
 out (i) = static_cast<bool> (re (i));
 tc = out;
 }
 else if (imag)
 {
 // imaginary data subelement
 NDArray im (dims);
 if (read_mat5_tag (is, swap, type, len))
 {
 error ("load: reading matrix data for `%s'", retval.c_str ());
 goto data_read_error;
 }
 {
 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 (octave_idx_type i = 0; i < n; i++)
 is.seekg (pos + static_cast<std::streamoff> (element_length));
 return read_mat5_binary_element (is, filename, swap, global, tc);
 }
 int
 read_mat5_binary_file_header (std::istream& is, bool& swap, bool quiet,
 const std::string& filename)
 {
 int16_t version=0, magic=0;
 uint64_t subsys_offset;
 }
 return 0;
 }
 static int
 write_mat5_tag (std::ostream& is, int type, octave_idx_type bytes)
 {
 int32_t temp;
 if (bytes > 0 && bytes <= 4)
 } \
 while (0)
 // 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)
 {
 save_type st = LS_DOUBLE;
 const double *data = m.data ();
 switch (st)
 {
 case LS_U_CHAR:
 MAT5_DO_WRITE (uint8_t, data, nel, os);
 break;
 case LS_U_SHORT:
 MAT5_DO_WRITE (uint16_t, data, nel, os);
 break;
 case LS_U_INT:
 MAT5_DO_WRITE (uint32_t, data, nel, os);
 break;
 case LS_U_LONG:
 MAT5_DO_WRITE (uint64_t, data, nel, os);
 break;
 case LS_CHAR:
 MAT5_DO_WRITE (int8_t, data, nel, os);
 break;
 case LS_SHORT:
 MAT5_DO_WRITE (int16_t, data, nel, os);
 break;
 case LS_INT:
 static char buf[9]="\x00\x00\x00\x00\x00\x00\x00\x00";
 os.write (buf, PAD (len) - len);
 }
 }
 static void
 write_mat5_array (std::ostream& os, const FloatNDArray& m, bool)
 {
 save_type st = LS_FLOAT;
 const float *data = m.data ();
 switch (st)
 {
 case LS_U_CHAR:
 MAT5_DO_WRITE (uint8_t, data, nel, os);
 break;
 case LS_U_SHORT:
 MAT5_DO_WRITE (uint16_t, data, nel, os);
 break;
 case LS_U_INT:
 MAT5_DO_WRITE (uint32_t, data, nel, os);
 break;
 case LS_U_LONG:
 MAT5_DO_WRITE (uint64_t, data, nel, os);
 break;
 case LS_CHAR:
 MAT5_DO_WRITE (int8_t, data, nel, os);
 break;
 case LS_SHORT:
 MAT5_DO_WRITE (int16_t, data, nel, os);
 break;
 case LS_INT:
 os.write (buf, PAD (len) - len);
 }
 }
 template <class T>
 void
 write_mat5_integer_data (std::ostream& os, const T *m, int size,
 octave_idx_type nel)
 {
 mat5_data_type mst;
 unsigned len;
 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)
 {
 octave_idx_type nel = cell.numel ();
 return ret;
 }
 int
 save_mat5_element_length (const octave_value& tc, const std::string& name,
 bool save_as_floats, bool mat7_format)
 {
 size_t max_namelen = (mat7_format ? 63 : 31);
 size_t len = name.length ();
 std::string cname = tc.class_name ();
 if (len > 4)
 ret += PAD (len > max_namelen ? max_namelen : len);
 ret += PAD (4 * tc.ndims ());
 if (tc.is_string ())
 {
 charNDArray chm = tc.char_array_value ();
 ret += 8;
 if (chm.numel () > 2)
 {
 Cell cell = tc.cell_value ();
 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 ())
 {
 if (tc.is_single_type ())
 {
 const FloatComplexNDArray m = tc.float_complex_array_value ();
 ret += save_mat5_array_length (m.fortran_vec (), m.numel (),
 save_as_floats);
 }
 else
 {
 const ComplexNDArray m = tc.complex_array_value ();
 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 ();
 octave_idx_type nel = m.numel ();
 for (Octave_map::const_iterator i = m.begin (); i != m.end (); i++)
 {
 const Cell elts = m.contents (i);
 ret += 8 + save_mat5_element_length (elts(j), "",
 save_as_floats, mat7_format);
 }
 }
 }
 else
 bool
 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 nnz_32 = 0;
 std::string cname = tc.class_name ();
 size_t max_namelen = (mat7_format ? 63 : 31);
 ret = save_mat5_binary_element (buf, tc, name, mark_as_global, true,
 save_as_floats, true);
 if (ret)
 {
 // destLen must be at least 0.1% larger than source buffer
 // + 12 bytes. Reality is it must be larger again than that.
 std::string buf_str = buf.str ();
 uLongf srcLen = buf_str.length ();
 uLongf destLen = srcLen * 101 / 100 + 12;
 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<octave_idx_type> (destLen));
 os.write (out_buf, destLen);
 }
 else
 {
 return ret;
 }
 #endif
 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);
 if (tc.is_bool_type ())
 flags |= 0x0200;
 if (tc.is_single_type ())
 flags |= MAT_FILE_SINGLE_CLASS;
 else
 flags |= MAT_FILE_DOUBLE_CLASS;
 }
 else if (tc.is_map ())
 flags |= MAT_FILE_STRUCT_CLASS;
 else if (tc.is_cell ())
 flags |= MAT_FILE_CELL_CLASS;
 else if (tc.is_inline_function () || tc.is_object ())
 flags |= MAT_FILE_OBJECT_CLASS;
 for (octave_idx_type i = 0; i < nel; i++)
 buf[i] = *s++ & 0x00FF;
 os.write (reinterpret_cast<char *> (buf), len);
 if (paddedlength > len)
 {
 static char padbuf[9]="\x00\x00\x00\x00\x00\x00\x00\x00";
 os.write (padbuf, paddedlength - len);
 }
 Cell cell = tc.cell_value ();
 if (! write_mat5_cell_array (os, cell, mark_as_global, save_as_floats))
 goto error_cleanup;
 }
 else if (tc.is_complex_scalar () || tc.is_complex_matrix ())
 {
 if (tc.is_single_type ())
 {
 FloatComplexNDArray m_cmplx = tc.float_complex_array_value ();
 write_mat5_array (os, ::real (m_cmplx), save_as_floats);
 write_mat5_array (os, ::imag (m_cmplx), save_as_floats);
 }
 }
 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";
 size_t namelen = classname.length ();
 // of the fields.
 for (octave_idx_type i = 0; i < nf; i++)
 {
 bool retval2 = save_mat5_binary_element (os, elts[i][j], "",
 mark_as_global,
 false,
 save_as_floats);
 if (! retval2)
 goto error_cleanup;
 }
 }

Mercurial > octave-nkf

comparison src/ls-mat5.cc @ 11586:12df7854fa7c