/*

Copyright (C) 2004, 2005, 2006, 2007 David Bateman

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/>.

In addition to the terms of the GPL, you are permitted to link

this program with any Open Source program, as defined by the

Open Source Initiative (www.opensource.org)

*/

#ifdef HAVE_CONFIG_H

#include <config.h>

#endif

#include <istream>

#include <iostream>

#include <sstream>

#include <vector>

#include "defun.h"

#include "error.h"

#include "gripes.h"

#include "oct-map.h"

#include "ov-base.h"

#include "ov-fcn-inline.h"

#include "pr-output.h"

#include "variables.h"

#include "parse.h"

#include "byte-swap.h"

#include "ls-oct-ascii.h"

#include "ls-hdf5.h"

#include "ls-utils.h"

#include "ls-ascii-helper.h"

DEFINE_OCTAVE_ALLOCATOR (octave_fcn_inline);

DEFINE_OV_TYPEID_FUNCTIONS_AND_DATA (octave_fcn_inline,

				     "inline function",

				     "function_handle");

octave_fcn_inline::octave_fcn_inline (const std::string& f,

				      const string_vector& a,

				      const std::string& n)

  : octave_fcn_handle (n), iftext (f), ifargs (a)

{

  // Form a string representing the function.

  std::ostringstream buf;

  buf << "@(";

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

    {

      if (i > 0)

	buf << ", ";

      buf << ifargs(i);

    }

  buf << ") " << iftext;

  int parse_status;

  octave_value anon_fcn_handle = eval_string (buf.str (), true, parse_status);

  if (parse_status == 0)

    {

      octave_fcn_handle *fh = anon_fcn_handle.fcn_handle_value ();

      if (fh)

	fcn = fh->fcn_val ();

    }

  if (fcn.is_undefined ())

    error ("inline: unable to define function");

}

// This function is supplied to allow a Matlab style class structure

// to be returned..

Octave_map

octave_fcn_inline::map_value (void) const

{

  Octave_map m;

  string_vector args = fcn_arg_names ();

  m.assign ("version", octave_value (1.0));

  m.assign ("isEmpty", octave_value (0.0));

  m.assign ("expr", octave_value (fcn_text ()));

  m.assign ("numArgs", octave_value (args.length ()));

  m.assign ("args", octave_value (args));

  std::ostringstream buf;

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

    buf << args(i) << " = INLINE_INPUTS_{" << i + 1 << "}; ";

  m.assign ("inputExpr", octave_value (buf.str ()));

  return m;

}

bool

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

{

  os << "# nargs: " <<  ifargs.length () << "\n";

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

    os << ifargs(i) << "\n";

  if (nm.length () < 1)

    // Write an invalid value to flag empty fcn handle name.

    os << "0\n";

  else

    os << nm << "\n";

  os << iftext << "\n";

  return true;

}

bool

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

{

  int nargs;

  if (extract_keyword (is, "nargs", nargs, true))

    {

      ifargs.resize (nargs);

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

	is >> ifargs(i);

      is >> nm;

      if (nm == "0")

	nm = "";

      char c;

      std::string buf;

      // Skip preceeding newline(s)

      skip_preceeding_newline (is);

      if (is)

	{

	  // Get a line of text whitespace characters included, leaving

	  // newline in the stream

	  buf = read_until_newline (is, true);

	}

      iftext = buf;

      octave_fcn_inline tmp (iftext, ifargs, nm);

      fcn = tmp.fcn;

      return true;

    }

  else

    return false;

}

bool

octave_fcn_inline::save_binary (std::ostream& os, bool&)

{

  int32_t tmp = ifargs.length ();

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

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

    {

      tmp = ifargs(i).length ();

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

      os.write (ifargs(i).c_str (), ifargs(i).length ());

    }

  tmp = nm.length ();

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

  os.write (nm.c_str (), nm.length ());

  tmp = iftext.length ();

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

  os.write (iftext.c_str (), iftext.length ());

  return true;

}

bool

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

				oct_mach_info::float_format)

{

  int32_t nargs;

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

    return false;

  if (swap)

    swap_bytes<4> (&nargs);

  if (nargs < 1)

    return false;

  else

    {

      int32_t tmp;

      ifargs.resize (nargs);

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

	{

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

	    return false;

	  if (swap)

	    swap_bytes<4> (&tmp);

	  OCTAVE_LOCAL_BUFFER (char, ctmp, tmp+1);

	  is.read (ctmp, tmp);

	  ifargs(i) = std::string (ctmp);

	  if (! is)

	    return false;

	}

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

	return false;

      if (swap)

	swap_bytes<4> (&tmp);

      OCTAVE_LOCAL_BUFFER (char, ctmp1, tmp+1);

      is.read (ctmp1, tmp);

      nm = std::string (ctmp1);

      if (! is)

	return false;

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

	return false;

      if (swap)

	swap_bytes<4> (&tmp);

      OCTAVE_LOCAL_BUFFER (char, ctmp2, tmp+1);

      is.read (ctmp2, tmp);

      iftext = std::string (ctmp2);

      if (! is)

	return false;

      octave_fcn_inline ftmp (iftext, ifargs, nm);

      fcn = ftmp.fcn;

    }

  return true;

}

#if defined (HAVE_HDF5)

bool

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

			      bool /* save_as_floats */)

{

  hid_t group_hid = -1;

  group_hid = H5Gcreate (loc_id, name, 0);

  if (group_hid < 0 ) return false;

  size_t len = 0;

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

    if (len < ifargs(i).length ())

      len = ifargs(i).length ();

  hid_t space_hid = -1, data_hid = -1, type_hid = -1;;

  bool retval = true;

  // FIXME Is there a better way of saving string vectors, than a

  // null padded matrix?

  OCTAVE_LOCAL_BUFFER (hsize_t, hdims, 2);

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

  hdims[1] = ifargs.length ();

  hdims[0] = len + 1;

  space_hid = H5Screate_simple (2, hdims, 0);

  if (space_hid < 0)

    {

      H5Gclose (group_hid);

      return false;

    }

  data_hid = H5Dcreate (group_hid, "args", H5T_NATIVE_CHAR, space_hid,

			H5P_DEFAULT);

  if (data_hid < 0)

    {

      H5Sclose (space_hid);

      H5Gclose (group_hid);

      return false;

    }

  OCTAVE_LOCAL_BUFFER (char, s, ifargs.length () * (len + 1));

  // Save the args as a null teminated list

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

    {

      const char * cptr = ifargs(i).c_str ();

      for (size_t j = 0; j < ifargs(i).length (); j++)

	s[i*(len+1)+j] = *cptr++;

      s[ifargs(i).length ()] = '\0';

    }

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

		     H5P_DEFAULT, s) >= 0;

  H5Dclose (data_hid);

  H5Sclose (space_hid);

  if (!retval)

    {

      H5Gclose (group_hid);

      return false;

    }

  // attach the type of the variable

  type_hid = H5Tcopy (H5T_C_S1);

  H5Tset_size (type_hid, nm.length () + 1);

  if (type_hid < 0)

    {

      H5Gclose (group_hid);

      return false;

    }

  hdims[0] = 0;

  space_hid = H5Screate_simple (0 , hdims, 0);

  if (space_hid < 0)

    {

      H5Tclose (type_hid);

      H5Gclose (group_hid);

      return false;

    }

  data_hid = H5Dcreate (group_hid, "nm",  type_hid, space_hid, H5P_DEFAULT);

  if (data_hid < 0 || H5Dwrite (data_hid, type_hid, H5S_ALL, H5S_ALL,

				H5P_DEFAULT, nm.c_str ()) < 0)

    {

      H5Sclose (space_hid);

      H5Tclose (type_hid);

      H5Gclose (group_hid);

      return false;

    }

  H5Dclose (data_hid);

  // attach the type of the variable

  H5Tset_size (type_hid, iftext.length () + 1);

  if (type_hid < 0)

    {

      H5Gclose (group_hid);

      return false;

    }

  data_hid = H5Dcreate (group_hid, "iftext",  type_hid, space_hid,

			H5P_DEFAULT);

  if (data_hid < 0 || H5Dwrite (data_hid, type_hid, H5S_ALL, H5S_ALL,

				H5P_DEFAULT, iftext.c_str ()) < 0)

    {

      H5Sclose (space_hid);

      H5Tclose (type_hid);

      H5Gclose (group_hid);

      return false;

    }

  H5Dclose (data_hid);

  H5Sclose (space_hid);

  H5Tclose (type_hid);

  H5Gclose (group_hid);

  return retval;

}

bool

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

			      bool /* have_h5giterate_bug */)

{

  hid_t group_hid, data_hid, space_hid, type_hid, type_class_hid, st_id;

  hsize_t rank;

  int slen;

  group_hid = H5Gopen (loc_id, name);

  if (group_hid < 0 ) return false;

  data_hid = H5Dopen (group_hid, "args");

  space_hid = H5Dget_space (data_hid);

  rank = H5Sget_simple_extent_ndims (space_hid);

  if (rank != 2)

    {

      H5Dclose (data_hid);

      H5Sclose (space_hid);

      H5Gclose (group_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);

  ifargs.resize (hdims[1]);

  OCTAVE_LOCAL_BUFFER (char, s1, hdims[0] * hdims[1]);

  if (H5Dread (data_hid, H5T_NATIVE_UCHAR, H5S_ALL, H5S_ALL,

	       H5P_DEFAULT, s1) < 0)

    {

      H5Dclose (data_hid);

      H5Sclose (space_hid);

      H5Gclose (group_hid);

      return false;

    }

  H5Dclose (data_hid);

  H5Sclose (space_hid);

  for (size_t i = 0; i < hdims[1]; i++)

    ifargs(i) = std::string (s1 + i*hdims[0]);

  data_hid = H5Dopen (group_hid, "nm");

  if (data_hid < 0)

    {

      H5Gclose (group_hid);

      return false;

    }

  type_hid = H5Dget_type (data_hid);

  type_class_hid = H5Tget_class (type_hid);

  if (type_class_hid != H5T_STRING)

    {

      H5Tclose (type_hid);

      H5Dclose (data_hid);

      H5Gclose (group_hid);

      return false;

    }

  space_hid = H5Dget_space (data_hid);

  rank = H5Sget_simple_extent_ndims (space_hid);

  if (rank != 0)

    {

      H5Sclose (space_hid);

      H5Tclose (type_hid);

      H5Dclose (data_hid);

      H5Gclose (group_hid);

      return false;

    }

  slen = H5Tget_size (type_hid);

  if (slen < 0)

    {

      H5Sclose (space_hid);

      H5Tclose (type_hid);

      H5Dclose (data_hid);

      H5Gclose (group_hid);

      return false;

    }

  OCTAVE_LOCAL_BUFFER (char, nm_tmp, slen);

  // create datatype for (null-terminated) string to read into:

  st_id = H5Tcopy (H5T_C_S1);

  H5Tset_size (st_id, slen);

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

    {

      H5Sclose (space_hid);

      H5Tclose (type_hid);

      H5Gclose (group_hid);

      return false;

    }

  H5Tclose (st_id);

  H5Dclose (data_hid);

  nm = nm_tmp;

  data_hid = H5Dopen (group_hid, "iftext");

  if (data_hid < 0)

    {

      H5Gclose (group_hid);

      return false;

    }

  type_hid = H5Dget_type (data_hid);

  type_class_hid = H5Tget_class (type_hid);

  if (type_class_hid != H5T_STRING)

    {

      H5Tclose (type_hid);

      H5Dclose (data_hid);

      H5Gclose (group_hid);

      return false;

    }

  space_hid = H5Dget_space (data_hid);

  rank = H5Sget_simple_extent_ndims (space_hid);

  if (rank != 0)

    {

      H5Sclose (space_hid);

      H5Tclose (type_hid);

      H5Dclose (data_hid);

      H5Gclose (group_hid);

      return false;

    }

  slen = H5Tget_size (type_hid);

  if (slen < 0)

    {

      H5Sclose (space_hid);

      H5Tclose (type_hid);

      H5Dclose (data_hid);

      H5Gclose (group_hid);

      return false;

    }

  OCTAVE_LOCAL_BUFFER (char, iftext_tmp, slen);

  // create datatype for (null-terminated) string to read into:

  st_id = H5Tcopy (H5T_C_S1);

  H5Tset_size (st_id, slen);

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

    {

      H5Sclose (space_hid);

      H5Tclose (type_hid);

      H5Gclose (group_hid);

      return false;

    }

  H5Tclose (st_id);

  H5Dclose (data_hid);

  iftext = iftext_tmp;

  octave_fcn_inline ftmp (iftext, ifargs, nm);

  fcn = ftmp.fcn;

  return true;

}

#endif

void

octave_fcn_inline::print (std::ostream& os, bool pr_as_read_syntax) const

{

  print_raw (os, pr_as_read_syntax);

  newline (os);

}

void

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

{

  std::ostringstream buf;

  if (nm.empty ())

    buf << "f(";

  else

    buf << nm << "(";

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

    {

      if (i)

	buf << ", ";

      buf << ifargs(i);

    }

  buf << ") = " << iftext;

  octave_print_internal (os, buf.str (), pr_as_read_syntax,

			 current_print_indent_level ());

}

octave_value

octave_fcn_inline::convert_to_str_internal (bool, bool, char type) const

{

  return octave_value (fcn_text (), type);

}

DEFUNX ("inline", Finline, args, ,

  "-*- texinfo -*-\n\

@deftypefn {Built-in Function} {} inline (@var{str})\n\

@deftypefnx {Built-in Function} {} inline (@var{str}, @var{arg1}, @dots{})\n\

@deftypefnx {Built-in Function} {} inline (@var{str}, @var{n})\n\

Create an inline function from the character string @var{str}.\n\

If called with a single argument, the arguments of the generated\n\

function are extracted from the function itself. The generated\n\

function arguments will then be in alphabetical order. It should\n\

be noted that i, and j are ignored as arguments due to the\n\

ambiguity between their use as a variable or their use as an inbuilt\n\

constant. All arguments followed by a parenthesis are considered\n\

to be functions.\n\

\n\

If the second and subsequent arguments are character strings,\n\

they are the names of the arguments of the function.\n\

\n\

If the second argument is an integer @var{n}, the arguments are\n\

@code{\"x\"}, @code{\"P1\"}, @dots{}, @code{\"P@var{N}\"}.\n\

@seealso{argnames, formula, vectorize}\n\

@end deftypefn")

{

  octave_value retval;

  int nargin = args.length ();

  if (nargin > 0)

    {

      std::string fun = args(0).string_value ();

      if (! error_state)

	{

	  string_vector fargs;

	  if (nargin == 1)

	    {

	      bool is_arg = false;

	      bool in_string = false;

	      std::string tmp_arg;

	      size_t i = 0;

	      while (i < fun.length ())

		{

		  bool terminate_arg = false;

		  char c = fun[i++];

		  if (in_string)

		    {

		      if (c == '\'' || c == '\"')

			in_string = false;

		    }

		  else if (c == '\'' || c == '\"')

		    {

		      in_string = true;

		      if (is_arg)

			terminate_arg = true;

		    }

		  else if (! isalpha (c) && c != '_')

		    if (! is_arg)

		      continue;

		    else if (isdigit (c))

		      tmp_arg.append (1, c);

		    else

		      {

			// Before we do anything remove trailing whitespaces.

			while (i < fun.length () && isspace (c))

			  c = fun[i++];

			// Do we have a variable or a function?

			if (c != '(')

			  terminate_arg = true;

			else

			  {

			    tmp_arg = std::string ();

			    is_arg = false;

			  }

		      }

		  else

		    {

		      tmp_arg.append (1, c);

		      is_arg = true;

		    }

		  if (terminate_arg || (i == fun.length () && is_arg))

		    {

		      bool have_arg = false;

		      for (int j = 0; j < fargs.length (); j++)

			if (tmp_arg == fargs (j))

			  {

			    have_arg = true;

			    break;

			  }

		      if (! have_arg && tmp_arg != "i" && tmp_arg != "j" &&

			  tmp_arg != "NaN" && tmp_arg != "nan" && 

			  tmp_arg != "Inf" && tmp_arg != "inf" && 

			  tmp_arg != "NA" && tmp_arg != "pi" &&

			  tmp_arg != "eps")

			fargs.append (tmp_arg);

		      tmp_arg = std::string ();

		      is_arg = false;

		    }

		}

	      // Sort the arguments into ascii order.

	      fargs.qsort ();

	    }

	  else if (nargin == 2 && args(1).is_numeric_type ())

	    {

	      int n = args(1).int_value ();

	      if (! error_state)

		{

		  if (n >= 0)

		    {

		      fargs.resize (n+1);

		      fargs(0) = "x";

		      for (int i = 1; i < n+1; i++)

			{

			  std::ostringstream buf;

			  buf << "P" << i;

			  fargs(i) = buf.str ();

			}

		    }

		  else

		    {

		      error ("inline: numeric argument must be nonnegative");

		      return retval;

		    }

		}

	      else

		{

		  error ("inline: expecting second argument to be an integer");

		  return retval;

		}

	    }

	  else

	    {

	      fargs.resize (nargin - 1);

	      for (int i = 1; i < nargin; i++)

		{

		  std::string s = args(i).string_value ();

		  if (! error_state)

		    fargs(i-1) = s;

		  else

		    {

		      error ("inline: expecting string arguments");

		      return retval;

		    }

		}

	    }

	  retval = octave_value (new octave_fcn_inline (fun, fargs));

	}

      else

	error ("inline: first argument must be a string");

    }

  else

    print_usage ();

  return retval;

}

DEFUN (formula, args, ,

  "-*- texinfo -*-\n\

@deftypefn {Built-in Function} {} formula (@var{fun})\n\

Return a character string representing the inline function @var{fun}.\n\

Note that @code{char (@var{fun})} is equivalent to\n\

@code{formula (@var{fun})}.\n\

@seealso{argnames, inline, vectorize}\n\

@end deftypefn")

{

  octave_value retval;

  int nargin = args.length ();

  if (nargin == 1)

    {

      octave_fcn_inline* fn = args(0).fcn_inline_value (true);

      if (fn)

	retval = octave_value (fn->fcn_text ());

      else

	error ("formula: must be an inline function");

    }

  else

    print_usage ();

  return retval;

}

DEFUN (argnames, args, ,

  "-*- texinfo -*-\n\

@deftypefn {Built-in Function} {} argnames (@var{fun})\n\

Return a cell array of character strings containing the names of\n\

the arguments of the inline function @var{fun}.\n\

@seealso{inline, formula, vectorize}\n\

@end deftypefn")

{

  octave_value retval;

  int nargin = args.length ();

  if (nargin == 1)

    {

      octave_fcn_inline *fn = args(0).fcn_inline_value (true);

      if (fn)

	{

	  string_vector t1 = fn->fcn_arg_names ();

	  Cell t2 (dim_vector (t1.length (), 1));

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

	    t2(i) = t1(i);

	  retval = t2;

	}

      else

	error ("argnames: argument must be an inline function");

    }

  else

    print_usage ();

  return retval;

}

DEFUN (vectorize, args, ,

  "-*- texinfo -*-\n\

@deftypefn {Built-in Function} {} vectorize (@var{fun})\n\

Create a vectorized version of the inline function @var{fun}\n\

by replacing all occurrences of @code{*}, @code{/}, etc., with\n\

@code{.*}, @code{./}, etc.\n\

@end deftypefn")

{

  octave_value retval;

  int nargin = args.length ();

  if (nargin == 1)

    {

      std::string old_func;

      octave_fcn_inline* old = 0;

      bool func_is_string = true;

      if (args(0).is_string ())

	old_func = args(0).string_value ();

      else

	{

	  old = args(0).fcn_inline_value (true);

	  func_is_string = false;

	  if (old)

	    old_func = old->fcn_text ();

	  else

	    error ("vectorize: must be a string or inline function");

	}

      if (! error_state)

	{

	  std::string new_func;

	  size_t i = 0;

	  while (i < old_func.length ())

	    {

	      std::string t1 = old_func.substr (i, 1);

	      if (t1 == "*" || t1 == "/" || t1 == "\\" || t1 == "^")

		{

		  if (i && old_func.substr (i-1, 1) != ".")

		    new_func.append (".");

		  // Special case for ** operator.

		  if (t1 == "*" && i < (old_func.length () - 1)

		      && old_func.substr (i+1, 1) == "*")

		    {

		      new_func.append ("*");

		      i++;

		    }

		}

	      new_func.append (t1);

	      i++;

	    }

	  if (func_is_string)

	    retval = octave_value (new_func);

	  else

	    retval = octave_value (new octave_fcn_inline 

				   (new_func, old->fcn_arg_names ()));

	}

    }

  else

    print_usage ();

  return retval;

}

/*

;;; Local Variables: ***

;;; mode: C++ ***

;;; End: ***

*/