23 #if defined (HAVE_CONFIG_H)
50 OCTAVE_NORETURN
static
60 acc_s =
"class-restricted";
62 error (
"%s: method `%s' has %s access and cannot be run in this context",
63 from.c_str (), meth.
get_name ().c_str (), acc_s.c_str ());
66 OCTAVE_NORETURN
static
77 acc_s =
"class-restricted";
80 error (
"%s: property `%s' has %s access and cannot be set in this context",
81 from.c_str (), prop.
get_name ().c_str (), acc_s.c_str ());
83 error (
"%s: property `%s' has %s access and cannot be obtained in this context",
84 from.c_str (), prop.
get_name ().c_str (), acc_s.c_str ());
90 std::string::size_type pos = nm.find_last_of (
'.');
92 if (pos != std::string::npos)
93 return nm.substr (pos + 1);
150 std::list<octave_value_list> idx (1, args);
154 return val.
subsref (type, idx, nargout);
159 bool load_if_not_found =
true)
189 static std::list<cdef_class>
192 std::list<cdef_class>
retval;
194 for (
int i = 0;
i < cls_list.
numel ();
i++)
198 retval.push_back (c);
205 to_ov (
const std::list<cdef_class>& class_list)
207 Cell cls (class_list.size (), 1);
210 for (std::list<cdef_class>::const_iterator it = class_list.begin ();
211 it != class_list.end (); ++it, ++
i)
212 cls(i) =
to_ov (*it);
219 bool allow_equal =
true,
int max_depth = -1)
223 if (allow_equal && clsa == clsb)
225 else if (max_depth != 0)
229 for (
int i = 0; ! retval &&
i < c.
numel ();
i++)
234 max_depth < 0 ? max_depth : max_depth-1);
254 if (args.
length () == 1 &&
args(0).type_name () ==
"object")
271 in_constructor =
false;
309 bool is_prop_set =
false)
315 if (acc_s ==
"public")
325 if (acc_s ==
"private")
327 else if (acc_s ==
"protected")
338 if (! meth_name.empty ())
347 else if (! prop_name.empty ())
358 prop_name, is_prop_set);
386 for (
int i = 0;
i < acc.
numel ();
i++)
396 error (
"invalid property/method access in class `%s'",
413 if (! uf || ! uf->
body ())
432 if (stack_fcn && stack_fcn == method_fcn)
451 if (pl && pl->
size () > 0)
459 return obj.
is (arg0_obj);
473 if (args.
length () == 1 &&
args(0).type_name () ==
"object")
488 if (args.
length () == 1 &&
args(0).type_name () ==
"object"
489 &&
args(0).class_name () ==
"meta.class")
506 if (args.
length () == 1 &&
args(0).type_name () ==
"object"
507 &&
args(0).class_name () ==
"meta.class")
525 error (
"fromName: invalid number of parameters");
537 if (args.
length () <= 1 ||
args(0).type_name () !=
"object")
538 error (
"fevalStatic: first argument must be a meta.class object");
542 std::string meth_name =
args(1).xstring_value (
"fevalStatic: method name must be a string");
547 error (
"fevalStatic: method not found: %s", meth_name.c_str ());
550 error (
"fevalStatic: method `%s' is not static", meth_name.c_str ());
560 if (args.
length () != 2 ||
args(0).type_name () !=
"object"
561 ||
args(0).class_name () !=
"meta.class")
562 error (
"getConstant: first argument must be a meta.class object");
566 std::string prop_name =
args(1).xstring_value (
"getConstant: property name must be a string");
571 error (
"getConstant: property not found: %s",
575 error (
"getConstant: property `%s' is not constant",
583 #define META_CLASS_CMP(OP, CLSA, CLSB, FUN) \
584 static octave_value_list \
585 class_ ## OP (const octave_value_list& args, int ) \
587 octave_value_list retval; \
589 if (args.length () != 2 \
590 || args(0).type_name () != "object" \
591 || args(1).type_name () != "object" \
592 || args(0).class_name () != "meta.class" \
593 || args(1).class_name () != "meta.class") \
594 error (#OP ": invalid arguments"); \
596 cdef_class clsa = to_cdef (args(0)); \
598 cdef_class clsb = to_cdef (args(1)); \
600 retval(0) = FUN (CLSA, CLSB); \
617 if (args.length () == 1 &&
args(0).type_name () ==
"object")
623 if (!
retval(0).is_defined ())
625 "no default value for property `%s'",
644 const std::list<cdef_class>& super_list = std::list<cdef_class> ())
649 cls.
put (
"Abstract",
false);
650 cls.
put (
"ConstructOnLoad",
false);
651 cls.
put (
"ContainingPackage",
Matrix ());
652 cls.
put (
"Description",
"");
653 cls.
put (
"DetailedDescription",
"");
655 cls.
put (
"Hidden",
false);
656 cls.
put (
"InferiorClasses",
Cell ());
658 cls.
put (
"Properties",
Cell ());
659 cls.
put (
"Sealed",
false);
661 if (name ==
"handle")
663 cls.
put (
"HandleCompatible",
true);
666 else if (super_list.empty ())
668 cls.
put (
"HandleCompatible",
false);
672 bool all_handle_compatible =
true;
673 bool has_handle_class =
false;
675 for (std::list<cdef_class>::const_iterator it = super_list.begin ();
676 it != super_list.end (); ++it)
678 all_handle_compatible = all_handle_compatible
679 && it->get (
"HandleCompatible").bool_value ();
680 has_handle_class = has_handle_class || it->is_handle_class ();
683 if (has_handle_class && ! all_handle_compatible)
684 error (
"%s: cannot mix handle and non-HandleCompatible classes",
687 cls.
put (
"HandleCompatible", all_handle_compatible);
688 if (has_handle_class)
701 return make_class (name, std::list<cdef_class> (1, super));
709 cls.
put (
"Sealed",
true);
725 prop.
put (
"Description",
"");
726 prop.
put (
"DetailedDescription",
"");
727 prop.
put (
"Abstract",
false);
728 prop.
put (
"Constant",
false);
729 prop.
put (
"GetAccess", get_access);
730 prop.
put (
"SetAccess", set_access);
731 prop.
put (
"Dependent",
false);
732 prop.
put (
"Transient",
false);
733 prop.
put (
"Hidden",
false);
734 prop.
put (
"GetObservable",
false);
735 prop.
put (
"SetObservable",
false);
736 prop.
put (
"GetMethod", get_method);
737 prop.
put (
"SetMethod", set_method);
738 prop.
put (
"DefiningClass",
to_ov (cls));
740 prop.
put (
"HasDefault",
false);
744 if (! get_method.is_empty ())
746 if (! set_method.is_empty ())
761 bool is_static =
false)
766 meth.
put (
"Abstract",
false);
767 meth.
put (
"Access", m_access);
768 meth.
put (
"DefiningClass",
to_ov (cls));
769 meth.
put (
"Description",
"");
770 meth.
put (
"DetailedDescription",
"");
771 meth.
put (
"Hidden",
false);
772 meth.
put (
"Sealed",
true);
773 meth.
put (
"Static", is_static);
789 bool is_static =
false)
793 return make_method (cls, name, fcn, m_access, is_static);
804 pack.
put (
"ContainingPackage",
Matrix ());
830 const std::list<octave_value_list>& idx,
851 retval = meth.
execute (args, nargout,
true,
"subsref");
859 retval =
object.subsref (type, idx, nargout, skip,
cdef_class ());
861 if (type.length () > skip && idx.size () > skip)
869 const std::list<octave_value_list>& idx,
880 retval =
object.subsref (type, idx, 1, skip,
cdef_class (), auto_add);
882 if (type.length () > skip && idx.size () > skip)
890 const std::list<octave_value_list>& idx,
913 retlist = meth.
execute (args, 1,
true,
"subsasgn");
915 if (retlist.
empty ())
916 error (
"overloaded method `subsasgn' did not return any value");
923 retval =
object.
subsasgn (type, idx, rhs);
930 const std::list<octave_value_list>& idx,
933 if (type.length () == 1 && type[0] ==
'(')
935 object =
object.make_array ();
960 meth.
execute (args, 0,
true,
"disp");
974 if (
object.is_array ())
1002 arg_names[0] =
name;
1006 meth.
execute (args, 0,
true,
"display");
1032 {
object.meta_release (); }
1038 const std::list<octave_value_list>& idx,
1040 {
return object.meta_subsref (type, idx, nargout); }
1044 const std::list<octave_value_list>& idx)
1048 retval =
subsref (type, idx, 1);
1058 std::list<octave_value_list> l (1, idx);
1061 return subsref (type, l, nargout);
1065 {
return object.meta_is_postfix_index_handled (type); }
1072 if (
object.is_class ())
1106 const std::list<octave_value_list>& idx,
1124 if (type.length () > skip && idx.size () > skip
1133 const std::list<octave_value_list>& idx)
1137 retval =
subsref (type, idx, 1);
1148 bool in_constructor;
1154 error (
"superclass calls can only occur in methods or constructors");
1164 error (
"`%s' is not a direct superclass of `%s'",
1165 cname.c_str (), ctx.
get_name ().c_str ());
1168 error (
"cannot call superclass constructor with variable `%s'",
1179 if (mname != meth_name)
1180 error (
"method name mismatch (`%s' != `%s')",
1181 mname.c_str (), meth_name.c_str ());
1184 error (
"`%s' is not a superclass of `%s'",
1185 cname.c_str (), ctx.
get_name ().c_str ());
1201 error (
"no method `%s' found in superclass `%s'",
1202 meth_name.c_str (), cname.c_str ());
1204 retval = meth.
execute (idx, nargout,
true,
1224 if (ret_list && ret_list->
length () == 1)
1244 "struct: converting a classdef object into a struct "
1245 "overrides the access restrictions defined for properties. "
1246 "All properties are returned, including private and "
1253 std::map<std::string, cdef_property> props;
1257 for (std::map<std::string, cdef_property>::iterator it = props.begin ();
1258 it != props.end (); ++it)
1267 cvalue (
i) = it->second.get_value (a_obj(
i),
false);
1269 retval.
setfield (it->first, cvalue);
1274 it->second.get_value (*
this,
false));
1276 retval.
setfield (it->first, cvalue);
1297 const std::list<octave_value_list>& idx,
1314 std::string name = (idx.front ())(0).string_value ();
1320 int _nargout = (type.length () > 2 ? 1 :
nargout);
1326 if (type.length () > 1 && type[1] ==
'(')
1328 std::list<octave_value_list>::const_iterator it = idx.begin ();
1336 retval = meth.
execute (args, _nargout,
true,
"subsref");
1350 error (
"subsref: unknown method or property: %s", name.c_str ());
1386 retval = new_obj.
subsref (type, idx, nargout, skip, cls, auto_add);
1392 error (
"object cannot be indexed with `%c'", type[0]);
1401 const std::list<octave_value_list>& idx,
1412 std::string name = (idx.front ())(0).string_value ();
1417 error (
"subsasgn: unknown property: %s", name.c_str ());
1420 error (
"subsasgn: cannot assign constant property: %s",
1427 if (type.length () == 1)
1429 prop.
set_value (obj, rhs,
true,
"subsasgn");
1431 retval =
to_ov (obj);
1438 std::list<octave_value_list>
args (idx);
1440 args.erase (args.begin ());
1443 type.substr (1),
args, rhs);
1447 prop.
set_value (obj, val,
true,
"subsasgn");
1449 retval =
to_ov (obj);
1473 error (
"subsasgn: object cannot be index with `%c'", type[0]);
1494 const std::list<octave_value_list>& idx,
1518 for (
int i = 0;
i < ival.
length ();
i++)
1522 iv(
i) = ival(
i).index_vector ();
1531 is_scalar = is_scalar && iv(
i).is_scalar ();
1557 if (type.size () == 1 && idx.size () == 1)
1583 error (
"can't perform indexing operation on array of %s objects",
1593 const std::list<octave_value_list>& idx,
1601 if (type.length () == 1)
1606 error (
"can't assign %s object into array of %s objects.",
1614 for (
int i = 0;
i < ival.
length ();
i++)
1618 iv(
i) = ival(
i).index_vector ();
1626 is_scalar = is_scalar && iv(
i).is_scalar ();
1634 rhs_mat(0) = rhs_obj;
1658 for (
int i = 0;
i < ival.
length ();
i++)
1662 iv(
i) = ival(
i).index_vector ();
1671 is_scalar = is_scalar && iv(
i).is_scalar ();
1674 error (
"subsasgn: invalid indexing for object array assignment"
1675 ", the index must reference a single object in the "
1681 for (
int i = ival.
length ();
i < 2;
i++)
1686 if (a.
numel () != 1)
1687 error (
"subsasgn: invalid indexing for object array assignment");
1691 int ignore_copies = 0;
1705 std::list<octave_value_list> next_idx (idx);
1707 next_idx.erase (next_idx.begin ());
1710 rhs, ignore_copies);
1717 error (
"subasgn: invalid assignment into array of %s objects",
1724 if (! robj.
is (a(0)))
1744 error (
"can't perform indexing operation on array of %s objects",
1759 int n = arr.
numel ();
1761 for (
int i = 0;
i < n;
i++)
1787 std::map< cdef_class, std::list<cdef_class> >::const_iterator it;
1792 || it->second.empty ())
1795 for (std::list<cdef_class>::const_iterator lit = it->second.begin ();
1796 lit != it->second.end (); ++lit)
1813 <<
" object (handle)" << std::endl;
1821 <<
" object (value)" << std::endl;
1828 object_count (0), meta (
false)
1830 put (
"SuperClasses",
to_ov (superclasses));
1839 if (it == method_map.end ())
1857 Cell super_classes =
get (
"SuperClasses").cell_value ();
1859 for (
int i = 0;
i < super_classes.
numel ();
i++)
1882 it != t.
end (); ++it)
1883 (*it)->accept (*
this);
1917 if (of->
name () ==
"__superclass_reference__")
1921 if (
args(0).string_value () == obj_name)
1928 ctor_list.push_back (cls);
1936 {
return ctor_list; }
1990 method_map[meth.
get_name ()] = meth;
2010 if (! ret_list || ret_list->
size () != 1)
2011 error (
"%s: invalid constructor output arguments",
2019 std::list<cdef_class> explicit_ctor_list
2020 =
a.get_constructor_list ();
2022 for (std::list<cdef_class>::const_iterator
2023 it = explicit_ctor_list.begin ();
2024 it != explicit_ctor_list.end ();
2028 std::cerr <<
"explicit superclass constructor: "
2029 << it->get_name () << std::endl;
2032 implicit_ctor_list.remove (*it);
2048 std::map<std::string,cdef_method> meths;
2050 find_methods (meths,
false);
2052 Cell c (meths.size (), 1);
2056 for (std::map<std::string,cdef_method>::const_iterator
2057 it = meths.begin (); it != meths.end (); ++it, ++idx)
2058 c (idx, 0) =
to_ov (it->second);
2066 bool only_inherited)
2068 load_all_methods ();
2072 for (it = method_map.begin (); it != method_map.end (); ++it)
2074 if (! it->second.is_constructor ())
2078 if (meths.find (nm) == meths.end ())
2089 meths[
nm] = it->second;
2096 Cell super_classes =
get (
"SuperClasses").cell_value ();
2098 for (
int i = 0;
i < super_classes.
numel ();
i++)
2111 if (it != property_map.end ())
2121 Cell super_classes =
get (
"SuperClasses").cell_value ();
2123 for (
int i = 0;
i < super_classes.
numel ();
i++)
2139 property_map[prop.
get_name ()] = prop;
2147 std::map<std::string,cdef_property> props;
2151 Cell c (props.size (), 1);
2155 for (std::map<std::string,cdef_property>::const_iterator
2156 it = props.begin (); it != props.end (); ++it, ++idx)
2157 c (idx, 0) =
to_ov (it->second);
2162 std::map<std::string, cdef_property>
2165 std::map<std::string,cdef_property> props;
2167 find_properties (props, mode);
2179 for (it = property_map.begin (); it != property_map.end (); ++it)
2183 if (props.find (nm) == props.end ())
2194 props[
nm] = it->second;
2200 Cell super_classes =
get (
"SuperClasses").cell_value ();
2202 for (
int i = 0;
i < super_classes.
numel ();
i++)
2217 load_all_methods ();
2220 it != method_map.end(); ++it)
2222 if (! it->second.is_constructor ())
2240 it != property_map.end (); ++it)
2258 Cell super_classes =
get (
"SuperClasses").cell_value ();
2260 for (
int i = 0;
i < super_classes.
numel ();
i++)
2271 std::set<std::string> names;
2273 find_names (names,
false);
2277 return v.
sort (
true);
2285 if (it != method_map.end ())
2300 Cell super_classes =
get (
"SuperClasses").cell_value ();
2302 for (
int i = 0;
i < super_classes.
numel ();
i++)
2312 const std::list<octave_value_list>& idx,
2325 std::cerr <<
"constructor" << std::endl;
2336 std::cerr <<
"static method/property" << std::endl;
2339 if (idx.front ().length () != 1)
2340 error (
"invalid meta.class indexing");
2342 std::string nm = idx.front ()(0).xstring_value (
"invalid meta.class indexing, expected a method or property name");
2349 error (
"method `%s' is not static", nm.c_str ());
2353 if (type.length () > 1 && idx.size () > 1
2356 args = *(++(idx.begin ()));
2360 retval = meth.
execute (args, (type.length () > skip
2369 error (
"no such method or property `%s'", nm.c_str ());
2372 error (
"property `%s' is not constant", nm.c_str ());
2380 error (
"invalid meta.class indexing");
2384 if (type.length () > skip && idx.size () > skip && ! retval.
empty ())
2402 get (
"SuperClasses").cell_value ());
2404 for (std::list<cdef_class>::iterator it = super_classes.begin ();
2405 it != super_classes.end (); ++it)
2406 it->initialize_object (obj);
2409 it != property_map.end (); ++it)
2411 if (! it->second.get (
"Dependent").bool_value ())
2416 obj.
put (it->first, pvalue);
2432 for (std::list<cdef_class>::const_iterator it = implicit_ctor_list.begin ();
2433 it != implicit_ctor_list.end (); ++it)
2451 ctor_retval = ctor.
execute (ctor_args, 1,
true,
"constructor");
2453 if (ctor_retval.
length () != 1)
2454 error (
"%s: invalid number of output arguments for classdef constructor",
2455 ctor_name.c_str ());
2457 obj =
to_cdef (ctor_retval(0));
2478 error (
"cannot instantiate object for abstract class `%s'",
2494 if (! empty_class.
ok ())
2495 empty_class =
make_class (
"", std::list<cdef_class> ());
2502 if (! empty_class.
ok ())
2503 empty_class =
make_class (
"", std::list<cdef_class> ());
2504 if (! empty_property.
ok ())
2506 obj = empty_property;
2512 if (! empty_class.
ok ())
2513 empty_class =
make_class (
"", std::list<cdef_class> ());
2514 if (! empty_method.
ok ())
2522 if (! empty_package.
ok ())
2524 obj = empty_package;
2560 else if (s ==
"protected")
2562 else if (s ==
"private")
2572 template <
typename T>
2578 else if (t->expression ())
2579 return t->expression ()->original_text ();
2592 class_name = full_class_name = t->
ident ()->
name ();
2594 full_class_name = t->
package_name () +
"." + full_class_name;
2597 std::cerr <<
"class: " << full_class_name << std::endl;
2600 std::list<cdef_class> slist;
2611 std::cerr <<
"superclass: " << sclass_name << std::endl;
2617 error (
"`%s' cannot inherit from `%s', because it is sealed",
2618 full_class_name.c_str (), sclass_name.c_str ());
2620 slist.push_back (sclass);
2633 retval.
put (
"ContainingPackage",
to_ov (pack));
2649 std::cerr <<
"class attribute: " << aname <<
" = "
2653 retval.
put (aname, avalue);
2665 std::map<std::string, octave_value> set_methods;
2669 std::list<tree_classdef_methods_block *> mb_list = b->
methods_list ();
2672 it != mb_list.end (); ++it)
2674 std::map<std::string, octave_value> amap;
2677 std::cerr <<
"method block" << std::endl;
2682 if ((*it)->attribute_list ())
2685 (*it)->attribute_list ()->begin ();
2686 ait != (*it)->attribute_list ()->end (); ++ait)
2692 std::cerr <<
"method attribute: " << aname <<
" = "
2697 amap[aname] = avalue;
2703 if ((*it)->element_list ())
2706 (*it)->element_list ()->begin ();
2707 mit != (*it)->element_list ()->end (); ++mit)
2709 std::string mname = mit->function_value ()->name ();
2712 if (mprefix ==
"get.")
2713 get_methods[mname.substr (4)] =
2715 else if (mprefix ==
"set.")
2716 set_methods[mname.substr (4)] =
2723 std::cerr << (mname == class_name ?
"constructor"
2725 <<
": " << mname << std::endl;
2728 for (std::map<std::string, octave_value>::iterator
2729 ait = amap.begin (); ait != amap.end (); ++ait)
2730 meth.
put (ait->first, ait->second);
2748 std::list<std::string> external_methods =
2751 for (std::list<std::string>::const_iterator
2752 it = external_methods.begin ();
2753 it != external_methods.end ();
2759 if (*it != class_name
2784 std::list<tree_classdef_properties_block *> pb_list
2788 it != pb_list.end (); ++it)
2790 std::map<std::string, octave_value> amap;
2793 std::cerr <<
"property block" << std::endl;
2798 if ((*it)->attribute_list ())
2801 (*it)->attribute_list ()->begin ();
2802 ait != (*it)->attribute_list ()->end (); ++ait)
2808 std::cerr <<
"property attribute: " << aname <<
" = "
2813 if (aname ==
"Access")
2815 amap[
"GetAccess"] = avalue;
2816 amap[
"SetAccess"] = avalue;
2819 amap[aname] = avalue;
2825 if ((*it)->element_list ())
2828 (*it)->element_list ()->begin ();
2829 pit != (*it)->element_list ()->end (); ++pit)
2831 std::string prop_name = (*pit)->ident ()->name ();
2836 std::cerr <<
"property: " << (*pit)->ident ()->name ()
2840 if ((*pit)->expression ())
2842 octave_value pvalue = (*pit)->expression ()->rvalue1 ();
2845 std::cerr <<
"property default: "
2850 prop.
put (
"DefaultValue", pvalue);
2857 for (std::map<std::string, octave_value>::iterator ait = amap.begin ();
2858 ait != amap.end (); ++ait)
2859 prop.
put (ait->first, ait->second);
2866 std::map<std::string, octave_value>::iterator git =
2867 get_methods.find (prop_name);
2869 if (git != get_methods.end ())
2872 prop.
put (
"GetMethod", git->second);
2873 get_methods.erase (git);
2876 std::map<std::string, octave_value>::iterator sit =
2877 set_methods.find (prop_name);
2879 if (sit != set_methods.end ())
2882 prop.
put (
"SetMethod", sit->second);
2883 set_methods.erase (sit);
2905 bool do_check_access,
2910 if (do_check_access && ! check_get_access ())
2918 error (
"cannot reference properties of class `%s' for non-constructed object",
2927 retval = obj.
get (
get (
"Name").string_value ());
2946 if (do_check_access && ! check_get_access ())
2949 return get (
"DefaultValue");
2962 bool do_check_access,
2965 if (do_check_access && ! check_set_access ())
2973 error (
"cannot reference properties of class `%s' for non-constructed object",
2980 obj.
put (
get (
"Name").string_value (), val);
2990 if (args.
length () > 0 &&
args(0).is_defined ())
2992 if (args (0).is_classdef_object ())
2999 ::warning (
"set-method of property `%s' returned a non-classdef object",
3038 size_t pos = cls_name.rfind (
'.');
3040 if (pos != std::string::npos)
3042 pack_name = cls_name.substr (0, pos);
3043 cls_name = cls_name.substr (pos + 1);
3048 dir_name, pack_name);
3050 if (! file_name.empty ())
3070 error (
"no definition found for method `%s' of class `%s'",
3071 get_name ().c_str (), dispatch_type.c_str ());
3077 int nargout,
bool do_check_access,
3085 if (
get (
"Abstract").bool_value ())
3086 error (
"%s: cannot execute abstract method",
3087 get (
"Name").string_value ().c_str ());
3091 if (
function.is_defined ())
3092 retval =
execute_ov (
function, args, nargout);
3100 int nargout,
bool do_check_access,
3108 if (
get (
"Abstract").bool_value ())
3109 error (
"%s: cannot execute abstract method",
3110 get (
"Name").string_value ().c_str ());
3114 if (
function.is_defined ())
3120 new_args(0) =
to_ov (obj);
3121 for (
int i = 0;
i < args.
length ();
i++)
3124 retval =
execute_ov (
function, new_args, nargout);
3133 if (
function.is_function())
3134 return function.function_value ()->is_classdef_constructor ();
3157 retval = execute (idx.front (), type.length () > 1 ? 1 :
nargout,
true);
3161 error (
"invalid meta.method indexing");
3165 if (type.length () > 1 && idx.size () > 1 && ! retval.
empty ())
3183 error (
"fromName: invalid number of parameters");
3185 std::string name =
args(0).xstring_value (
"fromName: PACKAGE_NAME must be a string");
3197 if (args.
length () == 1 &&
args(0).type_name () ==
"object"
3198 &&
args(0).class_name () ==
"meta.package")
3213 if (args.
length () == 0 &&
args(0).type_name () ==
"object"
3214 &&
args(0).class_name () ==
"meta.package")
3229 if (args.
length () == 0 &&
args(0).type_name () ==
"object"
3230 &&
args(0).class_name () ==
"meta.package")
3243 std::map<std::string, cdef_package> toplevel_packages;
3250 for (std::list<std::string>::const_iterator it = names.begin ();
3251 it != names.end (); ++it)
3254 Cell c (toplevel_packages.size (), 1);
3258 for (std::map<std::string, cdef_package>::const_iterator it =
3259 toplevel_packages.begin ();
3260 it != toplevel_packages.end (); ++it)
3261 c(i++,0) =
to_ov (it->second);
3270 class_map[
nm] = cls;
3279 function_map[
nm] =
fcn;
3286 package_map[
nm] = pack;
3291 template <
typename T1,
typename T2>
3298 for (
typename std::map<T1, T2>::const_iterator it = m.begin ();
3299 it != m.end (); ++it, ++
i)
3313 {
return map2Cell (function_map); }
3338 if (idx.front ().length () != 1)
3339 error (
"invalid meta.package indexing");
3341 std::string nm = idx.front ()(0).xstring_value (
"invalid meta.package indexing, expected a symbol name");
3344 std::cerr <<
"meta.package query: " << nm << std::endl;
3350 error (
"member `%s' in package `%s' does not exist",
3351 nm.c_str (),
get_name ().c_str ());
3363 if (type.size () > 1
3374 if (type.size () > 1 && idx.size () > 1)
3378 else if (type.size () > 1 && idx.size () > 1)
3386 error (
"invalid meta.package indexing");
3443 "public",
Matrix (),
"private"));
3447 "public",
Matrix (),
"private"));
3451 "public",
Matrix (),
"private"));
3456 "public",
Matrix (),
"private"));
3460 "public",
Matrix (),
"private"));
3465 "public",
Matrix (),
"private"));
3469 "public",
Matrix (),
"private"));
3516 "public",
Matrix (),
"private"));
3530 "public",
Matrix (),
"private"));
3534 "public",
Matrix (),
"private"));
3538 "public",
Matrix (),
"private"));
3542 "public",
Matrix (),
"private"));
3546 "public",
Matrix (),
"private"));
3550 "public",
Matrix (),
"private"));
3563 package_meta.
install_class (meta_dynproperty,
"dynproperty");
3595 bool error_if_not_found,
bool load_if_not_found)
3597 std::map<std::string, cdef_class>::iterator it = all_classes.find (name);
3599 if (it == all_classes.end ())
3601 if (load_if_not_found)
3605 size_t pos = name.rfind (
'.');
3607 if (pos == std::string::npos)
3613 cdef_package pack = do_find_package (pack_name,
false,
true);
3616 ov_cls = pack.
find (name.substr (pos+1));
3620 it = all_classes.find (name);
3624 if (it == all_classes.end ())
3626 if (error_if_not_found)
3627 error (
"class not found: %s", name.c_str ());
3639 all_classes.erase (it);
3651 cdef_class cls = find_class (class_name,
false,
false);
3666 bool error_if_not_found,
3667 bool load_if_not_found)
3671 std::map<std::string, cdef_package>::const_iterator it
3672 = all_packages.find (name);
3674 if (it != all_packages.end ())
3676 retval = it->second;
3679 error (
"invalid package `%s'", name.c_str ());
3685 size_t pos = name.find (
'.');
3687 if (pos == std::string::npos)
3696 else if (error_if_not_found)
3697 error (
"unknown package `%s'", name.c_str ());
3724 if (
args.length () != 1)
3727 std::string cname =
args(0).xstring_value (
"PACKAGE_NAME must be a string");
3732 DEFUN (__superclass_reference__,
args, ,
3748 std::cerr <<
"__meta_class_query__ ("
3749 <<
args(0).string_value () <<
")"
3753 if (
args.length () != 1)
3756 std::string cls =
args(0).xstring_value (
"CLASS_NAME must be a string");
3767 if (
args.length () != 1)
static octave_value_list class_ne(const octave_value_list &args, int)
void visit_postfix_expression(tree_postfix_expression &)
void visit_return_command(tree_return_command &)
bool called_from_builtin(void)
void warning_with_id(const char *id, const char *fmt,...)
static void install_built_in_function(const std::string &name, const octave_value &fcn)
void set_value(cdef_object &obj, const octave_value &val, bool do_check_access=true, const std::string &who="")
virtual bool is_classdef_constructor(const std::string &="") const
octave_value find(const std::string &nm)
bool is_static(void) const
void visit_argument_list(tree_argument_list &)
void visit_unwind_protect_command(tree_unwind_protect_command &)
octave_refcount< octave_idx_type > count
void visit_index_expression(tree_index_expression &t)
void visit_cell(tree_cell &)
void visit_octave_user_function(octave_user_function &)
Cell get_properties(int mode=property_normal)
bool is_direct_superclass(const cdef_class &clsa, const cdef_class &clsb)
octave_function * load_fcn_from_file(const std::string &file_name, const std::string &dir_name, const std::string &dispatch_type, const std::string &package_name, const std::string &fcn_name, bool autoload)
octave_value subsref(const std::string &type, const std::list< octave_value_list > &idx)
std::string get_name(void) const
std::list< tree_classdef_methods_block * >::iterator methods_list_iterator
static 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=false)
void visit_funcall(tree_funcall &t)
octave_value get_function(void) const
void install_method(const cdef_method &meth)
dim_vector dims(void) const
virtual bool is_postfix_index_handled(char type) const
static octave_value_list class_gt(const octave_value_list &args, int)
string_vector get_names(void)
octave_value_list(* fcn)(const octave_value_list &, int)
virtual bool is_class_method(const std::string &="") const
static octave_value_list class_le(const octave_value_list &args, int)
Cell get_functions(void) const
octave_value_list subsref(const std::string &type, const std::list< octave_value_list > &idx, int nargout, size_t &skip, const cdef_class &context, bool auto_add=false)
tree_parameter_list * parameter_list(void)
void run_constructor(cdef_object &obj, const octave_value_list &args)
OCTAVE_EXPORT octave_value_list isa nd deftypefn *return ovl(args(0).is_integer_type())
void print_with_name(std::ostream &os, const std::string &name, bool print_padding=true)
octave_value_list subsref(const std::string &type, const std::list< octave_value_list > &idx, int nargout, size_t &skip, const cdef_class &context, bool auto_add)
OCTINTERP_API void print_usage(void)
octave_map map_value(void) const
void set_value(cdef_object &obj, const octave_value &val, bool do_check_access=true, const std::string &who="")
static std::list< std::string > methods(const std::string &class_name, const std::string &pack_name="")
bool is_function(void) const
octave_idx_type numel(void) const
Number of elements in the array.
void visit_persistent_command(tree_persistent_command &)
identity matrix If supplied two scalar respectively For allows like xample val
void install_class(const cdef_class &cls, const std::string &nm)
void set_pos_if_unset(octave_idx_type nd_arg, octave_idx_type dim_arg)
octave_idx_type length(void) const
void accept(tree_walker &tw)
Return the CPU time used by your Octave session The first output is the total time spent executing your process and is equal to the sum of second and third which are the number of CPU seconds spent executing in user mode and the number of CPU seconds spent executing in system mode
friend void install_classdef(void)
octave_value_list execute_ov(octave_value val, const octave_value_list &args, int nargout)
static octave_value_list class_lt(const octave_value_list &args, int)
bool is_defined(void) const
bool is_classdef_constructor(const std::string &cname="") const
void find_properties(std::map< std::string, cdef_property > &props, int mode=0)
void mark_for_construction(const cdef_class &cls)
octave_function * get_method_function(const std::string &nm)
void put(const std::string &pname, const octave_value &val)
void visit_switch_case_list(tree_switch_case_list &)
static const cdef_class & meta_package(void)
static bool in_class_method(const cdef_class &cls)
Array< cdef_object > array
void find_methods(std::map< std::string, cdef_method > &meths, bool only_inherited)
void visit_statement(tree_statement &t)
static const cdef_class & meta_property(void)
#define DEFUN(name, args_name, nargout_name, doc)
void error(const char *fmt,...)
static octave_value_list class_get_inferiorclasses(const octave_value_list &args, int)
tree_classdef_body * body(void)
std::string name(void) const
#define META_CLASS_CMP(OP, CLSA, CLSB, FUN)
void install_function(const octave_value &fcn, const std::string &nm)
void indent(std::ostream &os) const
static std::list< cdef_class > lookup_classes(const Cell &cls_list)
cdef_object & to_cdef_ref(const octave_value &val)
static octave_function * current(void)
static octave_value_list class_getConstant(const octave_value_list &args, int)
std::list< tree_classdef_methods_block * > methods_list(void)
octave_value_list execute(const octave_value_list &args, int nargout, bool do_check_access=true, const std::string &who="")
static octave_value_list class_get_properties(const octave_value_list &args, int)
void visit_identifier(tree_identifier &)
std::map< cdef_class, std::list< cdef_class > > ctor_list
tree_identifier * ident(void)
octave_function * function_value(bool=false)
static void register_class(const cdef_class &cls)
static cdef_package find_package(const std::string &name, bool error_if_not_found=true, bool load_if_not_found=true)
std::list< tree_classdef_superclass * >::iterator iterator
void visit_statement_list(tree_statement_list &t)
static void make_function_of_class(const std::string &class_name, const octave_value &fcn)
bool is_constructed(void) const
OCTAVE_EXPORT octave_value_list return the number of command line arguments passed to Octave If called with the optional argument the function t
static std::string find_method(const std::string &class_name, const std::string &meth, std::string &dir_name, const std::string &pack_name="")
bool is_constructor(void) const
static std::string get_base_name(const std::string &nm)
tree_expression * expression(void)
bool is_recursive_set(const cdef_object &obj) const
void visit_parameter_list(tree_parameter_list &)
static cdef_package make_package(const std::string &nm, const std::string &parent="")
octave_value_list subsref(const std::string &type, const std::list< octave_value_list > &idx, int nargout)
virtual string_vector map_keys(void) const
octave_value_list meta_subsref(const std::string &type, const std::list< octave_value_list > &idx, int nargout)
void fill_empty_values(void)
void newline(std::ostream &os) const
cdef_class do_find_class(const std::string &name, bool error_if_not_found, bool load_if_not_found)
static octave_value_list class_get_methods(const octave_value_list &args, int)
bool is_partially_constructed_for(const cdef_class &cls) const
std::string class_name(void) const
bool check_get_access(void) const
static octave_value varval(const std::string &name, scope_id scope=xcurrent_scope, context_id context=xdefault_context)
static octave_value_list handle_delete(const octave_value_list &, int)
Array< cdef_object > array_value(void) const
void visit_global_command(tree_global_command &)
std::map< std::string, cdef_property >::iterator property_iterator
void load_all_methods(void)
std::string dispatch_class(void) const
void print_raw(std::ostream &os, bool pr_as_read_syntax=false) const
static octave_value compute_attribute_value(tree_classdef_attribute *t)
octave_value subsasgn(const std::string &type, const std::list< octave_value_list > &idx, const octave_value &rhs)
std::list< tree_classdef_properties_block * >::iterator properties_list_iterator
void initialize_object(cdef_object &obj)
std::map< std::string, cdef_property >::const_iterator property_const_iterator
bool is_handle_object(void) const
bool is_constructed_for(const cdef_class &cls) const
bool is_array(void) const
calling an anonymous function involves an overhead quite comparable to the overhead of an m file function Passing a handle to a built in function is because the interpreter is not involved in the internal loop For a
void mark_for_construction(const cdef_class &)
Cell cell_value(void) const
void install_method(const cdef_method &meth)
virtual octave_value undef_subsasgn(const std::string &type, const std::list< octave_value_list > &idx, const octave_value &rhs)
virtual cdef_class get_class(void) const
const dim_vector & dims(void) const
Return a const-reference so that dims ()(i) works efficiently.
void install_property(const cdef_property &prop)
octave_value_list do_multi_index_op(int nargout, const octave_value_list &idx)
cdef_class get_class(void) const
std::string get_name(void) const
Cell get_functions(void) const
octave_value value(void) const
void install_class(const cdef_class &cls, const std::string &nm)
static octave_value_list class_fromName(const octave_value_list &args, int)
OCTAVE_EXPORT octave_value_list isdir nd deftypefn *std::string nm
octave_value subsasgn(const std::string &type, const std::list< octave_value_list > &idx, const octave_value &rhs)
void visit_constant(tree_constant &)
octave_value_list property_get_defaultvalue(const octave_value_list &args, int)
octave_refcount< octave_idx_type > refcount
ctor_analyzer(const std::string &ctor, const std::string &obj)
tree_expression * right_hand_side(void)
virtual octave_user_function * user_function_value(bool silent=false)
static cdef_class make_class(const std::string &name, const std::list< cdef_class > &super_list=std::list< cdef_class >())
static cdef_class make_meta_class(tree_classdef *t, bool is_at_folder=false)
OCTAVE_EXPORT octave_value_list return the number of command line arguments passed to Octave If called with the optional argument the function xample nargout(@histc)
static octave_value to_ov(const std::list< cdef_class > &class_list)
cdef_method find_method(const std::string &nm, bool local=false)
octave_function * get_constructor_function(void)
std::list< cdef_class > get_constructor_list(void) const
octave_idx_type numel(const octave_value_list &idx)
Cell get_classes(void) const
static bool is_dummy_method(const octave_value &fcn)
static llvm::LLVMContext & context
std::string string_value(bool force=false) const
octave_value_list subsref(const std::string &type, const std::list< octave_value_list > &idx, int nargout, size_t &skip, const cdef_class &context, bool auto_add)
void stash_function_name(const std::string &s)
static cdef_method make_method(const cdef_class &cls, const std::string &name, const octave_value &fcn, const std::string &m_access="public", bool is_static=false)
void error_with_id(const char *id, const char *fmt,...)
tree_parameter_list * return_list(void)
nd deftypefn *octave_map m
void visit_prefix_expression(tree_prefix_expression &)
std::string name(void) const
void mark_as_external(const std::string &dtype)
void put(const std::string &pname, const octave_value &val)
static const cdef_class & meta_method(void)
bool is_string(void) const
bool check_access(void) const
octave_user_function * user_function_value(bool silent=false) const
bool is_strict_superclass(const cdef_class &clsa, const cdef_class &clsb)
static cdef_class _meta_method
static cdef_manager * instance
octave_value_list execute(const octave_value_list &args, int nargout, bool do_check_access=true, const std::string &who="")
static cdef_package lookup_package(const std::string &name)
void visit_no_op_command(tree_no_op_command &)
std::list< cdef_class > implicit_ctor_list
void mark_as_class_method(void)
octave_value_list meta_subsref(const std::string &type, const std::list< octave_value_list > &idx, int nargout)
octave_value & assign(assign_op op, const std::string &type, const std::list< octave_value_list > &idx, const octave_value &rhs)
Cell get_packages(void) const
static octave_value_list package_get_classes(const octave_value_list &args, int)
octave_value_list splice(octave_idx_type offset, octave_idx_type len, const octave_value_list &lst=octave_value_list()) const
bool is_constant(void) const
static cdef_package _meta
#define panic_impossible()
static octave_value_list package_fromName(const octave_value_list &args, int)
static cdef_class _meta_class
void visit_binary_expression(tree_binary_expression &)
octave_value find(const std::string &nm)
bool is_private_function(void) const
std::list< tree_classdef_properties_block * > properties_list(void)
void initialize_object(cdef_object &obj)
void visit_switch_case(tree_switch_case &)
octave_value get_value(bool do_check_access=true, const std::string &who="")
cdef_property make_attribute(const cdef_class &cls, const std::string &name)
static cdef_class _meta_package
string_vector & sort(bool make_uniq=false)
static octave_value_list class_ge(const octave_value_list &args, int)
octave_value subsref(const std::string &type, const std::list< octave_value_list > &idx)
octave_value construct(const octave_value_list &args)
tree_expression * expression(void)
static cdef_class _meta_property
cdef_class get_class(void) const
static octave_value_list class_eq(const octave_value_list &args, int)
void mark_as_meta_class(void)
octave_value_list meta_subsref(const std::string &type, const std::list< octave_value_list > &idx, int nargout)
the sparsity preserving column transformation such that that defines the pivoting threshold can be given in which case it defines the c
octave_value get(const std::string &pname) const
void install_package(const cdef_package &pack, const std::string &nm)
octave_value construct(const octave_value_list &args)
cdef_package do_find_package(const std::string &name, bool error_if_not_found, bool load_if_not_found)
static bool is_superclass(const cdef_class &clsa, const cdef_class &clsb, bool allow_equal=true, int max_depth=-1)
cdef_property find_property(const std::string &nm)
virtual bool print_name_tag(std::ostream &os, const std::string &name) const
bool is_scalar(const dim_vector &dim)
void visit_octave_user_script(octave_user_script &)
static cdef_property make_property(const cdef_class &cls, const std::string &name, const octave_value &get_method=Matrix(), const std::string &get_access="public", const octave_value &set_method=Matrix(), const std::string &set_access="public")
friend class octave_value
octave_lvalue lvalue(void)
void setfield(const std::string &key, const Cell &val)
octave_classdef_superclass_ref(const octave_value_list &a)
static octave_idx_type find(octave_idx_type i, octave_idx_type *pp)
octave_function * function_value(bool silent=false) const
T & xelem(octave_idx_type n)
octave_value_list do_multi_index_op(int nargout, const octave_value_list &idx)
void visit_if_command_list(tree_if_command_list &)
std::string class_name(void) const
cdef_property find_property(const std::string &nm)
void warning(const char *fmt,...)
virtual std::string name(void) const
std::map< std::string, cdef_property > get_property_map(int mode)
std::string type_name(void) const
void mark_as_classdef_constructor(void)
virtual octave_value rvalue1(int nargout=1)
charNDArray max(char d, const charNDArray &m)
octave_value undef_subsasgn(const std::string &type, const std::list< octave_value_list > &idx, const octave_value &rhs)
bool is_empty(void) const
std::list< tree_statement * >::const_iterator const_iterator
static cdef_class make_meta_class(const std::string &name, const cdef_class &super)
octave_value make_idx_args(const std::string &type, const std::list< octave_value_list > &idx, const std::string &who)
bool check_set_access(void) const
Cell get_classes(void) const
void visit_function_def(tree_function_def &)
bool is_constructor(void) const
static octave_value_list class_fevalStatic(const octave_value_list &args, int nargout)
cdef_object to_cdef(const octave_value &val)
static OCTAVE_NORETURN void err_method_access(const std::string &from, const cdef_method &meth)
void mark_as_handle_class(void)
static const std::string t_name
static octave_value_list package_get_functions(const octave_value_list &args, int)
void set_class(const cdef_class &cls)
void run_constructor(cdef_object &obj, const octave_value_list &args)
bool bool_value(bool warn=false) const
=val(i)}if ode{val(i)}occurs in table i
cdef_object construct_object(const octave_value_list &args)
void find_names(std::set< std::string > &names, bool all)
static int register_type(const std::string &, const std::string &, const octave_value &)
void visit_fcn_handle(tree_fcn_handle &)
std::map< std::string, cdef_property > get_property_map(int mode=property_normal)
tree_expression * expression(void)
bool is_meta_class(void) const
static octave_value_list package_getAllPackages(const octave_value_list &, int)
void visit_anon_fcn_handle(tree_anon_fcn_handle &)
void visit_simple_assignment(tree_simple_assignment &t)
static void register_package(const cdef_package &pkg)
static octave_value make_fcn_handle(octave_builtin::fcn ff, const std::string &nm)
void mark_as_constructed(void)
size_t length(void) const
octave_function * do_find_package_symbol(const std::string &pack_name)
void delete_object(cdef_object obj)
bool is_constructed_object(const std::string nm)
octave_value function(void) const
~octave_classdef_superclass_ref(void)
defaults to zero A value of zero computes the digamma a value of
void stash_dispatch_class(const std::string &nm)
cdef_class_rep * get_rep(void)
bool is_partially_constructed_for(const cdef_class &cls) const
std::string class_name(void) const
static octave_value_list class_get_superclasses(const octave_value_list &args, int)
bool print_name_tag(std::ostream &os, const std::string &name) const
virtual bool is_anonymous_function_of_class(const std::string &="") const
tree_classdef_superclass_list * superclass_list(void)
bool is_user_function(void) const
Cell get_properties(int mode)
std::string get_name(void) const
void resize(octave_idx_type n, const octave_value &rfv=octave_value())
void assign(const idx_vector &i, const Array< T > &rhs, const T &rfv)
Indexed assignment (always with resize & fill).
std::map< std::string, cdef_method >::const_iterator method_const_iterator
static std::string attribute_value_to_string(T *t, octave_value v)
cdef_object construct_object(const octave_value_list &args)
void delete_object(cdef_object obj)
void visit_multi_assignment(tree_multi_assignment &t)
static const cdef_class & meta_class(void)
octave_value_list subsref(const std::string &type, const std::list< octave_value_list > &idx, int nargout)
std::map< std::string, cdef_method >::iterator method_iterator
Cell map2Cell(const std::map< T1, T2 > &m)
bool is_expression(void) const
static OCTAVE_NORETURN void err_property_access(const std::string &from, const cdef_property &prop, bool is_set=false)
void visit_matrix(tree_matrix &)
void mark_as_constructed(void)
static cdef_class lookup_class(const std::string &name, bool error_if_not_found=true, bool load_if_not_found=true)
static void unregister_class(const cdef_class &cls)
std::string class_name(void) const
cdef_method find_method(const std::string &nm, bool local=false)
void visit_complex_for_command(tree_complex_for_command &)
octave_value get_value(const cdef_object &obj, bool do_check_access=true, const std::string &who="")
bool is_method_executing(const octave_value &ov, const cdef_object &obj)
void visit_try_catch_command(tree_try_catch_command &)
bool is_builtin(void) const
void visit_switch_command(tree_switch_command &)
void visit_simple_for_command(tree_simple_for_command &)
void visit_return_list(tree_return_list &)
void visit_while_command(tree_while_command &)
const std::string & package_name(void) const
static octave_value_list package_get_packages(const octave_value_list &args, int)
std::list< cdef_class > ctor_list
tree_statement_list * body(void)
bool is_handle_class(void) const
Vector representing the dimensions (size) of an Array.
octave_function * do_find_method_symbol(const std::string &method_name, const std::string &class_name)
void install_property(const cdef_property &prop)
void visit_colon_expression(tree_colon_expression &)
tree_expression * right_hand_side(void)
~handle_cdef_object(void)
string_vector get_names(void)
cdef_object copy(void) const
If this string is the system will ring the terminal sometimes it is useful to be able to print the original representation of the string
void visit_do_until_command(tree_do_until_command &)
void visit_if_command(tree_if_command &)
virtual void accept(tree_walker &tw)=0
void visit_decl_init_list(tree_decl_init_list &)
tree_classdef_attribute_list * attribute_list(void)
static cdef_class get_class_context(std::string &name, bool &in_constructor)
void print(std::ostream &os, bool pr_as_read_syntax=false)
virtual void print_with_name(std::ostream &output_buf, const std::string &name, bool print_padding=true)
static void create_instance(void)
void visit_if_clause(tree_if_clause &)
octave_value next_subsref(const std::string &type, const std::list< octave_value_list > &idx, size_t skip=1)
octave_value_list & prepend(const octave_value &val)
virtual bool is_identifier(void) const
static bool find_package(const std::string &package_name)
static std::list< std::string > get_all_package_names(bool only_top_level=true)
void visit_break_command(tree_break_command &)
Cell get_packages(void) const
bool is_constructed(void) const
void visit_decl_elt(tree_decl_elt &)
bool is_instance_of(const std::string &cls_name) const
void mark_as_class_constructor(void)
Array< T > index(const idx_vector &i) const
Indexing without resizing.
octave_value subsasgn(const std::string &type, const std::list< octave_value_list > &idx, const octave_value &rhs, int ignore_copies=0)
return octave_value(v1.char_array_value().concat(v2.char_array_value(), ra_idx),((a1.is_sq_string()||a2.is_sq_string())? '\'': '"'))
void set_function(const octave_value &fcn)
octave_value subsasgn(const std::string &type, const std::list< octave_value_list > &idx, const octave_value &rhs)
void visit_continue_command(tree_continue_command &)
static cdef_class find_class(const std::string &name, bool error_if_not_found=true, bool load_if_not_found=true)
bool is_abstract(void) const
static void register_type(void)
bool is(const cdef_object &obj) const
octave_value_list arguments(void) const
static octave_value find(const std::string &name, const octave_value_list &args=octave_value_list(), bool skip_variables=false, bool local_funcs=true)
void stash_name_tags(const string_vector &nm)