--- a/libinterp/corefcn/fcn-info.cc	Thu Oct 10 13:33:33 2019 -0400
+++ b/libinterp/corefcn/fcn-info.cc	Thu Oct 10 13:54:14 2019 -0400
@@ -160,10 +160,7 @@
         cdef_manager& cdm
           = __get_cdef_manager__ ("fcn_info::fcn_info_rep::load_class_method");
 
-        octave_function *cm = cdm.find_method_symbol (name, dispatch_type);
-
-        if (cm)
-          retval = octave_value (cm);
+        retval = cdm.find_method_symbol (name, dispatch_type);
 
         if (! retval.is_defined ())
           {
@@ -1034,10 +1031,7 @@
         cdef_manager& cdm
           = __get_cdef_manager__ ("fcn_info::fcn_info_rep::find_package");
 
-        octave_function *fcn = cdm.find_package_symbol (full_name ());
-
-        if (fcn)
-          package = octave_value (fcn);
+        package = cdm.find_package_symbol (full_name ());
       }
 
     return package;

--- a/libinterp/corefcn/interpreter.cc	Thu Oct 10 13:33:33 2019 -0400
+++ b/libinterp/corefcn/interpreter.cc	Thu Oct 10 13:54:14 2019 -0400
@@ -1438,8 +1438,6 @@
 
     unwind_protect frame;
 
-    octave_function *fcn_ptr = nullptr;
-
     // Open function file and parse.
 
     FILE *in_stream = command_editor::get_input_stream ();
@@ -1478,7 +1476,7 @@
 
         int status = parser.run ();
 
-        fcn_ptr = parser.m_primary_fcn_ptr;
+        octave_value ov_fcn = parser.m_primary_fcn;
 
         if (status == 0)
           {
@@ -1489,7 +1487,7 @@
                 // meta.class info (and stash it in the symbol
                 // table?).  Return pointer to constructor?
 
-                if (fcn_ptr)
+                if (ov_fcn.is_defined ())
                   panic_impossible ();
 
                 bool is_at_folder = ! dispatch_type.empty ();
@@ -1497,23 +1495,22 @@
                 std::shared_ptr<tree_classdef> cdef_obj
                   = parser.classdef_object();
 
-                fcn_ptr = cdef_obj->make_meta_class (*this, is_at_folder);
-
-                if (fcn_ptr)
-                  retval = octave_value (fcn_ptr);
+                return cdef_obj->make_meta_class (*this, is_at_folder);
               }
-            else if (fcn_ptr)
+            else if (ov_fcn.is_defined ())
               {
-                retval = octave_value (fcn_ptr);
+                retval = ov_fcn;
 
-                fcn_ptr->maybe_relocate_end ();
+                octave_function *fcn = ov_fcn.function_value ();
+
+                fcn->maybe_relocate_end ();
 
                 if (parser.m_parsing_subfunctions)
                   {
                     if (! parser.m_endfunction_found)
                       parser.m_subfunction_names.reverse ();
 
-                    fcn_ptr->stash_subfunction_names (parser.m_subfunction_names);
+                    fcn->stash_subfunction_names (parser.m_subfunction_names);
                   }
               }
           }

--- a/libinterp/octave-value/cdef-class.cc	Thu Oct 10 13:33:33 2019 -0400
+++ b/libinterp/octave-value/cdef-class.cc	Thu Oct 10 13:54:14 2019 -0400
@@ -244,11 +244,11 @@
         // Analyze the constructor code to determine what superclass
         // constructors are called explicitly.
 
-        octave_function *of = meth.get_function ().function_value (true);
+        octave_value ov_fcn = meth.get_function ();
 
-        if (of)
+        if (ov_fcn.is_defined ())
           {
-            octave_user_function *uf = of->user_function_value (true);
+            octave_user_function *uf = ov_fcn.user_function_value (true);
 
             if (uf)
               {
@@ -1152,11 +1152,9 @@
     return retval;
   }
 
-  octave_function*
+  octave_value
   cdef_class::get_method_function (const std::string& /* nm */)
   {
-    octave_classdef_meta *p = new octave_classdef_meta (*this);
-
-    return p;
+    return octave_value (new octave_classdef_meta (*this));
   }
 }

--- a/libinterp/octave-value/cdef-class.h	Thu Oct 10 13:33:33 2019 -0400
+++ b/libinterp/octave-value/cdef-class.h	Thu Oct 10 13:54:14 2019 -0400
@@ -330,9 +330,9 @@
       return get_rep ()->get_method (nm);
     }
 
-    octave_function * get_method_function (const std::string& nm);
+    octave_value get_method_function (const std::string& nm);
 
-    octave_function * get_constructor_function (void)
+    octave_value get_constructor_function (void)
     {
       return get_method_function (get_name ());
     }

--- a/libinterp/octave-value/cdef-manager.cc	Thu Oct 10 13:33:33 2019 -0400
+++ b/libinterp/octave-value/cdef-manager.cc	Thu Oct 10 13:54:14 2019 -0400
@@ -608,31 +608,25 @@
 
     // install built-in classes into the symbol table
     symtab.install_built_in_function
-      ("meta.class",
-       octave_value (m_meta_class.get_constructor_function ()));
+      ("meta.class", m_meta_class.get_constructor_function ());
 
     symtab.install_built_in_function
-      ("meta.method",
-       octave_value (m_meta_method.get_constructor_function ()));
+      ("meta.method", m_meta_method.get_constructor_function ());
 
     symtab.install_built_in_function
-      ("meta.property",
-       octave_value (m_meta_property.get_constructor_function ()));
+      ("meta.property", m_meta_property.get_constructor_function ());
 
     symtab.install_built_in_function
-      ("meta.package",
-       octave_value (m_meta_package.get_constructor_function ()));
+      ("meta.package", m_meta_package.get_constructor_function ());
 
     // FIXME: meta.event and meta.dynproperty are not implemented
     //        and should not be installed into symbol table.
 
     //  symtab.install_built_in_function
-    //    ("meta.event",
-    //     octave_value (tmp_meta_event.get_constructor_function ()));
+    //    ("meta.event", tmp_meta_event.get_constructor_function ());
 
     //  symtab.install_built_in_function
-    //    ("meta.dynproperty",
-    //     octave_value (tmp_meta_dynproperty.get_constructor_function ()));
+    //    ("meta.dynproperty", tmp_meta_dynproperty.get_constructor_function ());
   }
 
   cdef_class
@@ -687,12 +681,10 @@
     return cdef_class ();
   }
 
-  octave_function *
+  octave_value
   cdef_manager::find_method_symbol (const std::string& method_name,
                                     const std::string& class_name)
   {
-    octave_function *retval = nullptr;
-
     cdef_class cls = find_class (class_name, false, false);
 
     if (cls.ok ())
@@ -700,10 +692,10 @@
         cdef_method meth = cls.find_method (method_name);
 
         if (meth.ok ())
-          retval = new octave_classdef_meta (meth);
+          return octave_value (new octave_classdef_meta (meth));
       }
 
-    return retval;
+    return octave_value ();
   }
 
   cdef_package
@@ -746,17 +738,15 @@
     return retval;
   }
 
-  octave_function *
+  octave_value
   cdef_manager::find_package_symbol (const std::string& pack_name)
   {
-    octave_function *retval = nullptr;
-
     cdef_package pack = find_package (pack_name, false);
 
     if (pack.ok ())
-      retval = new octave_classdef_meta (pack);
+      return octave_value (new octave_classdef_meta (pack));
 
-    return retval;
+    return octave_value ();
   }
 
   cdef_class

--- a/libinterp/octave-value/cdef-manager.h	Thu Oct 10 13:33:33 2019 -0400
+++ b/libinterp/octave-value/cdef-manager.h	Thu Oct 10 13:54:14 2019 -0400
@@ -53,14 +53,14 @@
     cdef_class find_class (const std::string& name, bool error_if_not_found = true,
                            bool load_if_not_found = true);
 
-    octave_function * find_method_symbol (const std::string& method_name,
-                                          const std::string& class_name);
+    octave_value find_method_symbol (const std::string& method_name,
+                                     const std::string& class_name);
 
     cdef_package find_package (const std::string& name,
                                bool error_if_not_found = true,
                                bool load_if_not_found = true);
 
-    octave_function * find_package_symbol (const std::string& pack_name);
+    octave_value find_package_symbol (const std::string& pack_name);
 
     void register_class (const cdef_class& cls)
     {

--- a/libinterp/parse-tree/oct-parse.yy	Thu Oct 10 13:33:33 2019 -0400
+++ b/libinterp/parse-tree/oct-parse.yy	Thu Oct 10 13:54:14 2019 -0400
@@ -1475,7 +1475,7 @@
                         // after parsing the function.  Any function
                         // definitions found in the file have already
                         // been stored in the symbol table or in
-                        // base_parser::m_primary_fcn_ptr.
+                        // base_parser::m_primary_fcn.
 
                         // Unused symbol table context.
                         lexer.m_symtab_context.pop ();
@@ -2184,9 +2184,8 @@
       m_parsing_subfunctions (false), m_parsing_local_functions (false),
       m_max_fcn_depth (-1), m_curr_fcn_depth (-1), m_primary_fcn_scope (),
       m_curr_class_name (), m_curr_package_name (), m_function_scopes (),
-      m_primary_fcn_ptr (nullptr), m_subfunction_names (),
-      m_classdef_object (), m_stmt_list (), m_lexer (lxr),
-      m_parser_state (yypstate_new ())
+      m_primary_fcn (), m_subfunction_names (), m_classdef_object (),
+      m_stmt_list (), m_lexer (lxr), m_parser_state (yypstate_new ())
   { }
 
   base_parser::~base_parser (void)
@@ -2218,7 +2217,7 @@
     m_curr_class_name = "";
     m_curr_package_name = "";
     m_function_scopes.clear ();
-    m_primary_fcn_ptr  = nullptr;
+    m_primary_fcn = octave_value ();
     m_subfunction_names.clear ();
     m_classdef_object.reset ();
     m_stmt_list.reset ();
@@ -3289,7 +3288,7 @@
 
     script->stash_fcn_file_time (now);
 
-    m_primary_fcn_ptr = script;
+    m_primary_fcn = octave_value (script);
   }
 
   // Define a function.
@@ -3452,7 +3451,7 @@
 
     if (m_lexer.m_reading_fcn_file && m_curr_fcn_depth == 0
         && ! m_parsing_subfunctions)
-      m_primary_fcn_ptr = fcn;
+      m_primary_fcn = octave_value (fcn);
 
     return fcn;
   }
@@ -3528,7 +3527,7 @@
             // Otherwise, it is just inserted in the symbol table,
             // either as a subfunction or nested function (see above),
             // or as the primary function for the file, via
-            // m_primary_fcn_ptr (see also load_fcn_from_file,,
+            // m_primary_fcn (see also load_fcn_from_file,,
             // parse_fcn_file, and
             // fcn_info::fcn_info_rep::find_user_function).
 

--- a/libinterp/parse-tree/parse.h	Thu Oct 10 13:33:33 2019 -0400
+++ b/libinterp/parse-tree/parse.h	Thu Oct 10 13:54:14 2019 -0400
@@ -479,7 +479,7 @@
     parent_scope_info m_function_scopes;
 
     // Pointer to the primary user function or user script function.
-    octave_function *m_primary_fcn_ptr;
+    octave_value m_primary_fcn;
 
     // List of subfunction names, initially in the order they are
     // installed in the symbol table, then ordered as they appear in the

--- a/libinterp/parse-tree/pt-classdef.cc	Thu Oct 10 13:33:33 2019 -0400
+++ b/libinterp/parse-tree/pt-classdef.cc	Thu Oct 10 13:54:14 2019 -0400
@@ -201,7 +201,7 @@
 
   // Classdef
 
-  octave_function*
+  octave_value
   tree_classdef::make_meta_class (interpreter& interp, bool is_at_folder)
   {
     cdef_class cls = cdef_class::make_meta_class (interp, this, is_at_folder);
@@ -209,6 +209,6 @@
     if (cls.ok ())
       return cls.get_constructor_function ();
 
-    return nullptr;
+    return octave_value ();
   }
 }

--- a/libinterp/parse-tree/pt-classdef.h	Thu Oct 10 13:33:33 2019 -0400
+++ b/libinterp/parse-tree/pt-classdef.h	Thu Oct 10 13:54:14 2019 -0400
@@ -788,8 +788,8 @@
 
     const std::string& package_name (void) const { return m_pack_name; }
 
-    octave_function * make_meta_class (interpreter& interp,
-                                       bool is_at_folder = false);
+    octave_value make_meta_class (interpreter& interp,
+                                  bool is_at_folder = false);
 
     void accept (tree_walker& tw)
     {