Mercurial > octave
annotate libinterp/octave-value/ov-struct.h @ 29476:c74ff452e2bb stable
avoid memory leaks when returning handles to nested functions
When a handle to a nested function is created with a std::shared_ptr
object holding a reference to the stack frames associated with the
parent function, we create a circular reference because the referenced
stack frame contains the function handle object. To break the link,
we'll scan the stack frame associated with the nested function handle
and convert the shared_ptr links to be weak_ptr links instead,
breaking the circular reference allowing the resources held by the
closure frames to be released when all external references are cleared.
Another possible solution to this problem is to create weak_ptr links
initially and then convert them to shared_ptr links when the closure
"escapes" the scope of the function. While that might be slightly
more efficient (we would only have to look at assignments to global
variables and the values that are actually returned from the
function) the current design of global assignments does not make that
easy because it is possible to ask for a reference to a global
variable, so either all places where we grab references and then later
perform assignments must be checked for assignments of handles to
nested functions, or we must eliminate the interface that returns
references to global variables and only allow assignments so that we
would only have to perform the check in the assignment function(s).
Perhaps this can be done in a future version, but for now, it works
well enough to break the closure cycles in local variables when a
function returns.
* call-stack.cc (call_stack::pop): If popped stack frame is a closure
context, then break closure cycles.
* stack-frame.h, stack-frame.cc (stack_frame::m_is_closure_context):
New member variable.
(stack_frame::break_closure_cycles,
user_fcn_stack_frame::break_closure_cycles): New functions.
(stack_frame::mark_closure_context, stack_frame::is_closure_context):
New functions.
* ov-fcn-handle.h, ov-fcn-handle.cc (base_nested_fcn_handle):
New base class for handles to nested functions.
(nested_fcn_handle, weak_nested_fcn_handle): New classes to represent
handles to nested functions. Currently, all handles to nested
functions begin as nested_fcn_handle objects but are converted to
weak_nested_fcn_handles when the functions where they are created
return.
(base_fcn_handle::is_nested (const std::shared_ptr<stack_frame>&) const,
base_fcn_handle::make_weak_nested_handle,
New virtual functions.
(octave_fcn_handle::is_nested, octave_fcn_handle::is_weak_nested,
octave_fcn_handle::make_weak_nested_handle): New functions.
* ov-struct.h, ov-struct.cc (octave_scalar_map::break_closure_cycles,
octave_map::break_closure_cycles): New functions.
* ov.h, ov.cc (octave_value::break_closure_cycles): New function.
* ov-base.h (octave_base_value::break_closure_cycles): New virtual function.
* cdef-object.h (cdef_object::break_closure_cycles): New function.
(cdef_object_rep::break_closure_cycles): New virtual function.
* cdef-object.h, cdef-object.cc (cdef_object_scalar::break_closure_cycles):
New function.
* ov-cell.h, ov-cell.cc (octave_cell::break_closure_cycles): New function.
* ov-class.h, ov-class.cc (octave_class::break_closure_cycles): New function.
* ov-classdef.h (octave_classdef::break_closure_cycles): New function.
author | John W. Eaton <jwe@octave.org> |
---|---|
date | Fri, 05 Mar 2021 16:14:34 -0500 |
parents | 0a5b15007766 |
children | e88444be8468 d13d090cb03a |
rev | line source |
---|---|
27923
bd51beb6205e
update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents:
27919
diff
changeset
|
1 //////////////////////////////////////////////////////////////////////// |
bd51beb6205e
update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents:
27919
diff
changeset
|
2 // |
29358
0a5b15007766
update Octave Project Developers copyright for the new year
John W. Eaton <jwe@octave.org>
parents:
27923
diff
changeset
|
3 // Copyright (C) 1996-2021 The Octave Project Developers |
27923
bd51beb6205e
update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents:
27919
diff
changeset
|
4 // |
bd51beb6205e
update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents:
27919
diff
changeset
|
5 // See the file COPYRIGHT.md in the top-level directory of this |
bd51beb6205e
update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents:
27919
diff
changeset
|
6 // distribution or <https://octave.org/copyright/>. |
bd51beb6205e
update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents:
27919
diff
changeset
|
7 // |
bd51beb6205e
update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents:
27919
diff
changeset
|
8 // This file is part of Octave. |
bd51beb6205e
update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents:
27919
diff
changeset
|
9 // |
bd51beb6205e
update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents:
27919
diff
changeset
|
10 // Octave is free software: you can redistribute it and/or modify it |
bd51beb6205e
update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents:
27919
diff
changeset
|
11 // under the terms of the GNU General Public License as published by |
bd51beb6205e
update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents:
27919
diff
changeset
|
12 // the Free Software Foundation, either version 3 of the License, or |
bd51beb6205e
update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents:
27919
diff
changeset
|
13 // (at your option) any later version. |
bd51beb6205e
update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents:
27919
diff
changeset
|
14 // |
bd51beb6205e
update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents:
27919
diff
changeset
|
15 // Octave is distributed in the hope that it will be useful, but |
bd51beb6205e
update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents:
27919
diff
changeset
|
16 // WITHOUT ANY WARRANTY; without even the implied warranty of |
bd51beb6205e
update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents:
27919
diff
changeset
|
17 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
bd51beb6205e
update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents:
27919
diff
changeset
|
18 // GNU General Public License for more details. |
bd51beb6205e
update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents:
27919
diff
changeset
|
19 // |
bd51beb6205e
update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents:
27919
diff
changeset
|
20 // You should have received a copy of the GNU General Public License |
bd51beb6205e
update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents:
27919
diff
changeset
|
21 // along with Octave; see the file COPYING. If not, see |
bd51beb6205e
update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents:
27919
diff
changeset
|
22 // <https://www.gnu.org/licenses/>. |
bd51beb6205e
update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents:
27919
diff
changeset
|
23 // |
bd51beb6205e
update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents:
27919
diff
changeset
|
24 //////////////////////////////////////////////////////////////////////// |
2376 | 25 |
20791
f7084eae3318
maint: Use Octave coding conventions for #if statements.
Rik <rik@octave.org>
parents:
19863
diff
changeset
|
26 #if ! defined (octave_ov_struct_h) |
17822
ebb3ef964372
maint: Use common #define syntax "octave_filename_h" in h_files.
Rik <rik@octave.org>
parents:
17787
diff
changeset
|
27 #define octave_ov_struct_h 1 |
2376 | 28 |
21244
1473547f50f5
include octave-config.h in public header files
John W. Eaton <jwe@octave.org>
parents:
20791
diff
changeset
|
29 #include "octave-config.h" |
1473547f50f5
include octave-config.h in public header files
John W. Eaton <jwe@octave.org>
parents:
20791
diff
changeset
|
30 |
2376 | 31 #include <cstdlib> |
32 | |
8950
d865363208d6
include <iosfwd> instead of <iostream> in header files
John W. Eaton <jwe@octave.org>
parents:
8920
diff
changeset
|
33 #include <iosfwd> |
2376 | 34 #include <string> |
35 | |
36 #include "mx-base.h" | |
37 #include "str-vec.h" | |
38 | |
39 #include "error.h" | |
40 #include "oct-map.h" | |
41 #include "ov-base.h" | |
42 #include "ov-typeinfo.h" | |
43 | |
44 class octave_value_list; | |
45 | |
2477 | 46 // Data structures. |
2376 | 47 |
48 class | |
49 octave_struct : public octave_base_value | |
50 { | |
51 public: | |
52 | |
53 octave_struct (void) | |
11584
cda4aa780d58
Another round of initialising members in the constructor initialisation list
Pascal Dupuis <Pascal.Dupuis@uclouvain.be>
parents:
11523
diff
changeset
|
54 : octave_base_value (), map () { } |
2376 | 55 |
10742
604e13a89c7f
initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
56 octave_struct (const octave_map& m) |
604e13a89c7f
initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
57 : octave_base_value (), map (m) { } |
604e13a89c7f
initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
58 |
2376 | 59 octave_struct (const octave_struct& s) |
60 : octave_base_value (), map (s.map) { } | |
61 | |
22868
87e3163f6c87
use c++11 "= default" syntax for declaration of trivial destructors
John W. Eaton <jwe@octave.org>
parents:
22755
diff
changeset
|
62 ~octave_struct (void) = default; |
2376 | 63 |
23446
cd4e1ee28716
maint: Use convention 'void * fcn ()' for functions which return pointers.
Rik <rik@octave.org>
parents:
23220
diff
changeset
|
64 octave_base_value * clone (void) const { return new octave_struct (*this); } |
cd4e1ee28716
maint: Use convention 'void * fcn ()' for functions which return pointers.
Rik <rik@octave.org>
parents:
23220
diff
changeset
|
65 octave_base_value * empty_clone (void) const { return new octave_struct (); } |
3933 | 66 |
29476
c74ff452e2bb
avoid memory leaks when returning handles to nested functions
John W. Eaton <jwe@octave.org>
parents:
29358
diff
changeset
|
67 void break_closure_cycles (const std::shared_ptr<octave::stack_frame>& frame); |
c74ff452e2bb
avoid memory leaks when returning handles to nested functions
John W. Eaton <jwe@octave.org>
parents:
29358
diff
changeset
|
68 |
23446
cd4e1ee28716
maint: Use convention 'void * fcn ()' for functions which return pointers.
Rik <rik@octave.org>
parents:
23220
diff
changeset
|
69 octave_base_value * try_narrowing_conversion (void); |
10742
604e13a89c7f
initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
70 |
9529
8e5009334661
partially revert e79470be3ecb
Jaroslav Hajek <highegg@gmail.com>
parents:
9522
diff
changeset
|
71 Cell dotref (const octave_value_list& idx, bool auto_add = false); |
2376 | 72 |
7651
443a8f5a50fd
require both subsref variants to be defined in octave_value subclasses
John W. Eaton <jwe@octave.org>
parents:
7622
diff
changeset
|
73 octave_value subsref (const std::string& type, |
10313 | 74 const std::list<octave_value_list>& idx) |
17787
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
75 { |
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
76 octave_value_list tmp = subsref (type, idx, 1); |
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
77 return tmp.length () > 0 ? tmp(0) : octave_value (); |
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
78 } |
7622
c195bd0a5c64
treat structs and cells as "constants"
John W. Eaton <jwe@octave.org>
parents:
7336
diff
changeset
|
79 |
c195bd0a5c64
treat structs and cells as "constants"
John W. Eaton <jwe@octave.org>
parents:
7336
diff
changeset
|
80 octave_value_list subsref (const std::string&, |
10313 | 81 const std::list<octave_value_list>&, int); |
4994 | 82 |
8551
906f976d35a8
further improve struct&cell indexing & indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
8546
diff
changeset
|
83 octave_value subsref (const std::string& type, |
10313 | 84 const std::list<octave_value_list>& idx, |
8551
906f976d35a8
further improve struct&cell indexing & indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
8546
diff
changeset
|
85 bool auto_add); |
906f976d35a8
further improve struct&cell indexing & indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
8546
diff
changeset
|
86 |
8546
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
7651
diff
changeset
|
87 static octave_value numeric_conv (const octave_value& val, |
10313 | 88 const std::string& type); |
2376 | 89 |
4247 | 90 octave_value subsasgn (const std::string& type, |
10313 | 91 const std::list<octave_value_list>& idx, |
92 const octave_value& rhs); | |
2376 | 93 |
7046 | 94 octave_value squeeze (void) const { return map.squeeze (); } |
95 | |
96 octave_value permute (const Array<int>& vec, bool inv = false) const | |
17787
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
97 { return map.permute (vec, inv); } |
7046 | 98 |
99 octave_value do_index_op (const octave_value_list& idx, | |
10313 | 100 bool resize_ok = false); |
7046 | 101 |
4563 | 102 dim_vector dims (void) const { return map.dims (); } |
4200 | 103 |
4791 | 104 size_t byte_size (void) const; |
105 | |
5900 | 106 // This is the number of elements in each field. The total number |
107 // of elements is numel () * nfields (). | |
108 octave_idx_type numel (void) const | |
109 { | |
10742
604e13a89c7f
initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
110 return map.numel (); |
5900 | 111 } |
112 | |
6639 | 113 octave_idx_type nfields (void) const { return map.nfields (); } |
5900 | 114 |
4567 | 115 octave_value reshape (const dim_vector& new_dims) const |
17787
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
116 { return map.reshape (new_dims); } |
4567 | 117 |
10754
92eb5fb58ebc
fix resize with structs
Jaroslav Hajek <highegg@gmail.com>
parents:
10742
diff
changeset
|
118 octave_value resize (const dim_vector& dv, bool fill = false) const |
17787
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
119 { octave_map tmap = map; tmap.resize (dv, fill); return tmap; } |
4936 | 120 |
2376 | 121 bool is_defined (void) const { return true; } |
122 | |
7622
c195bd0a5c64
treat structs and cells as "constants"
John W. Eaton <jwe@octave.org>
parents:
7336
diff
changeset
|
123 bool is_constant (void) const { return true; } |
c195bd0a5c64
treat structs and cells as "constants"
John W. Eaton <jwe@octave.org>
parents:
7336
diff
changeset
|
124 |
23584
7ed6b258db91
maint: Deprecate is_map and replace with isstruct.
Rik <rik@octave.org>
parents:
23446
diff
changeset
|
125 bool isstruct (void) const { return true; } |
2376 | 126 |
10087
090173f2db40
improve overload dispatching of built-in classes
Jaroslav Hajek <highegg@gmail.com>
parents:
9881
diff
changeset
|
127 builtin_type_t builtin_type (void) const { return btyp_struct; } |
090173f2db40
improve overload dispatching of built-in classes
Jaroslav Hajek <highegg@gmail.com>
parents:
9881
diff
changeset
|
128 |
10742
604e13a89c7f
initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
129 octave_map map_value (void) const { return map; } |
2376 | 130 |
10742
604e13a89c7f
initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
131 string_vector map_keys (void) const { return map.fieldnames (); } |
3933 | 132 |
18416
bcd71a2531d3
Support disp/display overloading in classdef
Michael Goffioul <michael.goffioul@gmail.com>
parents:
17822
diff
changeset
|
133 void print (std::ostream& os, bool pr_as_read_syntax = false); |
2901 | 134 |
3523 | 135 void print_raw (std::ostream& os, bool pr_as_read_syntax = false) const; |
2901 | 136 |
3523 | 137 bool print_name_tag (std::ostream& os, const std::string& name) const; |
2376 | 138 |
24668
d4dd741b2794
new octave_value functions for formatting output
John W. Eaton <jwe@octave.org>
parents:
24660
diff
changeset
|
139 std::string edit_display (const float_display_format& fmt, |
d4dd741b2794
new octave_value functions for formatting output
John W. Eaton <jwe@octave.org>
parents:
24660
diff
changeset
|
140 octave_idx_type i, octave_idx_type j) const; |
24660
a4ea36915e38
handle structure arrays in the variable editor
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
141 |
6974 | 142 bool save_ascii (std::ostream& os); |
4687 | 143 |
144 bool load_ascii (std::istream& is); | |
145 | |
26399
586413770c7f
pass save_as_floats by value in octave_value save_binary functions
John W. Eaton <jwe@octave.org>
parents:
26376
diff
changeset
|
146 bool save_binary (std::ostream& os, bool save_as_floats); |
4687 | 147 |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11584
diff
changeset
|
148 bool load_binary (std::istream& is, bool swap, |
21739
c4ab2e54f100
use namespace for oct_mach_info class
John W. Eaton <jwe@octave.org>
parents:
21244
diff
changeset
|
149 octave::mach_info::float_format fmt); |
4687 | 150 |
19863
09ed6f7538dd
avoid needing to include hdf5 in public header files (bug #44370, #43180)
John W. Eaton <jwe@octave.org> and Mike Miller <mtmiller@ieee.org>
parents:
19697
diff
changeset
|
151 bool save_hdf5 (octave_hdf5_id loc_id, const char *name, bool save_as_floats); |
4687 | 152 |
19863
09ed6f7538dd
avoid needing to include hdf5 in public header files (bug #44370, #43180)
John W. Eaton <jwe@octave.org> and Mike Miller <mtmiller@ieee.org>
parents:
19697
diff
changeset
|
153 bool load_hdf5 (octave_hdf5_id loc_id, const char *name); |
4687 | 154 |
23446
cd4e1ee28716
maint: Use convention 'void * fcn ()' for functions which return pointers.
Rik <rik@octave.org>
parents:
23220
diff
changeset
|
155 mxArray * as_mxArray (void) const; |
5900 | 156 |
10760
76079e505f9d
optimize cellfun with uniform struct output
Jaroslav Hajek <highegg@gmail.com>
parents:
10754
diff
changeset
|
157 octave_value |
76079e505f9d
optimize cellfun with uniform struct output
Jaroslav Hajek <highegg@gmail.com>
parents:
10754
diff
changeset
|
158 fast_elem_extract (octave_idx_type n) const; |
76079e505f9d
optimize cellfun with uniform struct output
Jaroslav Hajek <highegg@gmail.com>
parents:
10754
diff
changeset
|
159 |
76079e505f9d
optimize cellfun with uniform struct output
Jaroslav Hajek <highegg@gmail.com>
parents:
10754
diff
changeset
|
160 bool |
76079e505f9d
optimize cellfun with uniform struct output
Jaroslav Hajek <highegg@gmail.com>
parents:
10754
diff
changeset
|
161 fast_elem_insert (octave_idx_type n, const octave_value& x); |
76079e505f9d
optimize cellfun with uniform struct output
Jaroslav Hajek <highegg@gmail.com>
parents:
10754
diff
changeset
|
162 |
7336 | 163 protected: |
2376 | 164 |
2477 | 165 // The associative array used to manage the structure data. |
10742
604e13a89c7f
initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
166 octave_map map; |
2376 | 167 |
7336 | 168 private: |
169 | |
3219 | 170 DECLARE_OV_TYPEID_FUNCTIONS_AND_DATA |
2376 | 171 }; |
172 | |
10742
604e13a89c7f
initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
173 class |
604e13a89c7f
initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
174 octave_scalar_struct : public octave_base_value |
604e13a89c7f
initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
175 { |
604e13a89c7f
initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
176 public: |
604e13a89c7f
initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
177 |
604e13a89c7f
initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
178 octave_scalar_struct (void) |
11584
cda4aa780d58
Another round of initialising members in the constructor initialisation list
Pascal Dupuis <Pascal.Dupuis@uclouvain.be>
parents:
11523
diff
changeset
|
179 : octave_base_value (), map () { } |
10742
604e13a89c7f
initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
180 |
604e13a89c7f
initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
181 octave_scalar_struct (const octave_scalar_map& m) |
604e13a89c7f
initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
182 : octave_base_value (), map (m) { } |
604e13a89c7f
initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
183 |
23678
dcba41788495
new struct/map constructors
John W. Eaton <jwe@octave.org>
parents:
23584
diff
changeset
|
184 octave_scalar_struct (const std::map<std::string, octave_value>& m) |
dcba41788495
new struct/map constructors
John W. Eaton <jwe@octave.org>
parents:
23584
diff
changeset
|
185 : octave_base_value (), map (m) { } |
dcba41788495
new struct/map constructors
John W. Eaton <jwe@octave.org>
parents:
23584
diff
changeset
|
186 |
10742
604e13a89c7f
initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
187 octave_scalar_struct (const octave_scalar_struct& s) |
604e13a89c7f
initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
188 : octave_base_value (), map (s.map) { } |
604e13a89c7f
initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
189 |
22868
87e3163f6c87
use c++11 "= default" syntax for declaration of trivial destructors
John W. Eaton <jwe@octave.org>
parents:
22755
diff
changeset
|
190 ~octave_scalar_struct (void) = default; |
10742
604e13a89c7f
initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
191 |
23446
cd4e1ee28716
maint: Use convention 'void * fcn ()' for functions which return pointers.
Rik <rik@octave.org>
parents:
23220
diff
changeset
|
192 octave_base_value * clone (void) const |
17787
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
193 { return new octave_scalar_struct (*this); } |
23446
cd4e1ee28716
maint: Use convention 'void * fcn ()' for functions which return pointers.
Rik <rik@octave.org>
parents:
23220
diff
changeset
|
194 octave_base_value * empty_clone (void) const |
17787
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
195 { return new octave_scalar_struct (); } |
10742
604e13a89c7f
initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
196 |
29476
c74ff452e2bb
avoid memory leaks when returning handles to nested functions
John W. Eaton <jwe@octave.org>
parents:
29358
diff
changeset
|
197 void break_closure_cycles (const std::shared_ptr<octave::stack_frame>& frame); |
c74ff452e2bb
avoid memory leaks when returning handles to nested functions
John W. Eaton <jwe@octave.org>
parents:
29358
diff
changeset
|
198 |
10742
604e13a89c7f
initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
199 octave_value dotref (const octave_value_list& idx, bool auto_add = false); |
604e13a89c7f
initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
200 |
604e13a89c7f
initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
201 octave_value subsref (const std::string& type, |
604e13a89c7f
initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
202 const std::list<octave_value_list>& idx); |
604e13a89c7f
initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
203 |
604e13a89c7f
initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
204 octave_value_list subsref (const std::string& type, |
604e13a89c7f
initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
205 const std::list<octave_value_list>& idx, int); |
604e13a89c7f
initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
206 |
604e13a89c7f
initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
207 octave_value subsref (const std::string& type, |
604e13a89c7f
initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
208 const std::list<octave_value_list>& idx, |
604e13a89c7f
initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
209 bool auto_add); |
604e13a89c7f
initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
210 |
604e13a89c7f
initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
211 static octave_value numeric_conv (const octave_value& val, |
604e13a89c7f
initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
212 const std::string& type); |
604e13a89c7f
initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
213 |
604e13a89c7f
initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
214 octave_value subsasgn (const std::string& type, |
604e13a89c7f
initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
215 const std::list<octave_value_list>& idx, |
604e13a89c7f
initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
216 const octave_value& rhs); |
604e13a89c7f
initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
217 |
604e13a89c7f
initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
218 octave_value squeeze (void) const { return map; } |
604e13a89c7f
initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
219 |
604e13a89c7f
initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
220 octave_value permute (const Array<int>& vec, bool inv = false) const |
17787
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
221 { return octave_map (map).permute (vec, inv); } |
10742
604e13a89c7f
initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
222 |
604e13a89c7f
initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
223 octave_value do_index_op (const octave_value_list& idx, |
604e13a89c7f
initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
224 bool resize_ok = false); |
604e13a89c7f
initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
225 |
604e13a89c7f
initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
226 dim_vector dims (void) const { static dim_vector dv (1, 1); return dv; } |
604e13a89c7f
initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
227 |
604e13a89c7f
initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
228 size_t byte_size (void) const; |
604e13a89c7f
initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
229 |
604e13a89c7f
initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
230 // This is the number of elements in each field. The total number |
604e13a89c7f
initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
231 // of elements is numel () * nfields (). |
604e13a89c7f
initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
232 octave_idx_type numel (void) const |
604e13a89c7f
initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
233 { |
604e13a89c7f
initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
234 return 1; |
604e13a89c7f
initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
235 } |
604e13a89c7f
initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
236 |
604e13a89c7f
initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
237 octave_idx_type nfields (void) const { return map.nfields (); } |
604e13a89c7f
initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
238 |
604e13a89c7f
initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
239 octave_value reshape (const dim_vector& new_dims) const |
17787
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
240 { return octave_map (map).reshape (new_dims); } |
10742
604e13a89c7f
initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
241 |
10754
92eb5fb58ebc
fix resize with structs
Jaroslav Hajek <highegg@gmail.com>
parents:
10742
diff
changeset
|
242 octave_value resize (const dim_vector& dv, bool fill = false) const |
17787
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
243 { octave_map tmap = map; tmap.resize (dv, fill); return tmap; } |
10742
604e13a89c7f
initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
244 |
604e13a89c7f
initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
245 bool is_defined (void) const { return true; } |
604e13a89c7f
initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
246 |
604e13a89c7f
initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
247 bool is_constant (void) const { return true; } |
604e13a89c7f
initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
248 |
23584
7ed6b258db91
maint: Deprecate is_map and replace with isstruct.
Rik <rik@octave.org>
parents:
23446
diff
changeset
|
249 bool isstruct (void) const { return true; } |
10742
604e13a89c7f
initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
250 |
604e13a89c7f
initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
251 builtin_type_t builtin_type (void) const { return btyp_struct; } |
604e13a89c7f
initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
252 |
604e13a89c7f
initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
253 octave_map map_value (void) const { return map; } |
604e13a89c7f
initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
254 |
604e13a89c7f
initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
255 octave_scalar_map scalar_map_value (void) const { return map; } |
604e13a89c7f
initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
256 |
604e13a89c7f
initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
257 string_vector map_keys (void) const { return map.fieldnames (); } |
604e13a89c7f
initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
258 |
18416
bcd71a2531d3
Support disp/display overloading in classdef
Michael Goffioul <michael.goffioul@gmail.com>
parents:
17822
diff
changeset
|
259 void print (std::ostream& os, bool pr_as_read_syntax = false); |
10742
604e13a89c7f
initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
260 |
604e13a89c7f
initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
261 void print_raw (std::ostream& os, bool pr_as_read_syntax = false) const; |
604e13a89c7f
initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
262 |
604e13a89c7f
initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
263 bool print_name_tag (std::ostream& os, const std::string& name) const; |
604e13a89c7f
initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
264 |
24668
d4dd741b2794
new octave_value functions for formatting output
John W. Eaton <jwe@octave.org>
parents:
24660
diff
changeset
|
265 std::string edit_display (const float_display_format& fmt, |
d4dd741b2794
new octave_value functions for formatting output
John W. Eaton <jwe@octave.org>
parents:
24660
diff
changeset
|
266 octave_idx_type i, octave_idx_type j) const; |
24660
a4ea36915e38
handle structure arrays in the variable editor
John W. Eaton <jwe@octave.org>
parents:
24534
diff
changeset
|
267 |
10742
604e13a89c7f
initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
268 bool save_ascii (std::ostream& os); |
604e13a89c7f
initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
269 |
604e13a89c7f
initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
270 bool load_ascii (std::istream& is); |
604e13a89c7f
initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
271 |
26399
586413770c7f
pass save_as_floats by value in octave_value save_binary functions
John W. Eaton <jwe@octave.org>
parents:
26376
diff
changeset
|
272 bool save_binary (std::ostream& os, bool save_as_floats); |
10742
604e13a89c7f
initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
273 |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11584
diff
changeset
|
274 bool load_binary (std::istream& is, bool swap, |
21739
c4ab2e54f100
use namespace for oct_mach_info class
John W. Eaton <jwe@octave.org>
parents:
21244
diff
changeset
|
275 octave::mach_info::float_format fmt); |
10742
604e13a89c7f
initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
276 |
19863
09ed6f7538dd
avoid needing to include hdf5 in public header files (bug #44370, #43180)
John W. Eaton <jwe@octave.org> and Mike Miller <mtmiller@ieee.org>
parents:
19697
diff
changeset
|
277 bool save_hdf5 (octave_hdf5_id loc_id, const char *name, bool save_as_floats); |
10742
604e13a89c7f
initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
278 |
19863
09ed6f7538dd
avoid needing to include hdf5 in public header files (bug #44370, #43180)
John W. Eaton <jwe@octave.org> and Mike Miller <mtmiller@ieee.org>
parents:
19697
diff
changeset
|
279 bool load_hdf5 (octave_hdf5_id loc_id, const char *name); |
10742
604e13a89c7f
initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
280 |
23446
cd4e1ee28716
maint: Use convention 'void * fcn ()' for functions which return pointers.
Rik <rik@octave.org>
parents:
23220
diff
changeset
|
281 mxArray * as_mxArray (void) const; |
10742
604e13a89c7f
initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
282 |
10760
76079e505f9d
optimize cellfun with uniform struct output
Jaroslav Hajek <highegg@gmail.com>
parents:
10754
diff
changeset
|
283 bool fast_elem_insert_self (void *where, builtin_type_t btyp) const; |
76079e505f9d
optimize cellfun with uniform struct output
Jaroslav Hajek <highegg@gmail.com>
parents:
10754
diff
changeset
|
284 |
10742
604e13a89c7f
initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
285 protected: |
604e13a89c7f
initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
286 |
604e13a89c7f
initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
287 // The associative array used to manage the structure data. |
604e13a89c7f
initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
288 octave_scalar_map map; |
604e13a89c7f
initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
289 |
604e13a89c7f
initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
290 private: |
604e13a89c7f
initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
291 |
604e13a89c7f
initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
292 octave_value to_array (void); |
604e13a89c7f
initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
293 |
604e13a89c7f
initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
294 DECLARE_OV_TYPEID_FUNCTIONS_AND_DATA |
604e13a89c7f
initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
295 }; |
604e13a89c7f
initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
296 |
604e13a89c7f
initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
297 #endif |