/*

Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 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/>.

*/

// Author: John W. Eaton.

// HDF5 support by Steven G. Johnson <stevenj@alum.mit.edu>

// Matlab v5 support by James R. Van Zandt <jrv@vanzandt.mv.com>

#ifdef HAVE_CONFIG_H

#include <config.h>

#endif

#include <cfloat>

#include <cstring>

#include <cctype>

#include <fstream>

#include <iomanip>

#include <iostream>

#include <sstream>

#include <string>

#ifdef HAVE_HDF5

#include <hdf5.h>

#endif

#include "byte-swap.h"

#include "data-conv.h"

#include "file-ops.h"

#include "file-stat.h"

#include "glob-match.h"

#include "lo-mappers.h"

#include "mach-info.h"

#include "oct-env.h"

#include "oct-time.h"

#include "quit.h"

#include "str-vec.h"

#include "Cell.h"

#include "defun.h"

#include "error.h"

#include "gripes.h"

#include "load-path.h"

#include "load-save.h"

#include "oct-obj.h"

#include "oct-map.h"

#include "ov-cell.h"

#include "pager.h"

#include "pt-exp.h"

#include "symtab.h"

#include "sysdep.h"

#include "unwind-prot.h"

#include "utils.h"

#include "variables.h"

#include "version.h"

#include "dMatrix.h"

#ifdef HAVE_HDF5

#include "ls-hdf5.h"

#endif

#include "ls-mat-ascii.h"

#include "ls-mat4.h"

#include "ls-mat5.h"

#include "ls-oct-ascii.h"

#include "ls-oct-binary.h"

#ifdef HAVE_ZLIB

#include "zfstream.h"

#endif

// Write octave-core file if Octave crashes or is killed by a signal.

static bool Vcrash_dumps_octave_core = true;

// The maximum amount of memory (in kilobytes) that we will attempt to

// write to the Octave core file.

static double Voctave_core_file_limit = -1.0;

// The name of the Octave core file.

static std::string Voctave_core_file_name = "octave-core";

// The default output format.  May be one of "binary", "text",

// "mat-binary", or "hdf5".

static std::string Vdefault_save_options = "-text";

// The output format for Octave core files.

static std::string Voctave_core_file_options = "-binary";

static std::string

default_save_header_format (void)

{

  return

    std::string ("# Created by Octave " OCTAVE_VERSION

		 ", %a %b %d %H:%M:%S %Y %Z <")

    + octave_env::get_user_name ()

    + std::string ("@")

    + octave_env::get_host_name ()

    + std::string (">");

}

// The format string for the comment line at the top of text-format

// save files.  Passed to strftime.  Should begin with `#' and contain

// no newline characters.

static std::string Vsave_header_format_string = default_save_header_format ();

static void

gripe_file_open (const std::string& fcn, const std::string& file)

{

  if (fcn == "load")

    error ("%s: unable to open input file `%s'", fcn.c_str (), file.c_str ());

  else if (fcn == "save")

    error ("%s: unable to open output file `%s'", fcn.c_str (), file.c_str ());

  else

    error ("%s: unable to open file `%s'", fcn.c_str (), file.c_str ());

}

// FIXME -- shouldn't this be implemented in terms of other

// functions that are already available?

// Install a variable with name NAME and the value specified TC in the

// symbol table.  If FORCE is TRUE, replace any existing definition

// for NAME.  If GLOBAL is TRUE, make the variable global.

//

// Assumes TC is defined.

static void

install_loaded_variable (int force, const std::string& name,

			 const octave_value& val,

			 int global, const std::string& doc)

{

  // Is there already a symbol by this name?  If so, what is it?

  symbol_record *lsr = curr_sym_tab->lookup (name);

  bool is_undefined = true;

  bool is_variable = false;

  bool is_function = false;

  bool is_global = false;

  if (lsr)

    {

      is_undefined = ! lsr->is_defined ();

      is_variable = lsr->is_variable ();

      is_function = lsr->is_function ();

      is_global = lsr->is_linked_to_global ();

    }

  symbol_record *sr = 0;

  if (global)

    {

      if (is_global || is_undefined)

	{

	  if (force || is_undefined)

	    {

	      lsr = curr_sym_tab->lookup (name, true);

	      link_to_global_variable (lsr);

	      sr = lsr;

	    }

	  else

	    {

	      warning ("load: global variable name `%s' exists",

		       name.c_str ());

	      warning ("use `load -force' to overwrite");

	    }

	}

      else if (is_function)

	{

	  if (force)

	    {

	      lsr = curr_sym_tab->lookup (name, true);

	      link_to_global_variable (lsr);

	      sr = lsr;

	    }

	  else

	    {

	      warning ("load: `%s' is currently a function in this scope",

		       name.c_str ());

	      warning ("`load -force' will load variable and hide function");

	    }

	}

      else if (is_variable)

	{

	  if (force)

	    {

	      lsr = curr_sym_tab->lookup (name, true);

	      link_to_global_variable (lsr);

	      sr = lsr;

	    }

	  else

	    {

	      warning ("load: local variable name `%s' exists",

		       name.c_str ());

	      warning ("use `load -force' to overwrite");

	    }

	}

      else

	error ("load: unable to load data for unknown symbol type");

    }

  else

    {

      if (is_global)

	{

	  if (force || is_undefined)

	    {

	      lsr = curr_sym_tab->lookup (name, true);

	      link_to_global_variable (lsr);

	      sr = lsr;

	    }

	  else

	    {

	      warning ("load: global variable name `%s' exists",

		       name.c_str ());

	      warning ("use `load -force' to overwrite");

	    }

	}

      else if (is_function)

	{

	  if (force)

	    {

	      lsr = curr_sym_tab->lookup (name, true);

	      link_to_global_variable (lsr);

	      sr = lsr;

	    }

	  else

	    {

	      warning ("load: `%s' is currently a function in this scope",

		       name.c_str ());

	      warning ("`load -force' will load variable and hide function");

	    }

	}

      else if (is_variable || is_undefined)

	{

	  if (force || is_undefined)

	    {

	      lsr = curr_sym_tab->lookup (name, true);

	      sr = lsr;

	    }

	  else

	    {

	      warning ("load: local variable name `%s' exists",

		       name.c_str ());

	      warning ("use `load -force' to overwrite");

	    }

	}

      else

	error ("load: unable to load data for unknown symbol type");

    }

  if (sr)

    {

      sr->define (val);

      sr->document (doc);

      return;

    }

  else

    error ("load: unable to load variable `%s'", name.c_str ());

  return;

}

// Return TRUE if NAME matches one of the given globbing PATTERNS.

static bool

matches_patterns (const string_vector& patterns, int pat_idx,

		  int num_pat, const std::string& name)

{

  for (int i = pat_idx; i < num_pat; i++)

    {

      glob_match pattern (patterns[i]);

      if (pattern.match (name))

	return true;

    }

  return false;

}

int

read_binary_file_header (std::istream& is, bool& swap,

			 oct_mach_info::float_format& flt_fmt, bool quiet)

{

  const int magic_len = 10;

  char magic[magic_len+1];

  is.read (magic, magic_len);

  magic[magic_len] = '\0';

  if (strncmp (magic, "Octave-1-L", magic_len) == 0)

    swap = oct_mach_info::words_big_endian ();

  else if (strncmp (magic, "Octave-1-B", magic_len) == 0)

    swap = ! oct_mach_info::words_big_endian ();

  else

    {

      if (! quiet)

	error ("load: unable to read read binary file");

      return -1;

    }

  char tmp = 0;

  is.read (&tmp, 1);

  flt_fmt = mopt_digit_to_float_format (tmp);

  if (flt_fmt == oct_mach_info::flt_fmt_unknown)

    {

      if (! quiet)

        error ("load: unrecognized binary format!");

      return -1;

    }

  return 0;

}

#ifdef HAVE_ZLIB

static bool

check_gzip_magic (const std::string& fname)

{

  bool retval = false;

  std::ifstream file (fname.c_str ());

  OCTAVE_LOCAL_BUFFER (unsigned char, magic, 2);

  if (file.read (reinterpret_cast<char *> (magic), 2) && magic[0] == 0x1f && 

      magic[1] == 0x8b)

    retval = true;

  file.close ();

  return retval;

} 

#endif

static load_save_format

get_file_format (std::istream& file, const std::string& filename)

{

  load_save_format retval = LS_UNKNOWN;

  oct_mach_info::float_format flt_fmt = oct_mach_info::flt_fmt_unknown;

  bool swap = false;

  if (read_binary_file_header (file, swap, flt_fmt, true) == 0)

    retval = LS_BINARY;

  else

    {

      file.clear ();

      file.seekg (0, std::ios::beg);

      int32_t mopt, nr, nc, imag, len;

      int err = read_mat_file_header (file, swap, mopt, nr, nc, imag, len, 1);

      if (! err)

	retval = LS_MAT_BINARY;

      else

	{

	  file.clear ();

	  file.seekg (0, std::ios::beg);

	  err = read_mat5_binary_file_header (file, swap, true, filename);

	  if (! err)

  	    {

	      file.clear ();

	      file.seekg (0, std::ios::beg);

	      retval = LS_MAT5_BINARY;

  	    }

  	  else

  	    {

	      file.clear ();

	      file.seekg (0, std::ios::beg);

	      std::string tmp = extract_keyword (file, "name");

	      if (! tmp.empty ())

		retval = LS_ASCII;

	    }

	}

    }

  return retval;

}

static load_save_format

get_file_format (const std::string& fname, const std::string& orig_fname, 

		 bool &use_zlib)

{

  load_save_format retval = LS_UNKNOWN;

#ifdef HAVE_HDF5

  // check this before we open the file

  if (H5Fis_hdf5 (fname.c_str ()) > 0)

    return LS_HDF5;

#endif /* HAVE_HDF5 */

  std::ifstream file (fname.c_str ());

  use_zlib = false;

  if (file)

    {

      retval = get_file_format (file, orig_fname);

      file.close ();

#ifdef HAVE_ZLIB

      if (retval == LS_UNKNOWN && check_gzip_magic (fname))	

	{

	  gzifstream gzfile (fname.c_str ());

	  use_zlib = true;

	  if (gzfile)

	    {

	      retval = get_file_format (gzfile, orig_fname);

	      gzfile.close ();

	    }

	}

#endif

      if (retval == LS_UNKNOWN)

	{

	  // Try reading the file as numbers only, determining the

	  // number of rows and columns from the data.  We don't

	  // even bother to check to see if the first item in the

	  // file is a number, so that get_complete_line() can

	  // skip any comments that might appear at the top of the

	  // file.

	  retval = LS_MAT_ASCII;

	}

    }

  else

    gripe_file_open ("load", orig_fname);

  return retval;

}

octave_value

do_load (std::istream& stream, const std::string& orig_fname, bool force,

	 load_save_format format, oct_mach_info::float_format flt_fmt,

	 bool list_only, bool swap, bool verbose,

	 const string_vector& argv, int argv_idx, int argc, int nargout)

{

  octave_value retval;

  Octave_map retstruct;

  std::ostringstream output_buf;

  octave_idx_type count = 0;

  for (;;)

    {

      bool global = false;

      octave_value tc;

      std::string name;

      std::string doc;

      switch (format)

	{

	case LS_ASCII:

	  name = read_ascii_data (stream, orig_fname, global, tc, count);

	  break;

	case LS_BINARY:

	  name = read_binary_data (stream, swap, flt_fmt, orig_fname,

				   global, tc, doc);

	  break;

	case LS_MAT_ASCII:

	  name = read_mat_ascii_data (stream, orig_fname, tc);

	  break;

	case LS_MAT_BINARY:

	  name = read_mat_binary_data (stream, orig_fname, tc);

	  break;

#ifdef HAVE_HDF5

	case LS_HDF5:

	  name = read_hdf5_data (stream, orig_fname, global, tc, doc);

	  break;

#endif /* HAVE_HDF5 */

	case LS_MAT5_BINARY:

	case LS_MAT7_BINARY:

	  name = read_mat5_binary_element (stream, orig_fname, swap,

					   global, tc);

	  break;

	default:

	  gripe_unrecognized_data_fmt ("load");

	  break;

	}

      if (error_state || stream.eof () || name.empty ())

	break;

      else if (! error_state && ! name.empty ())

	{

	  if (tc.is_defined ())

	    {

	      if (format == LS_MAT_ASCII && argv_idx < argc)

		warning ("load: loaded ASCII file `%s' -- ignoring extra args",

			 orig_fname.c_str ());

	      if (format == LS_MAT_ASCII

		  || argv_idx == argc

		  || matches_patterns (argv, argv_idx, argc, name))

		{

		  count++;

		  if (list_only)

		    {

		      if (verbose)

			{

			  if (count == 1)

			    output_buf

			      << "type               rows   cols   name\n"

			      << "====               ====   ====   ====\n";

			  output_buf

			    << std::setiosflags (std::ios::left)

			    << std::setw (16) << tc.type_name () . c_str ()

			    << std::setiosflags (std::ios::right)

			    << std::setw (7) << tc.rows ()

			    << std::setw (7) << tc.columns ()

			    << "   ";

			}

		      output_buf << name << "\n";

		    }

		  else

		    {

		      if (nargout == 1)

			{

			  if (format == LS_MAT_ASCII)

			    retval = tc;

			  else

			    retstruct.assign (name, tc);

			}

		      else

			install_loaded_variable (force, name, tc, global, doc);

		    }

		}

	      // Only attempt to read one item from a headless text file.

	      if (format == LS_MAT_ASCII)

		break;

	    }

	  else

	    error ("load: unable to load variable `%s'", name.c_str ());

	}

      else

	{

	  if (count == 0)

	    error ("load: are you sure `%s' is an Octave data file?",

		   orig_fname.c_str ());

	  break;

	}

    }

  if (list_only && count)

    {

      std::string msg = output_buf.str ();

      if (nargout > 0)

	retval = msg;

      else

	octave_stdout << msg;

    }

  else if (retstruct.nfields () != 0)

    retval = retstruct;

  return retval;

}

std::string

find_file_to_load (const std::string& name, const std::string& orig_name)

{

  std::string fname = name;

  if (! (octave_env::absolute_pathname (fname)

	 || octave_env::rooted_relative_pathname (fname)))

    {

      file_stat fs (fname);

      if (! (fs.exists () && fs.is_reg ()))

	{

	  std::string tmp = octave_env::make_absolute

	    (load_path::find_file (fname), octave_env::getcwd ());

	  if (! tmp.empty ())

	    {

	      warning_with_id ("Octave:load-file-in-path",

			       "load: file found in load path");

	      fname = tmp;

	    }

	}

    }

  size_t dot_pos = fname.rfind (".");

  size_t sep_pos = fname.find_last_of (file_ops::dir_sep_chars);

  if (dot_pos == NPOS || (sep_pos != NPOS && dot_pos < sep_pos))

    {

      // Either no '.' in name or no '.' appears after last directory

      // separator.

      file_stat fs (fname);

      if (! (fs.exists () && fs.is_reg ()))

	fname = find_file_to_load (fname + ".mat", orig_name);

    }

  else

    {

      file_stat fs (fname);

      if (! (fs.exists () && fs.is_reg ()))

	{

	  fname = "";

	  error ("load: unable to find file %s", orig_name.c_str ());

	}

    }

  return fname;

}

// HDF5 load/save documentation is included in the Octave manual

// regardless, but if HDF5 is not linked in we also include a

// sentence noting this, so the user understands that the features

// aren't available.  Define a macro for this sentence:

#ifdef HAVE_HDF5

#define HAVE_HDF5_HELP_STRING ""

#else /* ! HAVE_HDF5 */

#define HAVE_HDF5_HELP_STRING "\n\

HDF5 load and save are not available, as this Octave executable was\n\

not linked with the HDF5 library."

#endif /* ! HAVE HDF5 */

DEFCMD (load, args, nargout,

  "-*- texinfo -*-\n\

@deffn {Command} load options file v1 v2 @dots{}\n\

Load the named variables @var{v1}, @var{v2}, @dots{}, from the file\n\

@var{file}.  As with @code{save}, you may specify a list of variables\n\

and @code{load} will only extract those variables with names that\n\

match.  For example, to restore the variables saved in the file\n\

@file{data}, use the command\n\

\n\

@example\n\

load data\n\

@end example\n\

\n\

If load is invoked using the functional form\n\

\n\

@example\n\

load (\"-option1\", @dots{}, \"file\", \"v1\", @dots{})\n\

@end example\n\

\n\

@noindent\n\

then the @var{options}, @var{file}, and variable name arguments\n\

(@var{v1}, @dots{}) must be specified as character strings.\n\

\n\

If a variable that is not marked as global is loaded from a file when a\n\

global symbol with the same name already exists, it is loaded in the\n\

global symbol table.  Also, if a variable is marked as global in a file\n\

and a local symbol exists, the local symbol is moved to the global\n\

symbol table and given the value from the file.  Since it seems that\n\

both of these cases are likely to be the result of some sort of error,\n\

they will generate warnings.\n\

\n\

If invoked with a single output argument, Octave returns data instead\n\

of inserting variables in the symbol table.  If the data file contains\n\

only numbers (TAB- or space-delimited columns), a matrix of values is\n\

returned.  Otherwise, @code{load} returns a structure with members\n\

 corresponding to the names of the variables in the file.\n\

\n\

The @code{load} command can read data stored in Octave's text and\n\

binary formats, and @sc{Matlab}'s binary format.  It will automatically\n\

detect the type of file and do conversion from different floating point\n\

formats (currently only IEEE big and little endian, though other formats\n\

may added in the future).\n\

\n\

Valid options for @code{load} are listed in the following table.\n\

\n\

@table @code\n\

@item -force\n\

The @samp{-force} option is accepted but ignored for backward\n\

compatibility. Octave now overwrites variables currently in memory with\n\

the same name as those found in the file.\n\

\n\

@item -ascii\n\

Force Octave to assume the file contains columns of numbers in text format\n\

without any header or other information.  Data in the file will be loaded\n\

as a single numeric matrix with the name of the variable derived from the\n\

name of the file.\n\

\n\

@item -binary\n\

Force Octave to assume the file is in Octave's binary format.\n\

\n\

@item -mat\n\

@itemx -mat-binary\n\

@itemx -6\n\

@itemx -v6\n\

@itemx -7\n\

@itemx -v7\n\

Force Octave to assume the file is in @sc{Matlab}'s version 6 or 7 binary\n\

format.\n\

\n\

@item -V4\n\

@itemx -v4\n\

@itemx -4\n\

@itemx -mat4-binary\n\

Force Octave to assume the file is in the binary format written by\n\

@sc{Matlab} version 4.\n\

\n\

@item -hdf5\n\

Force Octave to assume the file is in HDF5 format.\n\

(HDF5 is a free, portable binary format developed by the National\n\

Center for Supercomputing Applications at the University of Illinois.)\n\

Note that Octave can read HDF5 files not created by itself, but may\n\

skip some datasets in formats that it cannot support.\n"

HAVE_HDF5_HELP_STRING

"\n\

@item -import\n\

The @samp{-import} is accepted but ignored for backward compatibility.\n\

Octave can now support multi-dimensional HDF data and automatically\n\

modifies variable names if they are invalid Octave identifiers.\n\

\n\

@item -text\n\

Force Octave to assume the file is in Octave's text format.\n\

@end table\n\

@end deffn")

{

  octave_value_list retval;

  int argc = args.length () + 1;

  string_vector argv = args.make_argv ("load");

  if (error_state)

    return retval;

  // It isn't necessary to have the default load format stored in a

  // user preference variable since we can determine the type of file

  // as we are reading.

  load_save_format format = LS_UNKNOWN;

  bool force = true;

  bool list_only = false;

  bool verbose = false;

  int i;

  for (i = 1; i < argc; i++)

    {

      if (argv[i] == "-force" || argv[i] == "-f")

	{

	  // Silently ignore this

	  // warning ("load: -force ignored");

	}

      else if (argv[i] == "-list" || argv[i] == "-l")

	{

	  list_only = true;

	}

      else if (argv[i] == "-verbose" || argv[i] == "-v")

	{

	  verbose = true;

	}

      else if (argv[i] == "-ascii" || argv[i] == "-a")

	{

	  format = LS_MAT_ASCII;

	}

      else if (argv[i] == "-binary" || argv[i] == "-b")

	{

	  format = LS_BINARY;

	}

      else if (argv[i] == "-mat-binary" || argv[i] == "-mat" || argv[i] == "-m"

	       || argv[i] == "-6" || argv[i] == "-v6")

	{

	  format = LS_MAT5_BINARY;

	}

      else if (argv[i] == "-7" || argv[i] == "-v7")

	{

	  format = LS_MAT7_BINARY;

	}

      else if (argv[i] == "-mat4-binary" || argv[i] == "-V4"

	       || argv[i] == "-v4" || argv[i] == "-4")

	{

	  format = LS_MAT_BINARY;

	}

      else if (argv[i] == "-hdf5" || argv[i] == "-h")

	{

#ifdef HAVE_HDF5

	  format = LS_HDF5;

#else /* ! HAVE_HDF5 */

	  error ("load: octave executable was not linked with HDF5 library");

	  return retval;

#endif /* ! HAVE_HDF5 */

	}

      else if (argv[i] == "-import" || argv[i] == "-i")

	{

	  warning ("load: -import ignored");

	}

      else if (argv[i] == "-text" || argv[i] == "-t")

	{

	  format = LS_ASCII;

	}

      else

	break;

    }

  if (i == argc)

    {

      print_usage ();

      return retval;

    }

  std::string orig_fname = argv[i];

  oct_mach_info::float_format flt_fmt = oct_mach_info::flt_fmt_unknown;

  bool swap = false;

  if (argv[i] == "-")

    {

      i++;

#ifdef HAVE_HDF5

      if (format == LS_HDF5)

	error ("load: cannot read HDF5 format from stdin");

      else

#endif /* HAVE_HDF5 */

      if (format != LS_UNKNOWN)

	{

	  // FIXME -- if we have already seen EOF on a

	  // previous call, how do we fix up the state of std::cin so

	  // that we can get additional input?  I'm afraid that we

	  // can't fix this using std::cin only.

	  retval = do_load (std::cin, orig_fname, force, format, flt_fmt,

			    list_only, swap, verbose, argv, i, argc,

			    nargout);

	}

      else

	error ("load: must specify file format if reading from stdin");

    }

  else

    {

      std::string fname = file_ops::tilde_expand (argv[i]);

      fname = find_file_to_load (fname, orig_fname);

      if (error_state)

	return retval;

      bool use_zlib = false;

      if (format == LS_UNKNOWN)

	format = get_file_format (fname, orig_fname, use_zlib);

#ifdef HAVE_HDF5

      if (format == LS_HDF5)

	{

	  i++;

	  hdf5_ifstream hdf5_file (fname.c_str ());

	  if (hdf5_file.file_id >= 0)

	    {

	      retval = do_load (hdf5_file, orig_fname, force, format,

				flt_fmt, list_only, swap, verbose,

				argv, i, argc, nargout);

	      hdf5_file.close ();

	    }

	  else

	    gripe_file_open ("load", orig_fname);

	}

      else

#endif /* HAVE_HDF5 */

	// don't insert any statements here; the "else" above has to

	// go with the "if" below!!!!!

      if (format != LS_UNKNOWN)

	{

	  i++;

	  std::ios::openmode mode = std::ios::in;

	  // Open in binary mode in any case, to fix annoying bug that

	  // text-mode opened streams cannot be seekg'ed/tellg'ed with

	  // mingw32 (See http://oldwiki.mingw.org/index.php/Known%20Problems )

	  // The CR/LF issues are handled in ls-ascii-helper.cc

	  mode |= std::ios::binary;

#ifdef HAVE_ZLIB

	  if (use_zlib)

	    {

	      gzifstream file (fname.c_str (), mode);

	      if (file)

		{

		  if (format == LS_BINARY)

		    {

		      if (read_binary_file_header (file, swap, flt_fmt) < 0)

			{

			  if (file) file.close ();

			  return retval;

			}

		    }

		  else if (format == LS_MAT5_BINARY 

			   || format == LS_MAT7_BINARY)

		    {

		      if (read_mat5_binary_file_header (file, swap, false, orig_fname) < 0)

			{

			  if (file) file.close ();

			  return retval;

			}

		    }

		  retval = do_load (file, orig_fname, force, format,

				    flt_fmt, list_only, swap, verbose,

				argv, i, argc, nargout);

		  file.close ();

		}

	      else

		gripe_file_open ("load", orig_fname);

	    }

	  else

#endif

	    {

	      std::ifstream file (fname.c_str (), mode);

	      if (file)

		{

		  if (format == LS_BINARY)

		    {

		      if (read_binary_file_header (file, swap, flt_fmt) < 0)

			{

			  if (file) file.close ();

			  return retval;

			}

		    }

		  else if (format == LS_MAT5_BINARY 

			   || format == LS_MAT7_BINARY)

		    {

		      if (read_mat5_binary_file_header (file, swap, false, orig_fname) < 0)

			{

			  if (file) file.close ();

			  return retval;

			}

		    }

		  retval = do_load (file, orig_fname, force, format,

				    flt_fmt, list_only, swap, verbose,

				    argv, i, argc, nargout);

		  file.close ();

		}

	      else

		error ("load: unable open input file `%s'",

		       orig_fname.c_str ());

	    }

	}

    }

  return retval;

}

// Return TRUE if PATTERN has any special globbing chars in it.

static bool

glob_pattern_p (const std::string& pattern)

{