--- a/libinterp/corefcn/oct-stream.h	Tue Jan 17 11:42:25 2017 -0500
+++ b/libinterp/corefcn/oct-stream.h	Tue Jan 17 13:56:16 2017 -0500
@@ -25,24 +25,17 @@
 
 #include "octave-config.h"
 
+#include <ios>
 #include <iosfwd>
 #include <list>
 #include <map>
 #include <string>
 
-// These are only needed as arguments to private functions, so they
-// are also treated as private.
-
-class scanf_format_elt;
-class scanf_format_list;
-
-class printf_format_elt;
-class printf_format_list;
-
 // These only appear as reference arguments or return values.
 
 template <typename T> class Array;
 class Cell;
+class octave_value;
 class octave_value_list;
 class string_vector;
 
@@ -50,435 +43,451 @@
 #include "mach-info.h"
 #include "oct-refcount.h"
 
-#include "ov.h"
-
-// Provide an interface for Octave streams.
+namespace octave
+{
+  // These are only needed as arguments to private functions, so they
+  // are also treated as private.
 
-class
-OCTINTERP_API
-octave_base_stream
-{
-  friend class octave_stream;
+  class scanf_format_elt;
+  class scanf_format_list;
 
-public:
+  class printf_format_elt;
+  class printf_format_list;
+
+  // Provide an interface for Octave streams.
 
-  octave_base_stream (std::ios::openmode arg_md = std::ios::in | std::ios::out,
-                      octave::mach_info::float_format ff
-                        = octave::mach_info::native_float_format ())
-    : count (0), md (arg_md), flt_fmt (ff), fail (false), open_state (true),
+  class
+  OCTINTERP_API
+  base_stream
+  {
+    friend class stream;
+
+  public:
+
+    base_stream (std::ios::openmode arg_md = std::ios::in | std::ios::out,
+                 mach_info::float_format ff = mach_info::native_float_format ())
+      : count (0), md (arg_md), flt_fmt (ff), fail (false), open_state (true),
       errmsg ()
-  { }
-
-  // No copying!
-
-  octave_base_stream (const octave_base_stream&) = delete;
-
-  octave_base_stream& operator = (const octave_base_stream&) = delete;
+    { }
 
-  virtual ~octave_base_stream (void) = default;
+    // No copying!
 
-  // The remaining functions are not specific to input or output only,
-  // and must be provided by the derived classes.
+    base_stream (const base_stream&) = delete;
+
+    base_stream& operator = (const base_stream&) = delete;
 
-  // Position a stream at OFFSET relative to ORIGIN.
-
-  virtual int seek (off_t offset, int origin) = 0;
+    virtual ~base_stream (void) = default;
 
-  // Return current stream position.
+    // The remaining functions are not specific to input or output only,
+    // and must be provided by the derived classes.
 
-  virtual off_t tell (void) = 0;
+    // Position a stream at OFFSET relative to ORIGIN.
 
-  // Return TRUE if EOF has been reached on this stream.
+    virtual int seek (off_t offset, int origin) = 0;
 
-  virtual bool eof (void) const = 0;
+    // Return current stream position.
 
-  // The name of the file.
+    virtual off_t tell (void) = 0;
 
-  virtual std::string name (void) const = 0;
+    // Return TRUE if EOF has been reached on this stream.
+
+    virtual bool eof (void) const = 0;
 
-  // If the derived class provides this function and it returns a
-  // pointer to a valid istream, scanf(), read(), getl(), and gets()
-  // will automatically work for this stream.
+    // The name of the file.
 
-  virtual std::istream *input_stream (void) { return 0; }
+    virtual std::string name (void) const = 0;
 
-  // If the derived class provides this function and it returns a
-  // pointer to a valid ostream, flush(), write(), and printf() will
-  // automatically work for this stream.
+    // If the derived class provides this function and it returns a
+    // pointer to a valid istream, scanf(), read(), getl(), and gets()
+    // will automatically work for this stream.
 
-  virtual std::ostream *output_stream (void) { return 0; }
+    virtual std::istream *input_stream (void) { return 0; }
 
-  // Return TRUE if this stream is open.
+    // If the derived class provides this function and it returns a
+    // pointer to a valid ostream, flush(), write(), and printf() will
+    // automatically work for this stream.
 
-  bool is_open (void) const { return open_state; }
-
-  virtual void do_close (void) { }
+    virtual std::ostream *output_stream (void) { return 0; }
 
-  void close (void)
-  {
-    if (is_open ())
-      {
-        open_state = false;
-        do_close ();
-      }
-  }
+    // Return TRUE if this stream is open.
+
+    bool is_open (void) const { return open_state; }
+
+    virtual void do_close (void) { }
 
-  virtual int file_number (void) const
-  {
-    // Kluge alert!
+    void close (void)
+    {
+      if (is_open ())
+        {
+          open_state = false;
+          do_close ();
+        }
+    }
 
-    if (name () == "stdin")
-      return 0;
-    else if (name () == "stdout")
-      return 1;
-    else if (name () == "stderr")
-      return 2;
-    else
-      return -1;
-  }
+    virtual int file_number (void) const
+    {
+      // Kluge alert!
 
-  bool ok (void) const { return ! fail; }
-
-  // Return current error message for this stream.
+      if (name () == "stdin")
+        return 0;
+      else if (name () == "stdout")
+        return 1;
+      else if (name () == "stderr")
+        return 2;
+      else
+        return -1;
+    }
 
-  std::string error (bool clear, int& err_num);
+    bool ok (void) const { return ! fail; }
 
-protected:
+    // Return current error message for this stream.
 
-  int mode (void) const { return md; }
+    std::string error (bool clear, int& err_num);
 
-  octave::mach_info::float_format float_format (void) const { return flt_fmt; }
+  protected:
 
-  // Set current error state and set fail to TRUE.
+    int mode (void) const { return md; }
 
-  void error (const std::string& msg);
-  void error (const std::string& who, const std::string& msg);
+    mach_info::float_format float_format (void) const { return flt_fmt; }
 
-  // Clear any error message and set fail to FALSE.
+    // Set current error state and set fail to TRUE.
 
-  void clear (void);
+    void error (const std::string& msg);
+    void error (const std::string& who, const std::string& msg);
 
-  // Clear stream state.
+    // Clear any error message and set fail to FALSE.
 
-  void clearerr (void);
+    void clear (void);
+
+    // Clear stream state.
 
-private:
+    void clearerr (void);
 
-  // A reference count.
-  octave::refcount<octave_idx_type> count;
+  private:
 
-  // The permission bits for the file.  Should be some combination of
-  // std::ios::open_mode bits.
-  int md;
+    // A reference count.
+    refcount<octave_idx_type> count;
 
-  // Data format.
-  octave::mach_info::float_format flt_fmt;
+    // The permission bits for the file.  Should be some combination of
+    // std::ios::open_mode bits.
+    int md;
 
-  // TRUE if an error has occurred.
-  bool fail;
+    // Data format.
+    mach_info::float_format flt_fmt;
 
-  // TRUE if this stream is open.
-  bool open_state;
+    // TRUE if an error has occurred.
+    bool fail;
 
-  // Should contain error message if fail is TRUE.
-  std::string errmsg;
+    // TRUE if this stream is open.
+    bool open_state;
+
+    // Should contain error message if fail is TRUE.
+    std::string errmsg;
 
-  // Functions that are defined for all input streams (input streams
-  // are those that define is).
+    // Functions that are defined for all input streams (input streams
+    // are those that define is).
 
-  std::string do_gets (octave_idx_type max_len, bool& err, bool strip_newline,
-                       const std::string& who /* = "gets" */);
+    std::string do_gets (octave_idx_type max_len, bool& err, bool strip_newline,
+                         const std::string& who /* = "gets" */);
 
-  std::string getl (octave_idx_type max_len, bool& err,
-                    const std::string& who /* = "getl" */);
-  std::string gets (octave_idx_type max_len, bool& err,
-                    const std::string& who /* = "gets" */);
-  off_t skipl (off_t count, bool& err, const std::string& who /* = "skipl" */);
+    std::string getl (octave_idx_type max_len, bool& err,
+                      const std::string& who /* = "getl" */);
+    std::string gets (octave_idx_type max_len, bool& err,
+                      const std::string& who /* = "gets" */);
+    off_t skipl (off_t count, bool& err, const std::string& who /* = "skipl" */);
 
-  octave_value do_scanf (scanf_format_list& fmt_list, octave_idx_type nr,
-                         octave_idx_type nc,
-                         bool one_elt_size_spec, octave_idx_type& count,
-                         const std::string& who /* = "scanf" */);
+    octave_value do_scanf (scanf_format_list& fmt_list, octave_idx_type nr,
+                           octave_idx_type nc,
+                           bool one_elt_size_spec, octave_idx_type& count,
+                           const std::string& who /* = "scanf" */);
 
-  octave_value scanf (const std::string& fmt, const Array<double>& size,
-                      octave_idx_type& count, const std::string& who /* = "scanf" */);
+    octave_value scanf (const std::string& fmt, const Array<double>& size,
+                        octave_idx_type& count, const std::string& who /* = "scanf" */);
 
-  bool do_oscanf (const scanf_format_elt *elt, octave_value&,
-                  const std::string& who /* = "scanf" */);
-
-  octave_value_list oscanf (const std::string& fmt,
-                            const std::string& who /* = "scanf" */);
+    bool do_oscanf (const scanf_format_elt *elt, octave_value&,
+                    const std::string& who /* = "scanf" */);
 
-  octave_value do_textscan (const std::string& fmt, octave_idx_type ntimes,
-                            const octave_value_list& options,
-                            const std::string& who, octave_idx_type& count);
+    octave_value_list oscanf (const std::string& fmt,
+                              const std::string& who /* = "scanf" */);
 
-  // Functions that are defined for all output streams (output streams
-  // are those that define os).
+    octave_value do_textscan (const std::string& fmt, octave_idx_type ntimes,
+                              const octave_value_list& options,
+                              const std::string& who, octave_idx_type& count);
 
-  int flush (void);
+    // Functions that are defined for all output streams (output streams
+    // are those that define os).
+
+    int flush (void);
 
-  int do_numeric_printf_conv (std::ostream& os, const printf_format_elt *elt,
-                              int nsa, int sa_1, int sa_2,
-                              const octave_value& val,
-                              const std::string& who);
+    int do_numeric_printf_conv (std::ostream& os, const printf_format_elt *elt,
+                                int nsa, int sa_1, int sa_2,
+                                const octave_value& val,
+                                const std::string& who);
 
-  int do_printf (printf_format_list& fmt_list, const octave_value_list& args,
-                 const std::string& who /* = "printf" */);
+    int do_printf (printf_format_list& fmt_list, const octave_value_list& args,
+                   const std::string& who /* = "printf" */);
 
-  int printf (const std::string& fmt, const octave_value_list& args,
-              const std::string& who /* = "printf" */);
+    int printf (const std::string& fmt, const octave_value_list& args,
+                const std::string& who /* = "printf" */);
 
-  int puts (const std::string& s, const std::string& who /* = "puts" */);
+    int puts (const std::string& s, const std::string& who /* = "puts" */);
 
-  // We can always do this in terms of seek(), so the derived class
-  // only has to provide that.
+    // We can always do this in terms of seek(), so the derived class
+    // only has to provide that.
 
-  void invalid_operation (const std::string& who, const char *rw);
-};
+    void invalid_operation (const std::string& who, const char *rw);
+  };
 
-class
-OCTINTERP_API
-octave_stream
-{
-public:
+  class
+  OCTINTERP_API
+  stream
+  {
+  public:
 
-  octave_stream (octave_base_stream *bs = 0);
+    stream (base_stream *bs = 0);
 
-  ~octave_stream (void);
+    ~stream (void);
 
-  octave_stream (const octave_stream&);
+    stream (const stream&);
 
-  octave_stream& operator = (const octave_stream&);
+    stream& operator = (const stream&);
 
-  int flush (void);
+    int flush (void);
 
-  std::string getl (octave_idx_type max_len, bool& err,
-                    const std::string& who /* = "getl" */);
-  std::string getl (const octave_value& max_len, bool& err,
-                    const std::string& who /* = "getl" */);
+    std::string getl (octave_idx_type max_len, bool& err,
+                      const std::string& who /* = "getl" */);
+    std::string getl (const octave_value& max_len, bool& err,
+                      const std::string& who /* = "getl" */);
 
-  std::string gets (octave_idx_type max_len, bool& err,
-                    const std::string& who /* = "gets" */);
-  std::string gets (const octave_value& max_len, bool& err,
-                    const std::string& who /* = "gets" */);
+    std::string gets (octave_idx_type max_len, bool& err,
+                      const std::string& who /* = "gets" */);
+    std::string gets (const octave_value& max_len, bool& err,
+                      const std::string& who /* = "gets" */);
 
-  off_t skipl (off_t count, bool& err, const std::string& who /* = "skipl" */);
-  off_t skipl (const octave_value& count, bool& err,
-               const std::string& who /* = "skipl" */);
+    off_t skipl (off_t count, bool& err, const std::string& who /* = "skipl" */);
+    off_t skipl (const octave_value& count, bool& err,
+                 const std::string& who /* = "skipl" */);
 
-  int seek (off_t offset, int origin);
-  int seek (const octave_value& offset, const octave_value& origin);
+    int seek (off_t offset, int origin);
+    int seek (const octave_value& offset, const octave_value& origin);
 
-  off_t tell (void);
+    off_t tell (void);
 
-  int rewind (void);
+    int rewind (void);
 
-  bool is_open (void) const;
+    bool is_open (void) const;
 
-  void close (void);
+    void close (void);
 
-  octave_value read (const Array<double>& size, octave_idx_type block_size,
-                     oct_data_conv::data_type input_type,
-                     oct_data_conv::data_type output_type,
-                     octave_idx_type skip, octave::mach_info::float_format flt_fmt,
-                     octave_idx_type& count);
+    octave_value read (const Array<double>& size, octave_idx_type block_size,
+                       oct_data_conv::data_type input_type,
+                       oct_data_conv::data_type output_type,
+                       octave_idx_type skip, mach_info::float_format flt_fmt,
+                       octave_idx_type& count);
 
-  octave_idx_type write (const octave_value& data, octave_idx_type block_size,
-                         oct_data_conv::data_type output_type,
-                         octave_idx_type skip,
-                         octave::mach_info::float_format flt_fmt);
+    octave_idx_type write (const octave_value& data, octave_idx_type block_size,
+                           oct_data_conv::data_type output_type,
+                           octave_idx_type skip,
+                           mach_info::float_format flt_fmt);
 
-  bool write_bytes (const void *data, size_t n_elts);
+    bool write_bytes (const void *data, size_t n_elts);
 
-  bool skip_bytes (size_t n_elts);
+    bool skip_bytes (size_t n_elts);
 
-  template <typename T>
-  octave_idx_type write (const Array<T>& data, octave_idx_type block_size,
-                         oct_data_conv::data_type output_type,
-                         octave_idx_type skip,
-                         octave::mach_info::float_format flt_fmt);
+    template <typename T>
+      octave_idx_type write (const Array<T>& data, octave_idx_type block_size,
+                             oct_data_conv::data_type output_type,
+                             octave_idx_type skip,
+                             mach_info::float_format flt_fmt);
 
-  octave_value scanf (const std::string& fmt, const Array<double>& size,
-                      octave_idx_type& count, const std::string& who /* = "scanf" */);
+    octave_value scanf (const std::string& fmt, const Array<double>& size,
+                        octave_idx_type& count, const std::string& who /* = "scanf" */);
 
-  octave_value scanf (const octave_value& fmt, const Array<double>& size,
-                      octave_idx_type& count, const std::string& who /* = "scanf" */);
+    octave_value scanf (const octave_value& fmt, const Array<double>& size,
+                        octave_idx_type& count, const std::string& who /* = "scanf" */);
 
-  octave_value_list oscanf (const std::string& fmt,
-                            const std::string& who /* = "scanf" */);
+    octave_value_list oscanf (const std::string& fmt,
+                              const std::string& who /* = "scanf" */);
 
-  octave_value_list oscanf (const octave_value& fmt,
-                            const std::string& who /* = "scanf" */);
+    octave_value_list oscanf (const octave_value& fmt,
+                              const std::string& who /* = "scanf" */);
 
-  octave_value textscan (const std::string& fmt, octave_idx_type ntimes,
-                         const octave_value_list& options,
-                         const std::string& who, octave_idx_type& count);
+    octave_value textscan (const std::string& fmt, octave_idx_type ntimes,
+                           const octave_value_list& options,
+                           const std::string& who, octave_idx_type& count);
+
+    int printf (const std::string& fmt, const octave_value_list& args,
+                const std::string& who /* = "printf" */);
 
-  int printf (const std::string& fmt, const octave_value_list& args,
-              const std::string& who /* = "printf" */);
-
-  int printf (const octave_value& fmt, const octave_value_list& args,
-              const std::string& who /* = "printf" */);
+    int printf (const octave_value& fmt, const octave_value_list& args,
+                const std::string& who /* = "printf" */);
 
-  int puts (const std::string& s, const std::string& who /* = "puts" */);
-  int puts (const octave_value& s, const std::string& who /* = "puts" */);
+    int puts (const std::string& s, const std::string& who /* = "puts" */);
+    int puts (const octave_value& s, const std::string& who /* = "puts" */);
 
-  bool eof (void) const;
+    bool eof (void) const;
 
-  std::string error (bool clear, int& err_num);
+    std::string error (bool clear, int& err_num);
 
-  std::string error (bool clear = false)
-  {
-    int err_num;
-    return error (clear, err_num);
-  }
+    std::string error (bool clear = false)
+    {
+      int err_num;
+      return error (clear, err_num);
+    }
+
+    // Set the error message and state.
 
-  // Set the error message and state.
+    void error (const std::string& msg)
+    {
+      if (rep)
+        rep->error (msg);
+    }
 
-  void error (const std::string& msg)
-  {
-    if (rep)
-      rep->error (msg);
-  }
+    void error (const char *msg) { error (std::string (msg)); }
+
+    int file_number (void) { return rep ? rep->file_number () : -1; }
 
-  void error (const char *msg) { error (std::string (msg)); }
+    bool is_valid (void) const { return (rep != 0); }
 
-  int file_number (void) { return rep ? rep->file_number () : -1; }
+    bool ok (void) const { return rep && rep->ok (); }
 
-  bool is_valid (void) const { return (rep != 0); }
+    operator bool () const { return ok (); }
 
-  bool ok (void) const { return rep && rep->ok (); }
+    std::string name (void) const;
 
-  operator bool () const { return ok (); }
+    int mode (void) const;
 
-  std::string name (void) const;
+    mach_info::float_format float_format (void) const;
 
-  int mode (void) const;
+    static std::string mode_as_string (int mode);
 
-  octave::mach_info::float_format float_format (void) const;
-
-  static std::string mode_as_string (int mode);
+    std::istream *input_stream (void)
+    {
+      return rep ? rep->input_stream () : 0;
+    }
 
-  std::istream *input_stream (void)
-  {
-    return rep ? rep->input_stream () : 0;
-  }
+    std::ostream *output_stream (void)
+    {
+      return rep ? rep->output_stream () : 0;
+    }
 
-  std::ostream *output_stream (void)
-  {
-    return rep ? rep->output_stream () : 0;
-  }
+    void clearerr (void) { if (rep) rep->clearerr (); }
+
+  private:
 
-  void clearerr (void) { if (rep) rep->clearerr (); }
+    // The actual representation of this stream.
+    base_stream *rep;
 
-private:
+    bool stream_ok (bool clear = true) const
+    {
+      bool retval = true;
 
-  // The actual representation of this stream.
-  octave_base_stream *rep;
+      if (rep)
+        {
+          if (clear)
+            rep->clear ();
+        }
+      else
+        retval = false;
 
-  bool stream_ok (bool clear = true) const
-  {
-    bool retval = true;
+      return retval;
+    }
 
-    if (rep)
-      {
-        if (clear)
-          rep->clear ();
-      }
-    else
-      retval = false;
+    void invalid_operation (const std::string& who, const char *rw)
+    {
+      if (rep)
+        rep->invalid_operation (who, rw);
+    }
 
-    return retval;
-  }
+    octave_value
+    finalize_read (std::list<void *>& input_buf_list,
+                   octave_idx_type input_buf_elts,
+                   octave_idx_type elts_read,
+                   octave_idx_type nr, octave_idx_type nc,
+                   oct_data_conv::data_type input_type,
+                   oct_data_conv::data_type output_type,
+                   mach_info::float_format ffmt);
+  };
 
-  void invalid_operation (const std::string& who, const char *rw)
+  class
+  OCTINTERP_API
+  stream_list
   {
-    if (rep)
-      rep->invalid_operation (who, rw);
-  }
+  protected:
+
+    stream_list (void) : list (), lookup_cache (list.end ()) { }
 
-  octave_value
-  finalize_read (std::list<void *>& input_buf_list,
-                 octave_idx_type input_buf_elts,
-                 octave_idx_type elts_read,
-                 octave_idx_type nr, octave_idx_type nc,
-                 oct_data_conv::data_type input_type,
-                 oct_data_conv::data_type output_type,
-                 octave::mach_info::float_format ffmt);
-};
+  public:
+
+    ~stream_list (void) = default;
 
-class
-OCTINTERP_API
-octave_stream_list
-{
-protected:
+    static bool instance_ok (void);
 
-  octave_stream_list (void) : list (), lookup_cache (list.end ()) { }
+    static int insert (stream& os);
 
-public:
-
-  ~octave_stream_list (void) = default;
+    static stream lookup (int fid, const std::string& who = "");
 
-  static bool instance_ok (void);
-
-  static int insert (octave_stream& os);
+    static stream lookup (const octave_value& fid, const std::string& who = "");
 
-  static octave_stream
-  lookup (int fid, const std::string& who = "");
+    static int remove (int fid, const std::string& who = "");
+    static int remove (const octave_value& fid, const std::string& who = "");
 
-  static octave_stream
-  lookup (const octave_value& fid, const std::string& who = "");
+    static void clear (bool flush = true);
 
-  static int remove (int fid, const std::string& who = "");
-  static int remove (const octave_value& fid,
-                     const std::string& who = "");
+    static string_vector get_info (int fid);
+    static string_vector get_info (const octave_value& fid);
 
-  static void clear (bool flush = true);
+    static std::string list_open_files (void);
+
+    static octave_value open_file_numbers (void);
+
+    static int get_file_number (const octave_value& fid);
 
-  static string_vector get_info (int fid);
-  static string_vector get_info (const octave_value& fid);
+  private:
 
-  static std::string list_open_files (void);
+    typedef std::map<int, stream> ostrl_map;
 
-  static octave_value open_file_numbers (void);
+    ostrl_map list;
 
-  static int get_file_number (const octave_value& fid);
+    mutable ostrl_map::const_iterator lookup_cache;
 
-private:
+    static stream_list *instance;
 
-  typedef std::map<int, octave_stream> ostrl_map;
+    static void cleanup_instance (void) { delete instance; instance = 0; }
 
-  ostrl_map list;
+    int do_insert (stream& os);
 
-  mutable ostrl_map::const_iterator lookup_cache;
+    stream do_lookup (int fid, const std::string& who = "") const;
+    stream do_lookup (const octave_value& fid,
+                      const std::string& who = "") const;
 
-  static octave_stream_list *instance;
-
-  static void cleanup_instance (void) { delete instance; instance = 0; }
+    int do_remove (int fid, const std::string& who = "");
+    int do_remove (const octave_value& fid, const std::string& who = "");
 
-  int do_insert (octave_stream& os);
+    void do_clear (bool flush = true);
 
-  octave_stream do_lookup (int fid,
-                           const std::string& who = "") const;
-  octave_stream do_lookup (const octave_value& fid,
-                           const std::string& who = "") const;
+    string_vector do_get_info (int fid) const;
+    string_vector do_get_info (const octave_value& fid) const;
+
+    std::string do_list_open_files (void) const;
 
-  int do_remove (int fid, const std::string& who = "");
-  int do_remove (const octave_value& fid,
-                 const std::string& who = "");
+    octave_value do_open_file_numbers (void) const;
 
-  void do_clear (bool flush = true);
+    int do_get_file_number (const octave_value& fid) const;
+  };
+}
+
+#if defined (OCTAVE_USE_DEPRECATED_FUNCTIONS)
 
-  string_vector do_get_info (int fid) const;
-  string_vector do_get_info (const octave_value& fid) const;
-
-  std::string do_list_open_files (void) const;
+OCTAVE_DEPRECATED ("use 'octave::base_stream' instead")
+typedef octave::base_stream octave_base_stream;
 
-  octave_value do_open_file_numbers (void) const;
+OCTAVE_DEPRECATED ("use 'octave::stream' instead")
+typedef octave::stream octave_stream;
 
-  int do_get_file_number (const octave_value& fid) const;
-};
+OCTAVE_DEPRECATED ("use 'octave::stream_list' instead")
+typedef octave::stream_list octave_stream_list;
 
 #endif
 
+#endif