octave: libinterp/corefcn/stack-frame.cc comparison

comparison libinterp/corefcn/stack-frame.cc @ 31607:aac27ad79be6 stable

maint: Re-indent code after switch to using namespace macros. * build-env.h, build-env.in.cc, Cell.h, __betainc__.cc, __eigs__.cc, __ftp__.cc, __ichol__.cc, __ilu__.cc, __isprimelarge__.cc, __magick_read__.cc, __pchip_deriv__.cc, amd.cc, base-text-renderer.cc, base-text-renderer.h, besselj.cc, bitfcns.cc, bsxfun.cc, c-file-ptr-stream.h, call-stack.cc, call-stack.h, ccolamd.cc, cellfun.cc, chol.cc, colamd.cc, dasrt.cc, data.cc, debug.cc, defaults.cc, defaults.h, det.cc, display.cc, display.h, dlmread.cc, dynamic-ld.cc, dynamic-ld.h, ellipj.cc, environment.cc, environment.h, error.cc, error.h, errwarn.h, event-manager.cc, event-manager.h, event-queue.cc, event-queue.h, fcn-info.cc, fcn-info.h, fft.cc, fft2.cc, file-io.cc, filter.cc, find.cc, ft-text-renderer.cc, ft-text-renderer.h, gcd.cc, gl-render.cc, gl-render.h, gl2ps-print.cc, gl2ps-print.h, graphics-toolkit.cc, graphics-toolkit.h, graphics.cc, gsvd.cc, gtk-manager.cc, gtk-manager.h, help.cc, help.h, hook-fcn.cc, hook-fcn.h, input.cc, input.h, interpreter-private.cc, interpreter-private.h, interpreter.cc, interpreter.h, inv.cc, jsondecode.cc, jsonencode.cc, latex-text-renderer.cc, latex-text-renderer.h, load-path.cc, load-path.h, load-save.cc, load-save.h, lookup.cc, ls-hdf5.cc, ls-mat4.cc, ls-mat5.cc, lsode.cc, lu.cc, mappers.cc, matrix_type.cc, max.cc, mex.cc, mexproto.h, mxarray.h, mxtypes.in.h, oct-errno.in.cc, oct-hdf5-types.cc, oct-hist.cc, oct-hist.h, oct-map.cc, oct-map.h, oct-opengl.h, oct-prcstrm.h, oct-process.cc, oct-process.h, oct-stdstrm.h, oct-stream.cc, oct-stream.h, oct-strstrm.h, octave-default-image.h, ordqz.cc, ordschur.cc, pager.cc, pager.h, pinv.cc, pow2.cc, pr-output.cc, psi.cc, qr.cc, quadcc.cc, rand.cc, regexp.cc, settings.cc, settings.h, sighandlers.cc, sighandlers.h, sparse-xpow.cc, sqrtm.cc, stack-frame.cc, stack-frame.h, stream-euler.cc, strfns.cc, svd.cc, syminfo.cc, syminfo.h, symrcm.cc, symrec.cc, symrec.h, symscope.cc, symscope.h, symtab.cc, symtab.h, sysdep.cc, sysdep.h, text-engine.cc, text-engine.h, text-renderer.cc, text-renderer.h, time.cc, toplev.cc, typecast.cc, url-handle-manager.cc, url-handle-manager.h, urlwrite.cc, utils.cc, utils.h, variables.cc, variables.h, xdiv.cc, __delaunayn__.cc, __init_fltk__.cc, __init_gnuplot__.cc, __ode15__.cc, __voronoi__.cc, audioread.cc, convhulln.cc, gzip.cc, cdef-class.cc, cdef-class.h, cdef-fwd.h, cdef-manager.cc, cdef-manager.h, cdef-method.cc, cdef-method.h, cdef-object.cc, cdef-object.h, cdef-package.cc, cdef-package.h, cdef-property.cc, cdef-property.h, cdef-utils.cc, cdef-utils.h, ov-base-diag.cc, ov-base-int.cc, ov-base-mat.cc, ov-base-mat.h, ov-base-scalar.cc, ov-base.cc, ov-base.h, ov-bool-mat.cc, ov-bool-mat.h, ov-bool-sparse.cc, ov-bool.cc, ov-builtin.h, ov-cell.cc, ov-ch-mat.cc, ov-class.cc, ov-class.h, ov-classdef.cc, ov-classdef.h, ov-complex.cc, ov-cx-diag.cc, ov-cx-mat.cc, ov-cx-sparse.cc, ov-dld-fcn.cc, ov-dld-fcn.h, ov-fcn-handle.cc, ov-fcn-handle.h, ov-fcn.h, ov-float.cc, ov-flt-complex.cc, ov-flt-cx-diag.cc, ov-flt-cx-mat.cc, ov-flt-re-diag.cc, ov-flt-re-mat.cc, ov-flt-re-mat.h, ov-intx.h, ov-java.cc, ov-lazy-idx.cc, ov-legacy-range.cc, ov-magic-int.cc, ov-mex-fcn.cc, ov-mex-fcn.h, ov-null-mat.cc, ov-perm.cc, ov-range.cc, ov-re-diag.cc, ov-re-mat.cc, ov-re-mat.h, ov-re-sparse.cc, ov-scalar.cc, ov-str-mat.cc, ov-struct.cc, ov-typeinfo.cc, ov-typeinfo.h, ov-usr-fcn.cc, ov-usr-fcn.h, ov.cc, ov.h, ovl.h, octave.cc, octave.h, op-b-sbm.cc, op-bm-sbm.cc, op-cs-scm.cc, op-fm-fcm.cc, op-fs-fcm.cc, op-s-scm.cc, op-scm-cs.cc, op-scm-s.cc, op-sm-cs.cc, ops.h, anon-fcn-validator.cc, anon-fcn-validator.h, bp-table.cc, bp-table.h, comment-list.cc, comment-list.h, filepos.h, lex.h, oct-lvalue.cc, oct-lvalue.h, parse.h, profiler.cc, profiler.h, pt-anon-scopes.cc, pt-anon-scopes.h, pt-arg-list.cc, pt-arg-list.h, pt-args-block.cc, pt-args-block.h, pt-array-list.cc, pt-array-list.h, pt-assign.cc, pt-assign.h, pt-binop.cc, pt-binop.h, pt-bp.cc, pt-bp.h, pt-cbinop.cc, pt-cbinop.h, pt-cell.cc, pt-cell.h, pt-check.cc, pt-check.h, pt-classdef.cc, pt-classdef.h, pt-cmd.h, pt-colon.cc, pt-colon.h, pt-const.cc, pt-const.h, pt-decl.cc, pt-decl.h, pt-eval.cc, pt-eval.h, pt-except.cc, pt-except.h, pt-exp.cc, pt-exp.h, pt-fcn-handle.cc, pt-fcn-handle.h, pt-id.cc, pt-id.h, pt-idx.cc, pt-idx.h, pt-jump.h, pt-loop.cc, pt-loop.h, pt-mat.cc, pt-mat.h, pt-misc.cc, pt-misc.h, pt-pr-code.cc, pt-pr-code.h, pt-select.cc, pt-select.h, pt-spmd.cc, pt-spmd.h, pt-stmt.cc, pt-stmt.h, pt-tm-const.cc, pt-tm-const.h, pt-unop.cc, pt-unop.h, pt-walk.cc, pt-walk.h, pt.cc, pt.h, token.cc, token.h, Range.cc, Range.h, idx-vector.cc, idx-vector.h, range-fwd.h, CollocWt.cc, CollocWt.h, aepbalance.cc, aepbalance.h, chol.cc, chol.h, gepbalance.cc, gepbalance.h, gsvd.cc, gsvd.h, hess.cc, hess.h, lo-mappers.cc, lo-mappers.h, lo-specfun.cc, lo-specfun.h, lu.cc, lu.h, oct-convn.cc, oct-convn.h, oct-fftw.cc, oct-fftw.h, oct-norm.cc, oct-norm.h, oct-rand.cc, oct-rand.h, oct-spparms.cc, oct-spparms.h, qr.cc, qr.h, qrp.cc, qrp.h, randgamma.cc, randgamma.h, randmtzig.cc, randmtzig.h, randpoisson.cc, randpoisson.h, schur.cc, schur.h, sparse-chol.cc, sparse-chol.h, sparse-lu.cc, sparse-lu.h, sparse-qr.cc, sparse-qr.h, svd.cc, svd.h, child-list.cc, child-list.h, dir-ops.cc, dir-ops.h, file-ops.cc, file-ops.h, file-stat.cc, file-stat.h, lo-sysdep.cc, lo-sysdep.h, lo-sysinfo.cc, lo-sysinfo.h, mach-info.cc, mach-info.h, oct-env.cc, oct-env.h, oct-group.cc, oct-group.h, oct-password.cc, oct-password.h, oct-syscalls.cc, oct-syscalls.h, oct-time.cc, oct-time.h, oct-uname.cc, oct-uname.h, action-container.cc, action-container.h, base-list.h, cmd-edit.cc, cmd-edit.h, cmd-hist.cc, cmd-hist.h, f77-fcn.h, file-info.cc, file-info.h, lo-array-errwarn.cc, lo-array-errwarn.h, lo-hash.cc, lo-hash.h, lo-ieee.h, lo-regexp.cc, lo-regexp.h, lo-utils.cc, lo-utils.h, oct-base64.cc, oct-base64.h, oct-glob.cc, oct-glob.h, oct-inttypes.h, oct-mutex.cc, oct-mutex.h, oct-refcount.h, oct-shlib.cc, oct-shlib.h, oct-sparse.cc, oct-sparse.h, oct-string.h, octave-preserve-stream-state.h, pathsearch.cc, pathsearch.h, quit.cc, quit.h, unwind-prot.cc, unwind-prot.h, url-transfer.cc, url-transfer.h: Re-indent code after switch to using namespace macros.

author	Rik <rik@octave.org>
date	Thu, 01 Dec 2022 18:02:15 -0800
parents	e88a07dec498
children	597f3ee61a48

comparison

equal deleted inserted replaced

-:e88a07dec498
+:aac27ad79be6
 #include "symscope.h"
 #include "variables.h"
 OCTAVE_BEGIN_NAMESPACE(octave)
 class compiled_fcn_stack_frame : public stack_frame
 {
 public:
 compiled_fcn_stack_frame (void) = delete;
 compiled_fcn_stack_frame (tree_evaluator& tw, octave_function *fcn,
-std::size_t index,
-const std::shared_ptr<stack_frame>& parent_link,
-const std::shared_ptr<stack_frame>& static_link)
-: stack_frame (tw, index, parent_link, static_link,
-static_link->access_link ()),
-m_fcn (fcn)
-{ }
-compiled_fcn_stack_frame (const compiled_fcn_stack_frame& elt) = default;
-compiled_fcn_stack_frame&
-operator = (const compiled_fcn_stack_frame& elt) = delete;
-~compiled_fcn_stack_frame (void) = default;
-bool is_compiled_fcn_frame (void) const { return true; }
-symbol_scope get_scope (void) const
-{
-return m_static_link->get_scope ();
-}
-octave_function * function (void) const { return m_fcn; }
-symbol_record lookup_symbol (const std::string& name) const
-{
-return m_static_link->lookup_symbol (name);
-}
-symbol_record insert_symbol (const std::string& name)
-{
-return m_static_link->insert_symbol (name);
-}
-stack_frame::scope_flags scope_flag (const symbol_record& sym) const
-{
-// Look in closest stack frame that contains values (either the
-// top scope, or a user-defined function or script).
-return m_static_link->scope_flag (sym);
-}
-void set_auto_fcn_var (auto_var_type avt, const octave_value& val)
-{
-m_static_link->set_auto_fcn_var (avt, val);
-}
-octave_value get_auto_fcn_var (auto_var_type avt) const
-{
-return m_static_link->get_auto_fcn_var (avt);
-}
-// We only need to override one of each of these functions.  The
-// using declaration will avoid warnings about partially-overloaded
-// virtual functions.
-using stack_frame::varval;
-using stack_frame::varref;
-octave_value varval (const symbol_record& sym) const
-{
-// Look in closest stack frame that contains values (either the
-// top scope, or a user-defined function or script).
-return m_static_link->varval (sym);
-}
-octave_value& varref (const symbol_record& sym)
-{
-// Look in closest stack frame that contains values (either the
-// top scope, or a user-defined function or script).
-return m_static_link->varref (sym);
-}
-void mark_scope (const symbol_record& sym, scope_flags flag)
-{
-// Look in closest stack frame that contains values (either the
-// top scope, or a user-defined function or script).
-m_static_link->mark_scope (sym, flag);
-}
-void display (bool follow = true) const;
-void accept (stack_frame_walker& sfw);
-private:
-// Compiled function object associated with this stack frame.
-// Should always be a built-in, .oct or .mex file function and
-// should always be valid.
-octave_function *m_fcn;
-};
-// Scripts have a symbol_scope object to store the set of variables
-// in the script, but values for those variables are stored in the
-// stack frame corresponding to the nearest calling function or in
-// the top-level scope (the evaluation stack frame).
-//
-// Accessing values in a scope requires a mapping from the index of
-// the variable for the script scope to the list of values in the
-// evaluation frame(s).  The frame offset tells us how many access
-// links we must follow to find the stack frame that holds the
-// value.  The value offset is the index into the vector of values
-// in that stack frame that we should use to find the value.
-//
-// Frame and value offsets are set in this stack frame when it is
-// created using information from the script and enclosing scopes.
-//
-// If a script is invoked in a nested function context, the frame
-// offsets for individual values may be different.  Some may be
-// accessed from the invoking function and some may come from a
-// parent function.
-class script_stack_frame : public stack_frame
-{
-public:
-script_stack_frame (void) = delete;
-script_stack_frame (tree_evaluator& tw, octave_user_script *script,
-std::size_t index,
-const std::shared_ptr<stack_frame>& parent_link,
-const std::shared_ptr<stack_frame>& static_link);
-script_stack_frame (const script_stack_frame& elt) = default;
-script_stack_frame& operator = (const script_stack_frame& elt) = delete;
-~script_stack_frame (void)
-{
-delete m_unwind_protect_frame;
-}
-bool is_user_script_frame (void) const { return true; }
-static std::shared_ptr<stack_frame>
-get_access_link (const std::shared_ptr<stack_frame>& static_link);
-static std::size_t get_num_symbols (octave_user_script *script);
-void set_script_offsets (void);
-void set_script_offsets_internal (const std::map<std::string,
-symbol_record>& symbols);
-void resize_and_update_script_offsets (const symbol_record& sym);
-symbol_scope get_scope (void) const { return m_script->scope (); }
-octave_function * function (void) const { return m_script; }
-unwind_protect * unwind_protect_frame (void);
-symbol_record lookup_symbol (const std::string& name) const;
-symbol_record insert_symbol (const std::string&);
-std::size_t size (void) const { return m_lexical_frame_offsets.size (); }
-void resize (std::size_t size)
-{
-m_lexical_frame_offsets.resize (size, 0);
-m_value_offsets.resize (size, 0);
-}
-void get_val_offsets_with_insert (const symbol_record& sym,
-std::size_t& frame_offset,
-std::size_t& data_offset);
-bool get_val_offsets_internal (const symbol_record& sym,
-std::size_t& frame_offset,
-std::size_t& data_offset) const;
-bool get_val_offsets (const symbol_record& sym, std::size_t& frame_offset,
-std::size_t& data_offset) const;
-scope_flags scope_flag (const symbol_record& sym) const;
-void set_auto_fcn_var (auto_var_type avt, const octave_value& val)
-{
-m_access_link->set_auto_fcn_var (avt, val);
-}
-octave_value get_auto_fcn_var (auto_var_type avt) const
-{
-return m_access_link->get_auto_fcn_var (avt);
-}
-// We only need to override one of each of these functions.  The
-// using declaration will avoid warnings about partially-overloaded
-// virtual functions.
-using stack_frame::varval;
-using stack_frame::varref;
-octave_value varval (const symbol_record& sym) const;
-octave_value& varref (const symbol_record& sym);
-void mark_scope (const symbol_record& sym, scope_flags flag);
-void display (bool follow = true) const;
-void accept (stack_frame_walker& sfw);
-private:
-// Script object associated with this stack frame.  Should always
-// be valid.
-octave_user_script *m_script;
-// The nearest unwind protect frame that was active when this
-// stack frame was created.  Should always be valid.
-unwind_protect *m_unwind_protect_frame;
-// Mapping between the symbols in the symbol_scope object of the
-// script to the stack frame in which the script is executed.  The
-// frame offsets may be greater than one if the script is executed
-// in a nested function context.
-std::vector<std::size_t> m_lexical_frame_offsets;
-std::vector<std::size_t> m_value_offsets;
-};
-// Base class for values and offsets shared by user_fcn and scope
-// frames.
-class base_value_stack_frame : public stack_frame
-{
-public:
-base_value_stack_frame (void) = delete;
-base_value_stack_frame (tree_evaluator& tw, std::size_t num_symbols,
 std::size_t index,
 const std::shared_ptr<stack_frame>& parent_link,
-const std::shared_ptr<stack_frame>& static_link,
+const std::shared_ptr<stack_frame>& static_link)
-const std::shared_ptr<stack_frame>& access_link)
+: stack_frame (tw, index, parent_link, static_link,
-: stack_frame (tw, index, parent_link, static_link, access_link),
+static_link->access_link ()),
-m_values (num_symbols, octave_value ()),
+m_fcn (fcn)
-m_flags (num_symbols, LOCAL),
+{ }
-m_auto_vars (NUM_AUTO_VARS, octave_value ())
-{ }
+compiled_fcn_stack_frame (const compiled_fcn_stack_frame& elt) = default;
-base_value_stack_frame (const base_value_stack_frame& elt) = default;
+compiled_fcn_stack_frame&
+operator = (const compiled_fcn_stack_frame& elt) = delete;
-base_value_stack_frame&
-operator = (const base_value_stack_frame& elt) = delete;
+~compiled_fcn_stack_frame (void) = default;
-~base_value_stack_frame (void) = default;
+bool is_compiled_fcn_frame (void) const { return true; }
-std::size_t size (void) const
+symbol_scope get_scope (void) const
 {
-return m_values.size ();
+return m_static_link->get_scope ();
 }
-void resize (std::size_t size)
+octave_function * function (void) const { return m_fcn; }
-{
-m_values.resize (size, octave_value ());
+symbol_record lookup_symbol (const std::string& name) const
-m_flags.resize (size, LOCAL);
+{
-}
+return m_static_link->lookup_symbol (name);
+}
-stack_frame::scope_flags get_scope_flag (std::size_t data_offset) const
-{
+symbol_record insert_symbol (const std::string& name)
-return m_flags.at (data_offset);
+{
-}
+return m_static_link->insert_symbol (name);
+}
-void set_scope_flag (std::size_t data_offset, scope_flags flag)
-{
+stack_frame::scope_flags scope_flag (const symbol_record& sym) const
-m_flags.at (data_offset) = flag;
+{
-}
+// Look in closest stack frame that contains values (either the
+// top scope, or a user-defined function or script).
-octave_value get_auto_fcn_var (auto_var_type avt) const
-{
+return m_static_link->scope_flag (sym);
-return m_auto_vars.at (avt);
+}
-}
+void set_auto_fcn_var (auto_var_type avt, const octave_value& val)
-void set_auto_fcn_var (auto_var_type avt, const octave_value& val)
+{
-{
+m_static_link->set_auto_fcn_var (avt, val);
-m_auto_vars.at (avt) = val;
+}
-}
+octave_value get_auto_fcn_var (auto_var_type avt) const
-// We only need to override one of each of these functions.  The
+{
-// using declaration will avoid warnings about partially-overloaded
+return m_static_link->get_auto_fcn_var (avt);
-// virtual functions.
+}
-using stack_frame::varval;
-using stack_frame::varref;
+// We only need to override one of each of these functions.  The
+// using declaration will avoid warnings about partially-overloaded
-octave_value varval (std::size_t data_offset) const
+// virtual functions.
-{
+using stack_frame::varval;
-return m_values.at (data_offset);
+using stack_frame::varref;
-}
+octave_value varval (const symbol_record& sym) const
-octave_value& varref (std::size_t data_offset)
+{
-{
+// Look in closest stack frame that contains values (either the
-return m_values.at (data_offset);
+// top scope, or a user-defined function or script).
-}
+return m_static_link->varval (sym);
-void display (bool follow = true) const;
+}
-protected:
+octave_value& varref (const symbol_record& sym)
+{
-// Variable values.  This array is indexed by the data_offset
+// Look in closest stack frame that contains values (either the
-// value stored in the symbol_record objects of the scope
+// top scope, or a user-defined function or script).
-// associated with this stack frame.
-std::vector<octave_value> m_values;
+return m_static_link->varref (sym);
+}
-// The type of each variable (local, global, persistent) of each
-// value.  This array is indexed by the data_offset value stored
+void mark_scope (const symbol_record& sym, scope_flags flag)
-// in the symbol_record objects of the scope associated with this
+{
-// stack frame.  Local values are found in the M_VALUES array.
+// Look in closest stack frame that contains values (either the
-// Global values are stored in the tree_evaluator object that contains
+// top scope, or a user-defined function or script).
-// the stack frame.  Persistent values are stored in the function
-// scope corresponding to the stack frame.
+m_static_link->mark_scope (sym, flag);
-std::vector<scope_flags> m_flags;
+}
-// A fixed list of Automatic variables created for this function.
+void display (bool follow = true) const;
-// The elements of this vector correspond to the auto_var_type
-// enum.
+void accept (stack_frame_walker& sfw);
-std::vector<octave_value> m_auto_vars;
-};
+private:
-// User-defined functions have a symbol_scope object to store the set
+// Compiled function object associated with this stack frame.
-// of variables in the function and values are stored in the stack
+// Should always be a built-in, .oct or .mex file function and
-// frame corresponding to the invocation of the function or one of
+// should always be valid.
-// its parents.  The frame offset tells us how many access links we
+octave_function *m_fcn;
-// must follow to find the stack frame that holds the value.  The
+};
-// value offset is the index into the vector of values in that stack
-// frame that we should use to find the value.
+// Scripts have a symbol_scope object to store the set of variables
-//
+// in the script, but values for those variables are stored in the
-// Frame and value offsets are determined when the corresponding
+// stack frame corresponding to the nearest calling function or in
-// function is parsed.
+// the top-level scope (the evaluation stack frame).
+//
-class user_fcn_stack_frame : public base_value_stack_frame
+// Accessing values in a scope requires a mapping from the index of
-{
+// the variable for the script scope to the list of values in the
-public:
+// evaluation frame(s).  The frame offset tells us how many access
+// links we must follow to find the stack frame that holds the
-user_fcn_stack_frame (void) = delete;
+// value.  The value offset is the index into the vector of values
+// in that stack frame that we should use to find the value.
-user_fcn_stack_frame (tree_evaluator& tw, octave_user_function *fcn,
+//
+// Frame and value offsets are set in this stack frame when it is
+// created using information from the script and enclosing scopes.
+//
+// If a script is invoked in a nested function context, the frame
+// offsets for individual values may be different.  Some may be
+// accessed from the invoking function and some may come from a
+// parent function.
+class script_stack_frame : public stack_frame
+{
+public:
+script_stack_frame (void) = delete;
+script_stack_frame (tree_evaluator& tw, octave_user_script *script,
+std::size_t index,
+const std::shared_ptr<stack_frame>& parent_link,
+const std::shared_ptr<stack_frame>& static_link);
+script_stack_frame (const script_stack_frame& elt) = default;
+script_stack_frame& operator = (const script_stack_frame& elt) = delete;
+~script_stack_frame (void)
+{
+delete m_unwind_protect_frame;
+}
+bool is_user_script_frame (void) const { return true; }
+static std::shared_ptr<stack_frame>
+get_access_link (const std::shared_ptr<stack_frame>& static_link);
+static std::size_t get_num_symbols (octave_user_script *script);
+void set_script_offsets (void);
+void set_script_offsets_internal (const std::map<std::string,
+symbol_record>& symbols);
+void resize_and_update_script_offsets (const symbol_record& sym);
+symbol_scope get_scope (void) const { return m_script->scope (); }
+octave_function * function (void) const { return m_script; }
+unwind_protect * unwind_protect_frame (void);
+symbol_record lookup_symbol (const std::string& name) const;
+symbol_record insert_symbol (const std::string&);
+std::size_t size (void) const { return m_lexical_frame_offsets.size (); }
+void resize (std::size_t size)
+{
+m_lexical_frame_offsets.resize (size, 0);
+m_value_offsets.resize (size, 0);
+}
+void get_val_offsets_with_insert (const symbol_record& sym,
+std::size_t& frame_offset,
+std::size_t& data_offset);
+bool get_val_offsets_internal (const symbol_record& sym,
+std::size_t& frame_offset,
+std::size_t& data_offset) const;
+bool get_val_offsets (const symbol_record& sym, std::size_t& frame_offset,
+std::size_t& data_offset) const;
+scope_flags scope_flag (const symbol_record& sym) const;
+void set_auto_fcn_var (auto_var_type avt, const octave_value& val)
+{
+m_access_link->set_auto_fcn_var (avt, val);
+}
+octave_value get_auto_fcn_var (auto_var_type avt) const
+{
+return m_access_link->get_auto_fcn_var (avt);
+}
+// We only need to override one of each of these functions.  The
+// using declaration will avoid warnings about partially-overloaded
+// virtual functions.
+using stack_frame::varval;
+using stack_frame::varref;
+octave_value varval (const symbol_record& sym) const;
+octave_value& varref (const symbol_record& sym);
+void mark_scope (const symbol_record& sym, scope_flags flag);
+void display (bool follow = true) const;
+void accept (stack_frame_walker& sfw);
+private:
+// Script object associated with this stack frame.  Should always
+// be valid.
+octave_user_script *m_script;
+// The nearest unwind protect frame that was active when this
+// stack frame was created.  Should always be valid.
+unwind_protect *m_unwind_protect_frame;
+// Mapping between the symbols in the symbol_scope object of the
+// script to the stack frame in which the script is executed.  The
+// frame offsets may be greater than one if the script is executed
+// in a nested function context.
+std::vector<std::size_t> m_lexical_frame_offsets;
+std::vector<std::size_t> m_value_offsets;
+};
+// Base class for values and offsets shared by user_fcn and scope
+// frames.
+class base_value_stack_frame : public stack_frame
+{
+public:
+base_value_stack_frame (void) = delete;
+base_value_stack_frame (tree_evaluator& tw, std::size_t num_symbols,
 std::size_t index,
 const std::shared_ptr<stack_frame>& parent_link,
 const std::shared_ptr<stack_frame>& static_link,
-const std::shared_ptr<stack_frame>& access_link = std::shared_ptr<stack_frame> ())
+const std::shared_ptr<stack_frame>& access_link)
-: base_value_stack_frame (tw, get_num_symbols (fcn), index,
+: stack_frame (tw, index, parent_link, static_link, access_link),
-parent_link, static_link,
+m_values (num_symbols, octave_value ()),
-(access_link
+m_flags (num_symbols, LOCAL),
-? access_link
+m_auto_vars (NUM_AUTO_VARS, octave_value ())
-: get_access_link (fcn, static_link))),
+{ }
-m_fcn (fcn), m_unwind_protect_frame (nullptr)
-{ }
+base_value_stack_frame (const base_value_stack_frame& elt) = default;
-user_fcn_stack_frame (tree_evaluator& tw, octave_user_function *fcn,
+base_value_stack_frame&
-std::size_t index,
+operator = (const base_value_stack_frame& elt) = delete;
-const std::shared_ptr<stack_frame>& parent_link,
-const std::shared_ptr<stack_frame>& static_link,
+~base_value_stack_frame (void) = default;
-const local_vars_map& local_vars,
-const std::shared_ptr<stack_frame>& access_link = std::shared_ptr<stack_frame> ())
+std::size_t size (void) const
-: base_value_stack_frame (tw, get_num_symbols (fcn), index,
+{
-parent_link, static_link,
+return m_values.size ();
-(access_link
+}
-? access_link
-: get_access_link (fcn, static_link))),
+void resize (std::size_t size)
-m_fcn (fcn), m_unwind_protect_frame (nullptr)
+{
-{
+m_values.resize (size, octave_value ());
-// Initialize local variable values.
+m_flags.resize (size, LOCAL);
+}
-for (const auto& nm_ov : local_vars)
-assign (nm_ov.first, nm_ov.second);
+stack_frame::scope_flags get_scope_flag (std::size_t data_offset) const
-}
+{
+return m_flags.at (data_offset);
-user_fcn_stack_frame (const user_fcn_stack_frame& elt) = default;
+}
-user_fcn_stack_frame&
+void set_scope_flag (std::size_t data_offset, scope_flags flag)
-operator = (const user_fcn_stack_frame& elt) = delete;
+{
+m_flags.at (data_offset) = flag;
-~user_fcn_stack_frame (void)
+}
-{
-delete m_unwind_protect_frame;
+octave_value get_auto_fcn_var (auto_var_type avt) const
-}
+{
+return m_auto_vars.at (avt);
-bool is_user_fcn_frame (void) const { return true; }
+}
-static std::shared_ptr<stack_frame>
+void set_auto_fcn_var (auto_var_type avt, const octave_value& val)
-get_access_link (octave_user_function *fcn,
+{
-const std::shared_ptr<stack_frame>& static_link);
+m_auto_vars.at (avt) = val;
+}
-static std::size_t get_num_symbols (octave_user_function *fcn)
-{
+// We only need to override one of each of these functions.  The
-symbol_scope fcn_scope = fcn->scope ();
+// using declaration will avoid warnings about partially-overloaded
+// virtual functions.
-return fcn_scope.num_symbols ();
+using stack_frame::varval;
-}
+using stack_frame::varref;
-void clear_values (void);
+octave_value varval (std::size_t data_offset) const
+{
-symbol_scope get_scope (void) const { return m_fcn->scope (); }
+return m_values.at (data_offset);
+}
-octave_function * function (void) const { return m_fcn; }
+octave_value& varref (std::size_t data_offset)
-unwind_protect * unwind_protect_frame (void);
+{
+return m_values.at (data_offset);
-symbol_record lookup_symbol (const std::string& name) const;
+}
-symbol_record insert_symbol (const std::string&);
+void display (bool follow = true) const;
-scope_flags scope_flag (const symbol_record& sym) const;
+protected:
-// We only need to override one of each of these functions.  The
+// Variable values.  This array is indexed by the data_offset
-// using declaration will avoid warnings about partially-overloaded
+// value stored in the symbol_record objects of the scope
-// virtual functions.
+// associated with this stack frame.
-using base_value_stack_frame::varval;
+std::vector<octave_value> m_values;
-using base_value_stack_frame::varref;
+// The type of each variable (local, global, persistent) of each
-octave_value varval (const symbol_record& sym) const;
+// value.  This array is indexed by the data_offset value stored
+// in the symbol_record objects of the scope associated with this
-octave_value& varref (const symbol_record& sym);
+// stack frame.  Local values are found in the M_VALUES array.
+// Global values are stored in the tree_evaluator object that contains
-void mark_scope (const symbol_record& sym, scope_flags flag);
+// the stack frame.  Persistent values are stored in the function
+// scope corresponding to the stack frame.
-void display (bool follow = true) const;
+std::vector<scope_flags> m_flags;
-void accept (stack_frame_walker& sfw);
+// A fixed list of Automatic variables created for this function.
+// The elements of this vector correspond to the auto_var_type
-void break_closure_cycles (const std::shared_ptr<stack_frame>& frame);
+// enum.
+std::vector<octave_value> m_auto_vars;
-private:
+};
-// User-defined object associated with this stack frame.  Should
+// User-defined functions have a symbol_scope object to store the set
-// always be valid.
+// of variables in the function and values are stored in the stack
-octave_user_function *m_fcn;
+// frame corresponding to the invocation of the function or one of
+// its parents.  The frame offset tells us how many access links we
-// The nearest unwind protect frame that was active when this
+// must follow to find the stack frame that holds the value.  The
-// stack frame was created.  Should always be valid.
+// value offset is the index into the vector of values in that stack
-unwind_protect *m_unwind_protect_frame;
+// frame that we should use to find the value.
-};
+//
+// Frame and value offsets are determined when the corresponding
-// Pure scope stack frames (primarily the top-level workspace) have
+// function is parsed.
-// a set of variables and values are stored in the stack frame.  All
-// variable accesses are direct as there are no parent stack frames.
+class user_fcn_stack_frame : public base_value_stack_frame
-//
+{
-// Value offsets are determined when the corresponding variable is
+public:
-// entered into the symbol_scope object corresponding to the frame.
+user_fcn_stack_frame (void) = delete;
-class scope_stack_frame : public base_value_stack_frame
-{
+user_fcn_stack_frame (tree_evaluator& tw, octave_user_function *fcn,
-public:
+std::size_t index,
+const std::shared_ptr<stack_frame>& parent_link,
-scope_stack_frame (void) = delete;
+const std::shared_ptr<stack_frame>& static_link,
+const std::shared_ptr<stack_frame>& access_link = std::shared_ptr<stack_frame> ())
-scope_stack_frame (tree_evaluator& tw, const symbol_scope& scope,
+: base_value_stack_frame (tw, get_num_symbols (fcn), index,
-std::size_t index,
+parent_link, static_link,
-const std::shared_ptr<stack_frame>& parent_link,
+(access_link
-const std::shared_ptr<stack_frame>& static_link)
+? access_link
-: base_value_stack_frame (tw, scope.num_symbols (), index,
+: get_access_link (fcn, static_link))),
-parent_link, static_link, nullptr),
+m_fcn (fcn), m_unwind_protect_frame (nullptr)
-m_scope (scope)
+{ }
-{ }
+user_fcn_stack_frame (tree_evaluator& tw, octave_user_function *fcn,
-scope_stack_frame (const scope_stack_frame& elt) = default;
+std::size_t index,
+const std::shared_ptr<stack_frame>& parent_link,
-scope_stack_frame& operator = (const scope_stack_frame& elt) = delete;
+const std::shared_ptr<stack_frame>& static_link,
+const local_vars_map& local_vars,
-~scope_stack_frame (void) = default;
+const std::shared_ptr<stack_frame>& access_link = std::shared_ptr<stack_frame> ())
+: base_value_stack_frame (tw, get_num_symbols (fcn), index,
-bool is_scope_frame (void) const { return true; }
+parent_link, static_link,
+(access_link
-symbol_scope get_scope (void) const { return m_scope; }
+? access_link
+: get_access_link (fcn, static_link))),
-symbol_record lookup_symbol (const std::string& name) const
+m_fcn (fcn), m_unwind_protect_frame (nullptr)
 {
-return m_scope.lookup_symbol (name);
+// Initialize local variable values.
-}
+for (const auto& nm_ov : local_vars)
-symbol_record insert_symbol (const std::string&);
+assign (nm_ov.first, nm_ov.second);
+}
-scope_flags scope_flag (const symbol_record& sym) const;
+user_fcn_stack_frame (const user_fcn_stack_frame& elt) = default;
-// We only need to override one of each of these functions.  The
-// using declaration will avoid warnings about partially-overloaded
+user_fcn_stack_frame&
-// virtual functions.
+operator = (const user_fcn_stack_frame& elt) = delete;
-using base_value_stack_frame::varval;
-using base_value_stack_frame::varref;
+~user_fcn_stack_frame (void)
+{
-octave_value varval (const symbol_record& sym) const;
+delete m_unwind_protect_frame;
+}
-octave_value& varref (const symbol_record& sym);
+bool is_user_fcn_frame (void) const { return true; }
-void mark_scope (const symbol_record& sym, scope_flags flag);
+static std::shared_ptr<stack_frame>
-void display (bool follow = true) const;
+get_access_link (octave_user_function *fcn,
+const std::shared_ptr<stack_frame>& static_link);
-void accept (stack_frame_walker& sfw);
+static std::size_t get_num_symbols (octave_user_function *fcn)
-private:
+{
+symbol_scope fcn_scope = fcn->scope ();
-// The scope object associated with this stack frame.
-symbol_scope m_scope;
+return fcn_scope.num_symbols ();
-};
+}
-// FIXME: There should probably be a display method for the script,
+void clear_values (void);
-// fcn, and scope objects and the script and function objects should
-// be responsible for displaying the scopes they contain.
+symbol_scope get_scope (void) const { return m_fcn->scope (); }
-static void display_scope (std::ostream& os, const symbol_scope& scope)
+octave_function * function (void) const { return m_fcn; }
-{
-if (scope)
+unwind_protect * unwind_protect_frame (void);
-{
-os << "scope: " << scope.name () << std::endl;
+symbol_record lookup_symbol (const std::string& name) const;
-if (scope.num_symbols () > 0)
+symbol_record insert_symbol (const std::string&);
-{
-os << "name (frame offset, data offset, storage class):"
+scope_flags scope_flag (const symbol_record& sym) const;
-<< std::endl;
+// We only need to override one of each of these functions.  The
-std::list<symbol_record> symbols = scope.symbol_list ();
+// using declaration will avoid warnings about partially-overloaded
+// virtual functions.
-for (auto& sym : symbols)
+using base_value_stack_frame::varval;
-{
+using base_value_stack_frame::varref;
-os << "  " << sym.name () << " (" << sym.frame_offset ()
-<< ", " << sym.data_offset () << ", " << sym.storage_class ()
+octave_value varval (const symbol_record& sym) const;
-<< ")" << std::endl;
-}
+octave_value& varref (const symbol_record& sym);
-}
-}
+void mark_scope (const symbol_record& sym, scope_flags flag);
-}
+void display (bool follow = true) const;
-class stack_frame_walker
-{
+void accept (stack_frame_walker& sfw);
-protected:
+void break_closure_cycles (const std::shared_ptr<stack_frame>& frame);
-stack_frame_walker (void) { }
+private:
-virtual ~stack_frame_walker (void) = default;
+// User-defined object associated with this stack frame.  Should
-public:
+// always be valid.
+octave_user_function *m_fcn;
-// No copying!
+// The nearest unwind protect frame that was active when this
-stack_frame_walker (const stack_frame_walker&) = delete;
+// stack frame was created.  Should always be valid.
+unwind_protect *m_unwind_protect_frame;
-stack_frame_walker& operator = (const stack_frame_walker&) = delete;
+};
-virtual void
+// Pure scope stack frames (primarily the top-level workspace) have
-visit_compiled_fcn_stack_frame (compiled_fcn_stack_frame&) = 0;
+// a set of variables and values are stored in the stack frame.  All
+// variable accesses are direct as there are no parent stack frames.
-virtual void
+//
-visit_script_stack_frame (script_stack_frame&) = 0;
+// Value offsets are determined when the corresponding variable is
+// entered into the symbol_scope object corresponding to the frame.
-virtual void
-visit_user_fcn_stack_frame (user_fcn_stack_frame&) = 0;
+class scope_stack_frame : public base_value_stack_frame
+{
-virtual void
+public:
-visit_scope_stack_frame (scope_stack_frame&) = 0;
-};
+scope_stack_frame (void) = delete;
-class symbol_cleaner : public stack_frame_walker
+scope_stack_frame (tree_evaluator& tw, const symbol_scope& scope,
-{
+std::size_t index,
-public:
+const std::shared_ptr<stack_frame>& parent_link,
+const std::shared_ptr<stack_frame>& static_link)
-symbol_cleaner (const std::string& pattern, bool have_regexp = false)
+: base_value_stack_frame (tw, scope.num_symbols (), index,
-: stack_frame_walker (), m_patterns (pattern),
+parent_link, static_link, nullptr),
-m_clear_all_names (false), m_clear_objects (false),
+m_scope (scope)
-m_have_regexp (have_regexp), m_cleared_names ()
+{ }
-{ }
+scope_stack_frame (const scope_stack_frame& elt) = default;
-symbol_cleaner (const string_vector& patterns, bool have_regexp = false)
-: stack_frame_walker (), m_patterns (patterns),
+scope_stack_frame& operator = (const scope_stack_frame& elt) = delete;
-m_clear_all_names (false), m_clear_objects (false),
-m_have_regexp (have_regexp), m_cleared_names ()
+~scope_stack_frame (void) = default;
-{ }
+bool is_scope_frame (void) const { return true; }
-symbol_cleaner (bool clear_all_names = true, bool clear_objects = false)
-: stack_frame_walker (), m_patterns (),
+symbol_scope get_scope (void) const { return m_scope; }
-m_clear_all_names (clear_all_names), m_clear_objects (clear_objects),
-m_have_regexp (false), m_cleared_names ()
+symbol_record lookup_symbol (const std::string& name) const
-{ }
+{
+return m_scope.lookup_symbol (name);
-symbol_cleaner (const symbol_cleaner&) = delete;
+}
-symbol_cleaner& operator = (const symbol_cleaner&) = delete;
+symbol_record insert_symbol (const std::string&);
-~symbol_cleaner (void) = default;
+scope_flags scope_flag (const symbol_record& sym) const;
-void visit_compiled_fcn_stack_frame (compiled_fcn_stack_frame& frame)
+// We only need to override one of each of these functions.  The
-{
+// using declaration will avoid warnings about partially-overloaded
-// This one follows static link always.  Hmm, should the access
+// virtual functions.
-// link for a compiled_fcn_stack_frame be the same as the static
+using base_value_stack_frame::varval;
-// link?
+using base_value_stack_frame::varref;
-std::shared_ptr<stack_frame> slink = frame.static_link ();
+octave_value varval (const symbol_record& sym) const;
-if (slink)
+octave_value& varref (const symbol_record& sym);
-slink->accept (*this);
-}
+void mark_scope (const symbol_record& sym, scope_flags flag);
-void visit_script_stack_frame (script_stack_frame& frame)
+void display (bool follow = true) const;
-{
-std::shared_ptr<stack_frame> alink = frame.access_link ();
+void accept (stack_frame_walker& sfw);
-if (alink)
+private:
-alink->accept (*this);
-}
+// The scope object associated with this stack frame.
+symbol_scope m_scope;
-void visit_user_fcn_stack_frame (user_fcn_stack_frame& frame)
+};
-{
-clean_frame (frame);
+// FIXME: There should probably be a display method for the script,
+// fcn, and scope objects and the script and function objects should
-std::shared_ptr<stack_frame> alink = frame.access_link ();
+// be responsible for displaying the scopes they contain.
-if (alink)
+static void display_scope (std::ostream& os, const symbol_scope& scope)
-alink->accept (*this);
+{
-}
+if (scope)
+{
-void visit_scope_stack_frame (scope_stack_frame& frame)
+os << "scope: " << scope.name () << std::endl;
-{
-clean_frame (frame);
+if (scope.num_symbols () > 0)
-std::shared_ptr<stack_frame> alink = frame.access_link ();
-if (alink)
-alink->accept (*this);
-}
-private:
-void maybe_clear_symbol (stack_frame& frame, const symbol_record& sym)
-{
-std::string name = sym.name ();
-if (m_cleared_names.find (name) == m_cleared_names.end ())
 {
-// FIXME: Should we check that the name is defined and skip if
+os << "name (frame offset, data offset, storage class):"
-// it is not?  Is it possible for another symbol with the same
+<< std::endl;
-// name to appear in a later stack frame?
+std::list<symbol_record> symbols = scope.symbol_list ();
-// FIXME: If we are clearing objects and a symbol is found,
-// should we add it to the list of cleared names (since
+for (auto& sym : symbols)
-// we did find a symbol) but skip clearing the object?
-if (m_clear_objects && ! frame.is_object (sym))
-return;
-m_cleared_names.insert (name);
-frame.clear (sym);
-}
-}
-// FIXME: It would be nice to avoid the duplication in the following
-// function.
-void clear_symbols (stack_frame& frame,
-const std::list<symbol_record>& symbols)
-{
-if (m_clear_all_names)
-{
-for (const auto& sym : symbols)
-maybe_clear_symbol (frame, sym);
-}
-else if (m_have_regexp)
-{
-octave_idx_type npatterns = m_patterns.numel ();
-for (octave_idx_type j = 0; j < npatterns; j++)
 {
-std::string pattern = m_patterns[j];
+os << "  " << sym.name () << " (" << sym.frame_offset ()
+<< ", " << sym.data_offset () << ", " << sym.storage_class ()
-regexp pat (pattern);
+<< ")" << std::endl;
-for (const auto& sym : symbols)
-{
-if (pat.is_match (sym.name ()))
-maybe_clear_symbol (frame, sym);
-}
 }
 }
-else
+}
-{
+}
-octave_idx_type npatterns = m_patterns.numel ();
+class stack_frame_walker
-for (octave_idx_type j = 0; j < npatterns; j++)
+{
-{
+protected:
-std::string pattern = m_patterns[j];
+stack_frame_walker (void) { }
-glob_match pat (pattern);
+virtual ~stack_frame_walker (void) = default;
-for (const auto& sym : symbols)
-{
+public:
-if (pat.match (sym.name ()))
-maybe_clear_symbol (frame, sym);
+// No copying!
-}
-}
+stack_frame_walker (const stack_frame_walker&) = delete;
-}
-}
+stack_frame_walker& operator = (const stack_frame_walker&) = delete;
-void clean_frame (stack_frame& frame)
+virtual void
-{
+visit_compiled_fcn_stack_frame (compiled_fcn_stack_frame&) = 0;
-symbol_scope scope = frame.get_scope ();
+virtual void
-std::list<symbol_record> symbols = scope.symbol_list ();
+visit_script_stack_frame (script_stack_frame&) = 0;
-if (m_clear_all_names || ! m_patterns.empty ())
+virtual void
-clear_symbols (frame, symbols);
+visit_user_fcn_stack_frame (user_fcn_stack_frame&) = 0;
-}
+virtual void
-string_vector m_patterns;
+visit_scope_stack_frame (scope_stack_frame&) = 0;
+};
-bool m_clear_all_names;
-bool m_clear_objects;
+class symbol_cleaner : public stack_frame_walker
-bool m_have_regexp;
+{
+public:
-std::set<std::string> m_cleared_names;
-};
+symbol_cleaner (const std::string& pattern, bool have_regexp = false)
+: stack_frame_walker (), m_patterns (pattern),
-class symbol_info_accumulator : public stack_frame_walker
+m_clear_all_names (false), m_clear_objects (false),
-{
+m_have_regexp (have_regexp), m_cleared_names ()
-public:
+{ }
-symbol_info_accumulator (const std::string& pattern,
+symbol_cleaner (const string_vector& patterns, bool have_regexp = false)
-bool have_regexp = false)
+: stack_frame_walker (), m_patterns (patterns),
-: stack_frame_walker (), m_patterns (pattern), m_match_all (false),
+m_clear_all_names (false), m_clear_objects (false),
-m_first_only (false), m_have_regexp (have_regexp), m_sym_inf_list (),
+m_have_regexp (have_regexp), m_cleared_names ()
-m_found_names ()
+{ }
-{ }
+symbol_cleaner (bool clear_all_names = true, bool clear_objects = false)
-symbol_info_accumulator (const string_vector& patterns,
+: stack_frame_walker (), m_patterns (),
-bool have_regexp = false)
+m_clear_all_names (clear_all_names), m_clear_objects (clear_objects),
-: stack_frame_walker (), m_patterns (patterns), m_match_all (false),
+m_have_regexp (false), m_cleared_names ()
-m_first_only (false), m_have_regexp (have_regexp), m_sym_inf_list (),
+{ }
-m_found_names ()
-{ }
+symbol_cleaner (const symbol_cleaner&) = delete;
-symbol_info_accumulator (bool match_all = true, bool first_only = true)
+symbol_cleaner& operator = (const symbol_cleaner&) = delete;
-: stack_frame_walker (), m_patterns (), m_match_all (match_all),
-m_first_only (first_only), m_have_regexp (false),
+~symbol_cleaner (void) = default;
-m_sym_inf_list (), m_found_names ()
-{ }
+void visit_compiled_fcn_stack_frame (compiled_fcn_stack_frame& frame)
+{
-symbol_info_accumulator (const symbol_info_accumulator&) = delete;
+// This one follows static link always.  Hmm, should the access
+// link for a compiled_fcn_stack_frame be the same as the static
-symbol_info_accumulator& operator = (const symbol_info_accumulator&) = delete;
+// link?
-~symbol_info_accumulator (void) = default;
+std::shared_ptr<stack_frame> slink = frame.static_link ();
-bool is_empty  (void) const
+if (slink)
-{
+slink->accept (*this);
-for (const auto& nm_sil : m_sym_inf_list)
+}
-{
-const symbol_info_list& lst = nm_sil.second;
+void visit_script_stack_frame (script_stack_frame& frame)
+{
-if (! lst.empty ())
+std::shared_ptr<stack_frame> alink = frame.access_link ();
-return false;
-}
+if (alink)
+alink->accept (*this);
-return true;
+}
-}
+void visit_user_fcn_stack_frame (user_fcn_stack_frame& frame)
-std::list<std::string> names (void) const
+{
-{
+clean_frame (frame);
-std::list<std::string> retval;
+std::shared_ptr<stack_frame> alink = frame.access_link ();
-for (const auto& nm_sil : m_sym_inf_list)
-{
+if (alink)
-const symbol_info_list& lst = nm_sil.second;
+alink->accept (*this);
+}
-std::list<std::string> nm_list = lst.names ();
+void visit_scope_stack_frame (scope_stack_frame& frame)
-for (const auto& nm : nm_list)
+{
-retval.push_back (nm);
+clean_frame (frame);
-}
+std::shared_ptr<stack_frame> alink = frame.access_link ();
-return retval;
-}
+if (alink)
+alink->accept (*this);
-symbol_info_list symbol_info (void) const
+}
-{
-symbol_info_list retval;
+private:
-for (const auto& nm_sil : m_sym_inf_list)
+void maybe_clear_symbol (stack_frame& frame, const symbol_record& sym)
 {
-const symbol_info_list& lst = nm_sil.second;
+std::string name = sym.name ();
-for (const auto& syminf : lst)
+if (m_cleared_names.find (name) == m_cleared_names.end ())
-retval.push_back (syminf);
-}
-return retval;
-}
-octave_map map_value (void) const
-{
-octave_map retval;
-// FIXME: is there a better way to concatenate structures?
-std::size_t n_frames = m_sym_inf_list.size ();
-OCTAVE_LOCAL_BUFFER (octave_map, map_list, n_frames);
-std::size_t j = 0;
-for (const auto& nm_sil : m_sym_inf_list)
-{
-std::string scope_name = nm_sil.first;
-const symbol_info_list& lst = nm_sil.second;
-map_list[j] = lst.map_value (scope_name, n_frames-j);
-j++;
-}
-return octave_map::cat (-1, n_frames, map_list);
-}
-void display (std::ostream& os, const std::string& format) const
-{
-for (const auto& nm_sil : m_sym_inf_list)
-{
-os << "\nvariables in scope: " << nm_sil.first << "\n\n";
-const symbol_info_list& lst = nm_sil.second;
-lst.display (os, format);
-}
-}
-void visit_compiled_fcn_stack_frame (compiled_fcn_stack_frame& frame)
-{
-// This one follows static link always.  Hmm, should the access
-// link for a compiled_fcn_stack_frame be the same as the static
-// link?
-std::shared_ptr<stack_frame> slink = frame.static_link ();
-if (slink)
-slink->accept (*this);
-}
-void visit_script_stack_frame (script_stack_frame& frame)
-{
-std::shared_ptr<stack_frame> alink = frame.access_link ();
-if (alink)
-alink->accept (*this);
-}
-void visit_user_fcn_stack_frame (user_fcn_stack_frame& frame)
-{
-append_list (frame);
-std::shared_ptr<stack_frame> alink = frame.access_link ();
-if (alink)
-alink->accept (*this);
-}
-void visit_scope_stack_frame (scope_stack_frame& frame)
-{
-append_list (frame);
-std::shared_ptr<stack_frame> alink = frame.access_link ();
-if (alink)
-alink->accept (*this);
-}
-private:
-typedef std::pair<std::string, symbol_info_list> syminf_list_elt;
-// FIXME: the following is too complex and duplicates too much
-// code.  Maybe it should be split up so we have separate classes
-// that do each job that is needed?
-std::list<symbol_record>
-filter (stack_frame& frame, const std::list<symbol_record>& symbols)
-{
-std::list<symbol_record> new_symbols;
-if (m_match_all)
-{
-for (const auto& sym : symbols)
-{
-if (frame.is_defined (sym))
-{
-std::string name = sym.name ();
-if (m_first_only
-&& m_found_names.find (name) != m_found_names.end ())
-continue;
-m_found_names.insert (name);
-new_symbols.push_back (sym);
-}
-}
-}
-else if (m_have_regexp)
-{
-octave_idx_type npatterns = m_patterns.numel ();
-for (octave_idx_type j = 0; j < npatterns; j++)
-{
-std::string pattern = m_patterns[j];
-regexp pat (pattern);
-for (const auto& sym : symbols)
-{
-std::string name = sym.name ();
-if (pat.is_match (name) && frame.is_defined (sym))
-{
-if (m_first_only
-&& m_found_names.find (name) != m_found_names.end ())
-continue;
-m_found_names.insert (name);
-new_symbols.push_back (sym);
-}
-}
-}
-}
-else
-{
-octave_idx_type npatterns = m_patterns.numel ();
-for (octave_idx_type j = 0; j < npatterns; j++)
-{
-std::string pattern = m_patterns[j];
-glob_match pat (pattern);
-for (const auto& sym : symbols)
-{
-std::string name = sym.name ();
-if (pat.match (name) && frame.is_defined (sym))
-{
-if (m_first_only
-&& m_found_names.find (name) == m_found_names.end ())
-continue;
-m_found_names.insert (name);
-new_symbols.push_back (sym);
-}
-}
-}
-}
-return new_symbols;
-}
-void append_list (stack_frame& frame)
-{
-symbol_scope scope = frame.get_scope ();
-std::list<symbol_record> symbols = scope.symbol_list ();
-if (m_match_all || ! m_patterns.empty ())
-symbols = filter (frame, symbols);
-symbol_info_list syminf_list = frame.make_symbol_info_list (symbols);
-m_sym_inf_list.push_back (syminf_list_elt (scope.name (), syminf_list));
-}
-string_vector m_patterns;
-bool m_match_all;
-bool m_first_only;
-bool m_have_regexp;
-std::list<std::pair<std::string, symbol_info_list>> m_sym_inf_list;
-std::set<std::string> m_found_names;
-};
-stack_frame * stack_frame::create (tree_evaluator& tw, octave_function *fcn,
-std::size_t index,
-const std::shared_ptr<stack_frame>& parent_link,
-const std::shared_ptr<stack_frame>& static_link)
-{
-return new compiled_fcn_stack_frame (tw, fcn, index,
-parent_link, static_link);
-}
-stack_frame * stack_frame::create (tree_evaluator& tw,
-octave_user_script *script,
-std::size_t index,
-const std::shared_ptr<stack_frame>& parent_link,
-const std::shared_ptr<stack_frame>& static_link)
-{
-return new script_stack_frame (tw, script, index, parent_link, static_link);
-}
-stack_frame * stack_frame::create (tree_evaluator& tw,
-octave_user_function *fcn, std::size_t index,
-const std::shared_ptr<stack_frame>& parent_link,
-const std::shared_ptr<stack_frame>& static_link,
-const std::shared_ptr<stack_frame>& access_link)
-{
-return new user_fcn_stack_frame (tw, fcn, index,
-parent_link, static_link, access_link);
-}
-stack_frame * stack_frame::create (tree_evaluator& tw,
-octave_user_function *fcn, std::size_t index,
-const std::shared_ptr<stack_frame>& parent_link,
-const std::shared_ptr<stack_frame>& static_link,
-const local_vars_map& local_vars,
-const std::shared_ptr<stack_frame>& access_link)
-{
-return new user_fcn_stack_frame (tw, fcn, index,
-parent_link, static_link, local_vars,
-access_link);
-}
-stack_frame * stack_frame::create (tree_evaluator& tw,
-const symbol_scope& scope, std::size_t index,
-const std::shared_ptr<stack_frame>& parent_link,
-const std::shared_ptr<stack_frame>& static_link)
-{
-return new scope_stack_frame (tw, scope, index, parent_link, static_link);
-}
-// This function is only implemented and should only be called for
-// user_fcn stack frames.  Anything else indicates an error in the
-// implementation, but we'll simply warn if that happens.
-void stack_frame::clear_values (void)
-{
-warning ("invalid call to stack_frame::clear_values; please report");
-}
-symbol_info_list
-stack_frame::make_symbol_info_list (const std::list<symbol_record>& symrec_list) const
-{
-symbol_info_list symbol_stats;
-for (const auto& sym : symrec_list)
 {
-octave_value value = varval (sym);
+// FIXME: Should we check that the name is defined and skip if
+// it is not?  Is it possible for another symbol with the same
-if (! value.is_defined ()
+// name to appear in a later stack frame?
-|| (is_user_fcn_frame () && sym.frame_offset () > 0))
-continue;
+// FIXME: If we are clearing objects and a symbol is found,
+// should we add it to the list of cleared names (since
-symbol_info syminf (sym.name (), value, sym.is_formal (),
+// we did find a symbol) but skip clearing the object?
-is_global (sym), is_persistent (sym));
+if (m_clear_objects && ! frame.is_object (sym))
-symbol_stats.append (syminf);
+return;
+m_cleared_names.insert (name);
+frame.clear (sym);
 }
+}
-return symbol_stats;
-}
+// FIXME: It would be nice to avoid the duplication in the following
+// function.
-octave_value stack_frame::who (const string_vector& patterns,
-bool have_regexp, bool return_list,
+void clear_symbols (stack_frame& frame,
-bool verbose, const std::string& whos_line_fmt,
+const std::list<symbol_record>& symbols)
-const std::string& msg)
+{
-{
+if (m_clear_all_names)
-symbol_info_accumulator sym_inf_accum (patterns, have_regexp);
-accept (sym_inf_accum);
-if (return_list)
 {
-if (verbose)
+for (const auto& sym : symbols)
-return sym_inf_accum.map_value ();
+maybe_clear_symbol (frame, sym);
-else
-return Cell (string_vector (sym_inf_accum.names ()));
 }
-else if (! sym_inf_accum.is_empty ())
+else if (m_have_regexp)
 {
+octave_idx_type npatterns = m_patterns.numel ();
-if (msg.empty ())
-octave_stdout << "Variables visible from the current scope:\n";
+for (octave_idx_type j = 0; j < npatterns; j++)
-else
-octave_stdout << msg;
-if (verbose)
-sym_inf_accum.display (octave_stdout, whos_line_fmt);
-else
 {
-octave_stdout << "\n";
+std::string pattern = m_patterns[j];
-string_vector names (sym_inf_accum.names ());
-names.list_in_columns (octave_stdout);
+regexp pat (pattern);
-}
+for (const auto& sym : symbols)
-octave_stdout << "\n";
-}
-return octave_value ();
-}
-// Return first occurrence of variables in current stack frame and any
-// parent frames reachable through access links.
-symbol_info_list stack_frame::all_variables (void)
-{
-symbol_info_accumulator sia (true, true);
-accept (sia);
-return sia.symbol_info ();
-}
-octave_value stack_frame::workspace (void)
-{
-std::list<octave_scalar_map> ws_list;
-stack_frame *frame = this;
-while (frame)
-{
-symbol_info_list symbols = frame->all_variables ();
-octave_scalar_map ws;
-for (const auto& sym_name : symbols.names ())
-{
-octave_value val = symbols.varval (sym_name);
-if (val.is_defined ())
-ws.assign (sym_name, val);
-}
-ws_list.push_back (ws);
-std::shared_ptr<stack_frame> nxt = frame->access_link ();
-frame = nxt.get ();
-}
-Cell ws_frames (ws_list.size (), 1);
-octave_idx_type i = 0;
-for (const auto& elt : ws_list)
-ws_frames(i++) = elt;
-return ws_frames;
-}
-// FIXME: Should this function also find any variables in parent
-// scopes accessible through access_links?
-std::list<std::string> stack_frame::variable_names (void) const
-{
-std::list<std::string> retval;
-symbol_scope scope = get_scope ();
-const std::map<std::string, symbol_record>& symbols = scope.symbols ();
-for (const auto& nm_sr : symbols)
-{
-if (is_variable (nm_sr.second))
-retval.push_back (nm_sr.first);
-}
-retval.sort ();
-return retval;
-}
-symbol_info_list stack_frame::glob_symbol_info (const std::string& pattern)
-{
-symbol_info_accumulator sia (pattern, false);
-accept (sia);
-return sia.symbol_info ();
-}
-symbol_info_list stack_frame::regexp_symbol_info (const std::string& pattern)
-{
-symbol_info_accumulator sia (pattern, true);
-accept (sia);
-return sia.symbol_info ();
-}
-std::size_t stack_frame::size (void) const
-{
-// This function should only be called for user_fcn_stack_frame or
-// scope_stack_frame objects.  Anything else indicates an error in
-// the implementation.
-panic_impossible ();
-}
-void stack_frame::resize (std::size_t)
-{
-// This function should only be called for user_fcn_stack_frame or
-// scope_stack_frame objects.  Anything else indicates an error in
-// the implementation.
-panic_impossible ();
-}
-stack_frame::scope_flags stack_frame::get_scope_flag (std::size_t) const
-{
-// This function should only be called for user_fcn_stack_frame or
-// scope_stack_frame objects.  Anything else indicates an error in
-// the implementation.
-panic_impossible ();
-}
-void stack_frame::set_scope_flag (std::size_t, scope_flags)
-{
-// This function should only be called for user_fcn_stack_frame or
-// scope_stack_frame objects.  Anything else indicates an error in
-// the implementation.
-panic_impossible ();
-}
-void stack_frame::install_variable (const symbol_record& sym,
-const octave_value& value, bool global)
-{
-if (global && ! is_global (sym))
-{
-octave_value val = varval (sym);
-if (val.is_defined ())
-{
-std::string nm = sym.name ();
-warning_with_id ("Octave:global-local-conflict",
-"global: '%s' is defined in the current scope.\n",
-nm.c_str ());
-warning_with_id ("Octave:global-local-conflict",
-"global: in a future version, global variables must be declared before use.\n");
-// If the symbol is defined in the local but not the
-// global scope, then use the local value as the
-// initial value.  This value will also override any
-// initializer in the global statement.
-octave_value global_val = m_evaluator.global_varval (nm);
-if (global_val.is_defined ())
 {
-warning_with_id ("Octave:global-local-conflict",
+if (pat.is_match (sym.name ()))
-"global: global value overrides existing local value");
+maybe_clear_symbol (frame, sym);
-clear (sym);
-}
-else
-{
-warning_with_id ("Octave:global-local-conflict",
-"global: existing local value used to initialize global variable");
-m_evaluator.global_varref (nm) = val;
-}
-}
-mark_global (sym);
-}
-if (value.is_defined ())
-assign (sym, value);
-}
-octave_value stack_frame::varval (std::size_t) const
-{
-// This function should only be called for user_fcn_stack_frame or
-// scope_stack_frame objects.  Anything else indicates an error in
-// the implementation.
-panic_impossible ();
-}
-octave_value& stack_frame::varref (std::size_t)
-{
-// This function should only be called for user_fcn_stack_frame or
-// scope_stack_frame objects.  Anything else indicates an error in
-// the implementation.
-panic_impossible ();
-}
-void stack_frame::clear_objects (void)
-{
-symbol_cleaner sc (true, true);
-accept (sc);
-}
-void stack_frame::clear_variable (const std::string& name)
-{
-symbol_cleaner sc (name);
-accept (sc);
-}
-void stack_frame::clear_variable_pattern (const std::string& pattern)
-{
-symbol_cleaner sc (pattern);
-accept (sc);
-}
-void stack_frame::clear_variable_pattern (const string_vector& patterns)
-{
-symbol_cleaner sc (patterns);
-accept (sc);
-}
-void stack_frame::clear_variable_regexp (const std::string& pattern)
-{
-symbol_cleaner sc (pattern, true);
-accept (sc);
-}
-void stack_frame::clear_variable_regexp (const string_vector& patterns)
-{
-symbol_cleaner sc (patterns, true);
-accept (sc);
-}
-void stack_frame::clear_variables (void)
-{
-symbol_cleaner sc;
-accept (sc);
-}
-void stack_frame::display_stopped_in_message (std::ostream& os) const
-{
-if (index () == 0)
-os << "at top level" << std::endl;
-else
-{
-os << "stopped in " << fcn_name ();
-int l = line ();
-if (l > 0)
-os << " at line " << line ();
-os << " [" << fcn_file_name () << "] " << std::endl;
-}
-}
-void stack_frame::display (bool follow) const
-{
-std::ostream& os = octave_stdout;
-os << "-- [stack_frame] (" << this << ") --" << std::endl;
-os << "parent link: ";
-if (m_parent_link)
-os << m_parent_link.get ();
-else
-os << "NULL";
-os << std::endl;
-os << "static link: ";
-if (m_static_link)
-os << m_static_link.get ();
-else
-os << "NULL";
-os << std::endl;
-os << "access link: ";
-if (m_access_link)
-os << m_access_link.get ();
-else
-os << "NULL";
-os << std::endl;
-os << "line: " << m_line << std::endl;
-os << "column: " << m_column << std::endl;
-os << "index: " << m_index << std::endl;
-os << std::endl;
-if (! follow)
-return;
-os << "FOLLOWING ACCESS LINKS:" << std::endl;
-std::shared_ptr<stack_frame> frm = access_link ();
-while (frm)
-{
-frm->display (false);
-os << std::endl;
-frm = frm->access_link ();
-}
-}
-void compiled_fcn_stack_frame::display (bool follow) const
-{
-std::ostream& os = octave_stdout;
-os << "-- [compiled_fcn_stack_frame] (" << this << ") --" << std::endl;
-stack_frame::display (follow);
-os << "fcn: " << m_fcn->name ()
-<< " (" << m_fcn->type_name () << ")" << std::endl;
-}
-void compiled_fcn_stack_frame::accept (stack_frame_walker& sfw)
-{
-sfw.visit_compiled_fcn_stack_frame (*this);
-}
-script_stack_frame::script_stack_frame (tree_evaluator& tw,
-octave_user_script *script,
-std::size_t index,
-const std::shared_ptr<stack_frame>& parent_link,
-const std::shared_ptr<stack_frame>& static_link)
-: stack_frame (tw, index, parent_link, static_link,
-get_access_link (static_link)),
-m_script (script), m_unwind_protect_frame (nullptr),
-m_lexical_frame_offsets (get_num_symbols (script), 1),
-m_value_offsets (get_num_symbols (script), 0)
-{
-set_script_offsets ();
-}
-std::size_t script_stack_frame::get_num_symbols (octave_user_script *script)
-{
-symbol_scope script_scope = script->scope ();
-return script_scope.num_symbols ();
-}
-void script_stack_frame::set_script_offsets (void)
-{
-// Set frame and data offsets inside stack frame based on enclosing
-// scope(s).
-symbol_scope script_scope = m_script->scope ();
-std::size_t num_script_symbols = script_scope.num_symbols ();
-resize (num_script_symbols);
-const std::map<std::string, symbol_record>& script_symbols
-= script_scope.symbols ();
-set_script_offsets_internal (script_symbols);
-}
-void script_stack_frame::set_script_offsets_internal
-(const std::map<std::string, symbol_record>& script_symbols)
-{
-// This scope will be used to evaluate the script.  Find (or
-// possibly insert) symbols from the dummy script scope here.
-symbol_scope eval_scope = m_access_link->get_scope ();
-if (eval_scope.is_nested ())
-{
-bool found = false;
-for (const auto& nm_sr : script_symbols)
-{
-std::string name = nm_sr.first;
-symbol_record script_sr = nm_sr.second;
-symbol_scope parent_scope = eval_scope;
-std::size_t count = 1;
-while (parent_scope)
-{
-const std::map<std::string, symbol_record>& parent_scope_symbols
-= parent_scope.symbols ();
-auto p = parent_scope_symbols.find (name);
-if (p != parent_scope_symbols.end ())
-{
-found = true;
-symbol_record parent_scope_sr = p->second;
-std::size_t script_sr_data_offset = script_sr.data_offset ();
-m_lexical_frame_offsets.at (script_sr_data_offset)
-= parent_scope_sr.frame_offset () + count;
-m_value_offsets.at (script_sr_data_offset)
-= parent_scope_sr.data_offset ();
-break;
-}
-else
-{
-count++;
-parent_scope = parent_scope.parent_scope ();
-}
-}
-if (! found)
-error ("symbol '%s' cannot be added to static scope",
-name.c_str ());
-}
-}
-else
-{
-const std::map<std::string, symbol_record>& eval_scope_symbols
-= eval_scope.symbols ();
-for (const auto& nm_sr : script_symbols)
-{
-std::string name = nm_sr.first;
-symbol_record script_sr = nm_sr.second;
-auto p = eval_scope_symbols.find (name);
-symbol_record eval_scope_sr;
-if (p == eval_scope_symbols.end ())
-eval_scope_sr = eval_scope.insert (name);
-else
-eval_scope_sr = p->second;
-std::size_t script_sr_data_offset = script_sr.data_offset ();
-// The +1 is for going from the script frame to the eval
-// frame.  Only one access_link should need to be followed.
-m_lexical_frame_offsets.at (script_sr_data_offset)
-= eval_scope_sr.frame_offset () + 1;
-m_value_offsets.at (script_sr_data_offset)
-= eval_scope_sr.data_offset ();
-}
-}
-}
-void script_stack_frame::resize_and_update_script_offsets (const symbol_record& sym)
-{
-std::size_t data_offset = sym.data_offset ();
-// This function is called when adding new symbols to a script
-// scope.  If the symbol wasn't present before, it should be outside
-// the range so we need to resize then update offsets.
-panic_unless (data_offset >= size ());
-resize (data_offset+1);
-// FIXME: We should be able to avoid creating the map object and the
-// looping in the set_scripts_offsets_internal function.  Can we do
-// that without (or with minimal) code duplication?
-std::map<std::string, symbol_record> tmp_symbols;
-tmp_symbols[sym.name ()] = sym;
-set_script_offsets_internal (tmp_symbols);
-}
-// If this is a nested scope, set access_link to nearest parent
-// stack frame that corresponds to the lexical parent of this scope.
-std::shared_ptr<stack_frame>
-script_stack_frame::get_access_link (const std::shared_ptr<stack_frame>& static_link)
-{
-// If this script is called from another script, set access
-// link to ultimate parent stack frame.
-std::shared_ptr<stack_frame> alink = static_link;
-while (alink->is_user_script_frame ())
-{
-if (alink->access_link ())
-alink = alink->access_link ();
-else
-break;
-}
-return alink;
-}
-unwind_protect * script_stack_frame::unwind_protect_frame (void)
-{
-if (! m_unwind_protect_frame)
-m_unwind_protect_frame = new unwind_protect ();
-return m_unwind_protect_frame;
-}
-symbol_record script_stack_frame::lookup_symbol (const std::string& name) const
-{
-symbol_scope scope = get_scope ();
-symbol_record sym = scope.lookup_symbol (name);
-if (sym)
-{
-panic_unless (sym.frame_offset () == 0);
-return sym;
-}
-sym = m_access_link->lookup_symbol (name);
-// Return symbol record with adjusted frame offset.
-symbol_record new_sym = sym.dup ();
-new_sym.set_frame_offset (sym.frame_offset () + 1);
-return new_sym;
-}
-symbol_record script_stack_frame::insert_symbol (const std::string& name)
-{
-// If the symbols is already in the immediate scope, there is
-// nothing more to do.
-symbol_scope scope = get_scope ();
-symbol_record sym = scope.lookup_symbol (name);
-if (sym)
-{
-// All symbol records in a script scope should have zero offset,
-// which means we redirect our lookup using
-// lexical_frame_offsets and values_offets.
-panic_unless (sym.frame_offset () == 0);
-return sym;
-}
-// Insert the symbol in the current scope then resize and update
-// offsets.  This operation should never fail.
-sym = scope.find_symbol (name);
-panic_unless (sym.is_valid ());
-resize_and_update_script_offsets (sym);
-return sym;
-}
-// Similar to set_script_offsets_internal except that we only return
-// frame and data offsets for symbols found by name in parent scopes
-// instead of updating the offsets stored in the script frame itself.
-bool
-script_stack_frame::get_val_offsets_internal (const symbol_record& script_sr,
-std::size_t& frame_offset,
-std::size_t& data_offset) const
-{
-bool found = false;
-// This scope will be used to evaluate the script.  Find symbols
-// here by name.
-symbol_scope eval_scope = m_access_link->get_scope ();
-if (eval_scope.is_nested ())
-{
-std::string name = script_sr.name ();
-symbol_scope parent_scope = eval_scope;
-std::size_t count = 1;
-while (parent_scope)
-{
-const std::map<std::string, symbol_record>& parent_scope_symbols
-= parent_scope.symbols ();
-auto p = parent_scope_symbols.find (name);
-if (p != parent_scope_symbols.end ())
-{
-found = true;
-symbol_record parent_scope_sr = p->second;
-frame_offset = parent_scope_sr.frame_offset () + count;
-data_offset = parent_scope_sr.data_offset ();
-break;
-}
-else
-{
-count++;
-parent_scope = parent_scope.parent_scope ();
 }
 }
 }
 else
 {
-const std::map<std::string, symbol_record>& eval_scope_symbols
+octave_idx_type npatterns = m_patterns.numel ();
-= eval_scope.symbols ();
+for (octave_idx_type j = 0; j < npatterns; j++)
-std::string name = script_sr.name ();
-auto p = eval_scope_symbols.find (name);
-symbol_record eval_scope_sr;
-if (p != eval_scope_symbols.end ())
 {
-found = true;
+std::string pattern = m_patterns[j];
-eval_scope_sr = p->second;
+glob_match pat (pattern);
-// The +1 is for going from the script frame to the eval
-// frame.  Only one access_link should need to be followed.
+for (const auto& sym : symbols)
+{
-frame_offset = eval_scope_sr.frame_offset () + 1;
+if (pat.match (sym.name ()))
+maybe_clear_symbol (frame, sym);
-data_offset = eval_scope_sr.data_offset ();
+}
 }
 }
+}
-return found;
-}
+void clean_frame (stack_frame& frame)
+{
-bool script_stack_frame::get_val_offsets (const symbol_record& sym,
+symbol_scope scope = frame.get_scope ();
-std::size_t& frame_offset,
-std::size_t& data_offset) const
+std::list<symbol_record> symbols = scope.symbol_list ();
-{
-data_offset = sym.data_offset ();
+if (m_clear_all_names || ! m_patterns.empty ())
-frame_offset = sym.frame_offset ();
+clear_symbols (frame, symbols);
+}
-if (frame_offset == 0)
+string_vector m_patterns;
+bool m_clear_all_names;
+bool m_clear_objects;
+bool m_have_regexp;
+std::set<std::string> m_cleared_names;
+};
+class symbol_info_accumulator : public stack_frame_walker
+{
+public:
+symbol_info_accumulator (const std::string& pattern,
+bool have_regexp = false)
+: stack_frame_walker (), m_patterns (pattern), m_match_all (false),
+m_first_only (false), m_have_regexp (have_regexp), m_sym_inf_list (),
+m_found_names ()
+{ }
+symbol_info_accumulator (const string_vector& patterns,
+bool have_regexp = false)
+: stack_frame_walker (), m_patterns (patterns), m_match_all (false),
+m_first_only (false), m_have_regexp (have_regexp), m_sym_inf_list (),
+m_found_names ()
+{ }
+symbol_info_accumulator (bool match_all = true, bool first_only = true)
+: stack_frame_walker (), m_patterns (), m_match_all (match_all),
+m_first_only (first_only), m_have_regexp (false),
+m_sym_inf_list (), m_found_names ()
+{ }
+symbol_info_accumulator (const symbol_info_accumulator&) = delete;
+symbol_info_accumulator& operator = (const symbol_info_accumulator&) = delete;
+~symbol_info_accumulator (void) = default;
+bool is_empty  (void) const
+{
+for (const auto& nm_sil : m_sym_inf_list)
 {
-// An out of range data_offset value here means that we have a
+const symbol_info_list& lst = nm_sil.second;
-// symbol that was not originally in the script.  But this
-// function is called in places where we can't insert a new
+if (! lst.empty ())
-// symbol, so we fail and it is up to the caller to decide what
+return false;
-// to do.
+}
-if (data_offset >= size ())
+return true;
-return get_val_offsets_internal (sym, frame_offset, data_offset);
+}
-// Use frame and value offsets stored in this stack frame,
+std::list<std::string> names (void) const
-// indexed by data_offset from the symbol_record to find the
+{
-// values.  These offsets were determined by
+std::list<std::string> retval;
-// script_stack_frame::set_script_offsets when this script was
-// invoked.
+for (const auto& nm_sil : m_sym_inf_list)
+{
-frame_offset = m_lexical_frame_offsets.at (data_offset);
+const symbol_info_list& lst = nm_sil.second;
-if (frame_offset == 0)
+std::list<std::string> nm_list = lst.names ();
+for (const auto& nm : nm_list)
+retval.push_back (nm);
+}
+return retval;
+}
+symbol_info_list symbol_info (void) const
+{
+symbol_info_list retval;
+for (const auto& nm_sil : m_sym_inf_list)
+{
+const symbol_info_list& lst = nm_sil.second;
+for (const auto& syminf : lst)
+retval.push_back (syminf);
+}
+return retval;
+}
+octave_map map_value (void) const
+{
+octave_map retval;
+// FIXME: is there a better way to concatenate structures?
+std::size_t n_frames = m_sym_inf_list.size ();
+OCTAVE_LOCAL_BUFFER (octave_map, map_list, n_frames);
+std::size_t j = 0;
+for (const auto& nm_sil : m_sym_inf_list)
+{
+std::string scope_name = nm_sil.first;
+const symbol_info_list& lst = nm_sil.second;
+map_list[j] = lst.map_value (scope_name, n_frames-j);
+j++;
+}
+return octave_map::cat (-1, n_frames, map_list);
+}
+void display (std::ostream& os, const std::string& format) const
+{
+for (const auto& nm_sil : m_sym_inf_list)
+{
+os << "\nvariables in scope: " << nm_sil.first << "\n\n";
+const symbol_info_list& lst = nm_sil.second;
+lst.display (os, format);
+}
+}
+void visit_compiled_fcn_stack_frame (compiled_fcn_stack_frame& frame)
+{
+// This one follows static link always.  Hmm, should the access
+// link for a compiled_fcn_stack_frame be the same as the static
+// link?
+std::shared_ptr<stack_frame> slink = frame.static_link ();
+if (slink)
+slink->accept (*this);
+}
+void visit_script_stack_frame (script_stack_frame& frame)
+{
+std::shared_ptr<stack_frame> alink = frame.access_link ();
+if (alink)
+alink->accept (*this);
+}
+void visit_user_fcn_stack_frame (user_fcn_stack_frame& frame)
+{
+append_list (frame);
+std::shared_ptr<stack_frame> alink = frame.access_link ();
+if (alink)
+alink->accept (*this);
+}
+void visit_scope_stack_frame (scope_stack_frame& frame)
+{
+append_list (frame);
+std::shared_ptr<stack_frame> alink = frame.access_link ();
+if (alink)
+alink->accept (*this);
+}
+private:
+typedef std::pair<std::string, symbol_info_list> syminf_list_elt;
+// FIXME: the following is too complex and duplicates too much
+// code.  Maybe it should be split up so we have separate classes
+// that do each job that is needed?
+std::list<symbol_record>
+filter (stack_frame& frame, const std::list<symbol_record>& symbols)
+{
+std::list<symbol_record> new_symbols;
+if (m_match_all)
+{
+for (const auto& sym : symbols)
 {
-// If the frame offset stored in m_lexical_frame_offsets is
+if (frame.is_defined (sym))
-// zero, then the data offset in the evaluation scope has
+{
-// not been determined so try to do that now.  The symbol
+std::string name = sym.name ();
-// may have been added by eval and without calling
-// resize_and_update_script_offsets.
+if (m_first_only
+&& m_found_names.find (name) != m_found_names.end ())
-return get_val_offsets_internal (sym, frame_offset, data_offset);
+continue;
+m_found_names.insert (name);
+new_symbols.push_back (sym);
+}
 }
+}
-data_offset = m_value_offsets.at (data_offset);
+else if (m_have_regexp)
+{
+octave_idx_type npatterns = m_patterns.numel ();
+for (octave_idx_type j = 0; j < npatterns; j++)
+{
+std::string pattern = m_patterns[j];
+regexp pat (pattern);
+for (const auto& sym : symbols)
+{
+std::string name = sym.name ();
+if (pat.is_match (name) && frame.is_defined (sym))
+{
+if (m_first_only
+&& m_found_names.find (name) != m_found_names.end ())
+continue;
+m_found_names.insert (name);
+new_symbols.push_back (sym);
+}
+}
+}
 }
 else
 {
-// If frame_offset is not zero, then then we must have a symbol
+octave_idx_type npatterns = m_patterns.numel ();
-// that was not originally in the script.  The values should
-// have been determined by the script_stack_frame::lookup function.
+for (octave_idx_type j = 0; j < npatterns; j++)
-}
-return true;
-}
-void script_stack_frame::get_val_offsets_with_insert (const symbol_record& sym,
-std::size_t& frame_offset,
-std::size_t& data_offset)
-{
-data_offset = sym.data_offset ();
-frame_offset = sym.frame_offset ();
-if (frame_offset == 0)
-{
-if (data_offset >= size ())
 {
-// If the data_offset is out of range, then we must have a
+std::string pattern = m_patterns[j];
-// symbol that was not originally in the script.  Resize and
-// update the offsets.
+glob_match pat (pattern);
-resize_and_update_script_offsets (sym);
+for (const auto& sym : symbols)
-}
-// Use frame and value offsets stored in this stack frame,
-// indexed by data_offset from the symbol_record to find the
-// values.  These offsets were determined by
-// script_stack_frame::set_script_offsets when this script was
-// invoked.
-frame_offset = m_lexical_frame_offsets.at (data_offset);
-if (frame_offset == 0)
-{
-// If the frame offset stored in m_lexical_frame_offsets is
-// zero, then the data offset in the evaluation scope has
-// not been determined so try to do that now.  The symbol
-// may have been added by eval and without calling
-// resize_and_update_script_offsets.
-// We don't need to resize here.  That case is handled above.
-// FIXME: We should be able to avoid creating the map object
-// and the looping in the set_scripts_offsets_internal
-// function.  Can we do that without (or with minimal) code
-// duplication?
-std::map<std::string, symbol_record> tmp_symbols;
-tmp_symbols[sym.name ()] = sym;
-set_script_offsets_internal (tmp_symbols);
-// set_script_offsets_internal may have modified
-// m_lexical_frame_offsets and m_value_offsets.
-frame_offset = m_lexical_frame_offsets.at (data_offset);
-}
-data_offset = m_value_offsets.at (data_offset);
-}
-else
-{
-// If frame_offset is not zero, then then we must have a symbol
-// that was not originally in the script.  The values were
-// determined by the script_stack_frame::lookup function.
-}
-}
-stack_frame::scope_flags
-script_stack_frame::scope_flag (const symbol_record& sym) const
-{
-std::size_t frame_offset;
-std::size_t data_offset;
-bool found = get_val_offsets (sym, frame_offset, data_offset);
-// It can't be global or persistent, so call it local.
-if (! found)
-return LOCAL;
-// Follow frame_offset access links to stack frame that holds
-// the value.
-const stack_frame *frame = this;
-for (std::size_t i = 0; i < frame_offset; i++)
-{
-std::shared_ptr<stack_frame> nxt = frame->access_link ();
-frame = nxt.get ();
-}
-if (! frame)
-error ("internal error: invalid access link in function call stack");
-if (data_offset >= frame->size ())
-return LOCAL;
-return frame->get_scope_flag (data_offset);
-}
-octave_value script_stack_frame::varval (const symbol_record& sym) const
-{
-std::size_t frame_offset;
-std::size_t data_offset;
-bool found = get_val_offsets (sym, frame_offset, data_offset);
-if (! found)
-return octave_value ();
-// Follow frame_offset access links to stack frame that holds
-// the value.
-const stack_frame *frame = this;
-for (std::size_t i = 0; i < frame_offset; i++)
-{
-std::shared_ptr<stack_frame> nxt = frame->access_link ();
-frame = nxt.get ();
-}
-if (! frame)
-error ("internal error: invalid access link in function call stack");
-if (data_offset >= frame->size ())
-return octave_value ();
-switch (frame->get_scope_flag (data_offset))
-{
-case LOCAL:
-return frame->varval (data_offset);
-case PERSISTENT:
-{
-symbol_scope scope = frame->get_scope ();
-return scope.persistent_varval (data_offset);
-}
-case GLOBAL:
-return m_evaluator.global_varval (sym.name ());
-}
-error ("internal error: invalid switch case");
-}
-octave_value& script_stack_frame::varref (const symbol_record& sym)
-{
-std::size_t frame_offset;
-std::size_t data_offset;
-get_val_offsets_with_insert (sym, frame_offset, data_offset);
-// Follow frame_offset access links to stack frame that holds
-// the value.
-stack_frame *frame = this;
-for (std::size_t i = 0; i < frame_offset; i++)
-{
-std::shared_ptr<stack_frame> nxt = frame->access_link ();
-frame = nxt.get ();
-}
-if (data_offset >= frame->size ())
-frame->resize (data_offset+1);
-switch (frame->get_scope_flag (data_offset))
-{
-case LOCAL:
-return frame->varref (data_offset);
-case PERSISTENT:
-{
-symbol_scope scope = frame->get_scope ();
-return scope.persistent_varref (data_offset);
-}
-case GLOBAL:
-return m_evaluator.global_varref (sym.name ());
-}
-error ("internal error: invalid switch case");
-}
-void script_stack_frame::mark_scope (const symbol_record& sym,
-scope_flags flag)
-{
-std::size_t data_offset = sym.data_offset ();
-if (data_offset >= size ())
-resize_and_update_script_offsets (sym);
-// Redirection to evaluation context for the script.
-std::size_t frame_offset = m_lexical_frame_offsets.at (data_offset);
-data_offset = m_value_offsets.at (data_offset);
-if (frame_offset > 1)
-error ("variables must be made PERSISTENT or GLOBAL in the first scope in which they are used");
-std::shared_ptr<stack_frame> frame = access_link ();
-if (data_offset >= frame->size ())
-frame->resize (data_offset+1);
-frame->set_scope_flag (data_offset, flag);
-}
-void script_stack_frame::display (bool follow) const
-{
-std::ostream& os = octave_stdout;
-os << "-- [script_stack_frame] (" << this << ") --" << std::endl;
-stack_frame::display (follow);
-os << "script: " << m_script->name ()
-<< " (" << m_script->type_name () << ")" << std::endl;
-os << "lexical_offsets: " << m_lexical_frame_offsets.size ()
-<< " elements:";
-for (std::size_t i = 0; i < m_lexical_frame_offsets.size (); i++)
-os << "  " << m_lexical_frame_offsets.at (i);
-os << std::endl;
-os << "value_offsets: " << m_value_offsets.size () << " elements:";
-for (std::size_t i = 0; i < m_value_offsets.size (); i++)
-os << "  " << m_value_offsets.at (i);
-os << std::endl;
-display_scope (os, get_scope ());
-}
-void script_stack_frame::accept (stack_frame_walker& sfw)
-{
-sfw.visit_script_stack_frame (*this);
-}
-void base_value_stack_frame::display (bool follow) const
-{
-std::ostream& os = octave_stdout;
-os << "-- [base_value_stack_frame] (" << this << ") --" << std::endl;
-stack_frame::display (follow);
-os << "values: " << m_values.size ()
-<< " elements (idx, scope flag, type):" << std::endl;
-for (std::size_t i = 0; i < m_values.size (); i++)
-{
-os << "  (" << i << ", " << m_flags.at (i) << ", ";
-octave_value val = varval (i);
-os << (val.is_defined () ? val.type_name () : " UNDEFINED") << ")"
-<< std::endl;
-}
-}
-// If this is a nested scope, set access_link to nearest parent
-// stack frame that corresponds to the lexical parent of this scope.
-std::shared_ptr<stack_frame>
-user_fcn_stack_frame::get_access_link (octave_user_function *fcn,
-const std::shared_ptr<stack_frame>& static_link)
-{
-std::shared_ptr<stack_frame> alink;
-symbol_scope fcn_scope = fcn->scope ();
-if (fcn_scope.is_nested ())
-{
-if (! static_link)
-error ("internal call stack error (invalid static link)");
-symbol_scope caller_scope = static_link->get_scope ();
-int nesting_depth = fcn_scope.nesting_depth ();
-int caller_nesting_depth = caller_scope.nesting_depth ();
-if (caller_nesting_depth < nesting_depth)
-{
-// FIXME: do we need to ensure that the called
-// function is a child of the caller?  Does it hurt
-// to panic_unless this condition, at least for now?
-alink = static_link;
-}
-else
-{
-// FIXME: do we need to check that the parent of the
-// called function is also a parent of the caller?
-// Does it hurt to panic_unless this condition, at least
-// for now?
-int links_to_follow = caller_nesting_depth - nesting_depth + 1;
-alink = static_link;
-while (alink && --links_to_follow >= 0)
-alink = alink->access_link ();
-if (! alink)
-error ("internal function nesting error (invalid access link)");
-}
-}
-return alink;
-}
-void user_fcn_stack_frame::clear_values (void)
-{
-symbol_scope fcn_scope = m_fcn->scope ();
-const std::list<symbol_record>& symbols = fcn_scope.symbol_list ();
-if (size () == 0)
-return;
-for (const auto& sym : symbols)
-{
-std::size_t frame_offset = sym.frame_offset ();
-if (frame_offset > 0)
-continue;
-std::size_t data_offset = sym.data_offset ();
-if (data_offset >= size ())
-continue;
-if (get_scope_flag (data_offset) == LOCAL)
-{
-octave_value& ref = m_values.at (data_offset);
-if (ref.get_count () == 1)
 {
-ref.call_object_destructor ();
+std::string name = sym.name ();
-ref = octave_value ();
+if (pat.match (name) && frame.is_defined (sym))
+{
+if (m_first_only
+&& m_found_names.find (name) == m_found_names.end ())
+continue;
+m_found_names.insert (name);
+new_symbols.push_back (sym);
+}
 }
 }
 }
-}
+return new_symbols;
-unwind_protect * user_fcn_stack_frame::unwind_protect_frame (void)
+}
-{
-if (! m_unwind_protect_frame)
+void append_list (stack_frame& frame)
-m_unwind_protect_frame = new unwind_protect ();
+{
+symbol_scope scope = frame.get_scope ();
-return m_unwind_protect_frame;
-}
+std::list<symbol_record> symbols = scope.symbol_list ();
-symbol_record user_fcn_stack_frame::lookup_symbol (const std::string& name) const
+if (m_match_all || ! m_patterns.empty ())
-{
+symbols = filter (frame, symbols);
-const stack_frame *frame = this;
+symbol_info_list syminf_list = frame.make_symbol_info_list (symbols);
-while (frame)
+m_sym_inf_list.push_back (syminf_list_elt (scope.name (), syminf_list));
+}
+string_vector m_patterns;
+bool m_match_all;
+bool m_first_only;
+bool m_have_regexp;
+std::list<std::pair<std::string, symbol_info_list>> m_sym_inf_list;
+std::set<std::string> m_found_names;
+};
+stack_frame *stack_frame::create (tree_evaluator& tw, octave_function *fcn,
+std::size_t index,
+const std::shared_ptr<stack_frame>& parent_link,
+const std::shared_ptr<stack_frame>& static_link)
+{
+return new compiled_fcn_stack_frame (tw, fcn, index,
+parent_link, static_link);
+}
+stack_frame *stack_frame::create (tree_evaluator& tw,
+octave_user_script *script,
+std::size_t index,
+const std::shared_ptr<stack_frame>& parent_link,
+const std::shared_ptr<stack_frame>& static_link)
+{
+return new script_stack_frame (tw, script, index, parent_link, static_link);
+}
+stack_frame *stack_frame::create (tree_evaluator& tw,
+octave_user_function *fcn, std::size_t index,
+const std::shared_ptr<stack_frame>& parent_link,
+const std::shared_ptr<stack_frame>& static_link,
+const std::shared_ptr<stack_frame>& access_link)
+{
+return new user_fcn_stack_frame (tw, fcn, index,
+parent_link, static_link, access_link);
+}
+stack_frame *stack_frame::create (tree_evaluator& tw,
+octave_user_function *fcn, std::size_t index,
+const std::shared_ptr<stack_frame>& parent_link,
+const std::shared_ptr<stack_frame>& static_link,
+const local_vars_map& local_vars,
+const std::shared_ptr<stack_frame>& access_link)
+{
+return new user_fcn_stack_frame (tw, fcn, index,
+parent_link, static_link, local_vars,
+access_link);
+}
+stack_frame *stack_frame::create (tree_evaluator& tw,
+const symbol_scope& scope, std::size_t index,
+const std::shared_ptr<stack_frame>& parent_link,
+const std::shared_ptr<stack_frame>& static_link)
+{
+return new scope_stack_frame (tw, scope, index, parent_link, static_link);
+}
+// This function is only implemented and should only be called for
+// user_fcn stack frames.  Anything else indicates an error in the
+// implementation, but we'll simply warn if that happens.
+void stack_frame::clear_values (void)
+{
+warning ("invalid call to stack_frame::clear_values; please report");
+}
+symbol_info_list
+stack_frame::make_symbol_info_list (const std::list<symbol_record>& symrec_list) const
+{
+symbol_info_list symbol_stats;
+for (const auto& sym : symrec_list)
+{
+octave_value value = varval (sym);
+if (! value.is_defined ()
+|| (is_user_fcn_frame () && sym.frame_offset () > 0))
+continue;
+symbol_info syminf (sym.name (), value, sym.is_formal (),
+is_global (sym), is_persistent (sym));
+symbol_stats.append (syminf);
+}
+return symbol_stats;
+}
+octave_value stack_frame::who (const string_vector& patterns,
+bool have_regexp, bool return_list,
+bool verbose, const std::string& whos_line_fmt,
+const std::string& msg)
+{
+symbol_info_accumulator sym_inf_accum (patterns, have_regexp);
+accept (sym_inf_accum);
+if (return_list)
+{
+if (verbose)
+return sym_inf_accum.map_value ();
+else
+return Cell (string_vector (sym_inf_accum.names ()));
+}
+else if (! sym_inf_accum.is_empty ())
+{
+if (msg.empty ())
+octave_stdout << "Variables visible from the current scope:\n";
+else
+octave_stdout << msg;
+if (verbose)
+sym_inf_accum.display (octave_stdout, whos_line_fmt);
+else
+{
+octave_stdout << "\n";
+string_vector names (sym_inf_accum.names ());
+names.list_in_columns (octave_stdout);
+}
+octave_stdout << "\n";
+}
+return octave_value ();
+}
+// Return first occurrence of variables in current stack frame and any
+// parent frames reachable through access links.
+symbol_info_list stack_frame::all_variables (void)
+{
+symbol_info_accumulator sia (true, true);
+accept (sia);
+return sia.symbol_info ();
+}
+octave_value stack_frame::workspace (void)
+{
+std::list<octave_scalar_map> ws_list;
+stack_frame *frame = this;
+while (frame)
+{
+symbol_info_list symbols = frame->all_variables ();
+octave_scalar_map ws;
+for (const auto& sym_name : symbols.names ())
+{
+octave_value val = symbols.varval (sym_name);
+if (val.is_defined ())
+ws.assign (sym_name, val);
+}
+ws_list.push_back (ws);
+std::shared_ptr<stack_frame> nxt = frame->access_link ();
+frame = nxt.get ();
+}
+Cell ws_frames (ws_list.size (), 1);
+octave_idx_type i = 0;
+for (const auto& elt : ws_list)
+ws_frames(i++) = elt;
+return ws_frames;
+}
+// FIXME: Should this function also find any variables in parent
+// scopes accessible through access_links?
+std::list<std::string> stack_frame::variable_names (void) const
+{
+std::list<std::string> retval;
+symbol_scope scope = get_scope ();
+const std::map<std::string, symbol_record>& symbols = scope.symbols ();
+for (const auto& nm_sr : symbols)
+{
+if (is_variable (nm_sr.second))
+retval.push_back (nm_sr.first);
+}
+retval.sort ();
+return retval;
+}
+symbol_info_list stack_frame::glob_symbol_info (const std::string& pattern)
+{
+symbol_info_accumulator sia (pattern, false);
+accept (sia);
+return sia.symbol_info ();
+}
+symbol_info_list stack_frame::regexp_symbol_info (const std::string& pattern)
+{
+symbol_info_accumulator sia (pattern, true);
+accept (sia);
+return sia.symbol_info ();
+}
+std::size_t stack_frame::size (void) const
+{
+// This function should only be called for user_fcn_stack_frame or
+// scope_stack_frame objects.  Anything else indicates an error in
+// the implementation.
+panic_impossible ();
+}
+void stack_frame::resize (std::size_t)
+{
+// This function should only be called for user_fcn_stack_frame or
+// scope_stack_frame objects.  Anything else indicates an error in
+// the implementation.
+panic_impossible ();
+}
+stack_frame::scope_flags stack_frame::get_scope_flag (std::size_t) const
+{
+// This function should only be called for user_fcn_stack_frame or
+// scope_stack_frame objects.  Anything else indicates an error in
+// the implementation.
+panic_impossible ();
+}
+void stack_frame::set_scope_flag (std::size_t, scope_flags)
+{
+// This function should only be called for user_fcn_stack_frame or
+// scope_stack_frame objects.  Anything else indicates an error in
+// the implementation.
+panic_impossible ();
+}
+void stack_frame::install_variable (const symbol_record& sym,
+const octave_value& value, bool global)
+{
+if (global && ! is_global (sym))
+{
+octave_value val = varval (sym);
+if (val.is_defined ())
+{
+std::string nm = sym.name ();
+warning_with_id ("Octave:global-local-conflict",
+"global: '%s' is defined in the current scope.\n",
+nm.c_str ());
+warning_with_id ("Octave:global-local-conflict",
+"global: in a future version, global variables must be declared before use.\n");
+// If the symbol is defined in the local but not the
+// global scope, then use the local value as the
+// initial value.  This value will also override any
+// initializer in the global statement.
+octave_value global_val = m_evaluator.global_varval (nm);
+if (global_val.is_defined ())
+{
+warning_with_id ("Octave:global-local-conflict",
+"global: global value overrides existing local value");
+clear (sym);
+}
+else
+{
+warning_with_id ("Octave:global-local-conflict",
+"global: existing local value used to initialize global variable");
+m_evaluator.global_varref (nm) = val;
+}
+}
+mark_global (sym);
+}
+if (value.is_defined ())
+assign (sym, value);
+}
+octave_value stack_frame::varval (std::size_t) const
+{
+// This function should only be called for user_fcn_stack_frame or
+// scope_stack_frame objects.  Anything else indicates an error in
+// the implementation.
+panic_impossible ();
+}
+octave_value& stack_frame::varref (std::size_t)
+{
+// This function should only be called for user_fcn_stack_frame or
+// scope_stack_frame objects.  Anything else indicates an error in
+// the implementation.
+panic_impossible ();
+}
+void stack_frame::clear_objects (void)
+{
+symbol_cleaner sc (true, true);
+accept (sc);
+}
+void stack_frame::clear_variable (const std::string& name)
+{
+symbol_cleaner sc (name);
+accept (sc);
+}
+void stack_frame::clear_variable_pattern (const std::string& pattern)
+{
+symbol_cleaner sc (pattern);
+accept (sc);
+}
+void stack_frame::clear_variable_pattern (const string_vector& patterns)
+{
+symbol_cleaner sc (patterns);
+accept (sc);
+}
+void stack_frame::clear_variable_regexp (const std::string& pattern)
+{
+symbol_cleaner sc (pattern, true);
+accept (sc);
+}
+void stack_frame::clear_variable_regexp (const string_vector& patterns)
+{
+symbol_cleaner sc (patterns, true);
+accept (sc);
+}
+void stack_frame::clear_variables (void)
+{
+symbol_cleaner sc;
+accept (sc);
+}
+void stack_frame::display_stopped_in_message (std::ostream& os) const
+{
+if (index () == 0)
+os << "at top level" << std::endl;
+else
+{
+os << "stopped in " << fcn_name ();
+int l = line ();
+if (l > 0)
+os << " at line " << line ();
+os << " [" << fcn_file_name () << "] " << std::endl;
+}
+}
+void stack_frame::display (bool follow) const
+{
+std::ostream& os = octave_stdout;
+os << "-- [stack_frame] (" << this << ") --" << std::endl;
+os << "parent link: ";
+if (m_parent_link)
+os << m_parent_link.get ();
+else
+os << "NULL";
+os << std::endl;
+os << "static link: ";
+if (m_static_link)
+os << m_static_link.get ();
+else
+os << "NULL";
+os << std::endl;
+os << "access link: ";
+if (m_access_link)
+os << m_access_link.get ();
+else
+os << "NULL";
+os << std::endl;
+os << "line: " << m_line << std::endl;
+os << "column: " << m_column << std::endl;
+os << "index: " << m_index << std::endl;
+os << std::endl;
+if (! follow)
+return;
+os << "FOLLOWING ACCESS LINKS:" << std::endl;
+std::shared_ptr<stack_frame> frm = access_link ();
+while (frm)
+{
+frm->display (false);
+os << std::endl;
+frm = frm->access_link ();
+}
+}
+void compiled_fcn_stack_frame::display (bool follow) const
+{
+std::ostream& os = octave_stdout;
+os << "-- [compiled_fcn_stack_frame] (" << this << ") --" << std::endl;
+stack_frame::display (follow);
+os << "fcn: " << m_fcn->name ()
+<< " (" << m_fcn->type_name () << ")" << std::endl;
+}
+void compiled_fcn_stack_frame::accept (stack_frame_walker& sfw)
+{
+sfw.visit_compiled_fcn_stack_frame (*this);
+}
+script_stack_frame::script_stack_frame (tree_evaluator& tw,
+octave_user_script *script,
+std::size_t index,
+const std::shared_ptr<stack_frame>& parent_link,
+const std::shared_ptr<stack_frame>& static_link)
+: stack_frame (tw, index, parent_link, static_link,
+get_access_link (static_link)),
+m_script (script), m_unwind_protect_frame (nullptr),
+m_lexical_frame_offsets (get_num_symbols (script), 1),
+m_value_offsets (get_num_symbols (script), 0)
+{
+set_script_offsets ();
+}
+std::size_t script_stack_frame::get_num_symbols (octave_user_script *script)
+{
+symbol_scope script_scope = script->scope ();
+return script_scope.num_symbols ();
+}
+void script_stack_frame::set_script_offsets (void)
+{
+// Set frame and data offsets inside stack frame based on enclosing
+// scope(s).
+symbol_scope script_scope = m_script->scope ();
+std::size_t num_script_symbols = script_scope.num_symbols ();
+resize (num_script_symbols);
+const std::map<std::string, symbol_record>& script_symbols
+= script_scope.symbols ();
+set_script_offsets_internal (script_symbols);
+}
+void script_stack_frame::set_script_offsets_internal
+(const std::map<std::string, symbol_record>& script_symbols)
+{
+// This scope will be used to evaluate the script.  Find (or
+// possibly insert) symbols from the dummy script scope here.
+symbol_scope eval_scope = m_access_link->get_scope ();
+if (eval_scope.is_nested ())
+{
+bool found = false;
+for (const auto& nm_sr : script_symbols)
+{
+std::string name = nm_sr.first;
+symbol_record script_sr = nm_sr.second;
+symbol_scope parent_scope = eval_scope;
+std::size_t count = 1;
+while (parent_scope)
+{
+const std::map<std::string, symbol_record>& parent_scope_symbols
+= parent_scope.symbols ();
+auto p = parent_scope_symbols.find (name);
+if (p != parent_scope_symbols.end ())
+{
+found = true;
+symbol_record parent_scope_sr = p->second;
+std::size_t script_sr_data_offset = script_sr.data_offset ();
+m_lexical_frame_offsets.at (script_sr_data_offset)
+= parent_scope_sr.frame_offset () + count;
+m_value_offsets.at (script_sr_data_offset)
+= parent_scope_sr.data_offset ();
+break;
+}
+else
+{
+count++;
+parent_scope = parent_scope.parent_scope ();
+}
+}
+if (! found)
+error ("symbol '%s' cannot be added to static scope",
+name.c_str ());
+}
+}
+else
+{
+const std::map<std::string, symbol_record>& eval_scope_symbols
+= eval_scope.symbols ();
+for (const auto& nm_sr : script_symbols)
+{
+std::string name = nm_sr.first;
+symbol_record script_sr = nm_sr.second;
+auto p = eval_scope_symbols.find (name);
+symbol_record eval_scope_sr;
+if (p == eval_scope_symbols.end ())
+eval_scope_sr = eval_scope.insert (name);
+else
+eval_scope_sr = p->second;
+std::size_t script_sr_data_offset = script_sr.data_offset ();
+// The +1 is for going from the script frame to the eval
+// frame.  Only one access_link should need to be followed.
+m_lexical_frame_offsets.at (script_sr_data_offset)
+= eval_scope_sr.frame_offset () + 1;
+m_value_offsets.at (script_sr_data_offset)
+= eval_scope_sr.data_offset ();
+}
+}
+}
+void script_stack_frame::resize_and_update_script_offsets (const symbol_record& sym)
+{
+std::size_t data_offset = sym.data_offset ();
+// This function is called when adding new symbols to a script
+// scope.  If the symbol wasn't present before, it should be outside
+// the range so we need to resize then update offsets.
+panic_unless (data_offset >= size ());
+resize (data_offset+1);
+// FIXME: We should be able to avoid creating the map object and the
+// looping in the set_scripts_offsets_internal function.  Can we do
+// that without (or with minimal) code duplication?
+std::map<std::string, symbol_record> tmp_symbols;
+tmp_symbols[sym.name ()] = sym;
+set_script_offsets_internal (tmp_symbols);
+}
+// If this is a nested scope, set access_link to nearest parent
+// stack frame that corresponds to the lexical parent of this scope.
+std::shared_ptr<stack_frame>
+script_stack_frame::get_access_link (const std::shared_ptr<stack_frame>& static_link)
+{
+// If this script is called from another script, set access
+// link to ultimate parent stack frame.
+std::shared_ptr<stack_frame> alink = static_link;
+while (alink->is_user_script_frame ())
+{
+if (alink->access_link ())
+alink = alink->access_link ();
+else
+break;
+}
+return alink;
+}
+unwind_protect *script_stack_frame::unwind_protect_frame (void)
+{
+if (! m_unwind_protect_frame)
+m_unwind_protect_frame = new unwind_protect ();
+return m_unwind_protect_frame;
+}
+symbol_record script_stack_frame::lookup_symbol (const std::string& name) const
+{
+symbol_scope scope = get_scope ();
+symbol_record sym = scope.lookup_symbol (name);
+if (sym)
+{
+panic_unless (sym.frame_offset () == 0);
+return sym;
+}
+sym = m_access_link->lookup_symbol (name);
+// Return symbol record with adjusted frame offset.
+symbol_record new_sym = sym.dup ();
+new_sym.set_frame_offset (sym.frame_offset () + 1);
+return new_sym;
+}
+symbol_record script_stack_frame::insert_symbol (const std::string& name)
+{
+// If the symbols is already in the immediate scope, there is
+// nothing more to do.
+symbol_scope scope = get_scope ();
+symbol_record sym = scope.lookup_symbol (name);
+if (sym)
+{
+// All symbol records in a script scope should have zero offset,
+// which means we redirect our lookup using
+// lexical_frame_offsets and values_offets.
+panic_unless (sym.frame_offset () == 0);
+return sym;
+}
+// Insert the symbol in the current scope then resize and update
+// offsets.  This operation should never fail.
+sym = scope.find_symbol (name);
+panic_unless (sym.is_valid ());
+resize_and_update_script_offsets (sym);
+return sym;
+}
+// Similar to set_script_offsets_internal except that we only return
+// frame and data offsets for symbols found by name in parent scopes
+// instead of updating the offsets stored in the script frame itself.
+bool
+script_stack_frame::get_val_offsets_internal (const symbol_record& script_sr,
+std::size_t& frame_offset,
+std::size_t& data_offset) const
+{
+bool found = false;
+// This scope will be used to evaluate the script.  Find symbols
+// here by name.
+symbol_scope eval_scope = m_access_link->get_scope ();
+if (eval_scope.is_nested ())
+{
+std::string name = script_sr.name ();
+symbol_scope parent_scope = eval_scope;
+std::size_t count = 1;
+while (parent_scope)
+{
+const std::map<std::string, symbol_record>& parent_scope_symbols
+= parent_scope.symbols ();
+auto p = parent_scope_symbols.find (name);
+if (p != parent_scope_symbols.end ())
+{
+found = true;
+symbol_record parent_scope_sr = p->second;
+frame_offset = parent_scope_sr.frame_offset () + count;
+data_offset = parent_scope_sr.data_offset ();
+break;
+}
+else
+{
+count++;
+parent_scope = parent_scope.parent_scope ();
+}
+}
+}
+else
+{
+const std::map<std::string, symbol_record>& eval_scope_symbols
+= eval_scope.symbols ();
+std::string name = script_sr.name ();
+auto p = eval_scope_symbols.find (name);
+symbol_record eval_scope_sr;
+if (p != eval_scope_symbols.end ())
+{
+found = true;
+eval_scope_sr = p->second;
+// The +1 is for going from the script frame to the eval
+// frame.  Only one access_link should need to be followed.
+frame_offset = eval_scope_sr.frame_offset () + 1;
+data_offset = eval_scope_sr.data_offset ();
+}
+}
+return found;
+}
+bool script_stack_frame::get_val_offsets (const symbol_record& sym,
+std::size_t& frame_offset,
+std::size_t& data_offset) const
+{
+data_offset = sym.data_offset ();
+frame_offset = sym.frame_offset ();
+if (frame_offset == 0)
+{
+// An out of range data_offset value here means that we have a
+// symbol that was not originally in the script.  But this
+// function is called in places where we can't insert a new
+// symbol, so we fail and it is up to the caller to decide what
+// to do.
+if (data_offset >= size ())
+return get_val_offsets_internal (sym, frame_offset, data_offset);
+// Use frame and value offsets stored in this stack frame,
+// indexed by data_offset from the symbol_record to find the
+// values.  These offsets were determined by
+// script_stack_frame::set_script_offsets when this script was
+// invoked.
+frame_offset = m_lexical_frame_offsets.at (data_offset);
+if (frame_offset == 0)
+{
+// If the frame offset stored in m_lexical_frame_offsets is
+// zero, then the data offset in the evaluation scope has
+// not been determined so try to do that now.  The symbol
+// may have been added by eval and without calling
+// resize_and_update_script_offsets.
+return get_val_offsets_internal (sym, frame_offset, data_offset);
+}
+data_offset = m_value_offsets.at (data_offset);
+}
+else
+{
+// If frame_offset is not zero, then then we must have a symbol
+// that was not originally in the script.  The values should
+// have been determined by the script_stack_frame::lookup function.
+}
+return true;
+}
+void script_stack_frame::get_val_offsets_with_insert (const symbol_record& sym,
+std::size_t& frame_offset,
+std::size_t& data_offset)
+{
+data_offset = sym.data_offset ();
+frame_offset = sym.frame_offset ();
+if (frame_offset == 0)
+{
+if (data_offset >= size ())
+{
+// If the data_offset is out of range, then we must have a
+// symbol that was not originally in the script.  Resize and
+// update the offsets.
+resize_and_update_script_offsets (sym);
+}
+// Use frame and value offsets stored in this stack frame,
+// indexed by data_offset from the symbol_record to find the
+// values.  These offsets were determined by
+// script_stack_frame::set_script_offsets when this script was
+// invoked.
+frame_offset = m_lexical_frame_offsets.at (data_offset);
+if (frame_offset == 0)
+{
+// If the frame offset stored in m_lexical_frame_offsets is
+// zero, then the data offset in the evaluation scope has
+// not been determined so try to do that now.  The symbol
+// may have been added by eval and without calling
+// resize_and_update_script_offsets.
+// We don't need to resize here.  That case is handled above.
+// FIXME: We should be able to avoid creating the map object
+// and the looping in the set_scripts_offsets_internal
+// function.  Can we do that without (or with minimal) code
+// duplication?
+std::map<std::string, symbol_record> tmp_symbols;
+tmp_symbols[sym.name ()] = sym;
+set_script_offsets_internal (tmp_symbols);
+// set_script_offsets_internal may have modified
+// m_lexical_frame_offsets and m_value_offsets.
+frame_offset = m_lexical_frame_offsets.at (data_offset);
+}
+data_offset = m_value_offsets.at (data_offset);
+}
+else
+{
+// If frame_offset is not zero, then then we must have a symbol
+// that was not originally in the script.  The values were
+// determined by the script_stack_frame::lookup function.
+}
+}
+stack_frame::scope_flags
+script_stack_frame::scope_flag (const symbol_record& sym) const
+{
+std::size_t frame_offset;
+std::size_t data_offset;
+bool found = get_val_offsets (sym, frame_offset, data_offset);
+// It can't be global or persistent, so call it local.
+if (! found)
+return LOCAL;
+// Follow frame_offset access links to stack frame that holds
+// the value.
+const stack_frame *frame = this;
+for (std::size_t i = 0; i < frame_offset; i++)
+{
+std::shared_ptr<stack_frame> nxt = frame->access_link ();
+frame = nxt.get ();
+}
+if (! frame)
+error ("internal error: invalid access link in function call stack");
+if (data_offset >= frame->size ())
+return LOCAL;
+return frame->get_scope_flag (data_offset);
+}
+octave_value script_stack_frame::varval (const symbol_record& sym) const
+{
+std::size_t frame_offset;
+std::size_t data_offset;
+bool found = get_val_offsets (sym, frame_offset, data_offset);
+if (! found)
+return octave_value ();
+// Follow frame_offset access links to stack frame that holds
+// the value.
+const stack_frame *frame = this;
+for (std::size_t i = 0; i < frame_offset; i++)
+{
+std::shared_ptr<stack_frame> nxt = frame->access_link ();
+frame = nxt.get ();
+}
+if (! frame)
+error ("internal error: invalid access link in function call stack");
+if (data_offset >= frame->size ())
+return octave_value ();
+switch (frame->get_scope_flag (data_offset))
+{
+case LOCAL:
+return frame->varval (data_offset);
+case PERSISTENT:
 {
 symbol_scope scope = frame->get_scope ();
-symbol_record sym = scope.lookup_symbol (name);
+return scope.persistent_varval (data_offset);
-if (sym)
-return sym;
-std::shared_ptr<stack_frame> nxt = frame->access_link ();
-frame = nxt.get ();
 }
-return symbol_record ();
+case GLOBAL:
-}
+return m_evaluator.global_varval (sym.name ());
+}
-symbol_record user_fcn_stack_frame::insert_symbol (const std::string& name)
-{
+error ("internal error: invalid switch case");
-// If the symbols is already in the immediate scope, there is
+}
-// nothing more to do.
+octave_value& script_stack_frame::varref (const symbol_record& sym)
-symbol_scope scope = get_scope ();
+{
+std::size_t frame_offset;
-symbol_record sym = scope.lookup_symbol (name);
+std::size_t data_offset;
+get_val_offsets_with_insert (sym, frame_offset, data_offset);
-if (sym)
-return sym;
+// Follow frame_offset access links to stack frame that holds
+// the value.
-// FIXME: This needs some thought... We may need to add a symbol to
-// a static workspace, but the symbol can never be defined as a
+stack_frame *frame = this;
-// variable.  This currently works by tagging the added symbol as
-// "added_static".  Aside from the bad name, this doesn't seem like
+for (std::size_t i = 0; i < frame_offset; i++)
-// the best solution.  Maybe scopes should have a separate set of
+{
-// symbols that may only be defined as functions?
+std::shared_ptr<stack_frame> nxt = frame->access_link ();
+frame = nxt.get ();
-// Insert the symbol in the current scope.  This is not possible for
+}
-// anonymous functions, nested functions, or functions that contain
-// nested functions (their scopes will all be marked static).
+if (data_offset >= frame->size ())
+frame->resize (data_offset+1);
-//    if (scope.is_static ())
-//      error ("can not add variable '%s' to a static workspace",
+switch (frame->get_scope_flag (data_offset))
-//             name.c_str ());
+{
+case LOCAL:
-// At this point, non-local references are not possible so we only
+return frame->varref (data_offset);
-// need to look in the current scope and insert there.  This
-// operation should never fail.
+case PERSISTENT:
+{
-sym = scope.find_symbol (name);
+symbol_scope scope = frame->get_scope ();
-panic_unless (sym.is_valid ());
+return scope.persistent_varref (data_offset);
+}
+case GLOBAL:
+return m_evaluator.global_varref (sym.name ());
+}
+error ("internal error: invalid switch case");
+}
+void script_stack_frame::mark_scope (const symbol_record& sym,
+scope_flags flag)
+{
+std::size_t data_offset = sym.data_offset ();
+if (data_offset >= size ())
+resize_and_update_script_offsets (sym);
+// Redirection to evaluation context for the script.
+std::size_t frame_offset = m_lexical_frame_offsets.at (data_offset);
+data_offset = m_value_offsets.at (data_offset);
+if (frame_offset > 1)
+error ("variables must be made PERSISTENT or GLOBAL in the first scope in which they are used");
+std::shared_ptr<stack_frame> frame = access_link ();
+if (data_offset >= frame->size ())
+frame->resize (data_offset+1);
+frame->set_scope_flag (data_offset, flag);
+}
+void script_stack_frame::display (bool follow) const
+{
+std::ostream& os = octave_stdout;
+os << "-- [script_stack_frame] (" << this << ") --" << std::endl;
+stack_frame::display (follow);
+os << "script: " << m_script->name ()
+<< " (" << m_script->type_name () << ")" << std::endl;
+os << "lexical_offsets: " << m_lexical_frame_offsets.size ()
+<< " elements:";
+for (std::size_t i = 0; i < m_lexical_frame_offsets.size (); i++)
+os << "  " << m_lexical_frame_offsets.at (i);
+os << std::endl;
+os << "value_offsets: " << m_value_offsets.size () << " elements:";
+for (std::size_t i = 0; i < m_value_offsets.size (); i++)
+os << "  " << m_value_offsets.at (i);
+os << std::endl;
+display_scope (os, get_scope ());
+}
+void script_stack_frame::accept (stack_frame_walker& sfw)
+{
+sfw.visit_script_stack_frame (*this);
+}
+void base_value_stack_frame::display (bool follow) const
+{
+std::ostream& os = octave_stdout;
+os << "-- [base_value_stack_frame] (" << this << ") --" << std::endl;
+stack_frame::display (follow);
+os << "values: " << m_values.size ()
+<< " elements (idx, scope flag, type):" << std::endl;
+for (std::size_t i = 0; i < m_values.size (); i++)
+{
+os << "  (" << i << ", " << m_flags.at (i) << ", ";
+octave_value val = varval (i);
+os << (val.is_defined () ? val.type_name () : " UNDEFINED") << ")"
+<< std::endl;
+}
+}
+// If this is a nested scope, set access_link to nearest parent
+// stack frame that corresponds to the lexical parent of this scope.
+std::shared_ptr<stack_frame>
+user_fcn_stack_frame::get_access_link (octave_user_function *fcn,
+const std::shared_ptr<stack_frame>& static_link)
+{
+std::shared_ptr<stack_frame> alink;
+symbol_scope fcn_scope = fcn->scope ();
+if (fcn_scope.is_nested ())
+{
+if (! static_link)
+error ("internal call stack error (invalid static link)");
+symbol_scope caller_scope = static_link->get_scope ();
+int nesting_depth = fcn_scope.nesting_depth ();
+int caller_nesting_depth = caller_scope.nesting_depth ();
+if (caller_nesting_depth < nesting_depth)
+{
+// FIXME: do we need to ensure that the called
+// function is a child of the caller?  Does it hurt
+// to panic_unless this condition, at least for now?
+alink = static_link;
+}
+else
+{
+// FIXME: do we need to check that the parent of the
+// called function is also a parent of the caller?
+// Does it hurt to panic_unless this condition, at least
+// for now?
+int links_to_follow = caller_nesting_depth - nesting_depth + 1;
+alink = static_link;
+while (alink && --links_to_follow >= 0)
+alink = alink->access_link ();
+if (! alink)
+error ("internal function nesting error (invalid access link)");
+}
+}
+return alink;
+}
+void user_fcn_stack_frame::clear_values (void)
+{
+symbol_scope fcn_scope = m_fcn->scope ();
+const std::list<symbol_record>& symbols = fcn_scope.symbol_list ();
+if (size () == 0)
+return;
+for (const auto& sym : symbols)
+{
+std::size_t frame_offset = sym.frame_offset ();
+if (frame_offset > 0)
+continue;
+std::size_t data_offset = sym.data_offset ();
+if (data_offset >= size ())
+continue;
+if (get_scope_flag (data_offset) == LOCAL)
+{
+octave_value& ref = m_values.at (data_offset);
+if (ref.get_count () == 1)
+{
+ref.call_object_destructor ();
+ref = octave_value ();
+}
+}
+}
+}
+unwind_protect *user_fcn_stack_frame::unwind_protect_frame (void)
+{
+if (! m_unwind_protect_frame)
+m_unwind_protect_frame = new unwind_protect ();
+return m_unwind_protect_frame;
+}
+symbol_record user_fcn_stack_frame::lookup_symbol (const std::string& name) const
+{
+const stack_frame *frame = this;
+while (frame)
+{
+symbol_scope scope = frame->get_scope ();
+symbol_record sym = scope.lookup_symbol (name);
+if (sym)
+return sym;
+std::shared_ptr<stack_frame> nxt = frame->access_link ();
+frame = nxt.get ();
+}
+return symbol_record ();
+}
+symbol_record user_fcn_stack_frame::insert_symbol (const std::string& name)
+{
+// If the symbols is already in the immediate scope, there is
+// nothing more to do.
+symbol_scope scope = get_scope ();
+symbol_record sym = scope.lookup_symbol (name);
+if (sym)
 return sym;
-}
+// FIXME: This needs some thought... We may need to add a symbol to
-stack_frame::scope_flags
+// a static workspace, but the symbol can never be defined as a
-user_fcn_stack_frame::scope_flag (const symbol_record& sym) const
+// variable.  This currently works by tagging the added symbol as
-{
+// "added_static".  Aside from the bad name, this doesn't seem like
-std::size_t frame_offset = sym.frame_offset ();
+// the best solution.  Maybe scopes should have a separate set of
-std::size_t data_offset = sym.data_offset ();
+// symbols that may only be defined as functions?
-// Follow frame_offset access links to stack frame that holds
+// Insert the symbol in the current scope.  This is not possible for
-// the value.
+// anonymous functions, nested functions, or functions that contain
+// nested functions (their scopes will all be marked static).
-const stack_frame *frame = this;
+//    if (scope.is_static ())
-for (std::size_t i = 0; i < frame_offset; i++)
+//      error ("can not add variable '%s' to a static workspace",
+//             name.c_str ());
+// At this point, non-local references are not possible so we only
+// need to look in the current scope and insert there.  This
+// operation should never fail.
+sym = scope.find_symbol (name);
+panic_unless (sym.is_valid ());
+return sym;
+}
+stack_frame::scope_flags
+user_fcn_stack_frame::scope_flag (const symbol_record& sym) const
+{
+std::size_t frame_offset = sym.frame_offset ();
+std::size_t data_offset = sym.data_offset ();
+// Follow frame_offset access links to stack frame that holds
+// the value.
+const stack_frame *frame = this;
+for (std::size_t i = 0; i < frame_offset; i++)
+{
+std::shared_ptr<stack_frame> nxt = frame->access_link ();
+frame = nxt.get ();
+}
+if (! frame)
+error ("internal error: invalid access link in function call stack");
+if (data_offset >= frame->size ())
+return LOCAL;
+return frame->get_scope_flag (data_offset);
+}
+octave_value user_fcn_stack_frame::varval (const symbol_record& sym) const
+{
+std::size_t frame_offset = sym.frame_offset ();
+std::size_t data_offset = sym.data_offset ();
+// Follow frame_offset access links to stack frame that holds
+// the value.
+const stack_frame *frame = this;
+for (std::size_t i = 0; i < frame_offset; i++)
+{
+std::shared_ptr<stack_frame> nxt = frame->access_link ();
+frame = nxt.get ();
+}
+if (! frame)
+error ("internal error: invalid access link in function call stack");
+if (data_offset >= frame->size ())
+return octave_value ();
+switch (frame->get_scope_flag (data_offset))
+{
+case LOCAL:
+return frame->varval (data_offset);
+case PERSISTENT:
 {
-std::shared_ptr<stack_frame> nxt = frame->access_link ();
+symbol_scope scope = frame->get_scope ();
-frame = nxt.get ();
+return scope.persistent_varval (data_offset);
 }
-if (! frame)
+case GLOBAL:
-error ("internal error: invalid access link in function call stack");
+return m_evaluator.global_varval (sym.name ());
+}
-if (data_offset >= frame->size ())
-return LOCAL;
+error ("internal error: invalid switch case");
+}
-return frame->get_scope_flag (data_offset);
-}
+octave_value& user_fcn_stack_frame::varref (const symbol_record& sym)
+{
-octave_value user_fcn_stack_frame::varval (const symbol_record& sym) const
+std::size_t frame_offset = sym.frame_offset ();
-{
+std::size_t data_offset = sym.data_offset ();
-std::size_t frame_offset = sym.frame_offset ();
-std::size_t data_offset = sym.data_offset ();
+// Follow frame_offset access links to stack frame that holds
+// the value.
-// Follow frame_offset access links to stack frame that holds
-// the value.
+stack_frame *frame = this;
-const stack_frame *frame = this;
+for (std::size_t i = 0; i < frame_offset; i++)
+{
-for (std::size_t i = 0; i < frame_offset; i++)
+std::shared_ptr<stack_frame> nxt = frame->access_link ();
+frame = nxt.get ();
+}
+if (data_offset >= frame->size ())
+frame->resize (data_offset+1);
+switch (frame->get_scope_flag (data_offset))
+{
+case LOCAL:
+return frame->varref (data_offset);
+case PERSISTENT:
 {
-std::shared_ptr<stack_frame> nxt = frame->access_link ();
+symbol_scope scope = frame->get_scope ();
-frame = nxt.get ();
+return scope.persistent_varref (data_offset);
 }
-if (! frame)
+case GLOBAL:
-error ("internal error: invalid access link in function call stack");
+return m_evaluator.global_varref (sym.name ());
+}
-if (data_offset >= frame->size ())
-return octave_value ();
+error ("internal error: invalid switch case");
+}
-switch (frame->get_scope_flag (data_offset))
-{
+void user_fcn_stack_frame::mark_scope (const symbol_record& sym, scope_flags flag)
-case LOCAL:
+{
-return frame->varval (data_offset);
+std::size_t frame_offset = sym.frame_offset ();
-case PERSISTENT:
+if (frame_offset > 0 && (flag == PERSISTENT || flag == GLOBAL))
-{
+error ("variables must be made PERSISTENT or GLOBAL in the first scope in which they are used");
-symbol_scope scope = frame->get_scope ();
+std::size_t data_offset = sym.data_offset ();
-return scope.persistent_varval (data_offset);
-}
+if (data_offset >= size ())
+resize (data_offset+1);
-case GLOBAL:
-return m_evaluator.global_varval (sym.name ());
+set_scope_flag (data_offset, flag);
 }
-error ("internal error: invalid switch case");
+void user_fcn_stack_frame::display (bool follow) const
-}
+{
+std::ostream& os = octave_stdout;
-octave_value& user_fcn_stack_frame::varref (const symbol_record& sym)
-{
+os << "-- [user_fcn_stack_frame] (" << this << ") --" << std::endl;
-std::size_t frame_offset = sym.frame_offset ();
+base_value_stack_frame::display (follow);
-std::size_t data_offset = sym.data_offset ();
+os << "fcn: " << m_fcn->name ()
-// Follow frame_offset access links to stack frame that holds
+<< " (" << m_fcn->type_name () << ")" << std::endl;
-// the value.
+display_scope (os, get_scope ());
-stack_frame *frame = this;
+}
-for (std::size_t i = 0; i < frame_offset; i++)
+void user_fcn_stack_frame::accept (stack_frame_walker& sfw)
 {
-std::shared_ptr<stack_frame> nxt = frame->access_link ();
+sfw.visit_user_fcn_stack_frame (*this);
-frame = nxt.get ();
+}
-}
+void user_fcn_stack_frame::break_closure_cycles (const std::shared_ptr<stack_frame>& frame)
-if (data_offset >= frame->size ())
+{
-frame->resize (data_offset+1);
+for (auto& val : m_values)
+val.break_closure_cycles (frame);
-switch (frame->get_scope_flag (data_offset))
-{
+if (m_access_link)
-case LOCAL:
+m_access_link->break_closure_cycles (frame);
-return frame->varref (data_offset);
+}
-case PERSISTENT:
+symbol_record scope_stack_frame::insert_symbol (const std::string& name)
 {
-symbol_scope scope = frame->get_scope ();
+// There is no access link for scope frames, so there is no other
+// frame to search in and the offset must be zero.
-return scope.persistent_varref (data_offset);
-}
+symbol_record sym = m_scope.lookup_symbol (name);
-case GLOBAL:
+if (sym)
-return m_evaluator.global_varref (sym.name ());
-}
-error ("internal error: invalid switch case");
-}
-void user_fcn_stack_frame::mark_scope (const symbol_record& sym, scope_flags flag)
-{
-std::size_t frame_offset = sym.frame_offset ();
-if (frame_offset > 0 && (flag == PERSISTENT || flag == GLOBAL))
-error ("variables must be made PERSISTENT or GLOBAL in the first scope in which they are used");
-std::size_t data_offset = sym.data_offset ();
-if (data_offset >= size ())
-resize (data_offset+1);
-set_scope_flag (data_offset, flag);
-}
-void user_fcn_stack_frame::display (bool follow) const
-{
-std::ostream& os = octave_stdout;
-os << "-- [user_fcn_stack_frame] (" << this << ") --" << std::endl;
-base_value_stack_frame::display (follow);
-os << "fcn: " << m_fcn->name ()
-<< " (" << m_fcn->type_name () << ")" << std::endl;
-display_scope (os, get_scope ());
-}
-void user_fcn_stack_frame::accept (stack_frame_walker& sfw)
-{
-sfw.visit_user_fcn_stack_frame (*this);
-}
-void user_fcn_stack_frame::break_closure_cycles (const std::shared_ptr<stack_frame>& frame)
-{
-for (auto& val : m_values)
-val.break_closure_cycles (frame);
-if (m_access_link)
-m_access_link->break_closure_cycles (frame);
-}
-symbol_record scope_stack_frame::insert_symbol (const std::string& name)
-{
-// There is no access link for scope frames, so there is no other
-// frame to search in and the offset must be zero.
-symbol_record sym = m_scope.lookup_symbol (name);
-if (sym)
-return sym;
-// If the symbol is not found, insert it.  We only need to search in
-// the local scope object.  This operation should never fail.
-sym = m_scope.find_symbol (name);
-panic_unless (sym.is_valid ());
 return sym;
-}
+// If the symbol is not found, insert it.  We only need to search in
-stack_frame::scope_flags
+// the local scope object.  This operation should never fail.
-scope_stack_frame::scope_flag (const symbol_record& sym) const
-{
+sym = m_scope.find_symbol (name);
-// There is no access link for scope frames, so the frame
-// offset must be zero.
+panic_unless (sym.is_valid ());
-std::size_t data_offset = sym.data_offset ();
+return sym;
+}
-if (data_offset >= size ())
-return LOCAL;
+stack_frame::scope_flags
+scope_stack_frame::scope_flag (const symbol_record& sym) const
-return get_scope_flag (data_offset);
+{
-}
+// There is no access link for scope frames, so the frame
+// offset must be zero.
-octave_value scope_stack_frame::varval (const symbol_record& sym) const
-{
+std::size_t data_offset = sym.data_offset ();
-// There is no access link for scope frames, so the frame
-// offset must be zero.
+if (data_offset >= size ())
+return LOCAL;
-std::size_t data_offset = sym.data_offset ();
+return get_scope_flag (data_offset);
-if (data_offset >= size ())
+}
-return octave_value ();
+octave_value scope_stack_frame::varval (const symbol_record& sym) const
-switch (get_scope_flag (data_offset))
+{
-{
+// There is no access link for scope frames, so the frame
-case LOCAL:
+// offset must be zero.
-return m_values.at (data_offset);
+std::size_t data_offset = sym.data_offset ();
-case PERSISTENT:
-return m_scope.persistent_varval (data_offset);
+if (data_offset >= size ())
+return octave_value ();
-case GLOBAL:
-return m_evaluator.global_varval (sym.name ());
+switch (get_scope_flag (data_offset))
-}
+{
+case LOCAL:
-error ("internal error: invalid switch case");
+return m_values.at (data_offset);
-}
+case PERSISTENT:
-octave_value& scope_stack_frame::varref (const symbol_record& sym)
+return m_scope.persistent_varval (data_offset);
-{
-// There is no access link for scope frames, so the frame
+case GLOBAL:
-// offset must be zero.
+return m_evaluator.global_varval (sym.name ());
+}
-std::size_t data_offset = sym.data_offset ();
+error ("internal error: invalid switch case");
-if (data_offset >= size ())
+}
-resize (data_offset+1);
+octave_value& scope_stack_frame::varref (const symbol_record& sym)
-switch (get_scope_flag (data_offset))
+{
-{
+// There is no access link for scope frames, so the frame
-case LOCAL:
+// offset must be zero.
-return m_values.at (data_offset);
+std::size_t data_offset = sym.data_offset ();
-case PERSISTENT:
-return m_scope.persistent_varref (data_offset);
+if (data_offset >= size ())
+resize (data_offset+1);
-case GLOBAL:
-return m_evaluator.global_varref (sym.name ());
+switch (get_scope_flag (data_offset))
-}
+{
+case LOCAL:
-error ("internal error: invalid switch case");
+return m_values.at (data_offset);
-}
+case PERSISTENT:
-void scope_stack_frame::mark_scope (const symbol_record& sym,
+return m_scope.persistent_varref (data_offset);
-scope_flags flag)
-{
+case GLOBAL:
-// There is no access link for scope frames, so the frame
+return m_evaluator.global_varref (sym.name ());
-// offset must be zero.
+}
-std::size_t data_offset = sym.data_offset ();
+error ("internal error: invalid switch case");
+}
-if (data_offset >= size ())
-resize (data_offset+1);
+void scope_stack_frame::mark_scope (const symbol_record& sym,
+scope_flags flag)
-set_scope_flag (data_offset, flag);
+{
-}
+// There is no access link for scope frames, so the frame
+// offset must be zero.
-void scope_stack_frame::display (bool follow) const
-{
+std::size_t data_offset = sym.data_offset ();
-std::ostream& os = octave_stdout;
+if (data_offset >= size ())
-os << "-- [scope_stack_frame] (" << this << ") --" << std::endl;
+resize (data_offset+1);
-base_value_stack_frame::display (follow);
+set_scope_flag (data_offset, flag);
-display_scope (os, m_scope);
+}
-}
+void scope_stack_frame::display (bool follow) const
-void scope_stack_frame::accept (stack_frame_walker& sfw)
+{
-{
+std::ostream& os = octave_stdout;
-sfw.visit_scope_stack_frame (*this);
-}
+os << "-- [scope_stack_frame] (" << this << ") --" << std::endl;
+base_value_stack_frame::display (follow);
+display_scope (os, m_scope);
+}
+void scope_stack_frame::accept (stack_frame_walker& sfw)
+{
+sfw.visit_scope_stack_frame (*this);
+}
 OCTAVE_END_NAMESPACE(octave)

Mercurial > octave

comparison libinterp/corefcn/stack-frame.cc @ 31607:aac27ad79be6 stable