cdef-manager.cc

Go to the documentation of this file.

////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2012-2021 The Octave Project Developers
//
// See the file COPYRIGHT.md in the top-level directory of this
// distribution or <https://octave.org/copyright/>.
//
// This file is part of Octave.
//
// Octave is free software: you can redistribute it and/or modify it
// under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// Octave is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Octave; see the file COPYING.  If not, see
// <https://www.gnu.org/licenses/>.
//
////////////////////////////////////////////////////////////////////////
 
#if defined (HAVE_CONFIG_H)
#  include "config.h"
#endif
 
#include "cdef-manager.h"
#include "cdef-utils.h"
#include "interpreter.h"
#include "ov-classdef.h"
 
namespace octave
{
  static octave_value
  make_fcn_handle (octave_builtin::fcn ff, const std::string& nm)
  {
    octave_value fcn (new octave_builtin (ff, nm));
 
    return octave_value (new octave_fcn_handle (fcn));
  }
 
  static octave_value_list
  class_get_properties (const octave_value_list& args, int /* nargout */)
  {
    octave_value_list retval;
 
    if (args.length () == 1 && args(0).type_name () == "object")
      {
        cdef_class cls (to_cdef (args(0)));
 
        retval(0) = cls.get_properties ();
      }
 
    return retval;
  }
 
  static octave_value_list
  class_get_methods (const octave_value_list& args, int /* nargout */)
  {
    octave_value_list retval;
 
    if (args.length () == 1 && args(0).type_name () == "object")
      {
        cdef_class cls (to_cdef (args(0)));
 
        retval(0) = cls.get_methods ();
      }
 
    return retval;
  }
 
  static octave_value_list
  class_get_superclasses (const octave_value_list& args, int /* nargout */)
  {
    octave_value_list retval;
 
    if (args.length () == 1 && args(0).type_name () == "object"
        && args(0).class_name () == "meta.class")
      {
        cdef_class cls (to_cdef (args(0)));
 
        Cell classes = cls.get ("SuperClasses").cell_value ();
 
        retval(0) = to_ov (lookup_classes (classes));
      }
 
    return retval;
  }
 
  static octave_value_list
  class_get_inferiorclasses (const octave_value_list& args, int /* nargout */)
  {
    octave_value_list retval;
 
    if (args.length () == 1 && args(0).type_name () == "object"
        && args(0).class_name () == "meta.class")
      {
        cdef_class cls (to_cdef (args(0)));
 
        Cell classes = cls.get ("InferiorClasses").cell_value ();
 
        retval(0) = to_ov (lookup_classes (classes));
      }
 
    return retval;
  }
 
  static octave_value_list
  class_fromName (const octave_value_list& args, int /* nargout */)
  {
    octave_value_list retval;
 
    if (args.length () != 1)
      error ("fromName: invalid number of parameters");
 
    std::string name = args(0).xstring_value ("fromName: CLASS_NAME must be a string");
 
    retval(0) = to_ov (lookup_class (name, false));
 
    return retval;
  }
 
  static octave_value_list
  class_fevalStatic (const octave_value_list& args, int nargout)
  {
    if (args.length () <= 1 || args(0).type_name () != "object")
      error ("fevalStatic: first argument must be a meta.class object");
 
    cdef_class cls (to_cdef (args(0)));
 
    std::string meth_name = args(1).xstring_value ("fevalStatic: method name must be a string");
 
    cdef_method meth = cls.find_method (meth_name);
 
    if (! meth.ok ())
      error ("fevalStatic: method not found: %s", meth_name.c_str ());
 
    if (! meth.is_static ())
      error ("fevalStatic: method '%s' is not static", meth_name.c_str ());
 
    return meth.execute (args.splice (0, 2), nargout, true, "fevalStatic");
  }
 
  static octave_value_list
  class_getConstant (const octave_value_list& args, int /* nargout */)
  {
    octave_value_list retval;
 
    if (args.length () != 2 || args(0).type_name () != "object"
        || args(0).class_name () != "meta.class")
      error ("getConstant: first argument must be a meta.class object");
 
    cdef_class cls = to_cdef (args(0));
 
    std::string prop_name = args(1).xstring_value ("getConstant: property name must be a string");
 
    cdef_property prop = cls.find_property (prop_name);
 
    if (! prop.ok ())
      error ("getConstant: property not found: %s",
             prop_name.c_str ());
 
    if (! prop.is_constant ())
      error ("getConstant: property '%s' is not constant",
             prop_name.c_str ());
 
    retval(0) = prop.get_value (true, "getConstant");
 
    return retval;
  }
 
#define META_CLASS_CMP(OP, CLSA, CLSB, FUN)                             \
  static octave_value_list                                              \
  class_ ## OP (const octave_value_list& args, int /* nargout */)       \
  {                                                                     \
    octave_value_list retval;                                           \
                                                                        \
    if (args.length () != 2                                             \
        || args(0).type_name () != "object"                             \
        || args(1).type_name () != "object"                             \
        || args(0).class_name () != "meta.class"                        \
        || args(1).class_name () != "meta.class")                       \
      error (#OP ": invalid arguments");                                \
                                                                        \
    cdef_class clsa = to_cdef (args(0));                                \
                                                                        \
    cdef_class clsb = to_cdef (args(1));                                \
                                                                        \
    retval(0) = FUN (CLSA, CLSB);                                       \
                                                                        \
    return retval;                                                      \
  }
 
  META_CLASS_CMP (lt, clsb, clsa, is_strict_superclass)
  META_CLASS_CMP (le, clsb, clsa, is_superclass)
  META_CLASS_CMP (gt, clsa, clsb, is_strict_superclass)
  META_CLASS_CMP (ge, clsa, clsb, is_superclass)
  META_CLASS_CMP (eq, clsa, clsb, operator==)
  META_CLASS_CMP (ne, clsa, clsb, operator!=)
 
  static octave_value_list
  property_get_defaultvalue (const octave_value_list& args, int /* nargout */)
  {
    octave_value_list retval;
 
    if (args.length () == 1 && args(0).type_name () == "object")
      {
        cdef_property prop (to_cdef (args(0)));
 
        retval(0) = prop.get ("DefaultValue");
 
        if (! retval(0).is_defined ())
          error_with_id ("Octave:class:NoDefaultDefined",
                         "no default value for property '%s'",
                         prop.get_name ().c_str ());
      }
 
    return retval;
  }
 
  static octave_value_list
  handle_delete (const octave_value_list& /* args */, int /* nargout */)
  {
    octave_value_list retval;
 
    // FIXME: implement this.  Wait, what is this supposed to do?
 
    return retval;
  }
 
  static octave_value_list
  package_get_classes (const octave_value_list& args, int /* nargout */)
  {
    octave_value_list retval (1, Matrix ());
 
    if (args.length () == 1 && args(0).type_name () == "object"
        && args(0).class_name () == "meta.package")
      {
        cdef_package pack (to_cdef (args(0)));
 
        retval(0) = pack.get_classes ();
      }
 
    return retval;
  }
 
  static octave_value_list
  package_get_functions (const octave_value_list& args, int /* nargout */)
  {
    octave_value_list retval (1, Matrix ());
 
    if (args.length () == 0 && args(0).type_name () == "object"
        && args(0).class_name () == "meta.package")
      {
        cdef_package pack (to_cdef (args(0)));
 
        retval(0) = pack.get_functions ();
      }
 
    return retval;
  }
 
  static octave_value_list
  package_get_packages (const octave_value_list& args, int /* nargout */)
  {
    octave_value_list retval (1, Matrix ());
 
    if (args.length () == 0 && args(0).type_name () == "object"
        && args(0).class_name () == "meta.package")
      {
        cdef_package pack (to_cdef (args(0)));
 
        retval(0) = pack.get_packages ();
      }
 
    return retval;
  }
 
  static octave_value_list
  package_getAllPackages (interpreter& interp,
                          const octave_value_list& /* args */, int /* nargout */)
  {
    std::map<std::string, cdef_package> toplevel_packages;
 
    load_path& lp = interp.get_load_path ();
 
    std::list<std::string> names = lp.get_all_package_names ();
 
    cdef_manager& cdm = interp.get_cdef_manager ();
 
    toplevel_packages["meta"] = cdm.find_package ("meta", false, false);
 
    for (const auto& nm : names)
      toplevel_packages[nm] = cdm.find_package (nm, false, true);
 
    Cell c (toplevel_packages.size (), 1);
 
    int i = 0;
 
    for (const auto& nm_pkg : toplevel_packages)
      c(i++,0) = to_ov (nm_pkg.second);
 
    return octave_value_list (octave_value (c));
  }
 
  static octave_value_list
  package_fromName (const octave_value_list& args, int /* nargout */)
  {
    octave_value_list retval;
 
    if (args.length () != 1)
      error ("fromName: invalid number of parameters");
 
    std::string name = args(0).xstring_value ("fromName: PACKAGE_NAME must be a string");
 
    retval(0) = to_ov (lookup_package (name, false));
 
    return retval;
  }
 
  cdef_manager::cdef_manager (interpreter& interp)
    : m_interpreter (interp), m_all_classes (), m_all_packages (),
      m_meta_class (), m_meta_property (), m_meta_method (),
      m_meta_package (), m_meta ()
  {
    type_info& ti = m_interpreter.get_type_info ();
 
    octave_classdef::register_type (ti);
 
    // bootstrap
    cdef_class tmp_handle = make_class ("handle");
 
    m_meta_class = make_meta_class ("meta.class", tmp_handle);
 
    tmp_handle.set_class (m_meta_class);
    m_meta_class.set_class (m_meta_class);
 
    // meta classes
    m_meta_property = make_meta_class ("meta.property", tmp_handle);
 
    m_meta_method = make_meta_class ("meta.method", tmp_handle);
 
    m_meta_package = make_meta_class ("meta.package", tmp_handle);
 
    cdef_class tmp_meta_event
      = make_meta_class ("meta.event", tmp_handle);
 
    cdef_class tmp_meta_dynproperty
      = make_meta_class ("meta.dynamicproperty", tmp_handle);
 
    // meta.class properties
    m_meta_class.install_property
      (make_attribute (m_meta_class, "Abstract"));
 
    m_meta_class.install_property
      (make_attribute (m_meta_class, "ConstructOnLoad"));
 
    m_meta_class.install_property
      (make_property (m_meta_class, "ContainingPackage"));
 
    m_meta_class.install_property
      (make_property (m_meta_class, "Description"));
 
    m_meta_class.install_property
      (make_property (m_meta_class, "DetailedDescription"));
 
    m_meta_class.install_property
      (make_property (m_meta_class, "Events"));
 
    m_meta_class.install_property
      (make_attribute (m_meta_class, "HandleCompatible"));
 
    m_meta_class.install_property
      (make_attribute (m_meta_class, "Hidden"));
 
    m_meta_class.install_property
      (make_property (m_meta_class, "InferiorClasses",
                      make_fcn_handle (class_get_inferiorclasses,
                                       "meta.class>get.InferiorClasses"),
                      "public", Matrix (), "private"));
 
    m_meta_class.install_property
      (make_property (m_meta_class, "Methods",
                      make_fcn_handle (class_get_methods,
                                       "meta.class>get.Methods"),
                      "public", Matrix (), "private"));
 
    m_meta_class.install_property
      (make_property (m_meta_class, "MethodList",
                      make_fcn_handle (class_get_methods,
                                       "meta.class>get.MethodList"),
                      "public", Matrix (), "private"));
 
    m_meta_class.install_property (make_attribute (m_meta_class, "Name"));
 
    m_meta_class.install_property
      (make_property (m_meta_class, "Properties",
                      make_fcn_handle (class_get_properties,
                                       "meta.class>get.Properties"),
                      "public", Matrix (), "private"));
 
    m_meta_class.install_property
      (make_property (m_meta_class, "PropertyList",
                      make_fcn_handle (class_get_properties,
                                       "meta.class>get.PropertyList"),
                      "public", Matrix (), "private"));
 
    m_meta_class.install_property (make_attribute (m_meta_class, "Sealed"));
 
    m_meta_class.install_property
      (make_property (m_meta_class, "SuperClasses",
                      make_fcn_handle (class_get_superclasses,
                                       "meta.class>get.SuperClasses"),
                      "public", Matrix (), "private"));
 
    m_meta_class.install_property
      (make_property (m_meta_class, "SuperclassList",
                      make_fcn_handle (class_get_superclasses,
                                       "meta.class>get.SuperclassList"),
                      "public", Matrix (), "private"));
 
    // FIXME: Matlab supports this property under "SuperclassList".
    //        Octave, however, has supported this under "SuperClassList".
    //        Alias the property.  Remove in Octave version 8.1.
    m_meta_class.install_property
      (make_property (m_meta_class, "SuperClassList",
                      make_fcn_handle (class_get_superclasses,
                                       "meta.class>get.SuperclassList"),
                      "public", Matrix (), "private"));
 
    // meta.class methods
    m_meta_class.install_method
      (make_method (m_meta_class, "fromName", class_fromName, "public", true));
 
    m_meta_class.install_method
      (make_method (m_meta_class, "fevalStatic", class_fevalStatic, "public",
                    false));
 
    m_meta_class.install_method
      (make_method (m_meta_class, "getConstant", class_getConstant, "public",
                    false));
 
    m_meta_class.install_method (make_method (m_meta_class, "eq", class_eq));
    m_meta_class.install_method (make_method (m_meta_class, "ne", class_ne));
    m_meta_class.install_method (make_method (m_meta_class, "lt", class_lt));
    m_meta_class.install_method (make_method (m_meta_class, "le", class_le));
    m_meta_class.install_method (make_method (m_meta_class, "gt", class_gt));
    m_meta_class.install_method (make_method (m_meta_class, "ge", class_ge));
 
    // meta.method properties
    m_meta_method.install_property
      (make_attribute (m_meta_method, "Abstract"));
 
    m_meta_method.install_property
      (make_attribute (m_meta_method, "Access"));
 
    m_meta_method.install_property
      (make_attribute (m_meta_method, "DefiningClass"));
 
    m_meta_method.install_property
      (make_attribute (m_meta_method, "Description"));
 
    m_meta_method.install_property
      (make_attribute (m_meta_method, "DetailedDescription"));
 
    m_meta_method.install_property
      (make_attribute (m_meta_method, "Hidden"));
 
    m_meta_method.install_property
      (make_attribute (m_meta_method, "Name"));
 
    m_meta_method.install_property
      (make_attribute (m_meta_method, "Sealed"));
 
    m_meta_method.install_property
      (make_attribute (m_meta_method, "Static"));
 
    // meta.property properties
    m_meta_property.install_property
      (make_attribute (m_meta_property, "Name"));
 
    m_meta_property.install_property
      (make_attribute (m_meta_property, "Description"));
 
    m_meta_property.install_property
      (make_attribute (m_meta_property, "DetailedDescription"));
 
    m_meta_property.install_property
      (make_attribute (m_meta_property, "Abstract"));
 
    m_meta_property.install_property
      (make_attribute (m_meta_property, "Constant"));
 
    m_meta_property.install_property
      (make_attribute (m_meta_property, "GetAccess"));
 
    m_meta_property.install_property
      (make_attribute (m_meta_property, "SetAccess"));
 
    m_meta_property.install_property
      (make_attribute (m_meta_property, "Dependent"));
 
    m_meta_property.install_property
      (make_attribute (m_meta_property, "Transient"));
 
    m_meta_property.install_property
      (make_attribute (m_meta_property, "Hidden"));
 
    m_meta_property.install_property
      (make_attribute (m_meta_property, "GetObservable"));
 
    m_meta_property.install_property
      (make_attribute (m_meta_property, "SetObservable"));
 
    m_meta_property.install_property
      (make_attribute (m_meta_property, "GetMethod"));
 
    m_meta_property.install_property
      (make_attribute (m_meta_property, "SetMethod"));
 
    m_meta_property.install_property
      (make_attribute (m_meta_property, "DefiningClass"));
 
    m_meta_property.install_property
      (make_property (m_meta_property, "DefaultValue",
                      make_fcn_handle (property_get_defaultvalue,
                                       "meta.property>get.DefaultValue"),
                      "public", Matrix (), "private"));
 
    m_meta_property.install_property
      (make_attribute (m_meta_property, "HasDefault"));
 
    // meta.property events
    // FIXME: add events
 
    // handle methods
 
    tmp_handle.install_method
      (make_method (tmp_handle, "delete", handle_delete));
 
    // meta.package properties
 
    m_meta_package.install_property
      (make_attribute (m_meta_package, "Name"));
 
    m_meta_package.install_property
      (make_property (m_meta_package, "ContainingPackage"));
 
    m_meta_package.install_property
      (make_property (m_meta_package, "ClassList",
                      make_fcn_handle (package_get_classes,
                                       "meta.package>get.ClassList"),
                      "public", Matrix (), "private"));
 
    m_meta_package.install_property
      (make_property (m_meta_package, "Classes",
                      make_fcn_handle (package_get_classes,
                                       "meta.package>get.Classes"),
                      "public", Matrix (), "private"));
 
    m_meta_package.install_property
      (make_property (m_meta_package, "FunctionList",
                      make_fcn_handle (package_get_functions,
                                       "meta.package>get.FunctionList"),
                      "public", Matrix (), "private"));
 
    m_meta_package.install_property
      (make_property (m_meta_package, "Functions",
                      make_fcn_handle (package_get_functions,
                                       "meta.package>get.Functions"),
                      "public", Matrix (), "private"));
 
    m_meta_package.install_property
      (make_property (m_meta_package, "PackageList",
                      make_fcn_handle (package_get_packages,
                                       "meta.package>get.PackageList"),
                      "public", Matrix (), "private"));
 
    m_meta_package.install_property
      (make_property (m_meta_package, "Packages",
                      make_fcn_handle (package_get_packages,
                                       "meta.package>get.Packages"),
                      "public", Matrix (), "private"));
 
    m_meta_package.install_method
      (make_method (m_meta_package, "fromName", package_fromName,
                    "public", true));
 
    m_meta_package.install_method
      (make_method (m_meta_package, "getAllPackages", package_getAllPackages,
                    "public", true));
 
    // create "meta" package
    cdef_package package_meta
      = m_meta
      = make_package ("meta");
 
    package_meta.install_class (m_meta_class, "class");
    package_meta.install_class (m_meta_property, "property");
    package_meta.install_class (m_meta_method, "method");
    package_meta.install_class (m_meta_package, "package");
    package_meta.install_class (tmp_meta_event, "event");
    package_meta.install_class (tmp_meta_dynproperty, "dynproperty");
 
    symbol_table& symtab = m_interpreter.get_symbol_table ();
 
    // install built-in classes into the symbol table
    symtab.install_built_in_function
      ("meta.class", m_meta_class.get_constructor_function ());
 
    symtab.install_built_in_function
      ("meta.method", m_meta_method.get_constructor_function ());
 
    symtab.install_built_in_function
      ("meta.property", m_meta_property.get_constructor_function ());
 
    symtab.install_built_in_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", tmp_meta_event.get_constructor_function ());
 
    //  symtab.install_built_in_function
    //    ("meta.dynproperty", tmp_meta_dynproperty.get_constructor_function ());
  }
 
  cdef_class
  cdef_manager::find_class (const std::string& name, bool error_if_not_found,
                            bool load_if_not_found)
  {
    auto it = m_all_classes.find (name);
 
    if (it == m_all_classes.end ())
      {
        if (load_if_not_found)
          {
            octave_value ov_cls;
 
            size_t pos = name.rfind ('.');
 
            if (pos == std::string::npos)
              ov_cls = m_interpreter.find (name);
            else
              {
                std::string pack_name = name.substr (0, pos);
 
                cdef_package pack = find_package (pack_name, false, true);
 
                if (pack.ok ())
                  ov_cls = pack.find (name.substr (pos+1));
              }
 
            if (ov_cls.is_defined ())
              it = m_all_classes.find (name);
          }
      }
 
    if (it == m_all_classes.end ())
      {
        if (error_if_not_found)
          error ("class not found: %s", name.c_str ());
      }
    else
      {
        cdef_class cls = it->second;
 
        if (! cls.is_builtin ())
          cls = lookup_class (cls);
 
        if (cls.ok ())
          return cls;
        else
          m_all_classes.erase (it);
      }
 
    return cdef_class ();
  }
 
  octave_value
  cdef_manager::find_method_symbol (const std::string& method_name,
                                    const std::string& class_name)
  {
    cdef_class cls = find_class (class_name, false, false);
 
    if (cls.ok ())
      {
        cdef_method meth = cls.find_method (method_name);
 
        if (meth.ok ())
          return octave_value (new octave_classdef_meta (meth));
      }
 
    return octave_value ();
  }
 
  cdef_package
  cdef_manager::find_package (const std::string& name, bool error_if_not_found,
                              bool load_if_not_found)
  {
    cdef_package retval;
 
    std::map<std::string, cdef_package>::const_iterator it
      = m_all_packages.find (name);
 
    if (it != m_all_packages.end ())
      {
        retval = it->second;
 
        if (! retval.ok ())
          error ("invalid package '%s'", name.c_str ());
      }
    else
      {
        load_path& lp = m_interpreter.get_load_path ();
 
        if (load_if_not_found && lp.find_package (name))
          {
            size_t pos = name.rfind ('.');
 
            if (pos == std::string::npos)
              retval = make_package (name, "");
            else
              {
                std::string parent_name = name.substr (0, pos);
 
                retval = make_package (name, parent_name);
              }
          }
        else if (error_if_not_found)
          error ("unknown package '%s'", name.c_str ());
      }
 
    return retval;
  }
 
  octave_value
  cdef_manager::find_package_symbol (const std::string& pack_name)
  {
    cdef_package pack = find_package (pack_name, false);
 
    if (pack.ok ())
      return octave_value (new octave_classdef_meta (pack));
 
    return octave_value ();
  }
 
  cdef_class
  cdef_manager::make_class (const std::string& name,
                            const std::list<cdef_class>& super_list)
  {
    cdef_class cls (name, super_list);
 
    cls.set_class (meta_class ());
 
    cls.put ("Abstract", false);
    cls.put ("ConstructOnLoad", false);
    cls.put ("ContainingPackage", Matrix ());
    cls.put ("Description", "");
    cls.put ("DetailedDescription", "");
    cls.put ("Events", Cell ());
    cls.put ("Hidden", false);
    cls.put ("InferiorClasses", Cell ());
    cls.put ("Methods", Cell ());
    cls.put ("Properties", Cell ());
    cls.put ("Sealed", false);
 
    if (name == "handle")
      {
        cls.put ("HandleCompatible", true);
        cls.mark_as_handle_class ();
      }
    else if (super_list.empty ())
      {
        cls.put ("HandleCompatible", false);
      }
    else
      {
        bool all_handle_compatible = true;
        bool has_handle_class = false;
 
        for (const auto& cl : super_list)
          {
            all_handle_compatible = all_handle_compatible
              && cl.get ("HandleCompatible").bool_value ();
 
            has_handle_class = has_handle_class || cl.is_handle_class ();
          }
 
        if (has_handle_class && ! all_handle_compatible)
          error ("%s: cannot mix handle and non-HandleCompatible classes",
                 name.c_str ());
 
        cls.put ("HandleCompatible", all_handle_compatible);
        if (has_handle_class)
          cls.mark_as_handle_class ();
      }
 
    if (! name.empty ())
      register_class (cls);
 
    return cls;
  }
 
  cdef_class
  cdef_manager::make_class (const std::string& name,
                            const cdef_class& super)
  {
    return make_class (name, std::list<cdef_class> (1, super));
  }
 
  cdef_class
  cdef_manager::make_meta_class (const std::string& name,
                                 const cdef_class& super)
  {
    cdef_class cls = make_class (name, super);
 
    cls.put ("Sealed", true);
    cls.mark_as_meta_class ();
 
    return cls;
  }
 
  cdef_property
  cdef_manager::make_property (const cdef_class& cls, const std::string& name,
                               const octave_value& get_method,
                               const std::string& get_access,
                               const octave_value& set_method,
                               const std::string& set_access)
  {
    cdef_property prop (name);
 
    prop.set_class (meta_property ());
 
    prop.put ("Description", "");
    prop.put ("DetailedDescription", "");
    prop.put ("Abstract", false);
    prop.put ("Constant", false);
    prop.put ("GetAccess", get_access);
    prop.put ("SetAccess", set_access);
    prop.put ("Dependent", false);
    prop.put ("Transient", false);
    prop.put ("Hidden", false);
    prop.put ("GetObservable", false);
    prop.put ("SetObservable", false);
    prop.put ("GetMethod", get_method);
    prop.put ("SetMethod", set_method);
    prop.put ("DefiningClass", to_ov (cls));
    prop.put ("DefaultValue", octave_value ());
    prop.put ("HasDefault", false);
 
    std::string class_name = cls.get_name ();
 
    if (! get_method.isempty ())
      make_function_of_class (class_name, get_method);
    if (! set_method.isempty ())
      make_function_of_class (class_name, set_method);
 
    return prop;
  }
 
  cdef_property
  cdef_manager::make_attribute (const cdef_class& cls, const std::string& name)
  {
    return make_property (cls, name, Matrix (), "public", Matrix (), "private");
  }
 
  cdef_method
  cdef_manager::make_method (const cdef_class& cls, const std::string& name,
                             const octave_value& fcn,
                             const std::string& m_access, bool is_static)
  {
    cdef_method meth (name);
 
    meth.set_class (meta_method ());
 
    meth.put ("Abstract", false);
    meth.put ("Access", m_access);
    meth.put ("DefiningClass", to_ov (cls));
    meth.put ("Description", "");
    meth.put ("DetailedDescription", "");
    meth.put ("Hidden", false);
    meth.put ("Sealed", true);
    meth.put ("Static", is_static);
 
    if (fcn.is_defined ())
      make_function_of_class (cls, fcn);
 
    meth.set_function (fcn);
 
    if (is_dummy_method (fcn))
      meth.mark_as_external (cls.get_name ());
 
    return meth;
  }
 
  cdef_method
  cdef_manager::make_method (const cdef_class& cls, const std::string& name,
                             octave_builtin::fcn ff,
                             const std::string& m_access, bool is_static)
  {
    octave_value fcn (new octave_builtin (ff, name));
 
    return make_method (cls, name, fcn, m_access, is_static);
  }
 
  cdef_method
  cdef_manager::make_method (const cdef_class& cls, const std::string& name,
                             octave_builtin::meth mm,
                             const std::string& m_access, bool is_static)
  {
    octave_value fcn (new octave_builtin (mm, name));
 
    return make_method (cls, name, fcn, m_access, is_static);
  }
 
  cdef_package
  cdef_manager::make_package (const std::string& nm, const std::string& parent)
  {
    cdef_package pack (nm);
 
    pack.set_class (meta_package ());
 
    if (parent.empty ())
      pack.put ("ContainingPackage", Matrix ());
    else
      pack.put ("ContainingPackage", to_ov (find_package (parent)));
 
    if (! nm.empty ())
      register_package (pack);
 
    return pack;
  }
 
  octave_value
  cdef_manager::find_method (const std::string& class_name,
                             const std::string& name) const
  {
    cdef_class cls = lookup_class (class_name);
 
    return cls.get_method (name);
  }
}