--- a/libinterp/octave-value/cdef-utils.cc	Fri Feb 22 15:40:15 2019 +0000
+++ b/libinterp/octave-value/cdef-utils.cc	Fri Feb 22 16:02:09 2019 +0000
@@ -35,314 +35,356 @@
 #include "ov-classdef.h"
 #include "ov-usr-fcn.h"
 
-std::string
-get_base_name (const std::string& nm)
-{
-  std::string::size_type pos = nm.find_last_of ('.');
-
-  if (pos != std::string::npos)
-    return nm.substr (pos + 1);
-
-  return nm;
-}
-
-void
-make_function_of_class (const std::string& class_name,
-                        const octave_value& fcn)
-{
-  octave_function *of = fcn.function_value ();
-
-  of->stash_dispatch_class (class_name);
-
-  octave_user_function *uf = of->user_function_value (true);
-
-  if (uf)
-    {
-      if (get_base_name (class_name) == uf->name ())
-        {
-          uf->mark_as_class_constructor ();
-          uf->mark_as_classdef_constructor ();
-        }
-      else
-        uf->mark_as_class_method ();
-    }
-}
-
-void
-make_function_of_class (const cdef_class& cls, const octave_value& fcn)
+namespace octave
 {
-  make_function_of_class (cls.get_name (), fcn);
-}
+  std::string
+  get_base_name (const std::string& nm)
+  {
+    std::string::size_type pos = nm.find_last_of ('.');
+
+    if (pos != std::string::npos)
+      return nm.substr (pos + 1);
 
-cdef_class
-lookup_class (const std::string& name, bool error_if_not_found,
-              bool load_if_not_found)
-{
-  cdef_manager& cdm = octave::__get_cdef_manager__ ("lookup_class");
+    return nm;
+  }
+
+  void
+  make_function_of_class (const std::string& class_name,
+                          const octave_value& fcn)
+  {
+    octave_function *of = fcn.function_value ();
+
+    of->stash_dispatch_class (class_name);
 
-  return cdm.find_class (name, error_if_not_found, load_if_not_found);
-}
+    octave_user_function *uf = of->user_function_value (true);
 
-cdef_class
-lookup_class (const cdef_class& cls)
-{
-  // FIXME: placeholder for the time being, the purpose
-  //        is to centralized any class update activity here.
+    if (uf)
+      {
+        if (get_base_name (class_name) == uf->name ())
+          {
+            uf->mark_as_class_constructor ();
+            uf->mark_as_classdef_constructor ();
+          }
+        else
+          uf->mark_as_class_method ();
+      }
+  }
+
+  void
+  make_function_of_class (const cdef_class& cls, const octave_value& fcn)
+  {
+    make_function_of_class (cls.get_name (), fcn);
+  }
 
-  return cls;
-}
+  cdef_class
+  lookup_class (const std::string& name, bool error_if_not_found,
+                bool load_if_not_found)
+  {
+    cdef_manager& cdm = __get_cdef_manager__ ("lookup_class");
+
+    return cdm.find_class (name, error_if_not_found, load_if_not_found);
+  }
+
+  cdef_class
+  lookup_class (const cdef_class& cls)
+  {
+    // FIXME: placeholder for the time being, the purpose
+    //        is to centralized any class update activity here.
+
+    return cls;
+  }
 
-cdef_class
-lookup_class (const octave_value& ov)
-{
-  if (ov.is_string())
-    return lookup_class (ov.string_value ());
-  else
-    {
-      cdef_class cls (to_cdef (ov));
+  cdef_class
+  lookup_class (const octave_value& ov)
+  {
+    if (ov.is_string())
+      return lookup_class (ov.string_value ());
+    else
+      {
+        cdef_class cls (to_cdef (ov));
+
+        return lookup_class (cls);
+      }
 
-      return lookup_class (cls);
-    }
+    return cdef_class ();
+  }
 
-  return cdef_class ();
-}
+  std::list<cdef_class>
+  lookup_classes (const Cell& cls_list)
+  {
+    std::list<cdef_class> retval;
 
-std::list<cdef_class>
-lookup_classes (const Cell& cls_list)
-{
-  std::list<cdef_class> retval;
+    for (int i = 0; i < cls_list.numel (); i++)
+      {
+        cdef_class c = lookup_class (cls_list(i));
+
+        retval.push_back (c);
+      }
 
-  for (int i = 0; i < cls_list.numel (); i++)
-    {
-      cdef_class c = lookup_class (cls_list(i));
-
-      retval.push_back (c);
-    }
+    return retval;
+  }
 
-  return retval;
-}
+  octave_value
+  to_ov (const cdef_object& obj)
+  {
+    if (obj.ok ())
+      return octave_value (new octave_classdef (obj));
+    else
+      return octave_value (Matrix ());
+  }
 
-octave_value
-to_ov (const std::list<cdef_class>& class_list)
-{
-  Cell cls (class_list.size (), 1);
-  int i = 0;
+  octave_value
+  to_ov (const octave_value& ov)
+  {
+    return ov;
+  }
 
-  for (const auto& cdef_cls : class_list)
-    cls(i++) = to_ov (cdef_cls);
+  cdef_object
+  to_cdef (const octave_value& val)
+  {
+    if (val.type_name () != "object")
+      error ("cannot convert `%s' into `object'", val.type_name().c_str ());
 
-  return octave_value (cls);
-}
+    return dynamic_cast<octave_classdef *> (val.internal_rep ())->get_object ();
+  }
 
-bool
-is_dummy_method (const octave_value& fcn)
-{
-  bool retval = false;
+  cdef_object&
+  to_cdef_ref (const octave_value& val)
+  {
+    if (val.type_name () != "object")
+      error ("cannot convert `%s' into `object'", val.type_name().c_str ());
 
-  if (fcn.is_defined ())
-    {
-      if (fcn.is_user_function ())
-        {
-          octave_user_function *uf = fcn.user_function_value (true);
+    return dynamic_cast<octave_classdef *> (val.internal_rep ())->get_object_ref ();
+  }
+
+  cdef_object
+  to_cdef (const cdef_object& obj)
+  {
+    return obj;
+  }
 
-          if (! uf || ! uf->body ())
-            retval = true;
-        }
-    }
-  else
-    retval = true;
+  octave_value
+  to_ov (const std::list<cdef_class>& class_list)
+  {
+    Cell cls (class_list.size (), 1);
+    int i = 0;
 
-  return retval;
-}
+    for (const auto& cdef_cls : class_list)
+      cls(i++) = to_ov (cdef_cls);
 
-bool
-is_superclass (const cdef_class& clsa, const cdef_class& clsb,
-               bool allow_equal, int max_depth)
-{
-  bool retval = false;
+    return octave_value (cls);
+  }
 
-  if (allow_equal && clsa == clsb)
-    retval = true;
-  else if (max_depth != 0)
-    {
-      Cell c = clsb.get ("SuperClasses").cell_value ();
+  bool
+  is_dummy_method (const octave_value& fcn)
+  {
+    bool retval = false;
+
+    if (fcn.is_defined ())
+      {
+        if (fcn.is_user_function ())
+          {
+            octave_user_function *uf = fcn.user_function_value (true);
 
-      for (int i = 0; ! retval && i < c.numel (); i++)
-        {
-          cdef_class cls = lookup_class (c(i));
+            if (! uf || ! uf->body ())
+              retval = true;
+          }
+      }
+    else
+      retval = true;
 
-          retval = is_superclass (clsa, cls, true,
-                                  max_depth < 0 ? max_depth : max_depth-1);
-        }
-    }
-
-  return retval;
-}
+    return retval;
+  }
 
-bool
-is_strict_superclass (const cdef_class& clsa, const cdef_class& clsb)
-{
-  return is_superclass (clsa, clsb, false);
-}
+  bool
+  is_superclass (const cdef_class& clsa, const cdef_class& clsb,
+                 bool allow_equal, int max_depth)
+  {
+    bool retval = false;
 
-bool
-is_direct_superclass (const cdef_class& clsa, const cdef_class& clsb)
-{
-  return is_superclass (clsa, clsb, false, 1);
-}
+    if (allow_equal && clsa == clsb)
+      retval = true;
+    else if (max_depth != 0)
+      {
+        Cell c = clsb.get ("SuperClasses").cell_value ();
+
+        for (int i = 0; ! retval && i < c.numel (); i++)
+          {
+            cdef_class cls = lookup_class (c(i));
 
-cdef_package
-lookup_package (const std::string& name, bool error_if_not_found,
-                bool load_if_not_found)
-{
-  cdef_manager& cdm = octave::__get_cdef_manager__ ("lookup_package");
+            retval = is_superclass (clsa, cls, true,
+                                    max_depth < 0 ? max_depth : max_depth-1);
+          }
+      }
+
+    return retval;
+  }
 
-  return cdm.find_package (name, error_if_not_found, load_if_not_found);
-}
+  bool
+  is_strict_superclass (const cdef_class& clsa, const cdef_class& clsb)
+  {
+    return is_superclass (clsa, clsb, false);
+  }
 
-cdef_class
-get_class_context (std::string& name, bool& in_constructor)
-{
-  cdef_class cls;
-
-  octave::call_stack& cs = octave::__get_call_stack__ ("get_class_context");
+  bool
+  is_direct_superclass (const cdef_class& clsa, const cdef_class& clsb)
+  {
+    return is_superclass (clsa, clsb, false, 1);
+  }
 
-  octave_function *fcn = cs.current ();
+  cdef_package
+  lookup_package (const std::string& name, bool error_if_not_found,
+                  bool load_if_not_found)
+  {
+    cdef_manager& cdm = __get_cdef_manager__ ("lookup_package");
 
-  in_constructor = false;
+    return cdm.find_package (name, error_if_not_found, load_if_not_found);
+  }
 
-  if (fcn && (fcn->is_class_method ()
-              || fcn->is_classdef_constructor ()
-              || fcn->is_anonymous_function_of_class ()
-              || (fcn->is_private_function ()
-                  && ! fcn->dispatch_class ().empty ())))
-    {
-      cls = lookup_class (fcn->dispatch_class ());
+  cdef_class
+  get_class_context (std::string& name, bool& in_constructor)
+  {
+    cdef_class cls;
 
-      name = fcn->name ();
-      in_constructor = fcn->is_classdef_constructor ();
-    }
+    call_stack& cs = __get_call_stack__ ("get_class_context");
 
-  return cls;
-}
+    octave_function *fcn = cs.current ();
+
+    in_constructor = false;
 
-cdef_class
-get_class_context (void)
-{
-  std::string dummy_string;
-  bool dummy_bool;
-
-  return get_class_context (dummy_string, dummy_bool);
-}
+    if (fcn && (fcn->is_class_method ()
+                || fcn->is_classdef_constructor ()
+                || fcn->is_anonymous_function_of_class ()
+                || (fcn->is_private_function ()
+                    && ! fcn->dispatch_class ().empty ())))
+      {
+        cls = lookup_class (fcn->dispatch_class ());
 
-bool
-check_access (const cdef_class& cls, const octave_value& acc,
-              const std::string& meth_name, const std::string& prop_name,
-              bool is_prop_set)
-{
-  if (acc.is_string ())
-    {
-      std::string acc_s = acc.string_value ();
+        name = fcn->name ();
+        in_constructor = fcn->is_classdef_constructor ();
+      }
+
+    return cls;
+  }
 
-      if (acc_s == "public")
-        return true;
+  cdef_class
+  get_class_context (void)
+  {
+    std::string dummy_string;
+    bool dummy_bool;
 
-      cdef_class ctx = get_class_context ();
-
-      // The access is private or protected, this requires a
-      // valid class context.
+    return get_class_context (dummy_string, dummy_bool);
+  }
 
-      if (ctx.ok ())
-        {
-          if (acc_s == "private")
-            return (ctx == cls);
-          else if (acc_s == "protected")
-            {
-              if (is_superclass (cls, ctx))
-                // Calling a protected method in a superclass.
-                return true;
-              else if (is_strict_superclass (ctx, cls))
-                {
-                  // Calling a protected method or property in a derived class.
-                  // This is only allowed if the context class knows about it
-                  // and has access to it.
+  bool
+  check_access (const cdef_class& cls, const octave_value& acc,
+                const std::string& meth_name, const std::string& prop_name,
+                bool is_prop_set)
+  {
+    if (acc.is_string ())
+      {
+        std::string acc_s = acc.string_value ();
+
+        if (acc_s == "public")
+          return true;
+
+        cdef_class ctx = get_class_context ();
+
+        // The access is private or protected, this requires a
+        // valid class context.
 
-                  if (! meth_name.empty ())
-                    {
-                      cdef_method m = ctx.find_method (meth_name);
-
-                      if (m.ok ())
-                        return check_access (ctx, m.get ("Access"), meth_name);
+        if (ctx.ok ())
+          {
+            if (acc_s == "private")
+              return (ctx == cls);
+            else if (acc_s == "protected")
+              {
+                if (is_superclass (cls, ctx))
+                  // Calling a protected method in a superclass.
+                  return true;
+                else if (is_strict_superclass (ctx, cls))
+                  {
+                    // Calling a protected method or property in a derived class.
+                    // This is only allowed if the context class knows about it
+                    // and has access to it.
 
-                      return false;
-                    }
-                  else if (! prop_name.empty ())
-                    {
-                      cdef_property p = ctx.find_property (prop_name);
+                    if (! meth_name.empty ())
+                      {
+                        cdef_method m = ctx.find_method (meth_name);
 
-                      if (p.ok ())
-                        {
-                          octave_value p_access = p.get (is_prop_set ?
-                                                         "SetAccess" :
-                                                         "GetAccess");
+                        if (m.ok ())
+                          return check_access (ctx, m.get ("Access"), meth_name);
 
-                          return check_access (ctx, p_access, meth_name,
-                                               prop_name, is_prop_set);
-                        }
-
-                      return false;
-                    }
-                  else
-                    panic_impossible ();
-                }
+                        return false;
+                      }
+                    else if (! prop_name.empty ())
+                      {
+                        cdef_property p = ctx.find_property (prop_name);
 
-              return false;
-            }
-          else
-            panic_impossible ();
-        }
-    }
-  else if (acc.isobject ())
-    {
-      cdef_class ctx = get_class_context ();
+                        if (p.ok ())
+                          {
+                            octave_value p_access = p.get (is_prop_set ?
+                                                           "SetAccess" :
+                                                           "GetAccess");
+
+                            return check_access (ctx, p_access, meth_name,
+                                                 prop_name, is_prop_set);
+                          }
+
+                        return false;
+                      }
+                    else
+                      panic_impossible ();
+                  }
 
-      // At this point, a class context is always required.
-      if (ctx.ok ())
-        {
-          if (ctx == cls)
-            return true;
-
-          cdef_class acc_cls (to_cdef (acc));
+                return false;
+              }
+            else
+              panic_impossible ();
+          }
+      }
+    else if (acc.isobject ())
+      {
+        cdef_class ctx = get_class_context ();
 
-          if (is_superclass (acc_cls, ctx))
-            return true;
-        }
-    }
-  else if (acc.iscell ())
-    {
-      Cell acc_c = acc.cell_value ();
+        // At this point, a class context is always required.
+        if (ctx.ok ())
+          {
+            if (ctx == cls)
+              return true;
+
+            cdef_class acc_cls (to_cdef (acc));
 
-      cdef_class ctx = get_class_context ();
-
-      // At this point, a class context is always required.
+            if (is_superclass (acc_cls, ctx))
+              return true;
+          }
+      }
+    else if (acc.iscell ())
+      {
+        Cell acc_c = acc.cell_value ();
 
-      if (ctx.ok ())
-        {
-          if (ctx == cls)
-            return true;
+        cdef_class ctx = get_class_context ();
+
+        // At this point, a class context is always required.
 
-          for (int i = 0; i < acc.numel (); i++)
-            {
-              cdef_class acc_cls (to_cdef (acc_c(i)));
+        if (ctx.ok ())
+          {
+            if (ctx == cls)
+              return true;
+
+            for (int i = 0; i < acc.numel (); i++)
+              {
+                cdef_class acc_cls (to_cdef (acc_c(i)));
 
-              if (is_superclass (acc_cls, ctx))
-                return true;
-            }
-        }
-    }
-  else
-    error ("invalid property/method access in class `%s'",
-           cls.get_name ().c_str ());
+                if (is_superclass (acc_cls, ctx))
+                  return true;
+              }
+          }
+      }
+    else
+      error ("invalid property/method access in class `%s'",
+             cls.get_name ().c_str ());
 
-  return false;
+    return false;
+  }
 }