1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286
|
////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 1996-2021 The Octave Project Developers
//
// See the file COPYRIGHT.md in the top-level directory of this
// distribution or <https://octave.org/copyright/>.
//
// This file is part of Octave.
//
// Octave is free software: you can redistribute it and/or modify it
// under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// Octave is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Octave; see the file COPYING. If not, see
// <https://www.gnu.org/licenses/>.
//
////////////////////////////////////////////////////////////////////////
#if ! defined (octave_ov_fcn_h)
#define octave_ov_fcn_h 1
#include "octave-config.h"
#include <string>
#include "oct-time.h"
#include "str-vec.h"
#include "ovl.h"
#include "ov-base.h"
#include "ov-typeinfo.h"
#include "symscope.h"
namespace octave
{
class stack_frame;
class tree_evaluator;
class tree_walker;
}
// Functions.
class
OCTINTERP_API
octave_function : public octave_base_value
{
public:
octave_function (void)
: relative (false), locked (false), private_function (false),
xdispatch_class (), xpackage_name (), my_name (), my_dir_name (),
doc () { }
// No copying!
octave_function (const octave_function& f) = delete;
octave_function& operator = (const octave_function& f) = delete;
~octave_function (void) = default;
octave_base_value * clone (void) const;
octave_base_value * empty_clone (void) const;
bool is_defined (void) const { return true; }
bool is_function (void) const { return true; }
virtual bool is_system_fcn_file (void) const { return false; }
virtual std::string fcn_file_name (void) const { return ""; }
virtual std::string src_file_name (void) const { return ""; }
// The name to show in the profiler (also used as map-key).
virtual std::string profiler_name (void) const { return name (); }
virtual std::string parent_fcn_name (void) const { return ""; }
virtual octave::symbol_scope parent_fcn_scope (void) const
{ return octave::symbol_scope (); }
virtual std::list<std::string> parent_fcn_names (void) const
{
return std::list<std::string> ();
}
virtual void mark_fcn_file_up_to_date (const octave::sys::time&) { }
virtual octave::symbol_scope scope (void) { return octave::symbol_scope (); }
virtual octave::sys::time time_parsed (void) const
{ return octave::sys::time (static_cast<time_t> (0)); }
virtual octave::sys::time time_checked (void) const
{ return octave::sys::time (static_cast<time_t> (0)); }
virtual int call_depth (void) const { return 0; }
virtual bool is_nested_function (void) const { return false; }
virtual bool is_parent_function (void) const { return false; }
virtual bool is_subfunction (void) const { return false; }
bool is_class_constructor (const std::string& cname = "") const
{
return (is_classdef_constructor (cname) || is_legacy_constructor (cname));
}
bool is_class_method (const std::string& cname = "") const
{
return (is_classdef_method (cname) || is_legacy_method (cname));
}
virtual bool
is_legacy_constructor (const std::string& = "") const
{ return false; }
virtual bool
is_classdef_constructor (const std::string& = "") const
{ return false; }
virtual bool is_legacy_method (const std::string& = "") const
{ return false; }
virtual bool is_classdef_method (const std::string& = "") const
{ return false; }
virtual bool takes_varargs (void) const { return false; }
virtual bool takes_var_return (void) const { return false; }
// The next two functions are for dispatching to built-in
// functions given built-in classes.
virtual void push_dispatch_class (const std::string&) { }
virtual bool handles_dispatch_class (const std::string&) const
{ return false; }
void stash_dispatch_class (const std::string& nm) { xdispatch_class = nm; }
std::string dispatch_class (void) const { return xdispatch_class; }
void stash_package_name (const std::string& pack) { xpackage_name = pack; }
std::string package_name (void) const { return xpackage_name; }
virtual void
mark_as_private_function (const std::string& cname = "")
{
private_function = true;
xdispatch_class = cname;
}
bool is_private_function (void) const { return private_function; }
bool is_private_function_of_class (const std::string& nm) const
{ return private_function && xdispatch_class == nm; }
virtual bool
is_anonymous_function_of_class (const std::string& = "") const
{ return false; }
std::string dir_name (void) const { return my_dir_name; }
void stash_dir_name (const std::string& dir) { my_dir_name = dir; }
void lock (void)
{
this->lock_subfunctions ();
locked = true;
}
void unlock (void)
{
this->unlock_subfunctions ();
locked = false;
}
bool islocked (void) const
{
return locked;
}
virtual void lock_subfunctions (void) { }
virtual void unlock_subfunctions (void) { }
virtual void maybe_relocate_end (void) { }
// Not valid until after the function is completley parsed.
virtual bool has_subfunctions (void) const { return false; }
virtual void stash_subfunction_names (const std::list<std::string>&) { }
virtual std::list<std::string> subfunction_names (void) const
{
return std::list<std::string> ();
}
void mark_relative (void) { relative = true; }
bool is_relative (void) const { return relative; }
std::string name (void) const { return my_name; }
std::string canonical_name (void) const
{
if (xpackage_name.empty ())
return my_name;
else
return xpackage_name + '.' + my_name;
}
void document (const std::string& ds) { doc = ds; }
virtual std::string
doc_string (const std::string& /*meth_name*/ = "") const
{
return doc;
}
virtual void unload (void) { }
virtual void accept (octave::tree_walker&) { }
virtual bool accepts_postfix_index (char type) const
{ return (type == '('); }
// Push new stack frame (if necessary) and execute function.
virtual octave_value_list
call (octave::tree_evaluator& tw, int nargout = 0,
const octave_value_list& args = octave_value_list ());
// Execute function without pushing new stack frame (assumes that has
// already been done).
virtual octave_value_list
execute (octave::tree_evaluator& tw, int nargout = 0,
const octave_value_list& args = octave_value_list ()) = 0;
protected:
octave_function (const std::string& nm,
const std::string& ds = "")
: relative (false), locked (false), private_function (false),
xdispatch_class (), my_name (nm), my_dir_name (), doc (ds) { }
// TRUE if this function was found from a relative path element.
bool relative;
// TRUE if this function is tagged so that it can't be cleared.
bool locked;
// TRUE means this is a private function.
bool private_function;
// If this object is a class method or constructor, or a private
// function inside a class directory, this is the name of the class
// to which the method belongs.
std::string xdispatch_class;
// If this function is part of a package, this is the full name
// of the package to which the function belongs.
std::string xpackage_name;
// The name of this function.
std::string my_name;
// The name of the directory in the path where we found this
// function. May be relative.
std::string my_dir_name;
// The help text for this function.
std::string doc;
};
#endif
|