--- a/libinterp/corefcn/input.h	Tue Jan 17 14:25:51 2017 -0500
+++ b/libinterp/corefcn/input.h	Tue Jan 17 14:40:40 2017 -0500
@@ -86,211 +86,232 @@
 
 extern octave::sys::time Vlast_prompt_time;
 
-class
-octave_base_reader
+namespace octave
 {
-public:
+  class
+  base_reader
+  {
+  public:
 
-  friend class octave_input_reader;
+    friend class input_reader;
 
-  octave_base_reader (octave::base_lexer *lxr)
-    : count (1), pflag (0), lexer (lxr)
-  { }
+    base_reader (octave::base_lexer *lxr)
+      : count (1), pflag (0), lexer (lxr)
+    { }
 
-  octave_base_reader (const octave_base_reader& x)
-    : count (1), pflag (x.pflag), lexer (x.lexer)
-  { }
+    base_reader (const base_reader& x)
+      : count (1), pflag (x.pflag), lexer (x.lexer)
+    { }
 
-  virtual ~octave_base_reader (void) = default;
+    virtual ~base_reader (void) = default;
 
-  virtual std::string get_input (bool& eof) = 0;
+    virtual std::string get_input (bool& eof) = 0;
 
-  virtual std::string input_source (void) const { return in_src; }
+    virtual std::string input_source (void) const { return in_src; }
 
-  void reset (void) { promptflag (1); }
+    void reset (void) { promptflag (1); }
 
-  void increment_promptflag (void) { pflag++; }
+    void increment_promptflag (void) { pflag++; }
 
-  void decrement_promptflag (void) { pflag--; }
+    void decrement_promptflag (void) { pflag--; }
 
-  int promptflag (void) const { return pflag; }
+    int promptflag (void) const { return pflag; }
 
-  int promptflag (int n)
-  {
-    int retval = pflag;
-    pflag = n;
-    return retval;
-  }
+    int promptflag (int n)
+    {
+      int retval = pflag;
+      pflag = n;
+      return retval;
+    }
+
+    std::string octave_gets (bool& eof);
 
-  std::string octave_gets (bool& eof);
+    virtual bool reading_fcn_file (void) const;
 
-  virtual bool reading_fcn_file (void) const;
+    virtual bool reading_classdef_file (void) const;
 
-  virtual bool reading_classdef_file (void) const;
+    virtual bool reading_script_file (void) const;
 
-  virtual bool reading_script_file (void) const;
+    virtual bool input_from_terminal (void) const { return false; }
 
-  virtual bool input_from_terminal (void) const { return false; }
+    virtual bool input_from_file (void) const { return false; }
 
-  virtual bool input_from_file (void) const { return false; }
+    virtual bool input_from_eval_string (void) const { return false; }
 
-  virtual bool input_from_eval_string (void) const { return false; }
+  private:
 
-private:
+    octave::refcount<int> count;
 
-  octave::refcount<int> count;
+    int pflag;
 
-  int pflag;
+    octave::base_lexer *lexer;
 
-  octave::base_lexer *lexer;
+    void do_input_echo (const std::string&) const;
 
-  void do_input_echo (const std::string&) const;
+    static const std::string in_src;
+  };
 
-  static const std::string in_src;
-};
+  class
+  terminal_reader : public base_reader
+  {
+  public:
 
-class
-octave_terminal_reader : public octave_base_reader
-{
-public:
+    terminal_reader (octave::base_lexer *lxr = 0)
+      : base_reader (lxr)
+    { }
+
+    std::string get_input (bool& eof);
 
-  octave_terminal_reader (octave::base_lexer *lxr = 0)
-    : octave_base_reader (lxr)
-  { }
+    std::string input_source (void) const { return in_src; }
 
-  std::string get_input (bool& eof);
+    bool input_from_terminal (void) const { return true; }
+
+  private:
 
-  std::string input_source (void) const { return in_src; }
-
-  bool input_from_terminal (void) const { return true; }
+    static const std::string in_src;
+  };
 
-private:
+  class
+  file_reader : public base_reader
+  {
+  public:
 
-  static const std::string in_src;
-};
+    file_reader (FILE *f_arg, octave::base_lexer *lxr = 0)
+      : base_reader (lxr), file (f_arg) { }
+
+    std::string get_input (bool& eof);
 
-class
-octave_file_reader : public octave_base_reader
-{
-public:
+    std::string input_source (void) const { return in_src; }
+
+    bool input_from_file (void) const { return true; }
 
-  octave_file_reader (FILE *f_arg, octave::base_lexer *lxr = 0)
-    : octave_base_reader (lxr), file (f_arg) { }
+  private:
+
+    FILE *file;
 
-  std::string get_input (bool& eof);
-
-  std::string input_source (void) const { return in_src; }
+    static const std::string in_src;
+  };
 
-  bool input_from_file (void) const { return true; }
-
-private:
-
-  FILE *file;
+  class
+  eval_string_reader : public base_reader
+  {
+  public:
 
-  static const std::string in_src;
-};
-
-class
-octave_eval_string_reader : public octave_base_reader
-{
-public:
+    eval_string_reader (const std::string& str,
+                               octave::base_lexer *lxr = 0)
+      : base_reader (lxr), eval_string (str)
+    { }
 
-  octave_eval_string_reader (const std::string& str,
-                             octave::base_lexer *lxr = 0)
-    : octave_base_reader (lxr), eval_string (str)
-  { }
-
-  std::string get_input (bool& eof);
+    std::string get_input (bool& eof);
 
-  std::string input_source (void) const { return in_src; }
-
-  bool input_from_eval_string (void) const { return true; }
-
-private:
-
-  std::string eval_string;
+    std::string input_source (void) const { return in_src; }
 
-  static const std::string in_src;
-};
+    bool input_from_eval_string (void) const { return true; }
 
-class
-octave_input_reader
-{
-public:
-  octave_input_reader (octave::base_lexer *lxr = 0)
-    : rep (new octave_terminal_reader (lxr))
-  { }
+  private:
+
+    std::string eval_string;
 
-  octave_input_reader (FILE *file, octave::base_lexer *lxr = 0)
-    : rep (new octave_file_reader (file, lxr))
-  { }
-
-  octave_input_reader (const std::string& str, octave::base_lexer *lxr = 0)
-    : rep (new octave_eval_string_reader (str, lxr))
-  { }
+    static const std::string in_src;
+  };
 
-  octave_input_reader (const octave_input_reader& ir)
-  {
-    rep = ir.rep;
-    rep->count++;
-  }
-
-  octave_input_reader& operator = (const octave_input_reader& ir)
+  class
+  input_reader
   {
-    if (&ir != this)
-      {
-        rep = ir.rep;
-        rep->count++;
-      }
+  public:
+    input_reader (octave::base_lexer *lxr = 0)
+      : rep (new terminal_reader (lxr))
+    { }
+
+    input_reader (FILE *file, octave::base_lexer *lxr = 0)
+      : rep (new file_reader (file, lxr))
+    { }
 
-    return *this;
-  }
+    input_reader (const std::string& str, octave::base_lexer *lxr = 0)
+      : rep (new eval_string_reader (str, lxr))
+    { }
+
+    input_reader (const input_reader& ir)
+    {
+      rep = ir.rep;
+      rep->count++;
+    }
 
-  ~octave_input_reader (void)
-  {
-    if (--rep->count == 0)
-      delete rep;
-  }
+    input_reader& operator = (const input_reader& ir)
+    {
+      if (&ir != this)
+        {
+          rep = ir.rep;
+          rep->count++;
+        }
 
-  void reset (void) { return rep->reset (); }
+      return *this;
+    }
 
-  void increment_promptflag (void) { rep->increment_promptflag (); }
+    ~input_reader (void)
+    {
+      if (--rep->count == 0)
+        delete rep;
+    }
 
-  void decrement_promptflag (void) { rep->decrement_promptflag (); }
+    void reset (void) { return rep->reset (); }
 
-  int promptflag (void) const { return rep->promptflag (); }
+    void increment_promptflag (void) { rep->increment_promptflag (); }
+
+    void decrement_promptflag (void) { rep->decrement_promptflag (); }
 
-  int promptflag (int n) { return rep->promptflag (n); }
+    int promptflag (void) const { return rep->promptflag (); }
+
+    int promptflag (int n) { return rep->promptflag (n); }
 
-  std::string get_input (bool& eof)
-  {
-    return rep->get_input (eof);
-  }
+    std::string get_input (bool& eof)
+    {
+      return rep->get_input (eof);
+    }
+
+    std::string input_source (void) const
+    {
+      return rep->input_source ();
+    }
 
-  std::string input_source (void) const
-  {
-    return rep->input_source ();
-  }
+    bool input_from_terminal (void) const
+    {
+      return rep->input_from_terminal ();
+    }
 
-  bool input_from_terminal (void) const
-  {
-    return rep->input_from_terminal ();
-  }
+    bool input_from_file (void) const
+    {
+      return rep->input_from_file ();
+    }
 
-  bool input_from_file (void) const
-  {
-    return rep->input_from_file ();
-  }
+    bool input_from_eval_string (void) const
+    {
+      return rep->input_from_eval_string ();
+    }
+
+  private:
+
+    base_reader *rep;
+  };
+}
+
+#if defined (OCTAVE_USE_DEPRECATED_FUNCTIONS)
 
-  bool input_from_eval_string (void) const
-  {
-    return rep->input_from_eval_string ();
-  }
+OCTAVE_DEPRECATED ("use 'octave::base_reader' instead")
+typedef octave::base_reader octave_base_reader;
+
+OCTAVE_DEPRECATED ("use 'octave::terminal_reader' instead")
+typedef octave::terminal_reader octave_terminal_reader;
 
-private:
+OCTAVE_DEPRECATED ("use 'octave::file_reader' instead")
+typedef octave::file_reader octave_file_reader;
 
-  octave_base_reader *rep;
-};
+OCTAVE_DEPRECATED ("use 'octave::eval_string_reader' instead")
+typedef octave::eval_string_reader octave_eval_string_reader;
+
+OCTAVE_DEPRECATED ("use 'octave::input_reader' instead")
+typedef octave::input_reader octave_input_reader;
 
 #endif
 
+#endif