////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2012-2022 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"

OCTAVE_BEGIN_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, FCN)                             \
  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) = FCN (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;

          std::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))
        {
          std::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);
}

OCTAVE_END_NAMESPACE(octave)