--- a/liboctave/ChangeLog
+++ b/liboctave/ChangeLog
@@ -1,3 +1,36 @@
+Sun May  4 22:17:08 1997  John W. Eaton  <jwe@bevo.che.wisc.edu>
+
+	* statdefs.h: Only include sys/types.h if HAVE_SYS_STAT_H is defined.
+
+	* mach-info.h, mach-info.cc: Add missing const qualifiers.
+	(instance_ok ()): New function.
+
+	* glob-match.h, glob-match.cc: Rename from oct-glob.h, oct-glob.cc.
+
+	* cmd-hist.h, cmd-hist.cc: Make it work without GNU readline.
+
+	* lo-utils.h, lo-utils.cc (strsave, octave_putenv): Move here from
+	src/utils.h and src/utils.cc.
+	(octave_fgets): New function, extracted from src/input.cc.
+
+	* cmd-edit.h, cmd-edit.cc: New files.  Provide wrapper class for
+	GNU readline, and allow Octave to work without GNU readline.
+
+	* lo-sysdep.h, lo-sysdep.cc: New files for miscellaneous
+	system-dependent functions.
+
+	* oct-env.h, oct-env.cc: New files for process environment stuff.
+
+	* file-stat.h, file-stat.cc: New files.  Extract file_stat class
+	from file-ops.h and file-ops.cc and move here.
+
+	* file-ops.h, file-ops.cc: Wrap functions in struct.  Move
+	tilde_expand functions here from src/dirfns.cc.
+
+Fri May  2 19:50:12 1997  John W. Eaton  <jwe@bevo.che.wisc.edu>
+
+	* pathlen.h: New file, from ../src.
+
 Tue Apr 29 04:39:01 1997  John W. Eaton  <jwe@bevo.che.wisc.edu>
 
 	* Array2-idx.h (Array2<T>::maybe_delete_elements): Prevent

--- a/liboctave/Makefile.in
+++ b/liboctave/Makefile.in
@@ -43,11 +43,12 @@
 INCLUDES := Bounds.h CollocWt.h DAE.h DAEFunc.h DASSL.h FEGrid.h FSQP.h \
 	LinConst.h LP.h LPsolve.h LSODE.h NLConst.h NLEqn.h NLFunc.h \
 	NLP.h NPSOL.h ODE.h ODEFunc.h Objective.h QP.h QPSOL.h Quad.h \
-	Range.h base-de.h base-min.h byte-swap.h cmd-hist.h data-conv.h \
-	dir-ops.h file-ops.h getopt.h idx-vector.h \
-	lo-ieee.h lo-mappers.h lo-utils.h mach-info.h oct-alloc.h \
-	oct-cmplx.h oct-glob.h oct-math.h oct-term.h pathsearch.h \
-	prog-args.h statdefs.h str-vec.h sun-utils.h sysdir.h \
+	Range.h base-de.h base-min.h byte-swap.h cmd-edit.h cmd-hist.h \
+	data-conv.h dir-ops.h file-ops.h file-stat.h getopt.h \
+	glob-match.h idx-vector.h lo-ieee.h lo-mappers.h lo-sysdep.h \
+	lo-utils.h mach-info.h oct-alloc.h oct-cmplx.h oct-env.h \
+	oct-math.h pathsearch.h prog-args.h statdefs.h str-vec.h \
+	sun-utils.h sysdir.h \
 	$(MATRIX_INC) \
 	$(MX_OP_INC)
 
@@ -75,12 +76,13 @@
 
 SOURCES := Bounds.cc CollocWt.cc DAE.cc DASSL.cc FEGrid.cc FSQP.cc \
 	LinConst.cc LPsolve.cc LSODE.cc NLEqn.cc NPSOL.cc QPSOL.cc \
-	Quad.cc Range.cc acosh.c asinh.c atanh.c cmd-hist.cc \
-	data-conv.cc dir-ops.cc erf.c erfc.c f2c-main.c file-ops.cc \
-	filemode.c gamma.c getopt.c getopt1.c idx-vector.cc lgamma.c \
-	lo-ieee.cc lo-mappers.cc lo-utils.cc mach-info.cc mkdir.c \
-	oct-alloc.cc oct-glob.cc oct-term.cc pathsearch.cc \
-	prog-args.cc rename.c rmdir.c str-vec.cc tempname.c tempnam.c \
+	Quad.cc Range.cc acosh.c asinh.c atanh.c cmd-edit.cc \
+	cmd-hist.cc data-conv.cc dir-ops.cc erf.c erfc.c f2c-main.c \
+	file-ops.cc file-stat.cc filemode.c gamma.c getopt.c getopt1.c \
+	glob-match.cc idx-vector.cc lgamma.c lo-ieee.cc lo-mappers.cc \
+	lo-sysdep.cc lo-utils.cc mach-info.cc mkdir.c oct-alloc.cc \
+	oct-env.cc pathsearch.cc prog-args.cc rename.c rmdir.c \
+	str-vec.cc tempname.c tempnam.c \
 	$(TEMPLATE_SRC) \
 	$(TI_SRC) \
 	$(MATRIX_SRC) \

new file mode 100644
--- /dev/null
+++ b/liboctave/cmd-edit.cc
@@ -0,0 +1,850 @@
+/*
+
+Copyright (C) 1996, 1997 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 2, 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, write to the Free
+Software Foundation, 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+*/
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <cstring>
+#include <ctime>
+
+#include <string>
+
+#ifdef HAVE_UNISTD_H
+#ifdef HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+#include <unistd.h>
+#endif
+
+#include "cmd-edit.h"
+#include "cmd-hist.h"
+#include "lo-error.h"
+#include "lo-utils.h"
+#include "oct-env.h"
+
+command_editor *command_editor::instance = 0;
+
+#if defined (USE_READLINE)
+
+#include <cstdio>
+#include <cstdlib>
+
+#include <readline/readline.h>
+
+// It would be nice if readline.h declared these, I think.
+
+extern "C" void rl_deprep_terminal (void);
+
+extern int rl_blink_matching_paren;
+
+extern int screenheight;
+
+extern int screenwidth;
+
+class
+gnu_readline : public command_editor
+{
+public:
+
+  typedef command_editor::fcn fcn;
+
+  gnu_readline (void);
+
+  ~gnu_readline (void) { }
+
+  void do_set_name (const string& n);
+
+  string do_readline (const string& prompt);
+
+  void do_set_input_stream (FILE *f);
+
+  FILE *do_get_input_stream (void);
+
+  void do_set_output_stream (FILE *f);
+
+  FILE *do_get_output_stream (void);
+
+  int do_terminal_rows (void);
+
+  int do_terminal_cols (void);
+
+  void do_clear_screen (void);
+
+  string newline_chars (void);
+
+  void do_restore_terminal_state (void);
+
+  void do_blink_matching_paren (bool flag);
+
+  void do_set_paren_string_delimiters (const string& s);
+
+  void do_set_completion_append_character (char c);
+
+  void do_set_attempted_completion_function (fcn f);
+
+  void do_insert_text (const string& text);
+
+  void do_newline (void);
+
+  void do_clear_undo_list (void);
+
+  void do_set_startup_hook (fcn f);
+
+  void do_restore_startup_hook (void);
+
+  static void operate_and_get_next (int, int);
+
+private:
+
+  fcn previous_startup_hook;
+
+  fcn attempted_completion_function;
+};
+
+gnu_readline::gnu_readline ()
+  : command_editor (), previous_startup_hook (0),
+    attempted_completion_function (0)
+{
+  rl_initialize ();
+
+  do_blink_matching_paren (true);
+
+  // Bind operate-and-get-next.
+
+  rl_add_defun ("operate-and-get-next",
+		gnu_readline::operate_and_get_next, CTRL ('O'));
+
+  // And the history search functions.
+
+  rl_add_defun ("history-search-backward",
+		rl_history_search_backward, META ('p'));
+
+  rl_add_defun ("history-search-forward",
+		rl_history_search_forward, META ('n'));
+}
+
+void
+gnu_readline::do_set_name (const string& n)
+{
+  static char *nm = 0;
+
+  delete [] nm;
+
+  nm = strsave (n.c_str ());
+
+  rl_readline_name = nm;
+
+  // Since we've already called rl_initialize, we need to re-read the
+  // init file to take advantage of the conditional parsing feature
+  // based on rl_readline_name;
+
+  rl_re_read_init_file ();
+}
+
+string
+gnu_readline::do_readline (const string& prompt)
+{
+  string retval;
+
+  char *line = ::readline (prompt.c_str ());
+
+  if (line)
+    {
+      retval = line;
+
+      free (line);
+    }
+
+  return retval;
+}
+
+void
+gnu_readline::do_set_input_stream (FILE *f)
+{
+  rl_instream = f;
+}
+
+FILE *
+gnu_readline::do_get_input_stream (void)
+{
+  return rl_instream;
+}
+
+void
+gnu_readline::do_set_output_stream (FILE *f)
+{
+  rl_outstream = f;
+}
+
+FILE *
+gnu_readline::do_get_output_stream (void)
+{
+  return rl_outstream;
+}
+
+// GNU readline handles SIGWINCH, so these values have a good chance
+// of being correct even if the window changes size (they may be
+// wrong if, for example, the luser changes the window size while the
+// pager is running, and the signal is handled by the pager instead of
+// us.
+
+int
+gnu_readline::do_terminal_rows (void)
+{
+  return screenheight > 0 ? screenheight : 24;
+}
+
+int
+gnu_readline::do_terminal_cols (void)
+{
+  return screenwidth > 0 ? screenwidth : 80;
+}
+
+void
+gnu_readline::do_clear_screen (void)
+{
+  rl_clear_screen ();
+}
+
+string
+gnu_readline::newline_chars (void)
+{
+  return "\r\n";
+}
+
+void
+gnu_readline::do_restore_terminal_state (void)
+{
+  rl_deprep_terminal ();
+}
+
+void
+gnu_readline::do_blink_matching_paren (bool flag)
+{
+  rl_blink_matching_paren = flag ? 1 : 0;
+}
+
+void
+gnu_readline::do_set_paren_string_delimiters (const string& s)
+{
+  static char *ss = 0;
+
+  delete [] ss;
+
+  ss = strsave (s.c_str ());
+
+  rl_paren_string_delimiters = ss;
+}
+
+void
+gnu_readline::do_set_completion_append_character (char c)
+{
+  rl_completion_append_character = c;
+}
+
+void
+gnu_readline::do_set_attempted_completion_function (fcn f)
+{
+  attempted_completion_function = f;
+}
+
+void
+gnu_readline::do_insert_text (const string& text)
+{
+  rl_insert_text (text.c_str ());
+}
+
+void
+gnu_readline::do_newline (void)
+{
+  rl_newline ();
+}
+
+void
+gnu_readline::do_clear_undo_list ()
+{
+  if (rl_undo_list)
+    {
+      free_undo_list ();
+
+      rl_undo_list = 0;
+    }
+}
+
+void
+gnu_readline::do_set_startup_hook (fcn f)
+{
+  previous_startup_hook = rl_startup_hook;
+
+  rl_startup_hook = f;
+}
+
+void
+gnu_readline::do_restore_startup_hook (void)
+{
+  rl_startup_hook = previous_startup_hook;
+}
+
+void
+gnu_readline::operate_and_get_next (int /* count */, int /* c */)
+{
+  // Accept the current line.
+
+  command_editor::newline ();
+
+  // Find the current line, and find the next line to use.
+
+  int x_where = command_history::where ();
+
+  int x_length = command_history::length ();
+
+  if ((command_history::is_stifled ()
+       && (x_length >= command_history::max_input_history ()))
+      || (x_where >= x_length - 1))
+    command_history::set_mark (x_where);
+  else
+    command_history::set_mark (x_where + 1);
+
+  command_editor::set_startup_hook (command_history::goto_mark);
+}
+
+#endif
+
+class
+default_command_editor : public command_editor
+{
+public:
+
+  default_command_editor (void)
+    : command_editor (), input_stream (stdin), output_stream (stdout) { }
+
+  ~default_command_editor (void) { }
+
+  string do_readline (const string& prompt);
+
+  void do_set_input_stream (FILE *f);
+
+  FILE *do_get_input_stream (void);
+
+  void do_set_output_stream (FILE *f);
+
+  FILE *do_get_output_stream (void);
+
+  void do_insert_text (const string&);
+
+  void do_newline (void);
+
+private:
+
+  FILE *input_stream;
+
+  FILE *output_stream;
+};
+
+string
+default_command_editor::do_readline (const string& prompt)
+{
+  fprintf (output_stream, prompt.c_str ());
+  fflush (output_stream);
+
+  return octave_fgets (input_stream);
+}
+
+void
+default_command_editor::do_set_input_stream (FILE *f)
+{
+  input_stream = f;
+}
+
+FILE *
+default_command_editor::do_get_input_stream (void)
+{
+  return input_stream;
+}
+
+void
+default_command_editor::do_set_output_stream (FILE *f)
+{
+  output_stream = f;
+}
+
+FILE *
+default_command_editor::do_get_output_stream (void)
+{
+  return output_stream;
+}
+
+void
+default_command_editor::do_insert_text (const string&)
+{
+  // XXX FIXME XXX
+}
+
+void
+default_command_editor::do_newline (void)
+{
+  // XXX FIXME XXX
+}
+
+bool
+command_editor::instance_ok (void)
+{
+  bool retval = true;
+
+  if (! instance)
+    make_command_editor ();
+
+  if (! instance)
+    {
+      (*current_liboctave_error_handler)
+	("unable to create command history object!");
+
+      retval = false;
+    }
+
+  return retval;
+}
+
+void
+command_editor::make_command_editor (void)
+{
+#if defined (USE_READLINE)
+  instance = new gnu_readline ();
+#else
+  instance = new default_command_editor ();
+#endif
+}
+
+void
+command_editor::set_name (const string& n)
+{
+  if (instance_ok ())
+    instance->do_set_name (n);
+}
+
+string
+command_editor::readline (const string& prompt)
+{
+  return (instance_ok ())
+    ? instance->do_readline (prompt) : string ();
+}
+
+void
+command_editor::set_input_stream (FILE *f)
+{
+  if (instance_ok ())
+    instance->do_set_input_stream (f);
+}
+
+FILE *
+command_editor::get_input_stream (void)
+{
+  return (instance_ok ())
+    ? instance->do_get_input_stream () : 0;
+}
+
+void
+command_editor::set_output_stream (FILE *f)
+{
+  if (instance_ok ())
+    instance->do_set_output_stream (f);
+}
+
+FILE *
+command_editor::get_output_stream (void)
+{
+  return (instance_ok ())
+    ? instance->do_get_output_stream () : 0;
+}
+
+int
+command_editor::terminal_rows (void)
+{
+  return (instance_ok ())
+    ? instance->do_terminal_rows () : -1;
+}
+
+int
+command_editor::terminal_cols (void)
+{
+  return (instance_ok ())
+    ? instance->do_terminal_cols () : -1;
+}
+
+void
+command_editor::clear_screen (void)
+{
+  if (instance_ok ())
+    instance->do_clear_screen ();
+}
+
+string
+command_editor::decode_prompt_string (const string& s)
+{
+  return (instance_ok ())
+    ? instance->do_decode_prompt_string (s) : string ();
+}
+
+int
+command_editor::current_command_number (void)
+{
+  return (instance_ok ())
+    ? instance->command_number : 0;
+}
+
+void
+command_editor::reset_current_command_number (int n)
+{
+  if (instance_ok ())
+    instance->command_number = n;
+}
+
+void
+command_editor::restore_terminal_state (void)
+{
+  if (instance_ok ())
+    instance->do_restore_terminal_state ();
+}
+
+void
+command_editor::blink_matching_paren (bool flag)
+{
+  if (instance_ok ())
+    instance->do_blink_matching_paren (flag);
+}
+
+void
+command_editor::set_paren_string_delimiters (const string& s)
+{
+  if (instance_ok ())
+    instance->do_set_paren_string_delimiters (s);
+}
+
+void
+command_editor::set_completion_append_character (char c)
+{
+  if (instance_ok ())
+    instance->do_set_completion_append_character (c);
+}
+
+void
+command_editor::set_attempted_completion_function (fcn f)
+{
+  if (instance_ok ())
+    instance->do_set_attempted_completion_function (f);
+}
+
+void
+command_editor::insert_text (const string& text)
+{
+  if (instance_ok ())
+    instance->do_insert_text (text);
+}
+
+void
+command_editor::newline (void)
+{
+  if (instance_ok ())
+    instance->do_newline ();
+}
+
+void
+command_editor::clear_undo_list (void)
+{
+  if (instance_ok ())
+    instance->do_clear_undo_list ();
+}
+
+void
+command_editor::set_startup_hook (fcn f)
+{
+  if (instance_ok ())
+    instance->do_set_startup_hook (f);
+}
+
+void
+command_editor::restore_startup_hook (void)
+{
+  if (instance_ok ())
+    instance->do_restore_startup_hook ();
+}
+
+// Return a string which will be printed as a prompt.  The string may
+// contain special characters which are decoded as follows: 
+//   
+//	\t	the time
+//	\d	the date
+//	\n	CRLF
+//	\s	the name of the shell (program)
+//	\w	the current working directory
+//	\W	the last element of PWD
+//	\u	your username
+//	\h	the hostname
+//	\#	the command number of this command
+//	\!	the history number of this command
+//	\$	a $ or a # if you are root
+//	\<octal> character code in octal
+//	\\	a backslash
+
+string
+command_editor::do_decode_prompt_string (const string& s)
+{
+  string result;
+  string temp;
+  size_t i = 0;
+  size_t slen = s.length ();
+  int c;
+
+  while (i < slen)
+    {
+      c = s[i];
+
+      i++;
+
+      if (c == '\\')
+	{
+	  c = s[i];
+
+	  switch (c)
+	    {
+	    case '0':
+	    case '1':
+	    case '2':
+	    case '3':
+	    case '4':
+	    case '5':
+	    case '6':
+	    case '7':
+	      // Maybe convert an octal number.
+	      {
+		int n = read_octal (s.substr (i, 3));
+
+		temp = "\\";
+
+		if (n != -1)
+		  {
+		    i += 3;
+		    temp[0] = n;
+		  }
+
+		c = 0;
+		goto add_string;
+	      }
+	  
+	    case 't':
+	    case 'd':
+	      // Make the current time/date into a string.
+	      {
+		time_t now = time (0);
+
+		temp = ctime (&now);
+
+		if (c == 't')
+		  {
+		    temp = temp.substr (11);
+		    temp.resize (8);
+		  }
+		else
+		  temp.resize (10);
+
+		goto add_string;
+	      }
+
+	    case 'n':
+	      {
+		temp = newline_chars ();
+
+		goto add_string;
+	      }
+
+	    case 's':
+	      {
+		temp = octave_env::get_program_name ();
+		temp = octave_env::base_pathname (temp);
+
+		goto add_string;
+	      }
+	
+	    case 'w':
+	    case 'W':
+	      {
+		temp = octave_env::getcwd ();
+
+		if (c == 'W')
+		  {
+		    size_t pos = temp.rfind ('/');
+
+		    if (pos != NPOS && pos != 0)
+		      temp = temp.substr (pos + 1);
+		  }
+		else
+		  temp = octave_env::polite_directory_format (temp);
+
+		goto add_string;
+	      }
+      
+	    case 'u':
+	      {
+		temp = octave_env::get_user_name ();
+
+		goto add_string;
+	      }
+
+	    case 'H':
+	      {
+		temp = octave_env::get_host_name ();
+
+		goto add_string;
+	      }
+
+	    case 'h':
+	      {
+		temp = octave_env::get_host_name ();
+
+		size_t pos = temp.find ('.');
+
+		if (pos != NPOS)
+		  temp.resize (pos);
+		
+		goto add_string;
+	      }
+
+	    case '#':
+	      {
+		char number_buffer[128];
+		sprintf (number_buffer, "%d", command_number);
+		temp = number_buffer;
+
+		goto add_string;
+	      }
+
+	    case '!':
+	      {
+		char number_buffer[128];
+		int num = command_history::current_number ();
+		if (num > 0)
+                  sprintf (number_buffer, "%d", num);
+		else
+		  strcpy (number_buffer, "!");
+		temp = number_buffer;
+
+		goto add_string;
+	      }
+
+	    case '$':
+	      {
+		temp = (::geteuid () == 0 ? "#" : "$");
+
+		goto add_string;
+	      }
+
+#if defined (USE_READLINE)
+	    case '[':
+	    case ']':
+	      {
+		temp.resize (2);
+
+		temp[0] = '\001';
+		temp[1] = ((c == '[')
+			   ? RL_PROMPT_START_IGNORE
+			   : RL_PROMPT_END_IGNORE);
+
+		goto add_string;
+	      }
+#endif
+
+	    case '\\':
+	      {
+		temp = "\\";
+
+		goto add_string;
+	      }
+
+	    default:
+	      {
+		temp = "\\ ";
+		temp[1] = c;
+
+		goto add_string;
+	      }
+
+	    add_string:
+	      {
+		if (c)
+		  i++;
+
+		result.append (temp);
+
+		break;
+	      }
+	    }
+	}
+      else
+	result += c;
+    }
+
+  return result;
+}
+
+// Return the octal number parsed from STRING, or -1 to indicate that
+// the string contained a bad number.
+
+int
+command_editor::read_octal (const string& s)
+{
+  int result = 0;
+  int digits = 0;
+
+  size_t i = 0;
+  size_t slen = s.length ();
+
+  while (i < slen && s[i] >= '0' && s[i] < '8')
+    {
+      digits++;
+      result = (result * 8) + s[i] - '0';
+      i++;
+    }
+
+  if (! digits || result > 0777 || i < slen)
+    result = -1;
+
+  return result;
+}
+
+void
+command_editor::error (int err_num)
+{
+  (*current_liboctave_error_handler) ("%s", strerror (err_num));
+}
+
+void
+command_editor::error (const string& s)
+{
+  (*current_liboctave_error_handler) ("%s", s.c_str ());
+}
+
+/*
+;;; Local Variables: ***
+;;; mode: C++ ***
+;;; End: ***
+*/

new file mode 100644
--- /dev/null
+++ b/liboctave/cmd-edit.h
@@ -0,0 +1,167 @@
+/*
+
+Copyright (C) 1996, 1997 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 2, 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, write to the Free
+Software Foundation, 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+*/
+
+#if !defined (octave_cmd_edit_h)
+#define octave_cmd_edit_h 1
+
+#include <cstdio>
+
+#include <string>
+
+class
+command_editor
+{
+protected:
+
+  command_editor (void)
+    : command_number (0) { }
+
+public:
+
+  typedef int (*fcn) (...);
+
+  virtual ~command_editor (void) { }
+
+  static void set_name (const string& n);
+
+  static string readline (const string& prompt);
+
+  static void set_input_stream (FILE *f);
+
+  static FILE *get_input_stream (void);
+
+  static void set_output_stream (FILE *f);
+
+  static FILE *get_output_stream (void);
+
+  static int terminal_rows (void);
+
+  static int terminal_cols (void);
+
+  static void clear_screen (void);
+
+  static string decode_prompt_string (const string& s);
+
+  static void restore_terminal_state (void);
+
+  static void blink_matching_paren (bool flag);
+
+  static void set_paren_string_delimiters (const string& s);
+
+  static void set_completion_append_character (char c);
+
+  static void set_attempted_completion_function (fcn f);
+
+  static void insert_text (const string& text);
+
+  static void newline (void);
+
+  static void clear_undo_list (void);
+
+  static void set_startup_hook (fcn f);
+
+  static void restore_startup_hook (void);
+
+  static int current_command_number (void);
+
+  static void reset_current_command_number (int n);
+
+private:
+
+  // No copying!
+
+  command_editor (const command_editor&);
+
+  command_editor& operator = (const command_editor&);
+
+  static bool instance_ok (void);
+
+  static void make_command_editor (void);
+
+  // The real thing.
+  static command_editor *instance;
+
+protected:
+
+  // To use something other than the GNU readline library, derive a new
+  // class from command_editor, overload these functions as
+  // necessary, and make instance point to the new class.
+
+  virtual void do_set_name (const string&) { }
+
+  virtual string do_readline (const string&) = 0;
+
+  virtual void do_set_input_stream (FILE *) = 0;
+
+  virtual FILE *do_get_input_stream (void) = 0;
+
+  virtual void do_set_output_stream (FILE *) = 0;
+
+  virtual FILE *do_get_output_stream (void) = 0;
+
+  virtual int do_terminal_rows (void) { return 24; }
+
+  virtual int do_terminal_cols (void) { return 80; }
+
+  virtual void do_clear_screen (void) { }
+
+  virtual string do_decode_prompt_string (const string&);
+
+  virtual string newline_chars (void) { return "\n"; } 
+
+  virtual void do_restore_terminal_state (void) { }
+
+  virtual void do_blink_matching_paren (bool) { }
+
+  virtual void do_set_paren_string_delimiters (const string&) { }
+
+  virtual void do_set_completion_append_character (char) { }
+
+  virtual void do_set_attempted_completion_function (fcn) { }
+
+  virtual void do_insert_text (const string&) = 0;
+
+  virtual void do_newline (void) = 0;
+
+  virtual void do_clear_undo_list (void) { }
+
+  virtual void do_set_startup_hook (fcn) { }
+
+  virtual void do_restore_startup_hook (void) { }
+
+  int read_octal (const string& s);
+
+  void error (int);
+
+  void error (const string&);
+
+  // The current command number.
+  int command_number;
+};
+
+#endif
+
+/*
+;;; Local Variables: ***
+;;; mode: C++ ***
+;;; End: ***
+*/

--- a/liboctave/cmd-hist.cc
+++ b/liboctave/cmd-hist.cc
@@ -26,6 +26,19 @@
 
 #include <cstring>
 
+#include <string>
+
+#include "cmd-edit.h"
+#include "cmd-hist.h"
+#include "lo-error.h"
+#include "str-vec.h"
+
+command_history *command_history::instance = 0;
+
+#if defined (USE_READLINE)
+
+#include <cstdlib>
+
 #include <strstream.h>
 
 #ifdef HAVE_FCNTL_H
@@ -41,95 +54,82 @@
 
 #include <readline/history.h>
 
-#include "file-ops.h"
-#include "lo-error.h"
-#include "cmd-hist.h"
+#include "file-stat.h"
 
-bool command_history::initialized = false;
-
-command_history::command_history (const string& f, int n)
+class
+gnu_history : public command_history
 {
-  if (initialized)
-    error ("only one history object can be active at once");
-  else
-    {
-      ignoring_additions = false;
+public:
+
+  gnu_history (void)
+    : command_history (), mark (0) { }
+
+  ~gnu_history (void) { }
+
+  void do_add (const string&);
+
+  void do_remove (int);
 
-      lines_in_file = 0;
-      lines_this_session = 0;
+  int do_where (void);
+
+  int do_length (void);
+
+  int do_max_input_history (void);
+
+  int do_base (void);
+
+  int do_current_number (void);
+
+  void do_stifle (int);
 
-      xsize = -1;
+  int do_unstifle (void);
+
+  int do_is_stifled (void);
+
+  void do_set_mark (int);
 
-      if (! f.empty ())
-	{
-	  xfile = f;
+  void do_goto_mark (void);
+
+  void do_read (const string&, bool);
 
-	  ::read_history (f.c_str ());
+  void do_read_range (const string&, int, int, bool);
 
-	  lines_in_file = where ();
+  void do_write (const string&);
 
-	  ::using_history ();
-	}
+  void do_append (const string&);
+
+  void do_truncate_file (const string&, int);
+
+  string_vector do_list (int, bool);
+
+  string do_get_entry (int);
 
-      if (n > 0)
-	xsize = n;
+  void do_replace_entry (int, const string&);
+
+  void do_clean_up_and_save (const string&, int);
 
-      initialized = true;
-    }
-}
+private:
+
+  int mark;
+};
 
 void
-command_history::set_file (const string& f)
-{
-  xfile = f;
-}
-
-string
-command_history::file (void)
-{
-  return xfile;
-}
-
-void
-command_history::set_size (int n)
-{
-  xsize = n;
-}
-
-int
-command_history::size (void)
+gnu_history::do_add (const string& s)
 {
-  return xsize;
-}
-
-void
-command_history::ignore_entries (bool flag)
-{
-  ignoring_additions = flag;
-}
-
-bool
-command_history::ignoring_entries (void)
-{
-  return ignoring_additions;
-}
-
-void
-command_history::add (const string& s)
-{
-  if (! ignoring_entries ())
+  if (! do_ignoring_entries ())
     {
       if (s.empty ()
 	  || (s.length () == 1 && (s[0] == '\r' || s[0] == '\n')))
 	return;
 
       ::add_history (s.c_str ());
+
       lines_this_session++;
     }
 }
 
 void
-command_history::remove (int n)
+gnu_history::do_remove (int n)
 {
   HIST_ENTRY *discard = ::remove_history (n);
 
@@ -143,49 +143,87 @@
 }
 
 int
-command_history::where (void)
+gnu_history::do_where (void)
 {
   return ::where_history ();
 }
 
 int
-command_history::base (void)
+gnu_history::do_length (void)
+{
+  return ::history_length;
+}
+
+int
+gnu_history::do_max_input_history (void)
+{
+  return ::max_input_history;
+}
+
+int
+gnu_history::do_base (void)
 {
   return ::history_base;
 }
 
 int
-command_history::current_number (void)
+gnu_history::do_current_number (void)
 {
-  return (xsize > 0) ? base () + where () : -1;
+  return (xsize > 0) ? do_base () + do_where () : -1;
 }
 
 void
-command_history::stifle (int n)
+gnu_history::do_stifle (int n)
 {
   ::stifle_history (n);
 }
 
 int
-command_history::unstifle (void)
+gnu_history::do_unstifle (void)
 {
   return ::unstifle_history ();
 }
 
 int
-command_history::is_stifled (void)
+gnu_history::do_is_stifled (void)
 {
   return ::history_is_stifled ();
 }
 
 void
-command_history::read (bool must_exist)
+gnu_history::do_set_mark (int n)
 {
-  read (xfile, must_exist);
+  mark = n;
 }
 
 void
-command_history::read (const string& f, bool must_exist)
+gnu_history::do_goto_mark (void)
+{
+  HIST_ENTRY *h;
+
+  if (mark)
+    {
+      if (history_set_pos (mark))
+	{
+	  h = ::current_history ();
+
+	  if (h)
+	    {
+	      command_editor::insert_text (h->line);
+
+	      command_editor::clear_undo_list ();
+	    }
+	}
+    }
+
+  mark = 0;
+
+  // XXX FIXME XXX -- for operate_and_get_next.
+  command_editor::restore_startup_hook ();
+}
+
+void
+gnu_history::do_read (const string& f, bool must_exist)
 {
   if (! f.empty ())
     {
@@ -195,24 +233,18 @@
 	error (status);
       else
 	{
-	  lines_in_file = where ();
+	  lines_in_file = do_where ();
 
 	  ::using_history ();
 	}
     }
   else
-    error ("command_history::read: missing file name");
+    error ("gnu_history::read: missing file name");
 }
 
 void
-command_history::read_range (int from, int to, bool must_exist)
-{
-  read_range (xfile, from, to, must_exist);
-}
-
-void
-command_history::read_range (const string& f, int from, int to,
-			     bool must_exist)
+gnu_history::do_read_range (const string& f, int from, int to,
+			    bool must_exist)
 {
   if (from < 0)
     from = lines_in_file;
@@ -225,17 +257,17 @@
 	error (status);
       else
 	{
-	  lines_in_file = where ();
+	  lines_in_file = do_where ();
 
 	  ::using_history ();
 	}
     }
   else
-    error ("command_history::read_range: missing file name");
+    error ("gnu_history::read_range: missing file name");
 }
 
 void
-command_history::write (const string& f_arg)
+gnu_history::do_write (const string& f_arg)
 {
   string f = f_arg;
 
@@ -250,15 +282,15 @@
 	error (status);
     }
   else
-    error ("command_history::write: missing file name");
+    error ("gnu_history::write: missing file name");
 }
 
 void
-command_history::append (const string& f_arg)
+gnu_history::do_append (const string& f_arg)
 {
   if (lines_this_session)
     {
-      if (lines_this_session < where ())
+      if (lines_this_session < do_where ())
 	{
 	  // Create file if it doesn't already exist.
 
@@ -289,13 +321,13 @@
 	      lines_this_session = 0;
 	    }
 	  else
-	    error ("comman_history::append: missing file name");
+	    error ("gnu_history::append: missing file name");
 	}
     }
 }
 
 void
-command_history::truncate_file (const string& f_arg, int n)
+gnu_history::do_truncate_file (const string& f_arg, int n)
 {
   string f = f_arg;
 
@@ -305,11 +337,11 @@
   if (! f.empty ())
     ::history_truncate_file (f.c_str (), n);
   else
-    error ("command_history::truncate_file: missing file name");
+    error ("gnu_history::truncate_file: missing file name");
 }
 
 string_vector
-command_history::list (int limit, int number_lines)
+gnu_history::do_list (int limit, bool number_lines)
 {
   string_vector retval;
 
@@ -333,7 +365,7 @@
 	      ostrstream output_buf;
 
 	      if (number_lines)
-		output_buf.form ("%5d%c", i + ::history_base,
+		output_buf.form ("%5d%c", i + do_base (),
 				 hlist[i]->data ? '*' : ' '); 
 
 	      output_buf << hlist[i]->line << ends;
@@ -351,11 +383,11 @@
 }
 
 string
-command_history::get_entry (int n)
+gnu_history::do_get_entry (int n)
 {
   string retval;
 
-  HIST_ENTRY *entry = ::history_get (::history_base + n);
+  HIST_ENTRY *entry = ::history_get (do_base () + n);
 
   if (entry && entry->line)
     retval = entry->line;
@@ -364,7 +396,7 @@
 }
 
 void
-command_history::replace_entry (int which, const string& line)
+gnu_history::do_replace_entry (int which, const string& line)
 {
   HIST_ENTRY *discard = ::replace_history_entry (which, line.c_str (), 0);
 
@@ -378,7 +410,7 @@
 }
 
 void
-command_history::clean_up_and_save (const string& f_arg, int n)
+gnu_history::do_clean_up_and_save (const string& f_arg, int n)
 {
   string f = f_arg;
 
@@ -392,9 +424,448 @@
 
       stifle (n);
 
-      ::write_history (f.c_str ());
+      do_write (f.c_str ());
     }
   else
+    error ("gnu_history::clean_up_and_save: missing file name");
+}
+
+#endif
+
+bool
+command_history::instance_ok (void)
+{
+  bool retval = true;
+
+  if (! instance)
+    make_command_history ();
+
+  if (! instance)
+    {
+      (*current_liboctave_error_handler)
+	("unable to create command history object!");
+
+      retval = false;
+    }
+
+  return retval;
+}
+
+void
+command_history::make_command_history (void)
+{
+#if defined (USE_READLINE)
+  instance = new gnu_history ();
+#else
+  instance = new command_history ();
+#endif
+}
+
+void
+command_history::set_file (const string& f)
+{
+  if (instance_ok ())
+    instance->do_set_file (f);
+}
+
+string
+command_history::file (void)
+{
+  return (instance_ok ())
+    ? instance->do_file () : string ();
+}
+
+void
+command_history::set_size (int n)
+{
+  if (instance_ok ())
+    instance->do_set_size (n);
+}
+
+int
+command_history::size (void)
+{
+  return (instance_ok ())
+    ? instance->do_size () : 0;
+}
+
+void
+command_history::ignore_entries (bool flag)
+{
+  if (instance_ok ())
+    instance->do_ignore_entries (flag);
+}
+
+bool
+command_history::ignoring_entries (void)
+{
+  return (instance_ok ())
+    ? instance->do_ignoring_entries () : false;
+}
+
+void
+command_history::add (const string& s)
+{
+  if (instance_ok ())
+    instance->do_add (s);
+}
+
+void
+command_history::remove (int n)
+{
+  if (instance_ok ())
+    instance->do_remove (n);
+}
+
+int
+command_history::where (void)
+{
+  return (instance_ok ())
+    ? instance->do_where () : 0;
+}
+
+int
+command_history::length (void)
+{
+  return (instance_ok ())
+    ? instance->do_length () : 0;
+}
+
+int
+command_history::max_input_history (void)
+{
+  return (instance_ok ())
+    ? instance->do_max_input_history () : 0;
+}
+
+int
+command_history::base (void)
+{
+  return (instance_ok ())
+    ? instance->do_base () : 0;
+}
+
+int
+command_history::current_number (void)
+{
+  return (instance_ok ())
+    ? instance->do_current_number () : 0;
+}
+
+void
+command_history::stifle (int n)
+{
+  if (instance_ok ())
+    instance->do_stifle (n);
+}
+
+int
+command_history::unstifle (void)
+{
+  return (instance_ok ())
+    ? instance->do_unstifle () : 0;
+}
+
+int
+command_history::is_stifled (void)
+{
+  return (instance_ok ())
+    ? instance->do_is_stifled () : 0;
+}
+
+void
+command_history::set_mark (int n)
+{
+  if (instance_ok ())
+    instance->do_set_mark (n);
+}
+
+int
+command_history::goto_mark (...)
+{
+  if (instance_ok ())
+    instance->do_goto_mark ();
+
+  return 0;
+}
+
+void
+command_history::read (bool must_exist)
+{
+  if (instance_ok ())
+    instance->do_read (must_exist);
+}
+
+void
+command_history::read (const string& f, bool must_exist)
+{
+  if (instance_ok ())
+    instance->do_read (f, must_exist);
+}
+
+void
+command_history::read_range (int from, int to, bool must_exist)
+{
+  if (instance_ok ())
+    instance->do_read_range (from, to, must_exist);
+}
+
+void
+command_history::read_range (const string& f, int from, int to,
+			     bool must_exist) 
+{
+  if (instance_ok ())
+    instance->do_read_range (f, from, to, must_exist);
+}
+
+void
+command_history::write (const string& f)
+{
+  if (instance_ok ())
+    instance->do_write (f);
+}
+
+void
+command_history::append (const string& f)
+{
+  if (instance_ok ())
+    instance->do_append (f);
+}
+
+void
+command_history::truncate_file (const string& f, int n)
+{
+  if (instance_ok ())
+    instance->do_truncate_file (f, n);
+}
+
+string_vector
+command_history::list (int limit, bool number_lines)
+{
+  return (instance_ok ())
+    ? instance->do_list (limit, number_lines) : string_vector ();
+}
+
+string
+command_history::get_entry (int n)
+{
+  return (instance_ok ())
+    ? instance->do_get_entry (n) : string ();
+}
+
+void
+command_history::replace_entry (int which, const string& line)
+{
+  if (instance_ok ())
+    instance->do_replace_entry (which, line);
+}
+
+void
+command_history::clean_up_and_save (const string& f, int n)
+{
+  if (instance_ok ())
+    instance->do_clean_up_and_save (f, n);
+}
+
+void
+command_history::do_set_file (const string& f)
+{
+  xfile = f;
+}
+
+string
+command_history::do_file (void)
+{
+  return xfile;
+}
+
+void
+command_history::do_set_size (int n)
+{
+  xsize = n;
+}
+
+int
+command_history::do_size (void)
+{
+  return xsize;
+}
+
+void
+command_history::do_ignore_entries (bool flag)
+{
+  ignoring_additions = flag;
+}
+
+bool
+command_history::do_ignoring_entries (void)
+{
+  return ignoring_additions;
+}
+
+void
+command_history::do_add (const string&)
+{
+}
+
+void
+command_history::do_remove (int)
+{
+}
+
+int
+command_history::do_where (void)
+{
+  return 0;
+}
+
+int
+command_history::do_length (void)
+{
+  return 0;
+}
+
+int
+command_history::do_max_input_history (void)
+{
+  return 0;
+}
+
+int
+command_history::do_base (void)
+{
+  return 0;
+}
+
+int
+command_history::do_current_number (void)
+{
+  return (xsize > 0) ? do_base () + do_where () : -1;
+}
+
+void
+command_history::do_stifle (int)
+{
+}
+
+int
+command_history::do_unstifle (void)
+{
+  return -1;
+}
+
+int
+command_history::do_is_stifled (void)
+{
+  return 0;
+}
+
+void
+command_history::do_set_mark (int)
+{
+}
+
+void
+command_history::do_goto_mark (void)
+{
+}
+
+void
+command_history::do_read (bool must_exist)
+{
+  do_read (xfile, must_exist);
+}
+
+void
+command_history::do_read (const string& f, bool)
+{
+  if (f.empty ())
+    error ("command_history::read: missing file name");
+}
+
+void
+command_history::do_read_range (int from, int to, bool must_exist)
+{
+  do_read_range (xfile, from, to, must_exist);
+}
+
+void
+command_history::do_read_range (const string& f, int, int, bool)
+{
+  if (f.empty ())
+    error ("command_history::read_range: missing file name");
+}
+
+void
+command_history::do_write (const string& f_arg)
+{
+  string f = f_arg;
+
+  if (f.empty ())
+    f = xfile;
+
+  if (f.empty ())
+    error ("command_history::write: missing file name");
+}
+
+void
+command_history::do_append (const string& f_arg)
+{
+  if (lines_this_session)
+    {
+      if (lines_this_session < do_where ())
+	{
+	  // Create file if it doesn't already exist.
+
+	  string f = f_arg;
+
+	  if (f.empty ())
+	    f = xfile;
+
+	  if (f.empty ())
+	    error ("command_history::append: missing file name");
+	}
+    }
+}
+
+void
+command_history::do_truncate_file (const string& f_arg, int)
+{
+  string f = f_arg;
+
+  if (f.empty ())
+    f = xfile;
+
+  if (f.empty ())
+    error ("command_history::truncate_file: missing file name");
+}
+
+string_vector
+command_history::do_list (int, bool)
+{
+  return string_vector ();
+}
+
+string
+command_history::do_get_entry (int)
+{
+  return string ();
+}
+
+void
+command_history::do_replace_entry (int, const string&)
+{
+}
+
+void
+command_history::do_clean_up_and_save (const string& f_arg, int)
+{
+  string f = f_arg;
+
+  if (f.empty ())
+    f = xfile;
+
+  if (f.empty ())
     error ("command_history::clean_up_and_save: missing file name");
 }
 

--- a/liboctave/cmd-hist.h
+++ b/liboctave/cmd-hist.h
@@ -30,67 +30,160 @@
 class
 command_history
 {
+protected:
+
+  command_history (void)
+    : ignoring_additions (false), lines_in_file (0),
+      lines_this_session (0), xfile (), xsize (-1) { }
+
 public:
 
-  command_history (const string& = string (), int = -1);
+  virtual ~command_history (void) { }
+
+  static void set_file (const string&);
 
-  ~command_history (void) { initialized = false; }
+  static string file (void);
 
-  void set_file (const string&);
+  static void set_size (int);
 
-  string file (void);
+  static int size (void);
+
+  static void ignore_entries (bool = true);
 
-  void set_size (int);
+  static bool ignoring_entries (void);
 
-  int size (void);
+  static void add (const string&);
 
-  void ignore_entries (bool = true);
+  static void remove (int);
+
+  static int where (void);
 
-  bool ignoring_entries (void);
+  static int length (void);
 
-  void add (const string&);
+  static int max_input_history (void);
 
-  void remove (int);
+  static int base (void);
 
-  int where (void);
+  static int current_number (void);
 
-  int base (void);
+  static void stifle (int);
 
-  int current_number (void);
+  static int unstifle (void);
 
-  void stifle (int);
+  static int is_stifled (void);
 
-  int unstifle (void);
+  static void set_mark (int n);
 
-  int is_stifled (void);
+  // Gag.  This declaration has to match the Function typedef in
+  // readline.h.
 
-  void read (bool = true);
+  static int goto_mark (...);
+
+  static void read (bool = true);
 
-  void read (const string&, bool = true);
+  static void read (const string&, bool = true);
 
-  void read_range (int = -1, int = -1, bool = true);
+  static void read_range (int = -1, int = -1, bool = true);
 
-  void read_range (const string&, int = -1, int = -1,
-		   bool = true);
+  static void read_range (const string&, int = -1, int = -1,
+			  bool = true);
 
-  void write (const string& = string ());
+  static void write (const string& = string ());
 
-  void append (const string& = string ());
+  static void append (const string& = string ());
 
-  void truncate_file (const string& = string (), int = -1);
+  static void truncate_file (const string& = string (), int = -1);
 
-  string_vector list (int = -1, int = 0);
+  static string_vector list (int = -1, bool = false);
 
-  string get_entry (int);
+  static string get_entry (int);
 
-  void replace_entry (int, const string&);
+  static void replace_entry (int, const string&);
 
-  void clean_up_and_save (const string& = string (), int = -1);
+  static void clean_up_and_save (const string& = string (), int = -1);
 
 private:
 
-  // We can only have one history object in any given program.
-  static bool initialized;
+  // No copying!
+
+  command_history (const command_history&);
+
+  command_history& operator = (const command_history&);
+
+  static bool instance_ok (void);
+
+  static void make_command_history (void);
+
+  // The real thing.
+  static command_history *instance;
+
+protected:
+
+  // To use something other than the GNU history library, derive a new
+  // class from command_history, overload these functions as
+  // necessary, and make instance point to the new class.
+
+  virtual void do_set_file (const string&);
+
+  virtual string do_file (void);
+
+  virtual void do_set_size (int);
+
+  virtual int do_size (void);
+
+  virtual void do_ignore_entries (bool);
+
+  virtual bool do_ignoring_entries (void);
+
+  virtual void do_add (const string&);
+
+  virtual void do_remove (int);
+
+  virtual int do_where (void);
+
+  virtual int do_length (void);
+
+  virtual int do_max_input_history (void);
+
+  virtual int do_base (void);
+
+  virtual int do_current_number (void);
+
+  virtual void do_stifle (int);
+
+  virtual int do_unstifle (void);
+
+  virtual int do_is_stifled (void);
+
+  virtual void do_set_mark (int);
+
+  virtual void do_goto_mark (void);
+
+  virtual void do_read (bool);
+
+  virtual void do_read (const string&, bool);
+
+  virtual void do_read_range (int, int, bool);
+
+  virtual void do_read_range (const string&, int, int, bool);
+
+  virtual void do_write (const string&);
+
+  virtual void do_append (const string&);
+
+  virtual void do_truncate_file (const string&, int);
+
+  virtual string_vector do_list (int, bool);
+
+  virtual string do_get_entry (int);
+
+  virtual void do_replace_entry (int, const string&);
+
+  virtual void do_clean_up_and_save (const string&, int);
+
+  void error (int);
+
+  void error (const string&);
 
   // TRUE means we are ignoring new additions.
   bool ignoring_additions;
@@ -106,14 +199,6 @@
 
   // The number of lines of history to save.
   int xsize;
-
-  void error (int);
-
-  void error (const string&);
-
-  command_history (const command_history&);
-
-  command_history& operator = (const command_history&);
 };
 
 #endif

--- a/liboctave/dir-ops.cc
+++ b/liboctave/dir-ops.cc
@@ -25,11 +25,14 @@
 #endif
 
 #include <cerrno>
+#include <cstdlib>
 #include <cstring>
 
 #include "sysdir.h"
 
 #include "dir-ops.h"
+#include "lo-error.h"
+#include "lo-sysdep.h"
 #include "str-vec.h"
 
 bool

--- a/liboctave/file-ops.cc
+++ b/liboctave/file-ops.cc
@@ -29,224 +29,43 @@
 #include <cstdlib>
 #include <cstring>
 
-#ifdef HAVE_UNISTD_H
+#include <iostream.h>
+
 #ifdef HAVE_SYS_TYPES_H
 #include <sys/types.h>
 #endif
+
+#ifdef HAVE_UNISTD_H
 #include <unistd.h>
 #endif
 
-#include "error.h"
+#ifdef HAVE_PWD_H
+#include <pwd.h>
+#endif
+
 #include "file-ops.h"
 #include "lo-error.h"
+#include "oct-env.h"
 #include "statdefs.h"
-
-// These must come after <sys/types.h> and <sys/stat.h>.
-
-#include <safe-lstat.h>
-#include <safe-stat.h>
-
-// XXX FIXME XXX -- the is_* and mode_as_string functions are only valid
-// for initialized objects.  If called for an object that is not
-// initialized, they should throw an exception.
-
-bool
-file_stat::is_blk (void) const
-{
-#ifdef S_ISBLK
-  return S_ISBLK (fs_mode);
-#else
-  return false;
-#endif
-}
-
-bool
-file_stat::is_chr (void) const
-{
-#ifdef S_ISCHR
-  return S_ISCHR (fs_mode);
-#else
-  return false;
-#endif
-}
-
-bool
-file_stat::is_dir (void) const
-{ 
-#ifdef S_ISDIR
-  return S_ISDIR (fs_mode);
-#else
-  return false;
-#endif
-}
-
-bool
-file_stat::is_fifo (void) const
-{ 
-#ifdef S_ISFIFO
-  return S_ISFIFO (fs_mode);
-#else
-  return false;
-#endif
-}
-
-bool
-file_stat::is_lnk (void) const
-{ 
-#ifdef S_ISLNK
-  return S_ISLNK (fs_mode);
-#else
-  return false;
-#endif
-}
-
-bool
-file_stat::is_reg (void) const
-{ 
-#ifdef S_ISREG
-  return S_ISREG (fs_mode);
-#else
-  return false;
-#endif
-}
-
-bool
-file_stat::is_sock (void) const
-{ 
-#ifdef S_ISSOCK
-  return S_ISSOCK (fs_mode);
-#else
-  return false;
-#endif
-}
-
-extern "C" void mode_string ();
-
-string
-file_stat::mode_as_string (void) const
-{
-  char buf[11];
-
-  mode_string (fs_mode, buf);
-
-  buf[10] = '\0';
-
-  return string (buf);
-}
-
-// Private stuff:
-
-void
-file_stat::update_internal (bool force)
-{
-  if (! initialized || force)
-    {
-      initialized = false;
-      fail = false;
-
-      const char *cname = file_name.c_str ();
-
-      struct stat buf;
-
-      int status = follow_links
-	? SAFE_STAT (cname, &buf) : SAFE_LSTAT (cname, &buf);
-
-      if (status < 0)
-	{
-	  fail = true;
-	  errmsg = strerror (errno);
-	}
-      else
-	{
-	  fs_mode = buf.st_mode;
-	  fs_ino = buf.st_ino;
-	  fs_dev = buf.st_dev;
-	  fs_nlink = buf.st_nlink;
-	  fs_uid = buf.st_uid;
-	  fs_gid = buf.st_gid;
-	  fs_size = buf.st_size;
-	  fs_atime = buf.st_atime;
-	  fs_mtime = buf.st_mtime;
-	  fs_ctime = buf.st_ctime;
-
-#if defined (HAVE_ST_RDEV)
-	  fs_rdev = buf.st_rdev;
-#endif
-
-#if defined (HAVE_ST_BLKSIZE)
-	  fs_blksize = buf.st_blksize;
-#endif
-
-#if defined (HAVE_ST_BLOCKS)
-	  fs_blocks = buf.st_blocks;
-#endif
-	}
-
-      initialized = true;
-    }
-}
-
-void
-file_stat::copy (const file_stat& fs)
-{
-  file_name = fs.file_name;
-  follow_links = fs.follow_links;
-  initialized = fs.initialized;
-  fail = fs.fail;
-  errmsg = fs.errmsg;
-  fs_mode = fs.fs_mode;
-  fs_ino = fs.fs_ino;
-  fs_dev = fs.fs_dev;
-  fs_nlink = fs.fs_nlink;
-  fs_uid = fs.fs_uid;
-  fs_gid = fs.fs_gid;
-  fs_size = fs.fs_size;
-  fs_atime = fs.fs_atime;
-  fs_mtime = fs.fs_mtime;
-  fs_ctime = fs.fs_ctime;
-
-#if defined (HAVE_ST_RDEV)
-  fs_rdev = fs.fs_rdev;
-#endif
-
-#if defined (HAVE_ST_BLKSIZE)
-  fs_blksize = fs.fs_blksize;
-#endif
-
-#if defined (HAVE_ST_BLOCKS)
-  fs_blocks = fs.fs_blocks;
-#endif
-}
-
-// Functions for octave.
-
-// Has FILE been modified since TIME?  Returns 1 for yes, 0 for no,
-// and -1 for any error.
-int
-is_newer (const string& file, time_t time)
-{
-  file_stat fs (file);
-
-  return fs ? fs.is_newer (time) : -1;
-}
+#include "str-vec.h"
 
 // We provide a replacement for mkdir().
 
 int
-oct_mkdir (const string& name, mode_t mode)
+file_ops::mkdir (const string& name, mode_t mode)
 {
-  return mkdir (name.c_str (), mode);
+  return ::mkdir (name.c_str (), mode);
 }
 
 int
-oct_mkdir (const string& name, mode_t mode, string& msg)
+file_ops::mkdir (const string& name, mode_t mode, string& msg)
 {
   msg = string ();
 
-  int status = mkdir (name.c_str (), mode);
+  int status = ::mkdir (name.c_str (), mode);
 
   if (status < 0)
-    msg = strerror (errno);
+    msg = ::strerror (errno);
 
   return status;
 }
@@ -254,30 +73,32 @@
 // I don't know how to emulate this on systems that don't provide it.
 
 int
-oct_mkfifo (const string& name, mode_t mode)
+file_ops::mkfifo (const string& name, mode_t mode)
 {
 #if defined (HAVE_MKFIFO)
-  return mkfifo (name.c_str (), mode);
+  return ::mkfifo (name.c_str (), mode);
 #else
-  ::error ("mkfifo: not implemented on this system");
+  (*current_liboctave_error_handler)
+    ("mkfifo: not implemented on this system");
   return -1;
 #endif
 }
 
 int
-oct_mkfifo (const string& name, mode_t mode, string& msg)
+file_ops::mkfifo (const string& name, mode_t mode, string& msg)
 {
   msg = string ();
 
 #if defined (HAVE_MKFIFO)
-  int status = mkfifo (name.c_str (), mode);
+  int status = ::mkfifo (name.c_str (), mode);
 
   if (status < 0)
-    msg = strerror (errno);
+    msg = ::strerror (errno);
 
   return status;
 #else
-  ::error ("mkfifo: not implemented on this system");
+  (*current_liboctave_error_handler)
+    ("mkfifo: not implemented on this system");
   return -1;
 #endif
 }
@@ -285,20 +106,20 @@
 // We provide a replacement for rename().
 
 int
-oct_rename (const string& from, const string& to)
+file_ops::rename (const string& from, const string& to)
 {
-  return rename (from.c_str (), to.c_str ());
+  return ::rename (from.c_str (), to.c_str ());
 }
 
 int
-oct_rename (const string& from, const string& to, string& msg)
+file_ops::rename (const string& from, const string& to, string& msg)
 {
   msg = string ();
 
-  int status = rename (from.c_str (), to.c_str ());
+  int status = ::rename (from.c_str (), to.c_str ());
 
   if (status < 0)
-    msg = strerror (errno);
+    msg = ::strerror (errno);
 
   return status;
 }
@@ -306,20 +127,20 @@
 // We provide a replacement for rmdir().
 
 int
-oct_rmdir (const string& name)
+file_ops::rmdir (const string& name)
 {
-  return rmdir (name.c_str ());
+  return ::rmdir (name.c_str ());
 }
 
 int
-oct_rmdir (const string& name, string& msg)
+file_ops::rmdir (const string& name, string& msg)
 {
   msg = string ();
 
-  int status = rmdir (name.c_str ());
+  int status = ::rmdir (name.c_str ());
 
   if (status < 0)
-    msg = strerror (errno);
+    msg = ::strerror (errno);
 
   return status;
 }
@@ -327,11 +148,11 @@
 // We provide a replacement for tempnam().
 
 string
-oct_tempnam (void)
+file_ops::tempnam (void)
 {
   string retval;
 
-  char *tmp = tempnam (0, "oct-");
+  char *tmp = ::tempnam (0, "oct-");
 
   if (tmp)
     {
@@ -345,32 +166,119 @@
   return retval;
 }
 
+// If NAME has a leading ~ or ~user, Unix-style, expand it to the
+// user's home directory.  If no ~, or no <pwd.h>, just return NAME.
+
+// Mostly stolen from kpathsea.  Readline also has a more complicated
+// tilde-expand function, but we can probalby get by with something a
+// bit simpler.
+
+// XXX FIXME XXX
+#define DIR_SEP_CHAR '/'
+
+string
+file_ops::tilde_expand (const string& name)
+{
+  string expansion = name;
+
+#if defined (HAVE_PWD_H)
+
+  // If no leading tilde, do nothing.
+
+  size_t beg = name.find_first_not_of (" \t");
+
+  if (beg != NPOS && name[beg] == '~')
+    {
+      // If `~' or `~/', use $HOME if it exists, or `.' if it doesn't.
+
+      // If `~user' or `~user/', look up user in the passwd database.
+
+      size_t len = name.length ();
+
+      if (beg == len-1 || name[beg+1] == DIR_SEP_CHAR)
+	{
+	  string home = octave_env::get_home_directory ();
+
+	  if (home.empty ())
+	    home = ".";
+        
+	  expansion = name.substr (0, beg) + home;
+
+	  if (beg < len)
+	    expansion.append (name.substr (beg+1));
+	}
+      else
+	{
+	  size_t end = name.find (DIR_SEP_CHAR, beg);
+
+	  size_t len = end;
+
+	  if (len != NPOS)
+	    len -= beg + 1;
+
+	  string user = name.substr (beg+1, len);
+
+	  struct passwd *p
+	    = static_cast<struct passwd *> (::getpwnam (user.c_str ()));
+
+	  // If no such user, just use `.'.
+
+	  string home = p ? p->pw_dir : ".";
+      
+	  expansion = string (" ", beg) + home;
+
+	  if (end != NPOS)
+	    expansion.append (name.substr (end));
+	}
+    }
+
+#endif
+
+  return expansion;
+}
+
+// A vector version of the above.
+
+string_vector
+file_ops::tilde_expand (const string_vector& names)
+{
+  string_vector retval;
+
+  int n = names.length ();
+
+  retval.resize (n);
+
+  for (int i = 0; i < n; i++)
+    retval[i] = file_ops::tilde_expand (names[i]);
+
+  return retval;
+}
 
 int
-oct_umask (mode_t mode)
+file_ops::umask (mode_t mode)
 {
 #if defined (HAVE_UMASK)
-  return umask (mode);
+  return ::umask (mode);
 #else
   return 0;
 #endif
 }
 
 int
-oct_unlink (const string& name)
+file_ops::unlink (const string& name)
 {
-  return unlink (name.c_str ());
+  return ::unlink (name.c_str ());
 }
 
 int
-oct_unlink (const string& name, string& errmsg)
+file_ops::unlink (const string& name, string& errmsg)
 {
   errmsg = string ();
 
-  int status = unlink (name.c_str ());
+  int status = ::unlink (name.c_str ());
 
   if (status < 0)
-    errmsg = strerror (errno);
+    errmsg = ::strerror (errno);
 
   return status;
 }

--- a/liboctave/file-ops.h
+++ b/liboctave/file-ops.h
@@ -25,192 +25,37 @@
 
 #include <string>
 
+class string_vector;
+
 #ifdef HAVE_SYS_TYPES_H
 #include <sys/types.h>
 #endif
 
-class
-file_stat
+struct
+file_ops
 {
-public:
-
-  file_stat (const string& n = string (), bool fl = true)
-    : file_name (n), follow_links (fl), initialized (false)
-      {
-	if (! file_name.empty ())
-	  update_internal ();
-      }
-
-  file_stat (const file_stat& f) { copy (f); }
-
-  file_stat& operator = (const file_stat& f)
-    {
-      if (this != &f)
-	copy (f);
-
-      return *this;
-    }
-
-  ~file_stat (void) { }
-
-  void get_stats (bool force = false)
-    {
-      if (! initialized || force)
-        update_internal (force);
-    }
-
-  void get_stats (const string& n, bool force = false)
-    {
-      if (n != file_name || ! initialized  || force)
-	{
-	  initialized = false;
-
-	  file_name = n;
-
-	  update_internal (force);
-	}
-    }
-
-  // File status and info.  These should only be called for objects
-  // that are already properly initialized.
+  static int mkdir (const string&, mode_t);
+  static int mkdir (const string&, mode_t, string&);
 
-  bool is_blk (void) const;
-  bool is_chr (void) const;
-  bool is_dir (void) const;
-  bool is_fifo (void) const;
-  bool is_lnk (void) const;
-  bool is_reg (void) const;
-  bool is_sock (void) const;
-
-  ino_t ino (void) const { return fs_ino; }
-  dev_t dev (void) const { return fs_dev; }
-
-  nlink_t nlink (void) const { return fs_nlink; }
-
-  uid_t uid (void) const { return fs_uid; }
-  gid_t gid (void) const { return fs_gid; }
-
-  off_t size (void) const { return fs_size; }
-
-  time_t atime (void) const { return fs_atime; }
-  time_t mtime (void) const { return fs_mtime; }
-  time_t ctime (void) const { return fs_ctime; }
+  static int mkfifo (const string&, mode_t);
+  static int mkfifo (const string&, mode_t, string&);
 
-#if defined (HAVE_ST_RDEV)
-  dev_t rdev (void) const { return fs_rdev; }
-#endif
-
-#if defined (HAVE_ST_BLKSIZE)
-  long blksize (void) const { return fs_blksize; }
-#endif
-
-#if defined (HAVE_ST_BLOCKS)
-  long blocks (void) const { return fs_blocks; }
-#endif
-
-  string mode_as_string (void) const;
-
-  bool ok (void) const { return initialized && ! fail; }
-
-  operator void* () const
-    { return ok ()
-	? static_cast<void *> (-1) : static_cast<void *> (0); }
-
-  bool exists (void) const { return ok (); }
-
-  string error (void) const { return ok () ? string () : errmsg; }
+  static int rename (const string&, const string&);
+  static int rename (const string&, const string&, string&);
 
-  // Has the file referenced by this object been modified since TIME?
-  bool is_newer (time_t time) const { return fs_mtime > time; }
-
-private:
-
-  // Name of the file.
-  string file_name;
-
-  // TRUE means follow symbolic links to the ultimate file (stat).
-  // FALSE means get information about the link itself (lstat).
-  bool follow_links;
-
-  // TRUE means we have already called stat.
-  bool initialized;
-
-  // TRUE means the stat for this file failed.
-  bool fail;
-
-  // If a failure occurs, this contains the system error text.
-  string errmsg;
+  static int rmdir (const string&);
+  static int rmdir (const string&, string&);
 
-  // file type and permissions
-  mode_t fs_mode;
-
-  // serial number
-  ino_t fs_ino;
-
-  // device number
-  dev_t fs_dev;
-
-  // number of links
-  nlink_t fs_nlink;
-
-  // user ID of owner
-  uid_t fs_uid;
-
-  // group ID of owner
-  gid_t fs_gid;
-
-  // size in bytes, for regular files
-  off_t fs_size;
-
-  // time of last access
-  time_t fs_atime;
+  static string tempnam (void);
 
-  // time of last modification
-  time_t fs_mtime;
-
-  // time of last file status change
-  time_t fs_ctime;
-
-#if defined (HAVE_ST_RDEV)
-  // device number for special files
-  dev_t fs_rdev;
-#endif
-
-#if defined (HAVE_ST_BLKSIZE)
-  // best I/O block size
-  long fs_blksize;
-#endif
-
-#if defined (HAVE_ST_BLOCKS)
-  // number of 512-byte blocks allocated
-  long fs_blocks;
-#endif
-
-  void update_internal (bool force = false);
+  static string tilde_expand (const string&);
+  static string_vector tilde_expand (const string_vector&);
 
-  void copy (const file_stat&);
-};
-
-extern int is_newer (const string&, time_t);
-
-extern int oct_mkdir (const string&, mode_t);
-extern int oct_mkdir (const string&, mode_t, string&);
-
-extern int oct_mkfifo (const string&, mode_t);
-extern int oct_mkfifo (const string&, mode_t, string&);
+  static int umask (mode_t);
 
-extern int oct_rename (const string&, const string&);
-extern int oct_rename (const string&, const string&, string&);
-
-extern int oct_rmdir (const string&);
-extern int oct_rmdir (const string&, string&);
-
-extern string oct_tempnam (void);
-
-extern int oct_umask (mode_t);
-
-extern int oct_unlink (const string&);
-extern int oct_unlink (const string&, string&);
+  static int unlink (const string&);
+  static int unlink (const string&, string&);
+};
 
 #endif
 

new file mode 100644
--- /dev/null
+++ b/liboctave/file-stat.cc
@@ -0,0 +1,232 @@
+/*
+
+Copyright (C) 1996, 1997 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 2, 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, write to the Free
+Software Foundation, 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+*/
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <cerrno>
+#include <cstring>
+
+#ifdef HAVE_UNISTD_H
+#ifdef HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+#include <unistd.h>
+#endif
+
+#include "file-stat.h"
+#include "statdefs.h"
+
+// These must come after <sys/types.h> and <sys/stat.h>.
+
+#include <safe-lstat.h>
+#include <safe-stat.h>
+
+// XXX FIXME XXX -- the is_* and mode_as_string functions are only valid
+// for initialized objects.  If called for an object that is not
+// initialized, they should throw an exception.
+
+bool
+file_stat::is_blk (void) const
+{
+#ifdef S_ISBLK
+  return S_ISBLK (fs_mode);
+#else
+  return false;
+#endif
+}
+
+bool
+file_stat::is_chr (void) const
+{
+#ifdef S_ISCHR
+  return S_ISCHR (fs_mode);
+#else
+  return false;
+#endif
+}
+
+bool
+file_stat::is_dir (void) const
+{ 
+#ifdef S_ISDIR
+  return S_ISDIR (fs_mode);
+#else
+  return false;
+#endif
+}
+
+bool
+file_stat::is_fifo (void) const
+{ 
+#ifdef S_ISFIFO
+  return S_ISFIFO (fs_mode);
+#else
+  return false;
+#endif
+}
+
+bool
+file_stat::is_lnk (void) const
+{ 
+#ifdef S_ISLNK
+  return S_ISLNK (fs_mode);
+#else
+  return false;
+#endif
+}
+
+bool
+file_stat::is_reg (void) const
+{ 
+#ifdef S_ISREG
+  return S_ISREG (fs_mode);
+#else
+  return false;
+#endif
+}
+
+bool
+file_stat::is_sock (void) const
+{ 
+#ifdef S_ISSOCK
+  return S_ISSOCK (fs_mode);
+#else
+  return false;
+#endif
+}
+
+extern "C" void mode_string ();
+
+string
+file_stat::mode_as_string (void) const
+{
+  char buf[11];
+
+  mode_string (fs_mode, buf);
+
+  buf[10] = '\0';
+
+  return string (buf);
+}
+
+// Has FILE been modified since TIME?  Returns 1 for yes, 0 for no,
+// and -1 for any error.
+
+int
+file_stat::is_newer (const string& file, time_t time)
+{
+  file_stat fs (file);
+
+  return fs ? fs.is_newer (time) : -1;
+}
+
+// Private stuff:
+
+void
+file_stat::update_internal (bool force)
+{
+  if (! initialized || force)
+    {
+      initialized = false;
+      fail = false;
+
+      const char *cname = file_name.c_str ();
+
+      struct stat buf;
+
+      int status = follow_links
+	? SAFE_STAT (cname, &buf) : SAFE_LSTAT (cname, &buf);
+
+      if (status < 0)
+	{
+	  fail = true;
+	  errmsg = strerror (errno);
+	}
+      else
+	{
+	  fs_mode = buf.st_mode;
+	  fs_ino = buf.st_ino;
+	  fs_dev = buf.st_dev;
+	  fs_nlink = buf.st_nlink;
+	  fs_uid = buf.st_uid;
+	  fs_gid = buf.st_gid;
+	  fs_size = buf.st_size;
+	  fs_atime = buf.st_atime;
+	  fs_mtime = buf.st_mtime;
+	  fs_ctime = buf.st_ctime;
+
+#if defined (HAVE_ST_RDEV)
+	  fs_rdev = buf.st_rdev;
+#endif
+
+#if defined (HAVE_ST_BLKSIZE)
+	  fs_blksize = buf.st_blksize;
+#endif
+
+#if defined (HAVE_ST_BLOCKS)
+	  fs_blocks = buf.st_blocks;
+#endif
+	}
+
+      initialized = true;
+    }
+}
+
+void
+file_stat::copy (const file_stat& fs)
+{
+  file_name = fs.file_name;
+  follow_links = fs.follow_links;
+  initialized = fs.initialized;
+  fail = fs.fail;
+  errmsg = fs.errmsg;
+  fs_mode = fs.fs_mode;
+  fs_ino = fs.fs_ino;
+  fs_dev = fs.fs_dev;
+  fs_nlink = fs.fs_nlink;
+  fs_uid = fs.fs_uid;
+  fs_gid = fs.fs_gid;
+  fs_size = fs.fs_size;
+  fs_atime = fs.fs_atime;
+  fs_mtime = fs.fs_mtime;
+  fs_ctime = fs.fs_ctime;
+
+#if defined (HAVE_ST_RDEV)
+  fs_rdev = fs.fs_rdev;
+#endif
+
+#if defined (HAVE_ST_BLKSIZE)
+  fs_blksize = fs.fs_blksize;
+#endif
+
+#if defined (HAVE_ST_BLOCKS)
+  fs_blocks = fs.fs_blocks;
+#endif
+}
+
+/*
+;;; Local Variables: ***
+;;; mode: C++ ***
+;;; End: ***
+*/

new file mode 100644
--- /dev/null
+++ b/liboctave/file-stat.h
@@ -0,0 +1,204 @@
+/*
+
+Copyright (C) 1996, 1997 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 2, 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, write to the Free
+Software Foundation, 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+*/
+
+#if !defined (octave_file_stat_h)
+#define octave_file_stat_h 1
+
+#include <string>
+
+#ifdef HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+
+class
+file_stat
+{
+public:
+
+  file_stat (const string& n = string (), bool fl = true)
+    : file_name (n), follow_links (fl), initialized (false)
+      {
+	if (! file_name.empty ())
+	  update_internal ();
+      }
+
+  file_stat (const file_stat& f) { copy (f); }
+
+  file_stat& operator = (const file_stat& f)
+    {
+      if (this != &f)
+	copy (f);
+
+      return *this;
+    }
+
+  ~file_stat (void) { }
+
+  void get_stats (bool force = false)
+    {
+      if (! initialized || force)
+        update_internal (force);
+    }
+
+  void get_stats (const string& n, bool force = false)
+    {
+      if (n != file_name || ! initialized  || force)
+	{
+	  initialized = false;
+
+	  file_name = n;
+
+	  update_internal (force);
+	}
+    }
+
+  // File status and info.  These should only be called for objects
+  // that are already properly initialized.
+
+  bool is_blk (void) const;
+  bool is_chr (void) const;
+  bool is_dir (void) const;
+  bool is_fifo (void) const;
+  bool is_lnk (void) const;
+  bool is_reg (void) const;
+  bool is_sock (void) const;
+
+  ino_t ino (void) const { return fs_ino; }
+  dev_t dev (void) const { return fs_dev; }
+
+  nlink_t nlink (void) const { return fs_nlink; }
+
+  uid_t uid (void) const { return fs_uid; }
+  gid_t gid (void) const { return fs_gid; }
+
+  off_t size (void) const { return fs_size; }
+
+  time_t atime (void) const { return fs_atime; }
+  time_t mtime (void) const { return fs_mtime; }
+  time_t ctime (void) const { return fs_ctime; }
+
+#if defined (HAVE_ST_RDEV)
+  dev_t rdev (void) const { return fs_rdev; }
+#endif
+
+#if defined (HAVE_ST_BLKSIZE)
+  long blksize (void) const { return fs_blksize; }
+#endif
+
+#if defined (HAVE_ST_BLOCKS)
+  long blocks (void) const { return fs_blocks; }
+#endif
+
+  string mode_as_string (void) const;
+
+  bool ok (void) const { return initialized && ! fail; }
+
+  operator void* () const
+    { return ok ()
+	? static_cast<void *> (-1) : static_cast<void *> (0); }
+
+  bool exists (void) const { return ok (); }
+
+  string error (void) const { return ok () ? string () : errmsg; }
+
+  // Has the file referenced by this object been modified since TIME?
+  bool is_newer (time_t time) const { return fs_mtime > time; }
+
+  // It's nice to be able to hide the file_stat object if we don't
+  // really care about it.
+  static int is_newer (const string&, time_t);
+
+private:
+
+  // Name of the file.
+  string file_name;
+
+  // TRUE means follow symbolic links to the ultimate file (stat).
+  // FALSE means get information about the link itself (lstat).
+  bool follow_links;
+
+  // TRUE means we have already called stat.
+  bool initialized;
+
+  // TRUE means the stat for this file failed.
+  bool fail;
+
+  // If a failure occurs, this contains the system error text.
+  string errmsg;
+
+  // file type and permissions
+  mode_t fs_mode;
+
+  // serial number
+  ino_t fs_ino;
+
+  // device number
+  dev_t fs_dev;
+
+  // number of links
+  nlink_t fs_nlink;
+
+  // user ID of owner
+  uid_t fs_uid;
+
+  // group ID of owner
+  gid_t fs_gid;
+
+  // size in bytes, for regular files
+  off_t fs_size;
+
+  // time of last access
+  time_t fs_atime;
+
+  // time of last modification
+  time_t fs_mtime;
+
+  // time of last file status change
+  time_t fs_ctime;
+
+#if defined (HAVE_ST_RDEV)
+  // device number for special files
+  dev_t fs_rdev;
+#endif
+
+#if defined (HAVE_ST_BLKSIZE)
+  // best I/O block size
+  long fs_blksize;
+#endif
+
+#if defined (HAVE_ST_BLOCKS)
+  // number of 512-byte blocks allocated
+  long fs_blocks;
+#endif
+
+  void update_internal (bool force = false);
+
+  void copy (const file_stat&);
+};
+
+#endif
+
+/*
+;;; Local Variables: ***
+;;; mode: C++ ***
+;;; End: ***
+*/

--- a/liboctave/glob-match.cc
+++ b/liboctave/glob-match.cc
@@ -32,7 +32,7 @@
 #include <string>
 
 #include "file-stat.h"
-#include "oct-glob.h"
+#include "glob-match.h"
 #include "str-vec.h"
 
 bool

--- a/liboctave/glob-match.h
+++ b/liboctave/glob-match.h
@@ -20,8 +20,8 @@
 
 */
 
-#if !defined (octave_oct_glob_h)
-#define octave_oct_glob_h 1
+#if !defined (octave_glob_match_h)
+#define octave_glob_match_h 1
 
 #include <string>
 

new file mode 100644
--- /dev/null
+++ b/liboctave/lo-sysdep.cc
@@ -0,0 +1,120 @@
+/*
+
+Copyright (C) 1996, 1997 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 2, 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, write to the Free
+Software Foundation, 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+*/
+
+/*
+
+The function gethostname was adapted from a similar function from GNU
+Bash, the Bourne Again SHell, copyright (C) 1987, 1989, 1991 Free
+Software Foundation, Inc.
+
+*/
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <string>
+
+#include <iostream.h>
+
+#ifdef HAVE_UNISTD_H
+#ifdef HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+#include <unistd.h>
+#endif
+
+#if ! defined (HAVE_GETHOSTNAME) && defined (HAVE_SYS_UTSNAME_H)
+#include <sys/utsname.h>
+#endif
+
+#include "pathlen.h"
+
+string
+octave_getcwd (void)
+{
+  string retval;
+  char buf[MAXPATHLEN];
+
+#if defined (__EMX__)
+  char *tmp = _getcwd2 (buf, MAXPATHLEN);
+#else
+  char *tmp = getcwd (buf, MAXPATHLEN);
+#endif
+
+  if (tmp)
+    retval = tmp;
+
+  return retval;
+}
+
+int
+octave_chdir (const string& path)
+{
+#if defined (__EMX__)
+  int retval = -1;
+
+  char *tmp_path = strsave (path.c_str ());
+
+  if (path.length () == 2 && path[1] == ':')
+    {
+      char *upper_case_dir_name = strupr (tmp_path);
+      _chdrive (upper_case_dir_name[0]);
+      if (_getdrive () == upper_case_dir_name[0])
+	retval = _chdir2 ("/");
+    }
+  else
+    retval = _chdir2 (tmp_path);
+
+  delete [] tmp_path;
+
+  return retval;
+#else
+  return chdir (path.c_str ());
+#endif
+}
+
+#if ! defined (HAVE_GETHOSTNAME) && defined (HAVE_SYS_UTSNAME_H)
+
+int
+gethostname (char *name, int namelen)
+{
+  int i;
+  struct utsname ut;
+
+  --namelen;
+
+  uname (&ut);
+  i = strlen (ut.nodename) + 1;
+  strncpy (name, ut.nodename, i < namelen ? i : namelen);
+  name[namelen] = '\0';
+
+  return 0;
+}
+
+#endif
+
+/*
+;;; Local Variables: ***
+;;; mode: C++ ***
+;;; End: ***
+*/

new file mode 100644
--- /dev/null
+++ b/liboctave/lo-sysdep.h
@@ -0,0 +1,44 @@
+/*
+
+Copyright (C) 1996, 1997 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 2, 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, write to the Free
+Software Foundation, 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+*/
+
+#if !defined (octave_liboctave_sysdep_h)
+#define octave_liboctave_sysdep_h 1
+
+#include <string>
+
+#include "lo-ieee.h"
+
+extern string octave_getcwd (void);
+
+extern bool octave_chdir (const string&);
+
+#if ! defined (HAVE_GETHOSTNAME) && defined (HAVE_SYS_UTSNAME_H)
+extern int gethostname (char *, int);
+#endif
+
+#endif
+
+/*
+;;; Local Variables: ***
+;;; mode: C++ ***
+;;; End: ***
+*/

--- a/liboctave/lo-utils.cc
+++ b/liboctave/lo-utils.cc
@@ -26,7 +26,19 @@
 #endif
 
 #include <climits>
+#include <cstdlib>
+#include <cstdio>
 
+#include <string>
+
+#ifdef HAVE_UNISTD_H
+#ifdef HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+#include <unistd.h>
+#endif
+
+#include "lo-error.h"
 #include "lo-mappers.h"
 #include "lo-utils.h"
 
@@ -53,6 +65,103 @@
     return floor (x + 0.5);
 }
 
+// Save a string.
+
+char *
+strsave (const char *s)
+{
+  if (! s)
+    return 0;
+
+  int len = strlen (s);
+  char *tmp = new char [len+1];
+  tmp = strcpy (tmp, s);
+  return tmp;
+}
+
+// This function was adapted from xputenv from Karl Berry's kpathsearch
+// library.
+
+// XXX FIXME XXX -- make this do the right thing if we don't have a
+// SMART_PUTENV.
+
+void
+octave_putenv (const string& name, const string& value)
+{
+  int new_len = name.length () + value.length () + 2;
+
+  char *new_item = static_cast<char*> (malloc (new_len));
+
+  sprintf (new_item, "%s=%s", name.c_str (), value.c_str ());
+
+  // As far as I can see there's no way to distinguish between the
+  // various errors; putenv doesn't have errno values.
+
+  if (putenv (new_item) < 0)
+    (*current_liboctave_error_handler) ("putenv (%s) failed", new_item);
+}
+
+string
+octave_fgets (FILE *f)
+{
+  string retval;
+
+  int grow_size = 1024;
+  int max_size = grow_size;
+
+  char *buf = static_cast<char *> (malloc (max_size));
+  char *bufptr = buf;
+  int len = 0;
+
+  do
+    {
+      if (fgets (bufptr, grow_size, f))
+	{
+	  len = strlen (bufptr);
+
+	  if (len == grow_size - 1)
+	    {
+	      int tmp = bufptr - buf + grow_size - 1;
+	      grow_size *= 2;
+	      max_size += grow_size;
+	      buf = static_cast<char *> (realloc (buf, max_size));
+	      bufptr = buf + tmp;
+
+	      if (*(bufptr-1) == '\n')
+		{
+		  *bufptr = '\0';
+		  retval = buf;
+		}
+	    }
+	  else if (bufptr[len-1] != '\n')
+	    {
+	      bufptr[len++] = '\n';
+	      bufptr[len] = '\0';
+	      retval = buf;
+	    }
+	  else
+	    retval = buf;
+	}
+      else
+	{
+	  if (len == 0)
+	    {
+	      free (buf);
+
+	      buf = 0;
+	    }
+
+	  break;
+	}
+    }
+  while (retval.empty ());
+
+  if (buf)
+    free (buf);
+
+  return retval;
+}
+
 /*
 ;;; Local Variables: ***
 ;;; mode: C++ ***

--- a/liboctave/lo-utils.h
+++ b/liboctave/lo-utils.h
@@ -23,9 +23,19 @@
 #if !defined (octave_liboctave_utils_h)
 #define octave_liboctave_utils_h 1
 
+#include <cstdio>
+
+#include <string>
+
 extern int NINT (double x);
 extern double D_NINT (double x);
 
+extern char *strsave (const char *);
+
+extern void octave_putenv (const string&, const string&);
+
+extern string octave_fgets (FILE *);
+
 #endif
 
 /*

--- a/liboctave/mach-info.cc
+++ b/liboctave/mach-info.cc
@@ -70,7 +70,7 @@
 }
 
 void
-oct_mach_info::init_float_format (void)
+oct_mach_info::init_float_format (void) const
 {
   float_params fp[5];
 
@@ -124,7 +124,7 @@
 }
 
 void
-oct_mach_info::ten_little_endians (void)
+oct_mach_info::ten_little_endians (void) const
 {
   // Are we little or big endian?  From Harbison & Steele.
 
@@ -145,31 +145,44 @@
   ten_little_endians ();
 }
 
+bool
+oct_mach_info::instance_ok (void)
+{
+  bool retval = true;
+
+  if (! instance)
+    instance = new oct_mach_info ();
+
+  if (! instance)
+    {
+      (*current_liboctave_error_handler)
+	("unable to create command history object!");
+
+      retval = false;
+    }
+
+  return retval;
+}
+
 oct_mach_info::float_format
 oct_mach_info::native_float_format (void)
 {
-  if (! instance)
-    instance = new oct_mach_info ();
-
-  return instance->native_float_fmt;
+  return (instance_ok ())
+    ? instance->native_float_fmt : oct_mach_info::unknown;
 }
 
 bool
 oct_mach_info::words_big_endian (void)
 {
-  if (! instance)
-    instance = new oct_mach_info ();
-
-  return instance->big_chief;
+  return (instance_ok ())
+    ? instance->big_chief : false;
 }
 
 bool
 oct_mach_info::words_little_endian (void)
 {
-  if (! instance)
-    instance = new oct_mach_info ();
-
-  return ! instance->big_chief;
+  return (instance_ok ())
+    ? (! instance->big_chief) : false;
 }
 
 oct_mach_info::float_format