--- a/liboctave/system/oct-env.cc	Wed May 18 14:09:17 2016 -0400
+++ b/liboctave/system/oct-env.cc	Wed May 18 14:58:29 2016 -0400
@@ -26,13 +26,13 @@
 from GNU Bash, the Bourne Again SHell, copyright (C) 1987, 1989, 1991
 Free Software Foundation, Inc.
 
-  octave_env::do_absolute_pathname
-  octave_env::do_base_pathname
-  octave_env::do_chdir
-  octave_env::do_getcwd
-  octave_env::do_make_absolute
-  octave_env::do_polite_directory_format
-  octave_env::pathname_backup
+  octave::sys::env::do_absolute_pathname
+  octave::sys:env::do_base_pathname
+  octave::sys:env::do_chdir
+  octave::sys:env::do_getcwd
+  octave::sys:env::do_make_absolute
+  octave::sys:env::do_polite_directory_format
+  octave::sys:env::pathname_backup
 
 */
 
@@ -60,543 +60,551 @@
 #include "oct-syscalls.h"
 #include "singleton-cleanup.h"
 
-octave_env::octave_env (void)
-  : follow_symbolic_links (true), verbatim_pwd (true),
-    current_directory (), prog_name (), prog_invocation_name (),
-    user_name (), host_name ()
+namespace
+octave
 {
-  // Get a real value for the current directory.
-  do_getcwd ();
+  namespace
+  sys
+  {
+    env::env (void)
+      : follow_symbolic_links (true), verbatim_pwd (true),
+        current_directory (), prog_name (), prog_invocation_name (),
+        user_name (), host_name ()
+    {
+      // Get a real value for the current directory.
+      do_getcwd ();
+
+      // Etc.
+      do_get_user_name ();
 
-  // Etc.
-  do_get_user_name ();
+      do_get_host_name ();
+    }
+
+    env *env::instance = 0;
 
-  do_get_host_name ();
-}
+    bool
+    env::instance_ok (void)
+    {
+      bool retval = true;
+
+      if (! instance)
+        {
+          instance = new env ();
 
-octave_env *octave_env::instance = 0;
+          if (instance)
+            singleton_cleanup_list::add (cleanup_instance);
+        }
 
-bool
-octave_env::instance_ok (void)
-{
-  bool retval = true;
+      if (! instance)
+        (*current_liboctave_error_handler)
+          ("unable to create current working directory object!");
+
+      return retval;
+    }
 
-  if (! instance)
+    std::string
+    env::polite_directory_format (const std::string& name)
+    {
+      return (instance_ok ())
+        ? instance->do_polite_directory_format (name) : "";
+    }
+
+    bool
+    env::absolute_pathname (const std::string& s)
     {
-      instance = new octave_env ();
+      return (instance_ok ())
+        ? instance->do_absolute_pathname (s) : false;
+    }
 
-      if (instance)
-        singleton_cleanup_list::add (cleanup_instance);
+    bool
+    env::rooted_relative_pathname (const std::string& s)
+    {
+      return (instance_ok ())
+        ? instance->do_rooted_relative_pathname (s) : false;
     }
 
-  if (! instance)
-    (*current_liboctave_error_handler)
-      ("unable to create current working directory object!");
-
-  return retval;
-}
+    std::string
+    env::base_pathname (const std::string& s)
+    {
+      return (instance_ok ())
+        ? instance->do_base_pathname (s) : "";
+    }
 
-std::string
-octave_env::polite_directory_format (const std::string& name)
-{
-  return (instance_ok ())
-         ? instance->do_polite_directory_format (name) : "";
-}
-
-bool
-octave_env::absolute_pathname (const std::string& s)
-{
-  return (instance_ok ())
-         ? instance->do_absolute_pathname (s) : false;
-}
+    std::string
+    env::make_absolute (const std::string& s, const std::string& dot_path)
+    {
+      return (instance_ok ())
+        ? instance->do_make_absolute (s, dot_path) : "";
+    }
 
-bool
-octave_env::rooted_relative_pathname (const std::string& s)
-{
-  return (instance_ok ())
-         ? instance->do_rooted_relative_pathname (s) : false;
-}
-
-std::string
-octave_env::base_pathname (const std::string& s)
-{
-  return (instance_ok ())
-         ? instance->do_base_pathname (s) : "";
-}
+    std::string
+    env::get_current_directory ()
+    {
+      return (instance_ok ())
+        ? instance->do_getcwd () : "";
+    }
 
-std::string
-octave_env::make_absolute (const std::string& s, const std::string& dot_path)
-{
-  return (instance_ok ())
-         ? instance->do_make_absolute (s, dot_path) : "";
-}
+    std::string
+    env::get_home_directory ()
+    {
+      return (instance_ok ())
+        ? instance->do_get_home_directory () : "";
+    }
 
-std::string
-octave_env::get_current_directory ()
-{
-  return (instance_ok ())
-         ? instance->do_getcwd () : "";
-}
+    std::string
+    env::get_temp_directory ()
+    {
+      return (instance_ok ())
+        ? instance->do_get_temp_directory () : "";
+    }
 
-std::string
-octave_env::get_home_directory ()
-{
-  return (instance_ok ())
-         ? instance->do_get_home_directory () : "";
-}
+    std::string
+    env::get_program_name (void)
+    {
+      return (instance_ok ())
+        ? instance->prog_name : "";
+    }
 
-std::string
-octave_env::get_temp_directory ()
-{
-  return (instance_ok ())
-         ? instance->do_get_temp_directory () : "";
-}
-
-std::string
-octave_env::get_program_name (void)
-{
-  return (instance_ok ())
-         ? instance->prog_name : "";
-}
+    std::string
+    env::get_program_invocation_name (void)
+    {
+      return (instance_ok ())
+        ? instance->prog_invocation_name : "";
+    }
 
-std::string
-octave_env::get_program_invocation_name (void)
-{
-  return (instance_ok ())
-         ? instance->prog_invocation_name : "";
-}
-
-void
-octave_env::set_program_name (const std::string& s)
-{
-  if (instance_ok ())
-    instance->do_set_program_name (s);
-}
+    void
+    env::set_program_name (const std::string& s)
+    {
+      if (instance_ok ())
+        instance->do_set_program_name (s);
+    }
 
-std::string
-octave_env::get_user_name (void)
-{
-  return (instance_ok ())
-         ? instance->do_get_user_name () : "";
-}
+    std::string
+    env::get_user_name (void)
+    {
+      return (instance_ok ())
+        ? instance->do_get_user_name () : "";
+    }
 
-std::string
-octave_env::get_host_name (void)
-{
-  return (instance_ok ())
-         ? instance->do_get_host_name () : "";
-}
+    std::string
+    env::get_host_name (void)
+    {
+      return (instance_ok ())
+        ? instance->do_get_host_name () : "";
+    }
 
-std::string
-octave_env::do_get_temp_directory (void) const
-{
-  std::string tempd;
+    std::string
+    env::do_get_temp_directory (void) const
+    {
+      std::string tempd;
 
 #if defined (__MINGW32__) || defined (_MSC_VER)
 
-  tempd = do_getenv ("TEMP");
+      tempd = do_getenv ("TEMP");
 
-  if (tempd.empty ())
-    tempd = do_getenv ("TMP");
+      if (tempd.empty ())
+        tempd = do_getenv ("TMP");
 
-  #if defined (P_tmpdir)
-  if (tempd.empty ())
-    tempd = P_tmpdir;
-  #endif
+#if defined (P_tmpdir)
+      if (tempd.empty ())
+        tempd = P_tmpdir;
+#endif
 
-  // Some versions of MinGW and MSVC either don't define P_tmpdir, or
-  // define it to a single backslash.  In such cases just use C:\temp.
-  if (tempd.empty () || tempd == "\\")
-    tempd = "c:\\temp";
+      // Some versions of MinGW and MSVC either don't define P_tmpdir, or
+      // define it to a single backslash.  In such cases just use C:\temp.
+      if (tempd.empty () || tempd == "\\")
+        tempd = "c:\\temp";
 
 #else
 
-  tempd = do_getenv ("TMP");
+      tempd = do_getenv ("TMP");
 
-  #if defined (P_tmpdir)
-  if (tempd.empty ())
-    tempd = P_tmpdir;
-  #else
-  if (tempd.empty ())
-    tempd = "/tmp";
-  #endif
+#if defined (P_tmpdir)
+      if (tempd.empty ())
+        tempd = P_tmpdir;
+#else
+      if (tempd.empty ())
+        tempd = "/tmp";
+#endif
 
 #endif
 
-  return tempd;
-}
+      return tempd;
+    }
 
-// FIXME: this leaves no way to distinguish between a
-// variable that is not set and one that is set to the empty string.
-// Is this a problem?
+    // FIXME: this leaves no way to distinguish between a
+    // variable that is not set and one that is set to the empty string.
+    // Is this a problem?
 
-std::string
-octave_env::getenv (const std::string& name)
-{
-  return (instance_ok ())
-         ? instance->do_getenv (name) : "";
-}
+    std::string
+    env::getenv (const std::string& name)
+    {
+      return (instance_ok ())
+        ? instance->do_getenv (name) : "";
+    }
 
-void
-octave_env::putenv (const std::string& name, const std::string& value)
-{
-  octave_putenv (name, value);
-}
+    void
+    env::putenv (const std::string& name, const std::string& value)
+    {
+      octave_putenv (name, value);
+    }
 
-bool
-octave_env::have_x11_display (void)
-{
-  std::string display = getenv ("DISPLAY");
+    bool
+    env::have_x11_display (void)
+    {
+      std::string display = getenv ("DISPLAY");
 
-  return ! display.empty ();
-}
+      return ! display.empty ();
+    }
 
-bool
-octave_env::chdir (const std::string& newdir)
-{
-  return (instance_ok ())
-         ? instance->do_chdir (newdir) : false;
-}
+    bool
+    env::chdir (const std::string& newdir)
+    {
+      return (instance_ok ())
+        ? instance->do_chdir (newdir) : false;
+    }
 
-void
-octave_env::do_set_program_name (const std::string& s) const
-{
-  static bool initialized = false;
-
-  if (! initialized)
+    void
+    env::do_set_program_name (const std::string& s) const
     {
-      // The string passed to gnulib's ::set_program_name function must
-      // exist for the duration of the program so allocate a copy here
-      // instead of passing S.c_str () which only exists as long as the
-      // string object S.
+      static bool initialized = false;
 
-      // For gnulib.
-      ::set_program_name (strsave (s.c_str ()));
+      if (! initialized)
+        {
+          // The string passed to gnulib's ::set_program_name function must
+          // exist for the duration of the program so allocate a copy here
+          // instead of passing S.c_str () which only exists as long as the
+          // string object S.
+
+          // For gnulib.
+          ::set_program_name (strsave (s.c_str ()));
 
-      // Let gnulib strip off things like the "lt-" prefix from libtool.
-      prog_invocation_name = program_name;
+          // Let gnulib strip off things like the "lt-" prefix from libtool.
+          prog_invocation_name = program_name;
 
-      size_t pos
-        = prog_invocation_name.find_last_of (file_ops::dir_sep_chars ());
+          size_t pos
+            = prog_invocation_name.find_last_of (file_ops::dir_sep_chars ());
 
-      // Also keep a shortened version of the program name.
-      prog_name = (pos == std::string::npos
-                   ? prog_invocation_name
-                   : prog_invocation_name.substr (pos+1));
+          // Also keep a shortened version of the program name.
+          prog_name = (pos == std::string::npos
+                       ? prog_invocation_name
+                       : prog_invocation_name.substr (pos+1));
 
-      initialized = true;
+          initialized = true;
+        }
     }
-}
 
-// Return a pretty pathname.  If the first part of the pathname is the
-// same as $HOME, then replace that with '~'.
+    // Return a pretty pathname.  If the first part of the pathname is the
+    // same as $HOME, then replace that with '~'.
 
-std::string
-octave_env::do_polite_directory_format (const std::string& name) const
-{
-  std::string retval;
+    std::string
+    env::do_polite_directory_format (const std::string& name) const
+    {
+      std::string retval;
 
-  std::string home_dir = do_get_home_directory ();
+      std::string home_dir = do_get_home_directory ();
 
-  size_t len = home_dir.length ();
+      size_t len = home_dir.length ();
 
-  if (len > 1 && home_dir == name.substr (0, len)
-      && (name.length () == len || file_ops::is_dir_sep (name[len])))
-    {
-      retval = "~";
-      retval.append (name.substr (len));
-    }
-  else
-    retval = name;
+      if (len > 1 && home_dir == name.substr (0, len)
+          && (name.length () == len || file_ops::is_dir_sep (name[len])))
+        {
+          retval = "~";
+          retval.append (name.substr (len));
+        }
+      else
+        retval = name;
 
-  return retval;
-}
+      return retval;
+    }
 
-bool
-octave_env::do_absolute_pathname (const std::string& s) const
-{
-  size_t len = s.length ();
+    bool
+    env::do_absolute_pathname (const std::string& s) const
+    {
+      size_t len = s.length ();
 
-  if (len == 0)
-    return false;
+      if (len == 0)
+        return false;
 
-  if (file_ops::is_dir_sep (s[0]))
-    return true;
+      if (file_ops::is_dir_sep (s[0]))
+        return true;
 
 #if defined (OCTAVE_HAVE_WINDOWS_FILESYSTEM)
-  if ((len == 2 && isalpha (s[0]) && s[1] == ':')
-      || (len > 2 && isalpha (s[0]) && s[1] == ':'
-          && file_ops::is_dir_sep (s[2])))
-    return true;
+      if ((len == 2 && isalpha (s[0]) && s[1] == ':')
+          || (len > 2 && isalpha (s[0]) && s[1] == ':'
+              && file_ops::is_dir_sep (s[2])))
+        return true;
 #endif
 
-  return false;
-}
+      return false;
+    }
 
-bool
-octave_env::do_rooted_relative_pathname (const std::string& s) const
-{
-  size_t len = s.length ();
+    bool
+    env::do_rooted_relative_pathname (const std::string& s) const
+    {
+      size_t len = s.length ();
+
+      if (len == 0)
+        return false;
 
-  if (len == 0)
-    return false;
+      if (len == 1 && s[0] == '.')
+        return true;
+
+      if (len > 1 && s[0] == '.' && file_ops::is_dir_sep (s[1]))
+        return true;
 
-  if (len == 1 && s[0] == '.')
-    return true;
+      if (len == 2 && s[0] == '.' && s[1] == '.')
+        return true;
 
-  if (len > 1 && s[0] == '.' && file_ops::is_dir_sep (s[1]))
-    return true;
+      if (len > 2 && s[0] == '.' && s[1] == '.' && file_ops::is_dir_sep (s[2]))
+        return true;
 
-  if (len == 2 && s[0] == '.' && s[1] == '.')
-    return true;
+      return false;
+    }
 
-  if (len > 2 && s[0] == '.' && s[1] == '.' && file_ops::is_dir_sep (s[2]))
-    return true;
-
-  return false;
-}
+    // Return the 'basename' of the pathname in STRING (the stuff after
+    // the last directory separator).  If STRING is not a full pathname,
+    // simply return it.
 
-// Return the 'basename' of the pathname in STRING (the stuff after
-// the last directory separator).  If STRING is not a full pathname,
-// simply return it.
+    std::string
+    env::do_base_pathname (const std::string& s) const
+    {
+      if (! (do_absolute_pathname (s) || do_rooted_relative_pathname (s)))
+        return s;
+
+      size_t pos = s.find_last_of (file_ops::dir_sep_chars ());
 
-std::string
-octave_env::do_base_pathname (const std::string& s) const
-{
-  if (! (do_absolute_pathname (s) || do_rooted_relative_pathname (s)))
-    return s;
+      if (pos == std::string::npos)
+        return s;
+      else
+        return s.substr (pos+1);
+    }
 
-  size_t pos = s.find_last_of (file_ops::dir_sep_chars ());
+    // Turn STRING (a pathname) into an absolute pathname, assuming that
+    // DOT_PATH contains the symbolic location of the current directory.
 
-  if (pos == std::string::npos)
-    return s;
-  else
-    return s.substr (pos+1);
-}
+    std::string
+    env::do_make_absolute (const std::string& s,
+                           const std::string& dot_path) const
+    {
+      if (dot_path.empty () || s.empty () || do_absolute_pathname (s))
+        return s;
 
-// Turn STRING (a pathname) into an absolute pathname, assuming that
-// DOT_PATH contains the symbolic location of the current directory.
+      std::string current_dir = dot_path;
 
-std::string
-octave_env::do_make_absolute (const std::string& s,
-                              const std::string& dot_path) const
-{
-  if (dot_path.empty () || s.empty () || do_absolute_pathname (s))
-    return s;
+      if (current_dir.empty ())
+        current_dir = do_getcwd ();
+
+      size_t pos = current_dir.length () - 1;
 
-  std::string current_dir = dot_path;
+      if (! file_ops::is_dir_sep (current_dir[pos]))
+        current_dir.append (file_ops::dir_sep_str ());
 
-  if (current_dir.empty ())
-    current_dir = do_getcwd ();
+      // FIXME: this is probably not correct for all systems.
+
+      size_t i = 0;
+      size_t slen = s.length ();
 
-  size_t pos = current_dir.length () - 1;
-
-  if (! file_ops::is_dir_sep (current_dir[pos]))
-    current_dir.append (file_ops::dir_sep_str ());
+      while (i < slen)
+        {
+          if (s[i] == '.')
+            {
+              if (i + 1 == slen)
+                return current_dir;
 
-  // FIXME: this is probably not correct for all systems.
-
-  size_t i = 0;
-  size_t slen = s.length ();
+              if (file_ops::is_dir_sep (s[i+1]))
+                {
+                  i += 2;
+                  continue;
+                }
 
-  while (i < slen)
-    {
-      if (s[i] == '.')
-        {
-          if (i + 1 == slen)
-            return current_dir;
+              if (s[i+1] == '.'
+                  && (i + 2 == slen || file_ops::is_dir_sep (s[i+2])))
+                {
+                  i += 2;
 
-          if (file_ops::is_dir_sep (s[i+1]))
-            {
-              i += 2;
-              continue;
+                  if (i != slen)
+                    i++;
+
+                  pathname_backup (current_dir, 1);
+
+                  continue;
+                }
             }
 
-          if (s[i+1] == '.'
-              && (i + 2 == slen || file_ops::is_dir_sep (s[i+2])))
-            {
-              i += 2;
+          size_t tmp = s.find_first_of (file_ops::dir_sep_chars (), i);
 
-              if (i != slen)
-                i++;
-
-              pathname_backup (current_dir, 1);
-
-              continue;
+          if (tmp == std::string::npos)
+            {
+              current_dir.append (s, i, tmp-i);
+              break;
+            }
+          else
+            {
+              current_dir.append (s, i, tmp-i+1);
+              i = tmp + 1;
             }
         }
 
-      size_t tmp = s.find_first_of (file_ops::dir_sep_chars (), i);
-
-      if (tmp == std::string::npos)
-        {
-          current_dir.append (s, i, tmp-i);
-          break;
-        }
-      else
-        {
-          current_dir.append (s, i, tmp-i+1);
-          i = tmp + 1;
-        }
+      return current_dir;
     }
 
-  return current_dir;
-}
-
-// Return a string which is the current working directory.
+    // Return a string which is the current working directory.
 
-std::string
-octave_env::do_getcwd () const
-{
-  if (! follow_symbolic_links)
-    current_directory = "";
+    std::string
+    env::do_getcwd () const
+    {
+      if (! follow_symbolic_links)
+        current_directory = "";
+
+      if (verbatim_pwd || current_directory.empty ())
+        current_directory = ::octave_getcwd ();
 
-  if (verbatim_pwd || current_directory.empty ())
-    current_directory = ::octave_getcwd ();
-
-  return current_directory;
-}
+      return current_directory;
+    }
 
-// This value is not cached because it can change while Octave is
-// running.
+    // This value is not cached because it can change while Octave is
+    // running.
 
-std::string
-octave_env::do_get_home_directory (void) const
-{
-  std::string hd = do_getenv ("HOME");
+    std::string
+    env::do_get_home_directory (void) const
+    {
+      std::string hd = do_getenv ("HOME");
 
 #if defined (__MINGW32__) || defined (_MSC_VER)
-  // Maybe we are started directly from cmd.exe.
-  if (hd.empty ())
-    {
-      std::string drv = do_getenv ("HOMEDRIVE");
-      if (drv.empty ())
-        hd = do_getenv ("HOMEPATH");
-      else
-        hd = drv + do_getenv ("HOMEPATH");
-    }
+      // Maybe we are started directly from cmd.exe.
+      if (hd.empty ())
+        {
+          std::string drv = do_getenv ("HOMEDRIVE");
+          if (drv.empty ())
+            hd = do_getenv ("HOMEPATH");
+          else
+            hd = drv + do_getenv ("HOMEPATH");
+        }
 #endif
 
-  if (hd.empty ())
-    {
-      octave::sys::password pw = octave::sys::password::getpwuid (octave::sys::getuid ());
+      if (hd.empty ())
+        {
+          octave::sys::password pw = octave::sys::password::getpwuid (octave::sys::getuid ());
 
-      hd = pw ? pw.dir () : std::string (file_ops::dir_sep_str ());
+          hd = pw ? pw.dir () : std::string (file_ops::dir_sep_str ());
+        }
+
+      return hd;
     }
 
-  return hd;
-}
+    std::string
+    env::do_get_user_name (void) const
+    {
+      if (user_name.empty ())
+        {
+          octave::sys::password pw = octave::sys::password::getpwuid (octave::sys::getuid ());
 
-std::string
-octave_env::do_get_user_name (void) const
-{
-  if (user_name.empty ())
-    {
-      octave::sys::password pw = octave::sys::password::getpwuid (octave::sys::getuid ());
+          user_name = pw ? pw.name () : std::string ("unknown");
+        }
 
-      user_name = pw ? pw.name () : std::string ("unknown");
+      return user_name;
     }
 
-  return user_name;
-}
+    std::string
+    env::do_get_host_name (void) const
+    {
+      if (host_name.empty ())
+        {
+          char hostname[1024];
 
-std::string
-octave_env::do_get_host_name (void) const
-{
-  if (host_name.empty ())
-    {
-      char hostname[1024];
+          int status = gnulib::gethostname (hostname, 1023);
 
-      int status = gnulib::gethostname (hostname, 1023);
+          host_name = (status < 0) ? "unknown" : hostname;
+        }
 
-      host_name = (status < 0) ? "unknown" : hostname;
+      return host_name;
     }
 
-  return host_name;
-}
+    std::string
+    env::do_getenv (const std::string& name) const
+    {
+      char *value = ::getenv (name.c_str ());
+
+      return value ? value : "";
+    }
 
-std::string
-octave_env::do_getenv (const std::string& name) const
-{
-  char *value = ::getenv (name.c_str ());
+    // Do the work of changing to the directory NEWDIR.  Handle symbolic
+    // link following, etc.
+
+    bool
+    env::do_chdir (const std::string& newdir)
+    {
+      bool retval = false;
 
-  return value ? value : "";
-}
+      std::string tmp;
+
+      if (follow_symbolic_links)
+        {
+          if (current_directory.empty ())
+            do_getcwd ();
 
-// Do the work of changing to the directory NEWDIR.  Handle symbolic
-// link following, etc.
+          if (current_directory.empty ())
+            tmp = newdir;
+          else
+            tmp = do_make_absolute (newdir, current_directory);
 
-bool
-octave_env::do_chdir (const std::string& newdir)
-{
-  bool retval = false;
+          // Get rid of trailing directory separator.
+
+          size_t len = tmp.length ();
 
-  std::string tmp;
+          if (len > 1)
+            {
+              if (file_ops::is_dir_sep (tmp[--len]))
+                tmp.resize (len);
+            }
 
-  if (follow_symbolic_links)
-    {
-      if (current_directory.empty ())
-        do_getcwd ();
-
-      if (current_directory.empty ())
-        tmp = newdir;
+          if (! ::octave_chdir (tmp))
+            {
+              current_directory = tmp;
+              retval = true;
+            }
+        }
       else
-        tmp = do_make_absolute (newdir, current_directory);
+        retval = (! ::octave_chdir (newdir));
 
-      // Get rid of trailing directory separator.
+      return retval;
+    }
+
+    // Remove the last N directories from PATH.
 
-      size_t len = tmp.length ();
+    void
+    env::pathname_backup (std::string& path, int n) const
+    {
+      if (path.empty ())
+        return;
+
+      size_t i = path.length () - 1;
 
-      if (len > 1)
+      while (n--)
         {
-          if (file_ops::is_dir_sep (tmp[--len]))
-            tmp.resize (len);
+          while (file_ops::is_dir_sep (path[i]) && i > 0)
+            i--;
+
+          while (! file_ops::is_dir_sep (path[i]) && i > 0)
+            i--;
+
+          i++;
         }
 
-      if (! ::octave_chdir (tmp))
-        {
-          current_directory = tmp;
-          retval = true;
-        }
-    }
-  else
-    retval = (! ::octave_chdir (newdir));
-
-  return retval;
-}
-
-// Remove the last N directories from PATH.
-
-void
-octave_env::pathname_backup (std::string& path, int n) const
-{
-  if (path.empty ())
-    return;
-
-  size_t i = path.length () - 1;
-
-  while (n--)
-    {
-      while (file_ops::is_dir_sep (path[i]) && i > 0)
-        i--;
-
-      while (! file_ops::is_dir_sep (path[i]) && i > 0)
-        i--;
-
-      i++;
+      path.resize (i);
     }
 
-  path.resize (i);
-}
+    void
+    env::error (int err_num) const
+    {
+      (*current_liboctave_error_handler) ("%s", gnulib::strerror (err_num));
+    }
 
-void
-octave_env::error (int err_num) const
-{
-  (*current_liboctave_error_handler) ("%s", gnulib::strerror (err_num));
+    void
+    env::error (const std::string& s) const
+    {
+      (*current_liboctave_error_handler) ("%s", s.c_str ());
+    }
+  }
 }
-
-void
-octave_env::error (const std::string& s) const
-{
-  (*current_liboctave_error_handler) ("%s", s.c_str ());
-}