/*

 Copyright (C) 1996, 1997, 1998, 2000, 2001, 2002, 2003, 2004, 2005,

               2006, 2007 John W. Eaton

 This file is part of Octave.

 Octave is free software; you can redistribute it and/or modify it

 under the terms of the GNU General Public License as published by the

 Free Software Foundation; either version 3 of the License, or (at your

 option) any later version.

 Octave is distributed in the hope that it will be useful, but WITHOUT

 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 for more details.

 You should have received a copy of the GNU General Public License

 along with Octave; see the file COPYING.  If not, see

 <http://www.gnu.org/licenses/>.

 */

 #ifdef HAVE_CONFIG_H

 #include <config.h>

 #endif

 #include <iostream>

 #include <vector>

 #include "data-conv.h"

 #include "lo-ieee.h"

 #include "mach-info.h"

 #include "mx-base.h"

 #include "defun.h"

 #include "byte-swap.h"

 #include "gripes.h"

 #include "ls-oct-ascii.h"

 #include "ls-hdf5.h"

 #include "ls-utils.h"

 #include "oct-obj.h"

 #include "oct-stream.h"

 #include "ops.h"

 #include "ov-scalar.h"

 #include "ov-re-mat.h"

 #include "ov-str-mat.h"

 #include "pr-output.h"

 #include "pt-mat.h"

 #include "utils.h"

 #include "ls-ascii-helper.h"

 DEFINE_OCTAVE_ALLOCATOR (octave_char_matrix_str);

 DEFINE_OCTAVE_ALLOCATOR (octave_char_matrix_sq_str);

 DEFINE_OV_TYPEID_FUNCTIONS_AND_DATA (octave_char_matrix_str, "string", "char");

 DEFINE_OV_TYPEID_FUNCTIONS_AND_DATA (octave_char_matrix_sq_str, "sq_string", "char");

 static octave_base_value *

 default_numeric_conversion_function (const octave_base_value& a)

 {

   octave_base_value *retval = 0;

   CAST_CONV_ARG (const octave_char_matrix_str&);

   NDArray nda = v.array_value (true);

   if (! error_state)

     {

       if (nda.numel () == 1)

 	retval = new octave_scalar (nda(0));

       else

 	retval = new octave_matrix (nda);

     }

   return retval;

 }

 octave_base_value::type_conv_fcn

 octave_char_matrix_str::numeric_conversion_function (void) const

 {

   return default_numeric_conversion_function;

 }

 octave_value

 octave_char_matrix_str::do_index_op_internal (const octave_value_list& idx,

 					      bool resize_ok, char type)

 {

   octave_value retval;

   octave_idx_type len = idx.length ();

   switch (len)

     {

     case 0:

       retval = octave_value (matrix, true, type);

       break;

     case 1:

       {

 	idx_vector i = idx (0).index_vector ();

 	if (! error_state)

 	  retval = octave_value (charNDArray (matrix.index (i, resize_ok)),

 				 true, type);

       }

       break;

     case 2:

       {

 	idx_vector i = idx (0).index_vector ();

 	idx_vector j = idx (1).index_vector ();

 	if (! error_state)

 	  retval = octave_value (charNDArray (matrix.index (i, j, resize_ok)),

 				 true, type);

       }

       break;

     default:

       {

 	Array<idx_vector> idx_vec (len);

 	for (octave_idx_type i = 0; i < len; i++)

 	  idx_vec(i) = idx(i).index_vector ();

 	if (! error_state)

 	  retval = octave_value (charNDArray (matrix.index (idx_vec, resize_ok)),

 				 true, type);

       }

       break;

     }

   return retval;

 }

 void

 octave_char_matrix_str::assign (const octave_value_list& idx,

 				const charMatrix& rhs)

 {

   octave_idx_type len = idx.length ();

   // FIXME

   charMatrix tmp = rhs;

   if (tmp.rows () == 1 && tmp.columns () == 0)

     tmp.resize (0, 0);    

   for (octave_idx_type i = 0; i < len; i++)

     matrix.set_index (idx(i).index_vector ());

   ::assign (matrix, tmp, Vstring_fill_char);

 }

 octave_value 

 octave_char_matrix_str::resize (const dim_vector& dv, bool fill) const

 {

   charNDArray retval (matrix);

   if (fill)

     retval.resize (dv, charNDArray::resize_fill_value());

   else

     retval.resize (dv);

   return octave_value (retval, true);

 }

 bool

 octave_char_matrix_str::valid_as_scalar_index (void) const

 {

   bool retval = false;

   error ("octave_char_matrix_str::valid_as_scalar_index(): not implemented");

   return retval;

 }

 #define CHAR_MATRIX_CONV(T, INIT, TNAME, FCN) \

   T retval INIT; \

  \

   if (! force_string_conv) \

     gripe_invalid_conversion ("string", TNAME); \

   else \

     { \

       warning_with_id ("Octave:str-to-num", \

 		       "implicit conversion from %s to %s", \

 		       "string", TNAME); \

  \

       retval = octave_char_matrix::FCN (); \

     } \

  \

   return retval

 double

 octave_char_matrix_str::double_value (bool force_string_conv) const

 {

   CHAR_MATRIX_CONV (double, = 0, "real scalar", double_value);

 }

 Complex

 octave_char_matrix_str::complex_value (bool force_string_conv) const

 {

   CHAR_MATRIX_CONV (Complex, = 0, "complex scalar", complex_value);

 }

 Matrix

 octave_char_matrix_str::matrix_value (bool force_string_conv) const

 {

   CHAR_MATRIX_CONV (Matrix, , "real matrix", matrix_value);

 }

 ComplexMatrix

 octave_char_matrix_str::complex_matrix_value (bool force_string_conv) const

 {

   CHAR_MATRIX_CONV (ComplexMatrix, , "complex matrix", complex_matrix_value);

 }

 NDArray

 octave_char_matrix_str::array_value (bool force_string_conv) const

 {

   CHAR_MATRIX_CONV (NDArray, , "real N-d array", array_value);

 }

 ComplexNDArray

 octave_char_matrix_str::complex_array_value (bool force_string_conv) const

 {

   CHAR_MATRIX_CONV (ComplexNDArray, , "complex N-d array",

 		    complex_array_value);

 }

 string_vector

 octave_char_matrix_str::all_strings (bool) const

 {

   string_vector retval;

   if (matrix.ndims () == 2)

     {

       charMatrix chm = matrix.matrix_value ();

       octave_idx_type n = chm.rows ();

       retval.resize (n);

       for (octave_idx_type i = 0; i < n; i++)

 	retval[i] = chm.row_as_string (i);

     }

   else

     error ("invalid conversion of charNDArray to string_vector");

   return retval;

 }

 std::string

 octave_char_matrix_str::string_value (bool) const

 {

   std::string retval;

   if (matrix.ndims () == 2)

     {

       charMatrix chm = matrix.matrix_value ();

       retval = chm.row_as_string (0);  // FIXME???

     }

   else

     error ("invalid conversion of charNDArray to string");

   return retval;

 }

 void

 octave_char_matrix_str::print_raw (std::ostream& os, bool pr_as_read_syntax) const

 {

   octave_print_internal (os, matrix, pr_as_read_syntax,

 			 current_print_indent_level (), true);

 }

 bool 

 octave_char_matrix_str::save_ascii (std::ostream& os)

 {

   dim_vector d = dims ();

   if (d.length () > 2)

     {

       charNDArray tmp = char_array_value ();

       os << "# ndims: " << d.length () << "\n";

       for (int i=0; i < d.length (); i++)

 	os << " " << d (i);

       os << "\n";

       os.write (tmp.fortran_vec (), d.numel ());

       os << "\n";

     }

   else

     {

       // Keep this case, rather than use generic code above for

       // backward compatiability. Makes load_ascii much more complex!!

       charMatrix chm = char_matrix_value ();

       octave_idx_type elements = chm.rows ();

       os << "# elements: " << elements << "\n";

       for (octave_idx_type i = 0; i < elements; i++)

 	{

 	  unsigned len = chm.cols ();

 	  os << "# length: " << len << "\n";

 	  std::string tstr = chm.row_as_string (i, false, true);

 	  const char *tmp = tstr.data ();

 	  if (tstr.length () > len)

 	    panic_impossible ();

 	  os.write (tmp, len);

 	  os << "\n";

 	}

     }

   return true;

 }

 bool 

 octave_char_matrix_str::load_ascii (std::istream& is)

 {

   bool success = true;

   string_vector keywords(3);

   keywords[0] = "ndims";

   keywords[1] = "elements";

   keywords[2] = "length";

   std::string kw;

   int val = 0;

   if (extract_keyword (is, keywords, kw, val, true))

     {

       if (kw == "ndims")

 	{

 	  int mdims = val;

 	  if (mdims >= 0)

 	    {

 	      dim_vector dv;

 	      dv.resize (mdims);

 	      for (int i = 0; i < mdims; i++)

 		is >> dv(i);

 	      if (is)

 		{

 		  charNDArray tmp(dv);

 		  if (tmp.is_empty ())

 		    matrix = tmp;

 		  else

 		    {

 		      char *ftmp = tmp.fortran_vec ();

 		      // Skip the return line

 		      skip_preceeding_newline (is);

 		      if (! is.read (ftmp, dv.numel ()) || !is)

 			{

 			  error ("load: failed to load string constant");

 			  success = false;

 			}

 		      else

 			matrix = tmp;

 		    }

 		}

 	      else

 		{

 		  error ("load: failed to read dimensions");

 		  success = false;

 		}

 	    }

 	  else

 	    {

 	      error ("load: failed to extract matrix size");

 	      success = false;

 	    }

 	}

       else if (kw == "elements")

 	{

 	  int elements = val;

 	  if (elements >= 0)

 	    {

 	      // FIXME -- need to be able to get max length

 	      // before doing anything.

 	      charMatrix chm (elements, 0);

 	      int max_len = 0;

 	      for (int i = 0; i < elements; i++)

 		{

 		  int len;

 		  if (extract_keyword (is, "length", len) && len >= 0)

 		    {

 		      // Use this instead of a C-style character

 		      // buffer so that we can properly handle

 		      // embedded NUL characters.

 		      charMatrix tmp (1, len);

 		      char *ptmp = tmp.fortran_vec ();

 		      if (len > 0 && ! is.read (ptmp, len))

 			{

 			  error ("load: failed to load string constant");

 			  success = false;

 			  break;

 			}

 		      else

 			{

 			  if (len > max_len)

 			    {

 			      max_len = len;

 			      chm.resize (elements, max_len, 0);

 			    }

 			  chm.insert (tmp, i, 0);

 			}

 		    }

 		  else

 		    {

 		      error ("load: failed to extract string length for element %d", 

 			     i+1);

 		      success = false;

 		    }

 		}

 	      if (! error_state)

 		matrix = chm;

 	    }

 	  else

 	    {

 	      error ("load: failed to extract number of string elements");

 	      success = false;

 	    }

 	}

       else if (kw == "length")

 	{

 	  int len = val;

 	  if (len >= 0)

 	    {

 	      // This is cruft for backward compatiability, 

 	      // but relatively harmless.

 	      // Use this instead of a C-style character buffer so

 	      // that we can properly handle embedded NUL characters.

 	      charMatrix tmp (1, len);

 	      char *ptmp = tmp.fortran_vec ();

 	      if (len > 0 && ! is.read (ptmp, len))

 		{

 		  error ("load: failed to load string constant");

 		}

 	      else

 		{

 		  if (is)

 		    matrix = tmp;

 		  else

 		    error ("load: failed to load string constant");

 		}

 	    }

 	}

       else

 	panic_impossible ();

     }

   else

     {

       error ("load: failed to extract number of rows and columns");

       success = false;

     }

   return success;

 }

 bool 

 octave_char_matrix_str::save_binary (std::ostream& os,

 				     bool& /* save_as_floats */)

 {

   dim_vector d = dims ();

   if (d.length() < 1)

     return false;

   // Use negative value for ndims to differentiate with old format!!

   int32_t tmp = - d.length();

   os.write (reinterpret_cast<char *> (&tmp), 4);

   for (int i=0; i < d.length (); i++)

     {

       tmp = d(i);

       os.write (reinterpret_cast<char *> (&tmp), 4);

     }

   charNDArray m = char_array_value ();

   os.write (m.fortran_vec (), d.numel ());

   return true;

 }

 bool 

 octave_char_matrix_str::load_binary (std::istream& is, bool swap,

 				     oct_mach_info::float_format /* fmt */)

 {

   int32_t elements;

   if (! is.read (reinterpret_cast<char *> (&elements), 4))

     return false;

   if (swap)

     swap_bytes<4> (&elements);

   if (elements < 0)

     {

       int32_t mdims = - elements;

       int32_t di;

       dim_vector dv;

       dv.resize (mdims);

       for (int i = 0; i < mdims; i++)

 	{

 	  if (! is.read (reinterpret_cast<char *> (&di), 4))

 	    return false;

 	  if (swap)

 	    swap_bytes<4> (&di);

 	  dv(i) = di;

 	}

       // Convert an array with a single dimension to be a row vector.

       // Octave should never write files like this, other software

       // might.

       if (mdims == 1)

 	{

 	  mdims = 2;

 	  dv.resize (mdims);

 	  dv(1) = dv(0);

 	  dv(0) = 1;

 	}

       charNDArray m(dv);

       char *tmp = m.fortran_vec ();

       is.read (tmp, dv.numel ());

       if (error_state || ! is)

 	return false;

       matrix = m;

     }

   else

     {

       charMatrix chm (elements, 0);

       int max_len = 0;

       for (int i = 0; i < elements; i++)

 	{

 	  int32_t len;

 	  if (! is.read (reinterpret_cast<char *> (&len), 4))

 	    return false;

 	  if (swap)

 	    swap_bytes<4> (&len);

 	  charMatrix btmp (1, len);

 	  char *pbtmp = btmp.fortran_vec ();

 	  if (! is.read (pbtmp, len))

 	    return false;

 	  if (len > max_len)

 	    {

 	      max_len = len;

 	      chm.resize (elements, max_len, 0);

 	    }

 	  chm.insert (btmp, i, 0);

 	}

       matrix = chm;

     }

   return true;

 }

 #if defined (HAVE_HDF5)

 bool

 octave_char_matrix_str::save_hdf5 (hid_t loc_id, const char *name,

 				   bool /* save_as_floats */)

 {

   dim_vector dv = dims ();

   int empty = save_hdf5_empty (loc_id, name, dv);

   if (empty)

     return (empty > 0);

   int rank = dv.length ();

   hid_t space_hid = -1, data_hid = -1;

   bool retval = true;

   charNDArray m = char_array_value ();

   OCTAVE_LOCAL_BUFFER (hsize_t, hdims, rank);

   // Octave uses column-major, while HDF5 uses row-major ordering

   for (int i = 0; i < rank; i++)

     hdims[i] = dv (rank-i-1);

   space_hid = H5Screate_simple (rank, hdims, 0);

   if (space_hid < 0)

     return false;

   data_hid = H5Dcreate (loc_id, name, H5T_NATIVE_CHAR, space_hid, 

 			H5P_DEFAULT);

   if (data_hid < 0)

     {

       H5Sclose (space_hid);

       return false;

     }

   OCTAVE_LOCAL_BUFFER (char, s, dv.numel ());

   for (int i = 0; i < dv.numel (); ++i)

     s[i] = m(i);

   retval = H5Dwrite (data_hid, H5T_NATIVE_CHAR, H5S_ALL, H5S_ALL, 

 		     H5P_DEFAULT, s) >= 0;

   H5Dclose (data_hid);

   H5Sclose (space_hid);

   return retval;

 }

 bool 

 octave_char_matrix_str::load_hdf5 (hid_t loc_id, const char *name,

 				   bool /* have_h5giterate_bug */)

 {

   bool retval = false;

   dim_vector dv;

   int empty = load_hdf5_empty (loc_id, name, dv);

   if (empty > 0)

     matrix.resize(dv);

   if (empty)

     return (empty > 0);

   hid_t data_hid = H5Dopen (loc_id, name);

   hid_t space_hid = H5Dget_space (data_hid);

   hsize_t rank = H5Sget_simple_extent_ndims (space_hid);

   hid_t type_hid = H5Dget_type (data_hid);

   hid_t type_class_hid = H5Tget_class (type_hid);

   if (type_class_hid == H5T_INTEGER)

     {

       if (rank < 1)

 	{

 	  H5Tclose (type_hid);

 	  H5Sclose (space_hid);

 	  H5Dclose (data_hid);

 	  return false;

 	}

       OCTAVE_LOCAL_BUFFER (hsize_t, hdims, rank);

       OCTAVE_LOCAL_BUFFER (hsize_t, maxdims, rank);

       H5Sget_simple_extent_dims (space_hid, hdims, maxdims);

       // Octave uses column-major, while HDF5 uses row-major ordering

       if (rank == 1)

 	{

 	  dv.resize (2);

 	  dv(0) = 1;

 	  dv(1) = hdims[0];

 	}

       else

 	{

 	  dv.resize (rank);

 	  for (hsize_t i = 0, j = rank - 1; i < rank; i++, j--)

 	    dv(j) = hdims[i];

 	}

       charNDArray m (dv);

       char *str = m.fortran_vec ();

       if (H5Dread (data_hid, H5T_NATIVE_CHAR, H5S_ALL, H5S_ALL, 

 		   H5P_DEFAULT, str) >= 0) 

 	{

 	  retval = true;

 	  matrix = m;

 	}

       H5Tclose (type_hid);

       H5Sclose (space_hid);

       H5Dclose (data_hid);

       return true;

     }

   else

     {

       // This is cruft for backward compatiability and easy data

       // importation

       if (rank == 0)

 	{

 	  // a single string:

 	  int slen = H5Tget_size (type_hid);

 	  if (slen < 0)

 	    {

 	      H5Tclose (type_hid);

 	      H5Sclose (space_hid);

 	      H5Dclose (data_hid);

 	      return false;

 	    }

 	  else

 	    {

 	      OCTAVE_LOCAL_BUFFER (char, s, slen);

 	      // create datatype for (null-terminated) string

 	      // to read into:

 	      hid_t st_id = H5Tcopy (H5T_C_S1);

 	      H5Tset_size (st_id, slen);

 	      if (H5Dread (data_hid, st_id, H5S_ALL, H5S_ALL, H5P_DEFAULT, s) < 0)

 		{

 		  H5Tclose (st_id);

 		  H5Tclose (type_hid);

 		  H5Sclose (space_hid);

 		  H5Dclose (data_hid);

 		  return false;

 		}

 	      matrix = charMatrix (s);

 	      H5Tclose (st_id);

 	      H5Tclose (type_hid);

 	      H5Sclose (space_hid);

 	      H5Dclose (data_hid);

 	      return true;

 	    }

 	}

       else if (rank == 1)

 	{

 	  // string vector

 	  hsize_t elements, maxdim;

 	  H5Sget_simple_extent_dims (space_hid, &elements, &maxdim);

 	  int slen = H5Tget_size (type_hid);

 	  if (slen < 0)

 	    {

 	      H5Tclose (type_hid);

 	      H5Sclose (space_hid);

 	      H5Dclose (data_hid);

 	      return false;

 	    }

 	  else

 	    {

 	      // hdf5 string arrays store strings of all the

 	      // same physical length (I think), which is

 	      // slightly wasteful, but oh well.

 	      OCTAVE_LOCAL_BUFFER (char, s, elements * slen);

 	      // create datatype for (null-terminated) string

 	      // to read into:

 	      hid_t st_id = H5Tcopy (H5T_C_S1);

 	      H5Tset_size (st_id, slen);

 	      if (H5Dread (data_hid, st_id, H5S_ALL, H5S_ALL, H5P_DEFAULT, s) < 0)

 		{

 		  H5Tclose (st_id);

 		  H5Tclose (type_hid);

 		  H5Sclose (space_hid);

 		  H5Dclose (data_hid);

 		  return false;

 		}

 	      charMatrix chm (elements, slen - 1);

 	      for (hsize_t i = 0; i < elements; ++i)

 		{

 		  chm.insert (s + i*slen, i, 0);

 		}

 	      matrix = chm;

 	      H5Tclose (st_id);

 	      H5Tclose (type_hid);

 	      H5Sclose (space_hid);

 	      H5Dclose (data_hid);

 	      return true;

 	    }

 	}

       else

 	{

 	  H5Tclose (type_hid);

 	  H5Sclose (space_hid);

 	  H5Dclose (data_hid);

 	  return false;

 	}

     }

   return retval;

 }

 #endif

 /*

 ;;; Local Variables: ***

 ;;; mode: C++ ***

 ;;; End: ***

 */