25 #if defined (HAVE_CONFIG_H)
88 error (
"handles to nested functions are not yet supported");
93 const std::list<octave_value_list>& idx,
101 const std::list<octave_value_list>& idx,
103 const std::list<octave_lvalue>* lvalue_list)
111 int tmp_nargout = (type.length () > 1 && nargout == 0) ? 1 : nargout;
114 idx.size () == 1 ? lvalue_list : 0);
122 error (
"%s cannot be indexed with %c", tnm.c_str (), type[0]);
150 const std::list<octave_lvalue>* lvalue_list)
173 str_ov_map::iterator it =
overloads.find (dispatch_type);
179 std::list<std::string> plist
182 std::list<std::string>::const_iterator pit = plist.begin ();
184 while (pit != plist.end ())
217 error (
"%s: no method for class %s",
218 nm.c_str (), dispatch_type.c_str ());
226 error (
"%s: no longer valid function handle",
nm.c_str ());
250 str_ov_map::const_iterator iter =
overloads.begin ();
251 str_ov_map::const_iterator hiter = h.
overloads.begin ();
253 retval = (iter->first == hiter->first)
254 && (iter->second.is_copy_of (hiter->second));
264 if (octaveroot.length () != 0
265 && fpath.length () >= octaveroot.length ()
266 && fpath.substr (0, octaveroot.length ()) == octaveroot
271 fpath.substr (octaveroot.length ());
284 error (
"function handle points to non-existent function");
293 std::list<std::string>
names;
294 names.push_back (
nm +
".oct");
295 names.push_back (
nm +
".mex");
296 names.push_back (
nm +
".m");
309 error (
"function handle points to non-existent function");
318 if (fpath.length () > 0)
327 error (
"function handle points to non-existent function");
338 error (
"function handle points to non-existent function");
360 std::list<symbol_table::symbol_record>
vars
363 size_t varlen = vars.size ();
367 os <<
"# length: " << varlen <<
"\n";
369 for (std::list<symbol_table::symbol_record>::const_iterator
370 p = vars.begin ();
p != vars.end ();
p++)
384 os <<
"# path: " << fnm <<
"\n";
396 std::streampos pos = is.tellg ();
398 if (octaveroot.empty ())
458 error (
"load: failed to load anonymous function handle");
476 if (parse_status == 0)
500 success =
set_fcn (octaveroot, fpath);
510 std::ostringstream nmbuf;
517 std::list<symbol_table::symbol_record>
vars
520 size_t varlen = vars.size ();
523 nmbuf <<
nm <<
" " << varlen;
528 int32_t
tmp = buf_str.length ();
529 os.write (reinterpret_cast<char *> (&tmp), 4);
530 os.write (buf_str.c_str (), buf_str.length ());
532 std::ostringstream buf;
535 tmp = stmp.length ();
536 os.write (reinterpret_cast<char *> (&tmp), 4);
537 os.write (stmp.c_str (), stmp.length ());
541 for (std::list<symbol_table::symbol_record>::const_iterator
542 p = vars.begin ();
p != vars.end ();
p++)
552 std::ostringstream nmbuf;
560 int32_t
tmp = buf_str.length ();
561 os.write (reinterpret_cast<char *> (&tmp), 4);
562 os.write (buf_str.c_str (), buf_str.length ());
575 if (! is.read (reinterpret_cast<char *> (&tmp), 4))
583 is.read (ctmp1, tmp);
596 if (
nm.length () > anl)
598 std::istringstream nm_is (
nm.substr (anl));
600 nm =
nm.substr (0, anl);
603 if (! is.read (reinterpret_cast<char *> (&tmp), 4))
611 is.read (ctmp2, tmp);
640 error (
"load: failed to load anonymous function handle");
652 if (parse_status == 0)
677 if (
nm.find_first_of (
"\n") != std::string::npos)
679 size_t pos1 =
nm.find_first_of (
"\n");
680 size_t pos2 =
nm.find_first_of (
"\n", pos1 + 1);
681 octaveroot =
nm.substr (pos1 + 1, pos2 - pos1 - 1);
682 fpath =
nm.substr (pos2 + 1);
683 nm =
nm.substr (0, pos1);
686 success =
set_fcn (octaveroot, fpath);
696 #if defined (HAVE_HDF5)
700 hid_t group_hid = -1;
701 #if defined (HAVE_HDF5_18)
705 group_hid = H5Gcreate (loc_id, name, 0);
710 hid_t space_hid, data_hid, type_hid;
711 space_hid = data_hid = type_hid = -1;
714 type_hid = H5Tcopy (H5T_C_S1);
715 H5Tset_size (type_hid,
nm.length () + 1);
718 H5Gclose (group_hid);
725 space_hid = H5Screate_simple (0 , hdims, 0);
729 H5Gclose (group_hid);
732 #if defined (HAVE_HDF5_18)
733 data_hid = H5Dcreate (group_hid,
"nm", type_hid, space_hid,
737 data_hid = H5Dcreate (group_hid,
"nm", type_hid, space_hid,
744 H5Sclose (space_hid);
746 H5Gclose (group_hid);
753 std::ostringstream buf;
758 H5Tset_size (type_hid, stmp.length () + 1);
761 H5Sclose (space_hid);
762 H5Gclose (group_hid);
766 #if defined (HAVE_HDF5_18)
767 data_hid = H5Dcreate (group_hid,
"fcn", type_hid, space_hid,
771 data_hid = H5Dcreate (group_hid,
"fcn", type_hid, space_hid,
778 H5Sclose (space_hid);
780 H5Gclose (group_hid);
788 std::list<symbol_table::symbol_record>
vars
791 size_t varlen = vars.size ();
795 hid_t as_id = H5Screate (H5S_SCALAR);
799 #if defined (HAVE_HDF5_18)
800 hid_t a_id = H5Acreate (group_hid,
"SYMBOL_TABLE",
805 hid_t a_id = H5Acreate (group_hid,
"SYMBOL_TABLE",
822 #if defined (HAVE_HDF5_18)
823 data_hid = H5Gcreate (group_hid,
"symbol table",
826 data_hid = H5Gcreate (group_hid,
"symbol table", 0);
830 H5Sclose (space_hid);
832 H5Gclose (group_hid);
836 for (std::list<symbol_table::symbol_record>::const_iterator
837 p = vars.begin ();
p != vars.end ();
p++)
853 H5Sclose (space_hid);
855 hdims[1] = octaveroot.length ();
856 space_hid = H5Screate_simple (0 , hdims, 0);
860 H5Gclose (group_hid);
865 type_hid = H5Tcopy (H5T_C_S1);
866 H5Tset_size (type_hid, octaveroot.length () + 1);
867 #if defined (HAVE_HDF5_18)
868 hid_t a_id = H5Acreate (group_hid,
"OCTAVEROOT",
871 hid_t a_id = H5Acreate (group_hid,
"OCTAVEROOT",
877 retval = (H5Awrite (a_id, type_hid, octaveroot.c_str ()) >= 0);
883 H5Sclose (space_hid);
885 H5Gclose (group_hid);
889 H5Sclose (space_hid);
891 hdims[1] = fpath.length ();
892 space_hid = H5Screate_simple (0 , hdims, 0);
896 H5Gclose (group_hid);
901 type_hid = H5Tcopy (H5T_C_S1);
902 H5Tset_size (type_hid, fpath.length () + 1);
904 #if defined (HAVE_HDF5_18)
905 a_id = H5Acreate (group_hid,
"FILE", type_hid, space_hid,
913 retval = (H5Awrite (a_id, type_hid, fpath.c_str ()) >= 0);
921 H5Sclose (space_hid);
923 H5Gclose (group_hid);
928 octave_unused_parameter (loc_id);
929 octave_unused_parameter (name);
930 octave_unused_parameter (save_as_floats);
941 #if defined (HAVE_HDF5)
945 hid_t group_hid, data_hid, space_hid, type_hid, type_class_hid, st_id;
949 #if defined (HAVE_HDF5_18)
952 group_hid = H5Gopen (loc_id, name);
957 #if defined (HAVE_HDF5_18)
960 data_hid = H5Dopen (group_hid,
"nm");
965 H5Gclose (group_hid);
969 type_hid = H5Dget_type (data_hid);
970 type_class_hid = H5Tget_class (type_hid);
972 if (type_class_hid != H5T_STRING)
976 H5Gclose (group_hid);
980 space_hid = H5Dget_space (data_hid);
981 rank = H5Sget_simple_extent_ndims (space_hid);
985 H5Sclose (space_hid);
988 H5Gclose (group_hid);
992 slen = H5Tget_size (type_hid);
995 H5Sclose (space_hid);
998 H5Gclose (group_hid);
1005 st_id = H5Tcopy (H5T_C_S1);
1006 H5Tset_size (st_id, slen);
1013 H5Sclose (space_hid);
1014 H5Tclose (type_hid);
1015 H5Dclose (data_hid);
1016 H5Gclose (group_hid);
1020 H5Dclose (data_hid);
1025 #if defined (HAVE_HDF5_18)
1028 data_hid = H5Dopen (group_hid,
"fcn");
1033 H5Sclose (space_hid);
1034 H5Tclose (type_hid);
1035 H5Gclose (group_hid);
1039 H5Tclose (type_hid);
1040 type_hid = H5Dget_type (data_hid);
1041 type_class_hid = H5Tget_class (type_hid);
1043 if (type_class_hid != H5T_STRING)
1045 H5Sclose (space_hid);
1046 H5Tclose (type_hid);
1047 H5Dclose (data_hid);
1048 H5Gclose (group_hid);
1052 H5Sclose (space_hid);
1053 space_hid = H5Dget_space (data_hid);
1054 rank = H5Sget_simple_extent_ndims (space_hid);
1058 H5Sclose (space_hid);
1059 H5Tclose (type_hid);
1060 H5Dclose (data_hid);
1061 H5Gclose (group_hid);
1065 slen = H5Tget_size (type_hid);
1068 H5Sclose (space_hid);
1069 H5Tclose (type_hid);
1070 H5Dclose (data_hid);
1071 H5Gclose (group_hid);
1078 st_id = H5Tcopy (H5T_C_S1);
1079 H5Tset_size (st_id, slen);
1086 H5Sclose (space_hid);
1087 H5Tclose (type_hid);
1088 H5Dclose (data_hid);
1089 H5Gclose (group_hid);
1093 H5Dclose (data_hid);
1101 H5E_auto_t err_func;
1102 void *err_func_data;
1106 #if defined (HAVE_HDF5_18)
1110 H5Eget_auto (&err_func, &err_func_data);
1114 hid_t attr_id = H5Aopen_name (group_hid,
"SYMBOL_TABLE");
1125 #if defined (HAVE_HDF5_18)
1128 H5Eset_auto (err_func, err_func_data);
1144 if (len > 0 && success)
1146 hsize_t num_obj = 0;
1147 #if defined (HAVE_HDF5_18)
1150 data_hid = H5Gopen (group_hid,
"symbol table");
1152 H5Gget_num_objs (data_hid, &num_obj);
1153 H5Gclose (data_hid);
1155 if (num_obj != static_cast<hsize_t>(len))
1156 error (
"load: failed to load anonymous function handle");
1159 int current_item = 0;
1164 error (
"load: failed to load anonymous function handle");
1176 if (parse_status == 0)
1207 H5E_auto_t err_func;
1208 void *err_func_data;
1212 #if defined (HAVE_HDF5_18)
1216 H5Eget_auto (&err_func, &err_func_data);
1220 hid_t attr_id = H5Aopen_name (group_hid,
"OCTAVEROOT");
1223 H5Tclose (type_hid);
1224 type_hid = H5Aget_type (attr_id);
1225 type_class_hid = H5Tget_class (type_hid);
1227 if (type_class_hid != H5T_STRING)
1231 slen = H5Tget_size (type_hid);
1232 st_id = H5Tcopy (H5T_C_S1);
1233 H5Tset_size (st_id, slen);
1236 if (H5Aread (attr_id, st_id, root_tmp) < 0)
1239 octaveroot = root_tmp;
1249 attr_id = H5Aopen_name (group_hid,
"FILE");
1252 H5Tclose (type_hid);
1253 type_hid = H5Aget_type (attr_id);
1254 type_class_hid = H5Tget_class (type_hid);
1256 if (type_class_hid != H5T_STRING)
1260 slen = H5Tget_size (type_hid);
1261 st_id = H5Tcopy (H5T_C_S1);
1262 H5Tset_size (st_id, slen);
1265 if (H5Aread (attr_id, st_id, path_tmp) < 0)
1278 #if defined (HAVE_HDF5_18)
1281 H5Eset_auto (err_func, err_func_data);
1284 success = (success ?
set_fcn (octaveroot, fpath) : success);
1287 H5Tclose (type_hid);
1288 H5Sclose (space_hid);
1289 H5Gclose (group_hid);
1294 octave_unused_parameter (loc_id);
1295 octave_unused_parameter (name);
1451 size_t len = nm.
length ();
1453 if (len == 3 && nm ==
".**")
1490 else if (nm[1] ==
'=')
1512 else if (nm ==
"**")
1577 if (local_funcs && fptr
1589 bool any_match = fptr != 0 || classes.size () > 0;
1595 any_match = classes.size () > 0;
1599 error (
"@%s: no function and no method found", tnm.c_str ());
1604 for (std::list<std::string>::iterator iter = classes.begin ();
1605 iter != classes.end (); iter++)
1610 bool is_builtin =
false;
1617 fh->set_overload (static_cast<builtin_type_t> (i), fmeth);
1622 fh->set_overload (class_name, fmeth);
1711 if (
args.length () != 1)
1714 octave_fcn_handle *fh =
args(0).fcn_handle_value (
"functions: FCN_HANDLE argument must be a function handle object");
1719 error (
"functions: FCN_HANDLE is not a valid function handle object");
1727 std::ostringstream buf;
1729 m.
setfield (
"function", buf.str ());
1739 m.
setfield (
"type",
"subfunction");
1741 parentage.
elem (0) = fh_nm;
1761 std::list<symbol_table::symbol_record>
vars
1764 size_t varlen = vars.size ();
1769 for (std::list<symbol_table::symbol_record>::const_iterator
1770 p = vars.begin ();
p != vars.end ();
p++)
1772 ws.
assign (
p->name (),
p->varval (0));
1797 if (
args.length () != 1)
1800 octave_fcn_handle *fh =
args(0).fcn_handle_value (
"func2str: FCN_HANDLE argument must be a function handle object");
1803 error (
"func2str: FCN_HANDLE must be a valid function handle");
1811 std::ostringstream buf;
1815 retval = buf.str ();
1836 if (nargin < 1 || nargin > 2)
1849 if (parse_status == 0)
1850 retval = anon_fcn_handle;
1897 if (
args.length () != 1)
1900 return ovl (
args(0).is_function_handle ());
1918 const std::vector<int>& mask,
1921 arg_mask (mask), expected_nargin (exp_nargin)
1937 cmd_list = usr_fcn->
body ();
1941 body_expr = (cmd_list->
length () == 1
1953 std::list<tree_argument_list *> arg_lists = idx_expr->
arg_lists ();
1956 if (type_tags.length () == 1 && type_tags[0] ==
'('
1959 assert (arg_lists.size () == 1);
1967 std::map<std::string, int> arginmap;
1973 it != param_list->
end (); ++it, ++npar)
1978 arginmap[id->
name ()] = npar;
1982 if (arg_list && arg_list->
length () > 0)
1985 int nargs = arg_list->
length ();
1993 it != arg_list->
end (); ++it, ++iarg)
2005 if (arginmap.find (elt_id->
name ()) != arginmap.end ())
2032 if (head_id->is_defined ())
2033 root_val = head_id->rvalue1 ();
2039 if (head_name ==
"eval" || head_name ==
"feval")
2059 catch (
const octave::execution_exception&)
2073 std::list<string_vector> arg_names = idx_expr->
arg_names ();
2074 assert (arg_names.size () == 1);
2106 const std::list<octave_lvalue>* lvalue_list)
std::string read_until_newline(std::istream &is, bool keep_newline)
static std::string system_path(void)
virtual bool is_classdef_constructor(const std::string &="") const
octave_value subsref(const std::string &type, const std::list< octave_value_list > &idx)
static const std::string anonymous
bool is_equal_to(const octave_fcn_handle &) const
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)
std::string find_first_of(const std::list< std::string > &names)
virtual bool is_constant(void) const
tree_parameter_list * parameter_list(void)
static octave_value find_method(const std::string &name, const std::string &dispatch_type)
OCTAVE_EXPORT octave_value_list isa nd deftypefn *return ovl(args(0).is_integer_type())
OCTINTERP_API void print_usage(void)
bool is_function(void) const
static std::string dir_sep_chars(void)
void print_raw(std::ostream &os, bool pr_as_read_syntax=false) const
F77_RET_T F77_REAL &F77_RET_T F77_DBLE &F77_RET_T F77_REAL &F77_RET_T F77_DBLE &F77_RET_T F77_REAL &F77_RET_T F77_DBLE &F77_RET_T const F77_REAL const F77_REAL F77_REAL &F77_RET_T const F77_DBLE const F77_DBLE F77_DBLE &F77_RET_T F77_REAL &F77_RET_T F77_DBLE &F77_RET_T F77_DBLE &F77_RET_T F77_REAL &F77_RET_T F77_REAL &F77_RET_T F77_DBLE &F77_RET_T const F77_DBLE F77_DBLE &F77_RET_T const F77_REAL F77_REAL &F77_RET_T F77_REAL F77_REAL &F77_RET_T F77_DBLE F77_DBLE &F77_RET_T const F77_DBLE const F77_DBLE * f
const octave_hdf5_id octave_H5S_ALL
bool set_fcn(const std::string &octaveroot, const std::string &fpath)
dim_vector dims(void) const
octave_idx_type length(void) const
static std::list< symbol_record > all_variables(scope_id scope=xcurrent_scope, context_id context=xdefault_context, bool defined_only=true, unsigned int exclude=symbol_record::hidden)
bool out_of_date_check(octave_value &function, const std::string &dispatch_type, bool check_relative)
bool is_defined(void) const
static void set_scope(scope_id scope)
std::vector< int > arg_mask
const octave_hdf5_id octave_H5E_DEFAULT
#define DEFUN(name, args_name, nargout_name, doc)
void error(const char *fmt,...)
symbol_table::scope_id scope(void)
virtual bool is_class_constructor(const std::string &="") const
void setfield(const std::string &key, const octave_value &val)
static std::map< std::string, std::string > vars
static scope_id alloc_scope(void)
#define DEFINE_OV_TYPEID_FUNCTIONS_AND_DATA(t, n, c)
std::list< tree_decl_elt * >::iterator iterator
void skip_preceeding_newline(std::istream &is)
T & elem(octave_idx_type n)
tree_expression * expression(void)
bool load_ascii(std::istream &is)
bool is_copy_of(const octave_value &val) const
octave_fcn_handle * fcn_handle_value(bool silent=false) const
bool is_overloaded(void) const
bool save_binary(std::ostream &os, bool &save_as_floats)
void newline(std::ostream &os) const
static octave_value find_function(const std::string &name, const octave_value_list &args=octave_value_list(), bool local_funcs=true)
std::string type_tags(void)
std::list< string_vector > arg_names(void)
static void cache_name(scope_id scope, const std::string &name)
tree_identifier * ident(void)
octave_value make_fcn_handle(const std::string &nm, bool local_funcs)
octave_fcn_binder(const octave_value &f, const octave_value &root, const octave_value_list &templ, const std::vector< int > &mask, int exp_nargin)
octave_value_list do_multi_index_op(int nargout, const octave_value_list &idx)
static std::string make_absolute(const std::string &s, const std::string &dot_path=get_current_directory())
void warn_load(const char *type) const
OCTAVE_EXPORT octave_value_list isdir nd deftypefn *std::string nm
void swap_bytes< 4 >(void *ptr)
std::list< tree_argument_list * > arg_lists(void)
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)
void add_fcn(void(*fcn)(void))
bool save_text_data(std::ostream &os, const octave_value &val_arg, const std::string &name, bool mark_as_global, int precision)
std::string extract_keyword(std::istream &is, const char *keyword, const bool next_only)
bool save_ascii(std::ostream &os)
nd deftypefn *octave_map m
std::string name(void) const
std::string btyp_class_name[btyp_num_types]
octave_user_function * user_function_value(bool silent=false) const
virtual bool is_index_expression(void) const
defaults to zero A value of zero computes the digamma a value the trigamma and so on The digamma function is for polygamma functions(ar{k}higher than 0)
std::string read_binary_data(std::istream &is, bool swap, octave::mach_info::float_format fmt, const std::string &filename, bool &global, octave_value &tc, std::string &doc)
bool save_hdf5(octave_hdf5_id loc_id, const char *name, bool save_as_floats)
octave_value_list arg_template
octave_hdf5_err hdf5_h5g_iterate(octave_hdf5_id loc_id, const char *name, int *idx, void *operator_data)
#define panic_impossible()
octave_value builtin_overloads[btyp_num_types]
virtual bool is_black_hole(void)
bool is_private_function(void) const
static fcn_info::dispatch_map_type get_dispatch(const std::string &name)
static void assign(const std::string &name, const octave_value &value=octave_value(), scope_id scope=xcurrent_scope, context_id context=xdefault_context, bool force_add=false)
virtual bool is_user_script(void) const
static void push(octave_function *f, symbol_table::scope_id scope=symbol_table::current_scope(), symbol_table::context_id context=symbol_table::current_context())
virtual bool is_user_function(void) const
static std::list< std::string > parent_classes(const std::string &dispatch_type)
virtual Matrix size(void)
void warn_save(const char *type) const
friend octave_value make_fcn_handle(const std::string &, bool)
friend class octave_value
bool takes_varargs(void) const
octave_function * function_value(bool silent=false) const
If this string is printed
bool load_binary(std::istream &is, bool swap, octave::mach_info::float_format fmt)
octave_value rvalue1(int nargout=1)
virtual std::string parent_fcn_name(void) const
octave::unwind_protect frame
void recover_from_exception(void)
virtual octave_value rvalue1(int nargout=1)
virtual std::string fcn_file_name(void) const
static std::list< std::string > overloads(const std::string &meth)
octave_value_list do_multi_index_op(int nargout, const octave_value_list &args)
virtual bool is_subfunction(void) const
bool save_binary_data(std::ostream &os, const octave_value &tc, const std::string &name, const std::string &doc, bool mark_as_global, bool save_as_floats)
=val(i)}if ode{val(i)}occurs in table i
#define OCTAVE_EXEC_PREFIX
static octave_fcn_handle * maybe_binder(const octave_value &f)
int current_print_indent_level(void) const
void assign(const std::string &k, const octave_value &val)
tree_expression * expression(void)
octave_value_list do_multi_index_op(int nargout, const octave_value_list &args)
void octave_print_internal(std::ostream &, char, bool)
size_t length(void) const
std::string get_dispatch_type(const octave_value_list &args, builtin_type_t &builtin_type)
std::string read_text_data(std::istream &is, const std::string &filename, bool &global, octave_value &tc, octave_idx_type count)
#define OCTAVE_LOCAL_BUFFER(T, buf, size)
std::string type_name(void) const
bool is_undefined(void) const
octave::sys::file_stat fs(filename)
const octave_hdf5_id octave_H5P_DEFAULT
void set_overload(builtin_type_t btyp, const octave_value &ov_fcn)
FloatComplex(* fptr)(const FloatComplex &, float, int, octave_idx_type &)
OCTINTERP_API octave_value_list eval_string(const std::string &, bool silent, int &parse_status, int nargout)
void print_fcn_handle_body(tree_statement_list *)
write the output to stdout if nargout is
tree_statement_list * body(void)
Vector representing the dimensions (size) of an Array.
bool add_hdf5_data(octave_hdf5_id loc_id, const octave_value &tc, const std::string &name, const std::string &doc, bool mark_as_global, bool save_as_floats)
void print(std::ostream &os, bool pr_as_read_syntax=false)
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 accept(tree_walker &tw)
bool load_hdf5(octave_hdf5_id loc_id, const char *name)
octave_value next_subsref(const std::string &type, const std::list< octave_value_list > &idx, size_t skip=1)
virtual bool is_identifier(void) const
octave_function * function_value(bool=false)
return octave_value(v1.char_array_value().concat(v2.char_array_value(), ra_idx),((a1.is_sq_string()||a2.is_sq_string())? '\'': '"'))
static void erase_scope(scope_id scope)
std::string fcn_name(void) const
bool is_nested_function(void) const
OCTINTERP_API void interpreter_try(octave::unwind_protect &)
void stash_name_tags(const string_vector &nm)
octave_user_function * user_function_value(bool=false)