|
1
|
1 /* |
|
|
2 |
|
7017
|
3 Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2002, |
|
|
4 2003, 2004, 2005, 2006, 2007 John W. Eaton |
|
1
|
5 |
|
|
6 This file is part of Octave. |
|
|
7 |
|
|
8 Octave is free software; you can redistribute it and/or modify it |
|
|
9 under the terms of the GNU General Public License as published by the |
|
7016
|
10 Free Software Foundation; either version 3 of the License, or (at your |
|
|
11 option) any later version. |
|
1
|
12 |
|
|
13 Octave is distributed in the hope that it will be useful, but WITHOUT |
|
|
14 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
|
|
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
|
|
16 for more details. |
|
|
17 |
|
|
18 You should have received a copy of the GNU General Public License |
|
7016
|
19 along with Octave; see the file COPYING. If not, see |
|
|
20 <http://www.gnu.org/licenses/>. |
|
1
|
21 |
|
|
22 */ |
|
|
23 |
|
240
|
24 #ifdef HAVE_CONFIG_H |
|
1192
|
25 #include <config.h> |
|
1
|
26 #endif |
|
|
27 |
|
1468
|
28 #include <cstdio> |
|
1343
|
29 #include <cstring> |
|
605
|
30 |
|
7336
|
31 #include <iomanip> |
|
4207
|
32 #include <set> |
|
1728
|
33 #include <string> |
|
|
34 |
|
2926
|
35 #include "file-stat.h" |
|
|
36 #include "oct-env.h" |
|
4604
|
37 #include "file-ops.h" |
|
2926
|
38 #include "glob-match.h" |
|
1755
|
39 #include "str-vec.h" |
|
|
40 |
|
2492
|
41 #include <defaults.h> |
|
4435
|
42 #include "Cell.h" |
|
1352
|
43 #include "defun.h" |
|
|
44 #include "dirfns.h" |
|
|
45 #include "error.h" |
|
2205
|
46 #include "gripes.h" |
|
1352
|
47 #include "help.h" |
|
3165
|
48 #include "input.h" |
|
1352
|
49 #include "lex.h" |
|
5832
|
50 #include "load-path.h" |
|
2926
|
51 #include "oct-map.h" |
|
|
52 #include "oct-obj.h" |
|
|
53 #include "ov.h" |
|
3933
|
54 #include "ov-usr-fcn.h" |
|
605
|
55 #include "pager.h" |
|
1352
|
56 #include "parse.h" |
|
2926
|
57 #include "symtab.h" |
|
2205
|
58 #include "toplev.h" |
|
1352
|
59 #include "unwind-prot.h" |
|
1
|
60 #include "utils.h" |
|
1352
|
61 #include "variables.h" |
|
2205
|
62 |
|
|
63 // Should Octave always check to see if function files have changed |
|
|
64 // since they were last compiled? |
|
5794
|
65 static int Vignore_function_time_stamp = 1; |
|
2205
|
66 |
|
7336
|
67 // Defines layout for the whos/who -long command |
|
|
68 static std::string Vwhos_line_format |
|
|
69 = " %a:4; %ln:6; %cs:16:6:8:1; %rb:12; %lc:-1;\n"; |
|
195
|
70 |
|
6068
|
71 void |
|
6072
|
72 clear_mex_functions (void) |
|
6068
|
73 { |
|
7336
|
74 symbol_table::clear_mex_functions (); |
|
|
75 } |
|
|
76 |
|
|
77 void |
|
|
78 clear_function (const std::string& nm) |
|
|
79 { |
|
|
80 symbol_table::clear_function (nm); |
|
|
81 } |
|
|
82 |
|
|
83 void |
|
|
84 clear_variable (const std::string& nm) |
|
|
85 { |
|
|
86 symbol_table::clear_variable (nm); |
|
|
87 } |
|
|
88 |
|
|
89 void |
|
|
90 clear_symbol (const std::string& nm) |
|
|
91 { |
|
|
92 symbol_table::clear_symbol (nm); |
|
6068
|
93 } |
|
|
94 |
|
593
|
95 // Attributes of variables and functions. |
|
|
96 |
|
4208
|
97 // Is this a command-style function? |
|
593
|
98 |
|
4208
|
99 static std::set <std::string> command_set; |
|
4207
|
100 |
|
7336
|
101 void |
|
4208
|
102 mark_as_command (const std::string& s) |
|
4207
|
103 { |
|
4208
|
104 command_set.insert (s); |
|
4207
|
105 } |
|
|
106 |
|
|
107 static inline void |
|
4208
|
108 unmark_command (const std::string& s) |
|
4207
|
109 { |
|
4208
|
110 command_set.erase (s); |
|
4207
|
111 } |
|
|
112 |
|
4208
|
113 DEFCMD (mark_as_command, args, , |
|
4207
|
114 "-*- texinfo -*-\n\ |
|
4208
|
115 @deftypefn {Built-in Function} {} mark_as_command (@var{name})\n\ |
|
|
116 Enter @var{name} into the list of commands.\n\ |
|
5642
|
117 @seealso{unmark_command, iscommand}\n\ |
|
|
118 @end deftypefn") |
|
4207
|
119 { |
|
|
120 octave_value_list retval; |
|
|
121 |
|
7336
|
122 if (symbol_table::at_top_level ()) |
|
4208
|
123 { |
|
|
124 int nargin = args.length (); |
|
4207
|
125 |
|
4208
|
126 if (nargin > 0) |
|
|
127 { |
|
|
128 int argc = nargin + 1; |
|
4207
|
129 |
|
4208
|
130 string_vector argv = args.make_argv ("mark_as_command"); |
|
4207
|
131 |
|
4208
|
132 if (! error_state) |
|
|
133 { |
|
|
134 for (int i = 1; i < argc; i++) |
|
|
135 mark_as_command (argv[i]); |
|
|
136 } |
|
4207
|
137 } |
|
4208
|
138 else |
|
5823
|
139 print_usage (); |
|
4207
|
140 } |
|
|
141 else |
|
4208
|
142 warning ("mark_as_command: invalid use inside function body"); |
|
4207
|
143 |
|
|
144 return retval; |
|
|
145 } |
|
|
146 |
|
4208
|
147 DEFCMD (unmark_command, args, , |
|
4207
|
148 "-*- texinfo -*-\n\ |
|
5102
|
149 @deftypefn {Built-in Function} {} unmark_command (@var{name})\n\ |
|
4208
|
150 Remove @var{name} from the list of commands.\n\ |
|
5642
|
151 @seealso{mark_as_command, iscommand}\n\ |
|
|
152 @end deftypefn") |
|
4207
|
153 { |
|
|
154 octave_value_list retval; |
|
|
155 |
|
7336
|
156 if (symbol_table::at_top_level ()) |
|
4208
|
157 { |
|
|
158 int nargin = args.length (); |
|
4207
|
159 |
|
4208
|
160 if (nargin > 0) |
|
|
161 { |
|
|
162 int argc = nargin + 1; |
|
4207
|
163 |
|
4208
|
164 string_vector argv = args.make_argv ("unmark_command"); |
|
4207
|
165 |
|
4208
|
166 if (! error_state) |
|
|
167 { |
|
|
168 for (int i = 1; i < argc; i++) |
|
|
169 unmark_command (argv[i]); |
|
|
170 } |
|
4207
|
171 } |
|
4208
|
172 else |
|
5823
|
173 print_usage (); |
|
4207
|
174 } |
|
|
175 else |
|
4208
|
176 warning ("mark_as_command: invalid use inside function body"); |
|
4207
|
177 |
|
|
178 return retval; |
|
|
179 } |
|
|
180 |
|
1827
|
181 bool |
|
4208
|
182 is_command_name (const std::string& s) |
|
593
|
183 { |
|
7336
|
184 return command_set.find (s) != command_set.end (); |
|
593
|
185 } |
|
|
186 |
|
7336
|
187 |
|
5102
|
188 DEFCMD (iscommand, args, , |
|
|
189 "-*- texinfo -*-\n\ |
|
|
190 @deftypefn {Built-in Function} {} iscommand (@var{name})\n\ |
|
|
191 Return true if @var{name} is a command style function. If @var{name}\n\ |
|
|
192 is omitted, return a list of identifiers which are marked as commands with\n\ |
|
6637
|
193 @code{mark_as_command}.\n\ |
|
5642
|
194 @seealso{mark_as_command, unmark_command}\n\ |
|
|
195 @end deftypefn") |
|
5102
|
196 { |
|
|
197 octave_value retval; |
|
|
198 |
|
|
199 int nargin = args.length (); |
|
|
200 |
|
|
201 if (nargin == 0) |
|
|
202 { |
|
|
203 string_vector lst (command_set.size ()); |
|
|
204 |
|
|
205 int i = 0; |
|
|
206 for (std::set<std::string>::const_iterator p = command_set.begin (); |
|
|
207 p != command_set.end (); p++) |
|
|
208 lst[i++] = *p; |
|
|
209 |
|
|
210 retval = Cell (lst.qsort ()); |
|
|
211 } |
|
|
212 else if (nargin == 1) |
|
|
213 { |
|
|
214 string_vector argv = args.make_argv ("iscommand"); |
|
|
215 |
|
|
216 if (! error_state) |
|
|
217 { |
|
|
218 std::string s = argv[1]; |
|
|
219 retval = is_command_name(s); |
|
|
220 } |
|
|
221 } |
|
|
222 else |
|
5823
|
223 print_usage (); |
|
5102
|
224 |
|
|
225 return retval; |
|
|
226 } |
|
|
227 |
|
|
228 // Is this a raw input command? |
|
|
229 |
|
|
230 static std::set <std::string> rawcommand_set; |
|
|
231 |
|
5685
|
232 void |
|
5102
|
233 mark_as_rawcommand (const std::string& s) |
|
|
234 { |
|
|
235 command_set.insert (s); |
|
|
236 rawcommand_set.insert (s); |
|
|
237 } |
|
|
238 |
|
5685
|
239 void |
|
5102
|
240 unmark_rawcommand (const std::string& s) |
|
|
241 { |
|
|
242 rawcommand_set.erase (s); |
|
|
243 } |
|
|
244 |
|
|
245 DEFCMD (mark_as_rawcommand, args, , |
|
|
246 "-*- texinfo -*-\n\ |
|
|
247 @deftypefn {Built-in Function} {} mark_as_rawcommand (@var{name})\n\ |
|
|
248 Enter @var{name} into the list of raw input commands and to the list of\n\ |
|
|
249 command style functions.\n\ |
|
|
250 Raw input commands are like normal command style functions, but they\n\ |
|
|
251 receive their input unprocessed (ie. strings still contain the quotes\n\ |
|
|
252 and escapes they had when input). However, comments and continuations\n\ |
|
|
253 are handled as usual, you cannot pass a token starting with a comment\n\ |
|
|
254 character ('#' or '%') to your function, and the last token cannot be\n\ |
|
|
255 a continuation token ('\\' or '...').\n\ |
|
5642
|
256 @seealso{unmark_rawcommand, israwcommand, iscommand, mark_as_command}\n\ |
|
|
257 @end deftypefn") |
|
5102
|
258 { |
|
|
259 octave_value_list retval; |
|
|
260 |
|
7336
|
261 if (symbol_table::at_top_level ()) |
|
5102
|
262 { |
|
|
263 int nargin = args.length (); |
|
|
264 |
|
|
265 if (nargin > 0) |
|
|
266 { |
|
|
267 int argc = nargin + 1; |
|
|
268 |
|
|
269 string_vector argv = args.make_argv ("mark_as_rawcommand"); |
|
|
270 |
|
|
271 if (! error_state) |
|
|
272 { |
|
|
273 for (int i = 1; i < argc; i++) |
|
|
274 mark_as_rawcommand (argv[i]); |
|
|
275 } |
|
|
276 } |
|
|
277 else |
|
5823
|
278 print_usage (); |
|
5102
|
279 } |
|
|
280 else |
|
|
281 warning ("mark_as_rawcommand: invalid use inside function body"); |
|
|
282 |
|
|
283 return retval; |
|
|
284 } |
|
|
285 |
|
|
286 DEFCMD (unmark_rawcommand, args, , |
|
|
287 "-*- texinfo -*-\n\ |
|
|
288 @deftypefn {Built-in Function} {} unmark_rawcommand (@var{name})\n\ |
|
|
289 Remove @var{name} from the list of raw input commands.\n\ |
|
|
290 Note that this does not remove @var{name} from the list of command style\n\ |
|
|
291 functions.\n\ |
|
5642
|
292 @seealso{mark_as_rawcommand, israwcommand, iscommand, unmark_command}\n\ |
|
|
293 @end deftypefn") |
|
5102
|
294 { |
|
|
295 octave_value_list retval; |
|
|
296 |
|
7336
|
297 if (symbol_table::at_top_level ()) |
|
5102
|
298 { |
|
|
299 int nargin = args.length (); |
|
|
300 |
|
|
301 if (nargin > 0) |
|
|
302 { |
|
|
303 int argc = nargin + 1; |
|
|
304 |
|
|
305 string_vector argv = args.make_argv ("unmark_rawcommand"); |
|
|
306 |
|
|
307 if (! error_state) |
|
|
308 { |
|
|
309 for (int i = 1; i < argc; i++) |
|
|
310 unmark_rawcommand (argv[i]); |
|
|
311 } |
|
|
312 } |
|
|
313 else |
|
5823
|
314 print_usage (); |
|
5102
|
315 } |
|
|
316 else |
|
|
317 warning ("unmark_rawcommand: invalid use inside function body"); |
|
|
318 |
|
|
319 return retval; |
|
|
320 } |
|
|
321 |
|
|
322 bool |
|
|
323 is_rawcommand_name (const std::string& s) |
|
|
324 { |
|
7336
|
325 return rawcommand_set.find (s) != rawcommand_set.end (); |
|
5102
|
326 } |
|
|
327 |
|
|
328 DEFCMD (israwcommand, args, , |
|
|
329 "-*- texinfo -*-\n\ |
|
|
330 @deftypefn {Built-in Function} {} israwcommand (@var{name})\n\ |
|
|
331 Return true if @var{name} is a raw input command function.\n\ |
|
|
332 If @var{name} is omitted, return a list of identifiers which are marked as\n\ |
|
|
333 raw input commands with mark_as_rawcommand.\n\ |
|
5642
|
334 @seealso{mark_as_rawcommand, unmark_rawcommand}\n\ |
|
|
335 @end deftypefn") |
|
5102
|
336 { |
|
|
337 octave_value retval; |
|
|
338 |
|
|
339 int nargin = args.length (); |
|
|
340 |
|
|
341 if (nargin == 0) |
|
|
342 { |
|
|
343 string_vector lst (rawcommand_set.size()); |
|
|
344 |
|
|
345 int i = 0; |
|
|
346 for (std::set<std::string>::const_iterator p = rawcommand_set.begin (); |
|
|
347 p != rawcommand_set.end (); |
|
|
348 p++) |
|
|
349 lst[i++] = *p; |
|
|
350 |
|
|
351 retval = Cell (lst.qsort ()); |
|
|
352 } |
|
|
353 else if (nargin == 1) |
|
|
354 { |
|
|
355 string_vector argv = args.make_argv ("israwcommand"); |
|
|
356 |
|
|
357 if (! error_state) |
|
|
358 { |
|
|
359 std::string s = argv[1]; |
|
|
360 retval = is_rawcommand_name(s); |
|
|
361 } |
|
|
362 } |
|
|
363 else |
|
5823
|
364 print_usage (); |
|
5102
|
365 |
|
|
366 return retval; |
|
|
367 } |
|
|
368 |
|
2086
|
369 // Is this octave_value a valid function? |
|
593
|
370 |
|
2975
|
371 octave_function * |
|
4345
|
372 is_valid_function (const std::string& fcn_name, |
|
|
373 const std::string& warn_for, bool warn) |
|
593
|
374 { |
|
2975
|
375 octave_function *ans = 0; |
|
593
|
376 |
|
1755
|
377 if (! fcn_name.empty ()) |
|
3618
|
378 { |
|
7336
|
379 octave_value val = symbol_table::find_function (fcn_name); |
|
|
380 |
|
|
381 if (val.is_defined ()) |
|
|
382 ans = val.function_value (true); |
|
3618
|
383 } |
|
593
|
384 |
|
7336
|
385 if (! ans && warn) |
|
|
386 error ("%s: the symbol `%s' is not valid as a function", |
|
|
387 warn_for.c_str (), fcn_name.c_str ()); |
|
593
|
388 |
|
|
389 return ans; |
|
|
390 } |
|
|
391 |
|
2975
|
392 octave_function * |
|
4345
|
393 is_valid_function (const octave_value& arg, |
|
|
394 const std::string& warn_for, bool warn) |
|
3178
|
395 { |
|
|
396 octave_function *ans = 0; |
|
|
397 |
|
3523
|
398 std::string fcn_name; |
|
3178
|
399 |
|
|
400 if (arg.is_string ()) |
|
4700
|
401 { |
|
|
402 fcn_name = arg.string_value (); |
|
3178
|
403 |
|
4700
|
404 if (! error_state) |
|
|
405 ans = is_valid_function (fcn_name, warn_for, warn); |
|
|
406 else if (warn) |
|
|
407 error ("%s: expecting function name as argument", warn_for.c_str ()); |
|
|
408 } |
|
3178
|
409 else if (warn) |
|
|
410 error ("%s: expecting function name as argument", warn_for.c_str ()); |
|
|
411 |
|
|
412 return ans; |
|
|
413 } |
|
|
414 |
|
|
415 octave_function * |
|
3523
|
416 extract_function (const octave_value& arg, const std::string& warn_for, |
|
|
417 const std::string& fname, const std::string& header, |
|
|
418 const std::string& trailer) |
|
2796
|
419 { |
|
2975
|
420 octave_function *retval = 0; |
|
2796
|
421 |
|
|
422 retval = is_valid_function (arg, warn_for, 0); |
|
|
423 |
|
|
424 if (! retval) |
|
|
425 { |
|
3523
|
426 std::string s = arg.string_value (); |
|
2796
|
427 |
|
3523
|
428 std::string cmd = header; |
|
2796
|
429 cmd.append (s); |
|
|
430 cmd.append (trailer); |
|
|
431 |
|
|
432 if (! error_state) |
|
|
433 { |
|
|
434 int parse_status; |
|
|
435 |
|
2898
|
436 eval_string (cmd, true, parse_status); |
|
2796
|
437 |
|
|
438 if (parse_status == 0) |
|
|
439 { |
|
|
440 retval = is_valid_function (fname, warn_for, 0); |
|
|
441 |
|
|
442 if (! retval) |
|
|
443 { |
|
|
444 error ("%s: `%s' is not valid as a function", |
|
|
445 warn_for.c_str (), fname.c_str ()); |
|
|
446 return retval; |
|
|
447 } |
|
|
448 } |
|
|
449 else |
|
|
450 error ("%s: `%s' is not valid as a function", |
|
|
451 warn_for.c_str (), fname.c_str ()); |
|
|
452 } |
|
|
453 else |
|
|
454 error ("%s: expecting first argument to be a string", |
|
|
455 warn_for.c_str ()); |
|
|
456 } |
|
|
457 |
|
|
458 return retval; |
|
|
459 } |
|
|
460 |
|
2921
|
461 string_vector |
|
3523
|
462 get_struct_elts (const std::string& text) |
|
2921
|
463 { |
|
|
464 int n = 1; |
|
|
465 |
|
|
466 size_t pos = 0; |
|
|
467 |
|
|
468 size_t len = text.length (); |
|
|
469 |
|
|
470 while ((pos = text.find ('.', pos)) != NPOS) |
|
|
471 { |
|
|
472 if (++pos == len) |
|
|
473 break; |
|
|
474 |
|
|
475 n++; |
|
|
476 } |
|
|
477 |
|
|
478 string_vector retval (n); |
|
|
479 |
|
|
480 pos = 0; |
|
|
481 |
|
|
482 for (int i = 0; i < n; i++) |
|
|
483 { |
|
4587
|
484 len = text.find ('.', pos); |
|
2921
|
485 |
|
|
486 if (len != NPOS) |
|
|
487 len -= pos; |
|
|
488 |
|
|
489 retval[i] = text.substr (pos, len); |
|
|
490 |
|
|
491 if (len != NPOS) |
|
|
492 pos += len + 1; |
|
|
493 } |
|
|
494 |
|
|
495 return retval; |
|
|
496 } |
|
|
497 |
|
4179
|
498 static inline bool |
|
|
499 is_variable (const std::string& name) |
|
|
500 { |
|
|
501 bool retval = false; |
|
|
502 |
|
|
503 if (! name.empty ()) |
|
|
504 { |
|
7336
|
505 octave_value val = symbol_table::varval (name); |
|
|
506 |
|
|
507 retval = val.is_defined (); |
|
4179
|
508 } |
|
|
509 |
|
|
510 return retval; |
|
|
511 } |
|
|
512 |
|
2921
|
513 string_vector |
|
3933
|
514 generate_struct_completions (const std::string& text, |
|
|
515 std::string& prefix, std::string& hint) |
|
2921
|
516 { |
|
|
517 string_vector names; |
|
|
518 |
|
|
519 size_t pos = text.rfind ('.'); |
|
|
520 |
|
3933
|
521 if (pos != NPOS) |
|
2921
|
522 { |
|
|
523 if (pos == text.length ()) |
|
|
524 hint = ""; |
|
|
525 else |
|
|
526 hint = text.substr (pos+1); |
|
|
527 |
|
|
528 prefix = text.substr (0, pos); |
|
|
529 |
|
4179
|
530 std::string base_name = prefix; |
|
|
531 |
|
|
532 pos = base_name.find_first_of ("{(."); |
|
2921
|
533 |
|
4179
|
534 if (pos != NPOS) |
|
|
535 base_name = base_name.substr (0, pos); |
|
4143
|
536 |
|
4179
|
537 if (is_variable (base_name)) |
|
|
538 { |
|
|
539 int parse_status; |
|
|
540 |
|
|
541 unwind_protect::begin_frame ("generate_struct_completions"); |
|
3935
|
542 |
|
4452
|
543 unwind_protect_int (error_state); |
|
|
544 unwind_protect_int (warning_state); |
|
|
545 |
|
4179
|
546 unwind_protect_bool (discard_error_messages); |
|
4452
|
547 unwind_protect_bool (discard_warning_messages); |
|
3935
|
548 |
|
4179
|
549 discard_error_messages = true; |
|
4452
|
550 discard_warning_messages = true; |
|
2921
|
551 |
|
4179
|
552 octave_value tmp = eval_string (prefix, true, parse_status); |
|
|
553 |
|
|
554 unwind_protect::run_frame ("generate_struct_completions"); |
|
3935
|
555 |
|
4179
|
556 if (tmp.is_defined () && tmp.is_map ()) |
|
|
557 names = tmp.map_keys (); |
|
|
558 } |
|
|
559 } |
|
2921
|
560 |
|
|
561 return names; |
|
|
562 } |
|
|
563 |
|
5775
|
564 // FIXME -- this will have to be much smarter to work |
|
4179
|
565 // "correctly". |
|
|
566 |
|
2921
|
567 bool |
|
3523
|
568 looks_like_struct (const std::string& text) |
|
2921
|
569 { |
|
4604
|
570 bool retval = (! text.empty () |
|
|
571 && text != "." |
|
|
572 && text.find_first_of (file_ops::dir_sep_chars) == NPOS |
|
|
573 && text.find ("..") == NPOS |
|
|
574 && text.rfind ('.') != NPOS); |
|
3968
|
575 |
|
4179
|
576 #if 0 |
|
3968
|
577 symbol_record *sr = curr_sym_tab->lookup (text); |
|
2963
|
578 |
|
3968
|
579 if (sr && ! sr->is_function ()) |
|
|
580 { |
|
|
581 int parse_status; |
|
2921
|
582 |
|
4143
|
583 unwind_protect::begin_frame ("looks_like_struct"); |
|
|
584 |
|
|
585 unwind_protect_bool (discard_error_messages); |
|
|
586 unwind_protect_int (error_state); |
|
|
587 |
|
|
588 discard_error_messages = true; |
|
|
589 |
|
3968
|
590 octave_value tmp = eval_string (text, true, parse_status); |
|
|
591 |
|
4143
|
592 unwind_protect::run_frame ("looks_like_struct"); |
|
|
593 |
|
3968
|
594 retval = (tmp.is_defined () && tmp.is_map ()); |
|
|
595 } |
|
4179
|
596 #endif |
|
3968
|
597 |
|
|
598 return retval; |
|
2921
|
599 } |
|
2796
|
600 |
|
5930
|
601 static octave_value |
|
|
602 do_isglobal (const octave_value_list& args) |
|
593
|
603 { |
|
4233
|
604 octave_value retval = false; |
|
593
|
605 |
|
712
|
606 int nargin = args.length (); |
|
|
607 |
|
|
608 if (nargin != 1) |
|
593
|
609 { |
|
5823
|
610 print_usage (); |
|
593
|
611 return retval; |
|
|
612 } |
|
|
613 |
|
3523
|
614 std::string name = args(0).string_value (); |
|
593
|
615 |
|
636
|
616 if (error_state) |
|
|
617 { |
|
4028
|
618 error ("isglobal: expecting std::string argument"); |
|
636
|
619 return retval; |
|
|
620 } |
|
|
621 |
|
7336
|
622 return symbol_table::is_global (name); |
|
593
|
623 } |
|
|
624 |
|
5930
|
625 DEFUN (isglobal, args, , |
|
|
626 "-*- texinfo -*-\n\ |
|
|
627 @deftypefn {Built-in Function} {} isglobal (@var{name})\n\ |
|
|
628 Return 1 if @var{name} is globally visible. Otherwise, return 0. For\n\ |
|
|
629 example,\n\ |
|
|
630 \n\ |
|
|
631 @example\n\ |
|
|
632 @group\n\ |
|
|
633 global x\n\ |
|
|
634 isglobal (\"x\")\n\ |
|
|
635 @result{} 1\n\ |
|
|
636 @end group\n\ |
|
|
637 @end example\n\ |
|
|
638 @end deftypefn") |
|
|
639 { |
|
|
640 return do_isglobal (args); |
|
|
641 } |
|
|
642 |
|
|
643 DEFUN (is_global, args, , |
|
|
644 "-*- texinfo -*-\n\ |
|
|
645 @deftypefn {Built-in Function} {} isglobal (@var{name})\n\ |
|
|
646 This function has been deprecated. Use isglobal instead.\n\ |
|
|
647 @end deftypefn") |
|
|
648 { |
|
|
649 return do_isglobal (args); |
|
|
650 } |
|
|
651 |
|
4016
|
652 int |
|
|
653 symbol_exist (const std::string& name, const std::string& type) |
|
593
|
654 { |
|
4016
|
655 int retval = 0; |
|
636
|
656 |
|
3523
|
657 std::string struct_elts; |
|
|
658 std::string symbol_name = name; |
|
1755
|
659 |
|
|
660 size_t pos = name.find ('.'); |
|
|
661 |
|
2790
|
662 if (pos != NPOS && pos > 0) |
|
1277
|
663 { |
|
1755
|
664 struct_elts = name.substr (pos+1); |
|
2790
|
665 symbol_name = name.substr (0, pos); |
|
1277
|
666 } |
|
|
667 |
|
4009
|
668 // We shouldn't need to look in the global symbol table, since any |
|
|
669 // name that is visible in the current scope will be in the local |
|
|
670 // symbol table. |
|
|
671 |
|
7336
|
672 octave_value_list evaluated_args; |
|
|
673 bool args_evaluated; |
|
|
674 |
|
|
675 octave_value val = symbol_table::find (symbol_name, 0, string_vector (), |
|
|
676 evaluated_args, args_evaluated); |
|
|
677 |
|
|
678 if (val.is_defined ()) |
|
1277
|
679 { |
|
4357
|
680 bool not_a_struct = struct_elts.empty (); |
|
7336
|
681 bool var_ok = not_a_struct /* || val.is_map_element (struct_elts) */; |
|
4357
|
682 |
|
4016
|
683 if (! retval |
|
4357
|
684 && var_ok |
|
4016
|
685 && (type == "any" || type == "var") |
|
7336
|
686 && val.is_constant ()) |
|
4009
|
687 { |
|
4016
|
688 retval = 1; |
|
4009
|
689 } |
|
4016
|
690 |
|
|
691 if (! retval |
|
|
692 && (type == "any" || type == "builtin")) |
|
4009
|
693 { |
|
7336
|
694 if (not_a_struct && val.is_builtin_function ()) |
|
4016
|
695 { |
|
|
696 retval = 5; |
|
|
697 } |
|
4009
|
698 } |
|
4016
|
699 |
|
|
700 if (! retval |
|
4357
|
701 && not_a_struct |
|
4016
|
702 && (type == "any" || type == "file") |
|
7336
|
703 && (val.is_user_function () || val.is_dld_function ())) |
|
4009
|
704 { |
|
7336
|
705 octave_function *f = val.function_value (true); |
|
4016
|
706 std::string s = f ? f->fcn_file_name () : std::string (); |
|
|
707 |
|
7336
|
708 retval = s.empty () ? 103 : (val.is_user_function () ? 2 : 3); |
|
4009
|
709 } |
|
1421
|
710 } |
|
4016
|
711 |
|
5140
|
712 if (! (type == "var" || type == "builtin")) |
|
593
|
713 { |
|
5140
|
714 if (! retval) |
|
593
|
715 { |
|
5484
|
716 std::string file_name = lookup_autoload (name); |
|
|
717 |
|
|
718 if (file_name.empty ()) |
|
5832
|
719 file_name = load_path::find_fcn (name); |
|
5140
|
720 |
|
|
721 size_t len = file_name.length (); |
|
|
722 |
|
5832
|
723 if (len > 0) |
|
4437
|
724 { |
|
5140
|
725 if (type == "any" || type == "file") |
|
|
726 { |
|
5864
|
727 if (len > 4 && (file_name.substr (len-4) == ".oct" |
|
|
728 || file_name.substr (len-4) == ".mex")) |
|
5140
|
729 retval = 3; |
|
|
730 else |
|
|
731 retval = 2; |
|
|
732 } |
|
4437
|
733 } |
|
593
|
734 } |
|
5140
|
735 |
|
|
736 if (! retval) |
|
593
|
737 { |
|
5140
|
738 std::string file_name = file_in_path (name, ""); |
|
|
739 |
|
|
740 if (file_name.empty ()) |
|
|
741 file_name = name; |
|
|
742 |
|
|
743 file_stat fs (file_name); |
|
|
744 |
|
|
745 if (fs) |
|
1421
|
746 { |
|
5140
|
747 if ((type == "any" || type == "file") |
|
|
748 && fs.is_reg ()) |
|
|
749 { |
|
|
750 retval = 2; |
|
|
751 } |
|
|
752 else if ((type == "any" || type == "dir") |
|
|
753 && fs.is_dir ()) |
|
|
754 { |
|
|
755 retval = 7; |
|
|
756 } |
|
1421
|
757 } |
|
593
|
758 } |
|
|
759 } |
|
|
760 |
|
|
761 return retval; |
|
|
762 } |
|
|
763 |
|
4962
|
764 #define GET_IDX(LEN) \ |
|
|
765 static_cast<int> ((LEN-1) * static_cast<double> (rand ()) / RAND_MAX) |
|
|
766 |
|
4954
|
767 std::string |
|
|
768 unique_symbol_name (const std::string& basename) |
|
|
769 { |
|
4962
|
770 static const std::string alpha |
|
|
771 = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"; |
|
|
772 |
|
|
773 static size_t len = alpha.length (); |
|
|
774 |
|
|
775 std::string nm = basename + alpha[GET_IDX (len)]; |
|
|
776 |
|
|
777 size_t pos = nm.length (); |
|
|
778 |
|
|
779 if (nm.substr (0, 2) == "__") |
|
|
780 nm.append ("__"); |
|
|
781 |
|
|
782 while (symbol_exist (nm, "any")) |
|
|
783 nm.insert (pos++, 1, alpha[GET_IDX (len)]); |
|
|
784 |
|
|
785 return nm; |
|
4954
|
786 } |
|
|
787 |
|
4016
|
788 DEFUN (exist, args, , |
|
|
789 "-*- texinfo -*-\n\ |
|
|
790 @deftypefn {Built-in Function} {} exist (@var{name}, @var{type})\n\ |
|
|
791 Return 1 if the name exists as a variable, 2 if the name (after\n\ |
|
5814
|
792 appending @samp{.m}) is a function file in Octave's @code{path}, 3 if the\n\ |
|
5864
|
793 name is a @samp{.oct} or @samp{.mex} file in Octave's @code{path},\n\ |
|
|
794 5 if the name is a built-in function, 7 if the name is a directory, or 103\n\ |
|
4016
|
795 if the name is a function not associated with a file (entered on\n\ |
|
|
796 the command line).\n\ |
|
|
797 \n\ |
|
|
798 Otherwise, return 0.\n\ |
|
|
799 \n\ |
|
|
800 This function also returns 2 if a regular file called @var{name}\n\ |
|
5814
|
801 exists in Octave's search path. If you want information about\n\ |
|
4016
|
802 other types of files, you should use some combination of the functions\n\ |
|
|
803 @code{file_in_path} and @code{stat} instead.\n\ |
|
|
804 \n\ |
|
|
805 If the optional argument @var{type} is supplied, check only for\n\ |
|
|
806 symbols of the specified type. Valid types are\n\ |
|
|
807 \n\ |
|
|
808 @table @samp\n\ |
|
|
809 @item \"var\"\n\ |
|
|
810 Check only for variables.\n\ |
|
|
811 @item \"builtin\"\n\ |
|
|
812 Check only for built-in functions.\n\ |
|
|
813 @item \"file\"\n\ |
|
|
814 Check only for files.\n\ |
|
|
815 @item \"dir\"\n\ |
|
|
816 Check only for directories.\n\ |
|
|
817 @end table\n\ |
|
|
818 @end deftypefn") |
|
|
819 { |
|
4233
|
820 octave_value retval = false; |
|
4016
|
821 |
|
|
822 int nargin = args.length (); |
|
|
823 |
|
|
824 if (nargin == 1 || nargin == 2) |
|
|
825 { |
|
|
826 std::string name = args(0).string_value (); |
|
|
827 |
|
|
828 if (! error_state) |
|
|
829 { |
|
|
830 std::string type |
|
|
831 = (nargin == 2) ? args(1).string_value () : std::string ("any"); |
|
|
832 |
|
|
833 if (! error_state) |
|
4233
|
834 retval = symbol_exist (name, type); |
|
4016
|
835 else |
|
|
836 error ("exist: expecting second argument to be a string"); |
|
|
837 } |
|
|
838 else |
|
|
839 error ("exist: expecting first argument to be a string"); |
|
|
840 } |
|
|
841 else |
|
5823
|
842 print_usage (); |
|
4016
|
843 |
|
|
844 return retval; |
|
|
845 } |
|
|
846 |
|
2849
|
847 octave_value |
|
4988
|
848 lookup_function_handle (const std::string& nm) |
|
|
849 { |
|
7336
|
850 octave_value val = symbol_table::varval (nm); |
|
|
851 |
|
|
852 return val.is_function_handle () ? val : octave_value (); |
|
4988
|
853 } |
|
|
854 |
|
|
855 octave_value |
|
5027
|
856 get_global_value (const std::string& nm, bool silent) |
|
2849
|
857 { |
|
7336
|
858 octave_value val = symbol_table::varval (nm, symbol_table::global_scope ()); |
|
|
859 |
|
|
860 if (val.is_undefined () && ! silent) |
|
|
861 error ("get_global_by_name: undefined symbol `%s'", nm.c_str ()); |
|
|
862 |
|
|
863 return val; |
|
2849
|
864 } |
|
|
865 |
|
|
866 void |
|
3523
|
867 set_global_value (const std::string& nm, const octave_value& val) |
|
2849
|
868 { |
|
7336
|
869 symbol_table::varref (nm, symbol_table::global_scope ()) = val; |
|
2849
|
870 } |
|
|
871 |
|
593
|
872 // Variable values. |
|
195
|
873 |
|
5791
|
874 octave_value |
|
|
875 set_internal_variable (bool& var, const octave_value_list& args, |
|
5794
|
876 int nargout, const char *nm) |
|
5791
|
877 { |
|
5794
|
878 octave_value retval; |
|
|
879 |
|
5800
|
880 int nargin = args.length (); |
|
|
881 |
|
|
882 if (nargout > 0 || nargin == 0) |
|
5794
|
883 retval = var; |
|
5791
|
884 |
|
|
885 if (nargin == 1) |
|
|
886 { |
|
|
887 bool bval = args(0).bool_value (); |
|
|
888 |
|
|
889 if (! error_state) |
|
|
890 var = bval; |
|
|
891 else |
|
|
892 error ("%s: expecting arg to be a logical value", nm); |
|
|
893 } |
|
|
894 else if (nargin > 1) |
|
5823
|
895 print_usage (); |
|
5791
|
896 |
|
|
897 return retval; |
|
|
898 } |
|
|
899 |
|
|
900 octave_value |
|
5794
|
901 set_internal_variable (char& var, const octave_value_list& args, |
|
|
902 int nargout, const char *nm) |
|
5791
|
903 { |
|
5794
|
904 octave_value retval; |
|
|
905 |
|
5800
|
906 int nargin = args.length (); |
|
|
907 |
|
|
908 if (nargout > 0 || nargin == 0) |
|
5794
|
909 retval = var; |
|
5791
|
910 |
|
|
911 if (nargin == 1) |
|
|
912 { |
|
|
913 std::string sval = args(0).string_value (); |
|
|
914 |
|
|
915 if (! error_state) |
|
5794
|
916 { |
|
|
917 switch (sval.length ()) |
|
|
918 { |
|
|
919 case 1: |
|
|
920 var = sval[0]; |
|
|
921 break; |
|
|
922 |
|
|
923 case 0: |
|
|
924 var = '\0'; |
|
|
925 break; |
|
|
926 |
|
|
927 default: |
|
|
928 error ("%s: argument must be a single character", nm); |
|
|
929 break; |
|
|
930 } |
|
|
931 } |
|
|
932 else |
|
|
933 error ("%s: argument must be a single character", nm); |
|
|
934 } |
|
|
935 else if (nargin > 1) |
|
5823
|
936 print_usage (); |
|
5794
|
937 |
|
|
938 return retval; |
|
|
939 } |
|
|
940 |
|
|
941 octave_value |
|
|
942 set_internal_variable (int& var, const octave_value_list& args, |
|
|
943 int nargout, const char *nm, |
|
|
944 int minval, int maxval) |
|
|
945 { |
|
|
946 octave_value retval; |
|
|
947 |
|
5800
|
948 int nargin = args.length (); |
|
|
949 |
|
|
950 if (nargout > 0 || nargin == 0) |
|
5794
|
951 retval = var; |
|
|
952 |
|
|
953 if (nargin == 1) |
|
|
954 { |
|
|
955 int ival = args(0).int_value (); |
|
|
956 |
|
|
957 if (! error_state) |
|
|
958 { |
|
|
959 if (ival < minval) |
|
|
960 error ("%s: expecting arg to be greater than %d", minval); |
|
|
961 else if (ival > maxval) |
|
|
962 error ("%s: expecting arg to be less than or equal to %d", maxval); |
|
|
963 else |
|
|
964 var = ival; |
|
|
965 } |
|
|
966 else |
|
|
967 error ("%s: expecting arg to be an integer value", nm); |
|
|
968 } |
|
|
969 else if (nargin > 1) |
|
5823
|
970 print_usage (); |
|
5794
|
971 |
|
|
972 return retval; |
|
|
973 } |
|
|
974 |
|
|
975 octave_value |
|
|
976 set_internal_variable (double& var, const octave_value_list& args, |
|
|
977 int nargout, const char *nm, |
|
|
978 double minval, double maxval) |
|
|
979 { |
|
|
980 octave_value retval; |
|
|
981 |
|
5800
|
982 int nargin = args.length (); |
|
|
983 |
|
|
984 if (nargout > 0 || nargin == 0) |
|
5794
|
985 retval = var; |
|
|
986 |
|
|
987 if (nargin == 1) |
|
|
988 { |
|
|
989 double dval = args(0).scalar_value (); |
|
|
990 |
|
|
991 if (! error_state) |
|
|
992 { |
|
|
993 if (dval < minval) |
|
|
994 error ("%s: expecting arg to be greater than %g", minval); |
|
|
995 else if (dval > maxval) |
|
|
996 error ("%s: expecting arg to be less than or equal to %g", maxval); |
|
|
997 else |
|
|
998 var = dval; |
|
|
999 } |
|
|
1000 else |
|
|
1001 error ("%s: expecting arg to be a scalar value", nm); |
|
|
1002 } |
|
|
1003 else if (nargin > 1) |
|
5823
|
1004 print_usage (); |
|
5794
|
1005 |
|
|
1006 return retval; |
|
|
1007 } |
|
|
1008 |
|
|
1009 octave_value |
|
|
1010 set_internal_variable (std::string& var, const octave_value_list& args, |
|
|
1011 int nargout, const char *nm, bool empty_ok) |
|
|
1012 { |
|
|
1013 octave_value retval; |
|
|
1014 |
|
5800
|
1015 int nargin = args.length (); |
|
|
1016 |
|
|
1017 if (nargout > 0 || nargin == 0) |
|
5794
|
1018 retval = var; |
|
|
1019 |
|
|
1020 if (nargin == 1) |
|
|
1021 { |
|
|
1022 std::string sval = args(0).string_value (); |
|
|
1023 |
|
|
1024 if (! error_state) |
|
|
1025 { |
|
|
1026 if (empty_ok || ! sval.empty ()) |
|
|
1027 var = sval; |
|
|
1028 else |
|
|
1029 error ("%s: value must not be empty", nm); |
|
|
1030 } |
|
5791
|
1031 else |
|
|
1032 error ("%s: expecting arg to be a character string", nm); |
|
|
1033 } |
|
|
1034 else if (nargin > 1) |
|
5823
|
1035 print_usage (); |
|
1
|
1036 |
|
|
1037 return retval; |
|
|
1038 } |
|
|
1039 |
|
7336
|
1040 struct |
|
|
1041 symbol_record_name_compare |
|
|
1042 { |
|
|
1043 bool operator () (const symbol_table::symbol_record& a, |
|
|
1044 const symbol_table::symbol_record& b) |
|
|
1045 { |
|
|
1046 std::string a_nm = a.name (); |
|
|
1047 std::string b_nm = b.name (); |
|
|
1048 |
|
|
1049 return a_nm.compare (b_nm); |
|
|
1050 } |
|
|
1051 }; |
|
|
1052 |
|
|
1053 struct |
|
|
1054 whos_parameter |
|
195
|
1055 { |
|
7336
|
1056 char command; |
|
|
1057 char modifier; |
|
|
1058 int parameter_length; |
|
|
1059 int first_parameter_length; |
|
|
1060 int dimensions; |
|
|
1061 int balance; |
|
|
1062 std::string text; |
|
|
1063 std::string line; |
|
|
1064 }; |
|
|
1065 |
|
|
1066 static void |
|
|
1067 print_descriptor (std::ostream& os, std::list<whos_parameter> params) |
|
|
1068 { |
|
|
1069 // This method prints a line of information on a given symbol |
|
|
1070 std::list<whos_parameter>::iterator i = params.begin (); |
|
|
1071 std::ostringstream param_buf; |
|
|
1072 |
|
|
1073 while (i != params.end ()) |
|
195
|
1074 { |
|
7336
|
1075 whos_parameter param = *i; |
|
|
1076 |
|
|
1077 if (param.command != '\0') |
|
|
1078 { |
|
|
1079 // Do the actual printing |
|
|
1080 switch (param.modifier) |
|
|
1081 { |
|
|
1082 case 'l': |
|
|
1083 os << std::setiosflags (std::ios::left) << std::setw (param.parameter_length); |
|
|
1084 param_buf << std::setiosflags (std::ios::left) << std::setw (param.parameter_length); |
|
|
1085 break; |
|
|
1086 |
|
|
1087 case 'r': |
|
|
1088 os << std::setiosflags (std::ios::right) << std::setw (param.parameter_length); |
|
|
1089 param_buf << std::setiosflags (std::ios::right) << std::setw (param.parameter_length); |
|
|
1090 break; |
|
|
1091 |
|
|
1092 case 'c': |
|
|
1093 if (param.command != 's') |
|
|
1094 { |
|
|
1095 os << std::setiosflags (std::ios::left) |
|
|
1096 << std::setw (param.parameter_length); |
|
|
1097 param_buf << std::setiosflags (std::ios::left) |
|
|
1098 << std::setw (param.parameter_length); |
|
|
1099 } |
|
|
1100 break; |
|
|
1101 |
|
|
1102 default: |
|
|
1103 os << std::setiosflags (std::ios::left) << std::setw (param.parameter_length); |
|
|
1104 param_buf << std::setiosflags (std::ios::left) << std::setw (param.parameter_length); |
|
|
1105 } |
|
|
1106 |
|
|
1107 if (param.command == 's' && param.modifier == 'c') |
|
|
1108 { |
|
|
1109 int a, b; |
|
|
1110 |
|
|
1111 if (param.modifier == 'c') |
|
|
1112 { |
|
|
1113 a = param.first_parameter_length - param.balance; |
|
|
1114 a = (a < 0 ? 0 : a); |
|
|
1115 b = param.parameter_length - a - param.text . length (); |
|
|
1116 b = (b < 0 ? 0 : b); |
|
|
1117 os << std::setiosflags (std::ios::left) << std::setw (a) |
|
|
1118 << "" << std::resetiosflags (std::ios::left) << param.text |
|
|
1119 << std::setiosflags (std::ios::left) |
|
|
1120 << std::setw (b) << "" |
|
|
1121 << std::resetiosflags (std::ios::left); |
|
|
1122 param_buf << std::setiosflags (std::ios::left) << std::setw (a) |
|
|
1123 << "" << std::resetiosflags (std::ios::left) << param.line |
|
|
1124 << std::setiosflags (std::ios::left) |
|
|
1125 << std::setw (b) << "" |
|
|
1126 << std::resetiosflags (std::ios::left); |
|
|
1127 } |
|
|
1128 } |
|
|
1129 else |
|
|
1130 { |
|
|
1131 os << param.text; |
|
|
1132 param_buf << param.line; |
|
|
1133 } |
|
|
1134 os << std::resetiosflags (std::ios::left) |
|
|
1135 << std::resetiosflags (std::ios::right); |
|
|
1136 param_buf << std::resetiosflags (std::ios::left) |
|
|
1137 << std::resetiosflags (std::ios::right); |
|
|
1138 i++; |
|
|
1139 } |
|
|
1140 else |
|
2975
|
1141 { |
|
7336
|
1142 os << param.text; |
|
|
1143 param_buf << param.line; |
|
|
1144 i++; |
|
2975
|
1145 } |
|
195
|
1146 } |
|
7336
|
1147 |
|
|
1148 os << param_buf.str (); |
|
195
|
1149 } |
|
|
1150 |
|
7336
|
1151 // Calculate how much space needs to be reserved for the first part of |
|
|
1152 // the dimensions string. For example, |
|
581
|
1153 // |
|
7336
|
1154 // mat is a 12x3 matrix |
|
|
1155 // ^^ => 2 columns |
|
|
1156 |
|
|
1157 static int |
|
|
1158 dimensions_string_req_first_space (const dim_vector& dims, int print_dims) |
|
593
|
1159 { |
|
7336
|
1160 int first_param_space = 0; |
|
|
1161 |
|
|
1162 // Calculating dimensions. |
|
|
1163 |
|
|
1164 std::string dim_str = ""; |
|
|
1165 std::stringstream ss; |
|
|
1166 long dim = dims.length (); |
|
|
1167 |
|
|
1168 first_param_space = (first_param_space >= 1 ? first_param_space : 1); |
|
|
1169 |
|
|
1170 // Preparing dimension string. |
|
|
1171 |
|
|
1172 if ((dim <= print_dims || print_dims < 0) && print_dims != 0) |
|
|
1173 { |
|
|
1174 // Dimensions string must be printed like this: 2x3x4x2. |
|
|
1175 |
|
|
1176 if (dim == 0 || dim == 1) |
|
|
1177 first_param_space = 1; // First parameter is 1. |
|
|
1178 else |
|
|
1179 { |
|
|
1180 ss << dims (0); |
|
|
1181 |
|
|
1182 dim_str = ss.str (); |
|
|
1183 first_param_space = dim_str.length (); |
|
|
1184 } |
|
|
1185 } |
|
|
1186 else |
|
593
|
1187 { |
|
7336
|
1188 // Printing dimension string as: a-D. |
|
|
1189 |
|
|
1190 ss << dim; |
|
|
1191 |
|
|
1192 dim_str = ss.str (); |
|
|
1193 first_param_space = dim_str.length (); |
|
|
1194 } |
|
|
1195 |
|
|
1196 return first_param_space; |
|
|
1197 } |
|
|
1198 |
|
|
1199 // Make the dimensions-string. For example: mat is a 2x3 matrix. |
|
|
1200 // ^^^ |
|
|
1201 // |
|
|
1202 // FIXME -- why not just use the dim_vector::str () method? |
|
|
1203 |
|
|
1204 std::string |
|
|
1205 make_dimensions_string (const dim_vector& dims, int print_dims) |
|
|
1206 { |
|
|
1207 // Calculating dimensions. |
|
|
1208 |
|
|
1209 std::string dim_str = ""; |
|
|
1210 std::stringstream ss; |
|
|
1211 long dim = dims.length (); |
|
|
1212 |
|
|
1213 // Preparing dimension string. |
|
|
1214 |
|
|
1215 if ((dim <= print_dims || print_dims < 0) && print_dims != 0) |
|
|
1216 { |
|
|
1217 // Only printing the dimension string as: axbxc... |
|
|
1218 |
|
|
1219 if (dim == 0) |
|
|
1220 ss << "1x1"; |
|
|
1221 else |
|
|
1222 { |
|
|
1223 for (int i = 0; i < dim; i++) |
|
2294
|
1224 { |
|
7336
|
1225 if (i == 0) |
|
2294
|
1226 { |
|
7336
|
1227 if (dim == 1) |
|
|
1228 { |
|
|
1229 // Looks like this is not going to happen in |
|
|
1230 // Octave, but ... |
|
|
1231 |
|
|
1232 ss << "1x" << dims (i); |
|
|
1233 } |
|
2294
|
1234 else |
|
7336
|
1235 ss << dims (i); |
|
2294
|
1236 } |
|
7336
|
1237 else if (i < dim && dim != 1) |
|
|
1238 ss << "x" << dims (i); |
|
2294
|
1239 } |
|
593
|
1240 } |
|
|
1241 } |
|
|
1242 else |
|
7336
|
1243 { |
|
|
1244 // Printing dimension string as: a-D. |
|
|
1245 |
|
|
1246 ss << dim << "-D"; |
|
|
1247 } |
|
|
1248 |
|
|
1249 dim_str = ss.str (); |
|
|
1250 |
|
|
1251 return dim_str; |
|
593
|
1252 } |
|
|
1253 |
|
7336
|
1254 // Calculate how much space needs to be reserved for the |
|
|
1255 // dimensions string. For example, |
|
|
1256 // |
|
|
1257 // mat is a 12x3 matrix |
|
|
1258 // ^^^^ => 4 columns |
|
|
1259 // |
|
|
1260 // FIXME -- why not just use the dim_vector::str () method? |
|
5659
|
1261 |
|
|
1262 static int |
|
7336
|
1263 dimensions_string_req_total_space (const dim_vector& dims, int print_dims) |
|
|
1264 { |
|
|
1265 std::string dim_str = ""; |
|
|
1266 std::stringstream ss; |
|
|
1267 |
|
|
1268 ss << make_dimensions_string (dims, print_dims); |
|
|
1269 dim_str = ss.str (); |
|
|
1270 |
|
|
1271 return dim_str.length (); |
|
|
1272 } |
|
|
1273 |
|
|
1274 static std::list<whos_parameter> |
|
|
1275 parse_whos_line_format (const std::list<symbol_table::symbol_record>& symbols) |
|
5659
|
1276 { |
|
7336
|
1277 // This method parses the string whos_line_format, and returns |
|
|
1278 // a parameter list, containing all information needed to print |
|
|
1279 // the given attributtes of the symbols |
|
|
1280 int idx; |
|
|
1281 size_t format_len = Vwhos_line_format.length (); |
|
|
1282 char garbage; |
|
|
1283 std::list<whos_parameter> params; |
|
|
1284 |
|
|
1285 size_t bytes1; |
|
|
1286 int elements1; |
|
|
1287 |
|
|
1288 std::string param_string = "abcenst"; |
|
|
1289 Array<int> param_length (dim_vector (param_string.length (), 1)); |
|
|
1290 Array<std::string> param_names (dim_vector (param_string.length (), 1)); |
|
|
1291 size_t pos_a, pos_b, pos_c, pos_e, pos_n, pos_s, pos_t; |
|
|
1292 |
|
|
1293 pos_a = param_string.find ('a'); // Attributes |
|
|
1294 pos_b = param_string.find ('b'); // Bytes |
|
|
1295 pos_c = param_string.find ('c'); // Class |
|
|
1296 pos_e = param_string.find ('e'); // Elements |
|
|
1297 pos_n = param_string.find ('n'); // Name |
|
|
1298 pos_s = param_string.find ('s'); // Size |
|
|
1299 pos_t = param_string.find ('t'); // Type |
|
|
1300 |
|
|
1301 param_names(pos_a) = "Attr"; |
|
|
1302 param_names(pos_b) = "Bytes"; |
|
|
1303 param_names(pos_c) = "Class"; |
|
|
1304 param_names(pos_e) = "Elements"; |
|
|
1305 param_names(pos_n) = "Name"; |
|
|
1306 param_names(pos_s) = "Size"; |
|
|
1307 param_names(pos_t) = "Type"; |
|
|
1308 |
|
|
1309 for (size_t i = 0; i < param_string.length (); i++) |
|
|
1310 param_length(i) = param_names(i) . length (); |
|
|
1311 |
|
|
1312 // Calculating necessary spacing for name column, |
|
|
1313 // bytes column, elements column and class column |
|
|
1314 |
|
|
1315 for (std::list<symbol_table::symbol_record>::const_iterator p = symbols.begin (); |
|
|
1316 p != symbols.end (); p++) |
|
|
1317 { |
|
|
1318 std::stringstream ss1, ss2; |
|
|
1319 std::string str; |
|
|
1320 |
|
|
1321 str = p->name (); |
|
|
1322 param_length(pos_n) = ((str.length () |
|
|
1323 > static_cast<size_t> (param_length(pos_n))) |
|
|
1324 ? str.length () : param_length(pos_n)); |
|
|
1325 |
|
|
1326 octave_value val = p->varval (); |
|
|
1327 |
|
|
1328 str = val.type_name (); |
|
|
1329 param_length(pos_t) = ((str.length () |
|
|
1330 > static_cast<size_t> (param_length(pos_t))) |
|
|
1331 ? str.length () : param_length(pos_t)); |
|
|
1332 |
|
|
1333 elements1 = val.capacity (); |
|
|
1334 ss1 << elements1; |
|
|
1335 str = ss1.str (); |
|
|
1336 param_length(pos_e) = ((str.length () |
|
|
1337 > static_cast<size_t> (param_length(pos_e))) |
|
|
1338 ? str.length () : param_length(pos_e)); |
|
|
1339 |
|
|
1340 bytes1 = val.byte_size (); |
|
|
1341 ss2 << bytes1; |
|
|
1342 str = ss2.str (); |
|
|
1343 param_length(pos_b) = ((str.length () |
|
|
1344 > static_cast<size_t> (param_length(pos_b))) |
|
|
1345 ? str.length () : param_length (pos_b)); |
|
|
1346 } |
|
|
1347 |
|
|
1348 idx = 0; |
|
|
1349 while (static_cast<size_t> (idx) < format_len) |
|
|
1350 { |
|
|
1351 whos_parameter param; |
|
|
1352 param.command = '\0'; |
|
|
1353 |
|
|
1354 if (Vwhos_line_format[idx] == '%') |
|
|
1355 { |
|
|
1356 bool error_encountered = false; |
|
|
1357 param.modifier = 'r'; |
|
|
1358 param.parameter_length = 0; |
|
|
1359 param.dimensions = 8; |
|
|
1360 |
|
|
1361 int a = 0, b = -1, c = 8, balance = 1; |
|
|
1362 unsigned int items; |
|
|
1363 size_t pos; |
|
|
1364 std::string cmd; |
|
|
1365 |
|
|
1366 // Parse one command from whos_line_format |
|
|
1367 cmd = Vwhos_line_format.substr (idx, Vwhos_line_format.length ()); |
|
|
1368 pos = cmd.find (';'); |
|
|
1369 if (pos != NPOS) |
|
|
1370 cmd = cmd.substr (0, pos+1); |
|
|
1371 else |
|
|
1372 error ("parameter without ; in whos_line_format"); |
|
|
1373 |
|
|
1374 idx += cmd.length (); |
|
|
1375 |
|
|
1376 // FIXME -- use iostream functions instead of sscanf! |
|
|
1377 |
|
|
1378 if (cmd.find_first_of ("crl") != 1) |
|
|
1379 items = sscanf (cmd.c_str (), "%c%c:%d:%d:%d:%d;", |
|
|
1380 &garbage, ¶m.command, &a, &b, &c, &balance); |
|
|
1381 else |
|
|
1382 items = sscanf (cmd.c_str (), "%c%c%c:%d:%d:%d:%d;", |
|
|
1383 &garbage, ¶m.modifier, ¶m.command, |
|
|
1384 &a, &b, &c, &balance) - 1; |
|
|
1385 |
|
|
1386 if (items < 2) |
|
|
1387 { |
|
|
1388 error ("whos_line_format: parameter structure without command in whos_line_format"); |
|
|
1389 error_encountered = true; |
|
|
1390 } |
|
|
1391 |
|
|
1392 // Insert data into parameter |
|
|
1393 param.first_parameter_length = 0; |
|
|
1394 pos = param_string.find (param.command); |
|
|
1395 if (pos != NPOS) |
|
|
1396 { |
|
|
1397 param.parameter_length = param_length(pos); |
|
|
1398 param.text = param_names(pos); |
|
|
1399 param.line.assign (param_names(pos).length (), '='); |
|
|
1400 |
|
|
1401 param.parameter_length = (a > param.parameter_length |
|
|
1402 ? a : param.parameter_length); |
|
|
1403 if (param.command == 's' && param.modifier == 'c' && b > 0) |
|
|
1404 param.first_parameter_length = b; |
|
|
1405 } |
|
|
1406 else |
|
|
1407 { |
|
|
1408 error ("whos_line_format: '%c' is not a command", |
|
|
1409 param.command); |
|
|
1410 error_encountered = true; |
|
|
1411 } |
|
|
1412 |
|
|
1413 if (param.command == 's') |
|
|
1414 { |
|
|
1415 // Have to calculate space needed for printing matrix dimensions |
|
|
1416 // Space needed for Size column is hard to determine in prior, |
|
|
1417 // because it depends on dimensions to be shown. That is why it is |
|
|
1418 // recalculated for each Size-command |
|
|
1419 int first, rest = 0, total; |
|
|
1420 param.dimensions = c; |
|
|
1421 first = param.first_parameter_length; |
|
|
1422 total = param.parameter_length; |
|
|
1423 |
|
|
1424 for (std::list<symbol_table::symbol_record>::const_iterator p = symbols.begin (); |
|
|
1425 p != symbols.end (); p++) |
|
|
1426 { |
|
|
1427 octave_value val = p->varval (); |
|
|
1428 dim_vector dims = val.dims (); |
|
|
1429 int first1 = dimensions_string_req_first_space (dims, param.dimensions); |
|
|
1430 int total1 = dimensions_string_req_total_space (dims, param.dimensions); |
|
|
1431 int rest1 = total1 - first1; |
|
|
1432 rest = (rest1 > rest ? rest1 : rest); |
|
|
1433 first = (first1 > first ? first1 : first); |
|
|
1434 total = (total1 > total ? total1 : total); |
|
|
1435 } |
|
|
1436 |
|
|
1437 if (param.modifier == 'c') |
|
|
1438 { |
|
|
1439 if (first < balance) |
|
|
1440 first += balance - first; |
|
|
1441 if (rest + balance < param.parameter_length) |
|
|
1442 rest += param.parameter_length - rest - balance; |
|
|
1443 |
|
|
1444 param.parameter_length = first + rest; |
|
|
1445 param.first_parameter_length = first; |
|
|
1446 param.balance = balance; |
|
|
1447 } |
|
|
1448 else |
|
|
1449 { |
|
|
1450 param.parameter_length = total; |
|
|
1451 param.first_parameter_length = 0; |
|
|
1452 } |
|
|
1453 } |
|
|
1454 else if (param.modifier == 'c') |
|
|
1455 { |
|
|
1456 error ("whos_line_format: modifier 'c' not available for command '%c'", |
|
|
1457 param.command); |
|
|
1458 error_encountered = true; |
|
|
1459 } |
|
|
1460 |
|
|
1461 // What happens if whos_line_format contains negative numbers |
|
|
1462 // at param_length positions? |
|
|
1463 param.balance = (b < 0 ? 0 : param.balance); |
|
|
1464 param.first_parameter_length = (b < 0 ? 0 : |
|
|
1465 param.first_parameter_length); |
|
|
1466 param.parameter_length = (a < 0 |
|
|
1467 ? 0 |
|
|
1468 : (param.parameter_length |
|
|
1469 < param_length(pos_s) |
|
|
1470 ? param_length(pos_s) |
|
|
1471 : param.parameter_length)); |
|
|
1472 |
|
|
1473 // Parameter will not be pushed into parameter list if ... |
|
|
1474 if (! error_encountered) |
|
|
1475 params.push_back (param); |
|
|
1476 } |
|
|
1477 else |
|
|
1478 { |
|
|
1479 // Text string, to be printed as it is ... |
|
|
1480 std::string text; |
|
|
1481 size_t pos; |
|
|
1482 text = Vwhos_line_format.substr (idx, Vwhos_line_format.length ()); |
|
|
1483 pos = text.find ('%'); |
|
|
1484 if (pos != NPOS) |
|
|
1485 text = text.substr (0, pos); |
|
|
1486 |
|
|
1487 // Push parameter into list ... |
|
|
1488 idx += text.length (); |
|
|
1489 param.text=text; |
|
|
1490 param.line.assign (text.length(), ' '); |
|
|
1491 params.push_back (param); |
|
|
1492 } |
|
|
1493 } |
|
|
1494 |
|
|
1495 return params; |
|
|
1496 } |
|
|
1497 |
|
|
1498 void |
|
|
1499 print_symbol_info_line (std::ostream& os, |
|
|
1500 const symbol_table::symbol_record& sr, |
|
|
1501 std::list<whos_parameter>& params) |
|
|
1502 { |
|
|
1503 octave_value val = sr.varval (); |
|
|
1504 dim_vector dims = val.dims (); |
|
|
1505 |
|
|
1506 std::list<whos_parameter>::iterator i = params.begin (); |
|
|
1507 |
|
|
1508 while (i != params.end ()) |
|
|
1509 { |
|
|
1510 whos_parameter param = *i; |
|
|
1511 |
|
|
1512 if (param.command != '\0') |
|
|
1513 { |
|
|
1514 // Do the actual printing. |
|
|
1515 |
|
|
1516 switch (param.modifier) |
|
|
1517 { |
|
|
1518 case 'l': |
|
|
1519 os << std::setiosflags (std::ios::left) |
|
|
1520 << std::setw (param.parameter_length); |
|
|
1521 break; |
|
|
1522 |
|
|
1523 case 'r': |
|
|
1524 os << std::setiosflags (std::ios::right) |
|
|
1525 << std::setw (param.parameter_length); |
|
|
1526 break; |
|
|
1527 |
|
|
1528 case 'c': |
|
|
1529 if (param.command == 's') |
|
|
1530 { |
|
|
1531 int front = param.first_parameter_length |
|
|
1532 - dimensions_string_req_first_space (dims, param.dimensions); |
|
|
1533 int back = param.parameter_length |
|
|
1534 - dimensions_string_req_total_space (dims, param.dimensions) |
|
|
1535 - front; |
|
|
1536 front = (front > 0) ? front : 0; |
|
|
1537 back = (back > 0) ? back : 0; |
|
|
1538 |
|
|
1539 os << std::setiosflags (std::ios::left) |
|
|
1540 << std::setw (front) |
|
|
1541 << "" |
|
|
1542 << std::resetiosflags (std::ios::left) |
|
|
1543 << make_dimensions_string (dims, param.dimensions) |
|
|
1544 << std::setiosflags (std::ios::left) |
|
|
1545 << std::setw (back) |
|
|
1546 << "" |
|
|
1547 << std::resetiosflags (std::ios::left); |
|
|
1548 } |
|
|
1549 else |
|
|
1550 { |
|
|
1551 os << std::setiosflags (std::ios::left) |
|
|
1552 << std::setw (param.parameter_length); |
|
|
1553 } |
|
|
1554 break; |
|
|
1555 |
|
|
1556 default: |
|
|
1557 error ("whos_line_format: modifier `%c' unknown", |
|
|
1558 param.modifier); |
|
|
1559 |
|
|
1560 os << std::setiosflags (std::ios::right) |
|
|
1561 << std::setw (param.parameter_length); |
|
|
1562 } |
|
|
1563 |
|
|
1564 switch (param.command) |
|
|
1565 { |
|
|
1566 case 'a': |
|
|
1567 { |
|
|
1568 char tmp[5]; |
|
|
1569 |
|
|
1570 tmp[0] = (sr.is_automatic () ? 'a' : ' '); |
|
|
1571 tmp[1] = (sr.is_formal () ? 'f' : ' '); |
|
|
1572 tmp[2] = (sr.is_global () ? 'g' : ' '); |
|
|
1573 tmp[3] = (sr.is_persistent () ? 'p' : ' '); |
|
|
1574 tmp[4] = 0; |
|
|
1575 |
|
|
1576 os << tmp; |
|
|
1577 } |
|
|
1578 break; |
|
|
1579 |
|
|
1580 case 'b': |
|
|
1581 os << val.byte_size (); |
|
|
1582 break; |
|
|
1583 |
|
|
1584 case 'c': |
|
|
1585 os << val.class_name (); |
|
|
1586 break; |
|
|
1587 |
|
|
1588 case 'e': |
|
|
1589 os << val.capacity (); |
|
|
1590 break; |
|
|
1591 |
|
|
1592 case 'n': |
|
|
1593 os << sr.name (); |
|
|
1594 break; |
|
|
1595 |
|
|
1596 case 's': |
|
|
1597 if (param.modifier != 'c') |
|
|
1598 os << make_dimensions_string (dims, param.dimensions); |
|
|
1599 break; |
|
|
1600 |
|
|
1601 case 't': |
|
|
1602 os << val.type_name (); |
|
|
1603 break; |
|
|
1604 |
|
|
1605 default: |
|
|
1606 error ("whos_line_format: command `%c' unknown", param.command); |
|
|
1607 } |
|
|
1608 |
|
|
1609 os << std::resetiosflags (std::ios::left) |
|
|
1610 << std::resetiosflags (std::ios::right); |
|
|
1611 i++; |
|
|
1612 } |
|
|
1613 else |
|
|
1614 { |
|
|
1615 os << param.text; |
|
|
1616 i++; |
|
|
1617 } |
|
|
1618 } |
|
5659
|
1619 } |
|
|
1620 |
|
4435
|
1621 static octave_value |
|
7336
|
1622 do_who (int argc, const string_vector& argv, bool return_list, |
|
|
1623 bool verbose = false) |
|
529
|
1624 { |
|
4435
|
1625 octave_value retval; |
|
529
|
1626 |
|
3523
|
1627 std::string my_name = argv[0]; |
|
584
|
1628 |
|
7336
|
1629 bool global_only = false; |
|
|
1630 |
|
1857
|
1631 int i; |
|
|
1632 for (i = 1; i < argc; i++) |
|
529
|
1633 { |
|
7336
|
1634 if (argv[i] == "-regexp" || argv[i] == "-file") |
|
529
|
1635 { |
|
7336
|
1636 error ("%s: `%s' option not implemented", my_name.c_str (), |
|
|
1637 argv[i].c_str ()); |
|
|
1638 |
|
|
1639 return retval; |
|
529
|
1640 } |
|
7336
|
1641 else if (argv[i] == "global") |
|
|
1642 global_only = true; |
|
1755
|
1643 else if (argv[i][0] == '-') |
|
|
1644 warning ("%s: unrecognized option `%s'", my_name.c_str (), |
|
|
1645 argv[i].c_str ()); |
|
529
|
1646 else |
|
867
|
1647 break; |
|
529
|
1648 } |
|
|
1649 |
|
7336
|
1650 int npats = argc - i; |
|
|
1651 string_vector pats (npats > 0 ? npats : 1); |
|
|
1652 if (npats > 0) |
|
3248
|
1653 { |
|
7336
|
1654 for (int j = 0; j < npats; j++) |
|
|
1655 pats[j] = argv[i+j]; |
|
3248
|
1656 } |
|
7336
|
1657 else |
|
|
1658 pats[0] = "*"; |
|
|
1659 |
|
|
1660 symbol_table::scope_id scope = global_only |
|
|
1661 ? symbol_table::global_scope () : symbol_table::current_scope (); |
|
|
1662 |
|
|
1663 std::list<symbol_table::symbol_record> symbols |
|
|
1664 = symbol_table::glob_variables (pats, scope); |
|
|
1665 |
|
|
1666 size_t symbols_len = symbols.size (); |
|
529
|
1667 |
|
4435
|
1668 if (return_list) |
|
529
|
1669 { |
|
7336
|
1670 if (verbose) |
|
4435
|
1671 { |
|
5659
|
1672 Array<octave_value> name_info (symbols_len, 1); |
|
|
1673 Array<octave_value> size_info (symbols_len, 1); |
|
|
1674 Array<octave_value> bytes_info (symbols_len, 1); |
|
|
1675 Array<octave_value> class_info (symbols_len, 1); |
|
|
1676 Array<octave_value> global_info (symbols_len, 1); |
|
|
1677 Array<octave_value> sparse_info (symbols_len, 1); |
|
|
1678 Array<octave_value> complex_info (symbols_len, 1); |
|
|
1679 Array<octave_value> nesting_info (symbols_len, 1); |
|
|
1680 |
|
7336
|
1681 std::list<symbol_table::symbol_record>::const_iterator p |
|
|
1682 = symbols.begin (); |
|
|
1683 |
|
|
1684 for (size_t j = 0; j < symbols_len; j++) |
|
5659
|
1685 { |
|
7336
|
1686 const symbol_table::symbol_record& sr = *p++; |
|
5659
|
1687 |
|
|
1688 Octave_map ni; |
|
|
1689 |
|
|
1690 std::string caller_function_name; |
|
5743
|
1691 |
|
|
1692 octave_function *caller = octave_call_stack::caller (); |
|
|
1693 if (caller) |
|
|
1694 caller_function_name = caller->name (); |
|
5659
|
1695 |
|
|
1696 ni.assign ("function", caller_function_name); |
|
|
1697 ni.assign ("level", 1); |
|
|
1698 |
|
7336
|
1699 name_info(j) = sr.name (); |
|
|
1700 global_info(j) = sr.is_global (); |
|
|
1701 |
|
|
1702 octave_value val = sr.varval (); |
|
|
1703 |
|
|
1704 size_info(j) = val.size (); |
|
|
1705 bytes_info(j) = val.byte_size (); |
|
|
1706 class_info(j) = val.class_name (); |
|
|
1707 sparse_info(j) = val.is_sparse_type (); |
|
|
1708 complex_info(j) = val.is_complex_type (); |
|
5659
|
1709 nesting_info(j) = ni; |
|
|
1710 } |
|
|
1711 |
|
|
1712 Octave_map info; |
|
|
1713 |
|
|
1714 info.assign ("name", name_info); |
|
|
1715 info.assign ("size", size_info); |
|
|
1716 info.assign ("bytes", bytes_info); |
|
|
1717 info.assign ("class", class_info); |
|
|
1718 info.assign ("global", global_info); |
|
|
1719 info.assign ("sparse", sparse_info); |
|
|
1720 info.assign ("complex", complex_info); |
|
|
1721 info.assign ("nesting", nesting_info); |
|
|
1722 |
|
|
1723 retval = info; |
|
4435
|
1724 } |
|
|
1725 else |
|
5659
|
1726 { |
|
|
1727 string_vector names; |
|
|
1728 |
|
|
1729 if (symbols_len > 0) |
|
|
1730 { |
|
|
1731 names.resize (symbols_len); |
|
|
1732 |
|
7336
|
1733 std::list<symbol_table::symbol_record>::const_iterator p |
|
|
1734 = symbols.begin (); |
|
|
1735 |
|
|
1736 for (size_t j = 0; j < symbols_len; j++) |
|
|
1737 { |
|
|
1738 names[j] = p->name (); |
|
|
1739 p++; |
|
|
1740 } |
|
5659
|
1741 } |
|
|
1742 |
|
|
1743 retval = Cell (names); |
|
|
1744 } |
|
529
|
1745 } |
|
7336
|
1746 else if (symbols_len > 0) |
|
529
|
1747 { |
|
7336
|
1748 if (global_only) |
|
|
1749 octave_stdout << "Global variables:\n\n"; |
|
|
1750 else |
|
|
1751 octave_stdout << "Variables in the current scope:\n\n"; |
|
|
1752 |
|
|
1753 if (verbose) |
|
4435
|
1754 { |
|
7336
|
1755 size_t bytes = 0; |
|
|
1756 size_t elements = 0; |
|
|
1757 |
|
|
1758 std::list<whos_parameter> params; |
|
|
1759 |
|
|
1760 params = parse_whos_line_format (symbols); |
|
|
1761 |
|
|
1762 print_descriptor (octave_stdout, params); |
|
|
1763 |
|
|
1764 octave_stdout << "\n"; |
|
|
1765 |
|
|
1766 for (std::list<symbol_table::symbol_record>::const_iterator p = symbols.begin (); |
|
|
1767 p != symbols.end (); p++) |
|
|
1768 { |
|
|
1769 print_symbol_info_line (octave_stdout, *p, params); |
|
|
1770 octave_value val = p->varval (); |
|
|
1771 elements += val.capacity (); |
|
|
1772 bytes += val.byte_size (); |
|
|
1773 } |
|
|
1774 |
|
|
1775 octave_stdout << "\nTotal is " << elements |
|
|
1776 << (elements == 1 ? " element" : " elements") |
|
|
1777 << " using " << bytes |
|
|
1778 << (bytes == 1 ? " byte" : " bytes") << "\n"; |
|
4435
|
1779 } |
|
7336
|
1780 else |
|
4435
|
1781 { |
|
7336
|
1782 string_vector names (symbols_len); |
|
|
1783 |
|
|
1784 std::list<symbol_table::symbol_record>::const_iterator p |
|
|
1785 = symbols.begin (); |
|
|
1786 |
|
|
1787 for (size_t j = 0; j < symbols_len; j++) |
|
|
1788 { |
|
|
1789 names[j] = p->name (); |
|
|
1790 p++; |
|
|
1791 } |
|
|
1792 |
|
|
1793 names.list_in_columns (octave_stdout); |
|
4435
|
1794 } |
|
|
1795 |
|
7336
|
1796 octave_stdout << "\n"; |
|
529
|
1797 } |
|
|
1798 |
|
581
|
1799 return retval; |
|
|
1800 } |
|
|
1801 |
|
4435
|
1802 DEFCMD (who, args, nargout, |
|
3361
|
1803 "-*- texinfo -*-\n\ |
|
|
1804 @deffn {Command} who options pattern @dots{}\n\ |
|
|
1805 @deffnx {Command} whos options pattern @dots{}\n\ |
|
|
1806 List currently defined symbols matching the given patterns. The\n\ |
|
|
1807 following are valid options. They may be shortened to one character but\n\ |
|
|
1808 may not be combined.\n\ |
|
|
1809 \n\ |
|
|
1810 @table @code\n\ |
|
|
1811 @item -all\n\ |
|
|
1812 List all currently defined symbols.\n\ |
|
|
1813 \n\ |
|
|
1814 @item -builtins\n\ |
|
5794
|
1815 List built-in functions. This includes all currently\n\ |
|
3361
|
1816 compiled function files, but does not include all function files that\n\ |
|
5814
|
1817 are in the search path.\n\ |
|
581
|
1818 \n\ |
|
3361
|
1819 @item -functions\n\ |
|
|
1820 List user-defined functions.\n\ |
|
|
1821 \n\ |
|
|
1822 @item -long\n\ |
|
|
1823 Print a long listing including the type and dimensions of any symbols.\n\ |
|
|
1824 The symbols in the first column of output indicate whether it is\n\ |
|
|
1825 possible to redefine the symbol, and whether it is possible for it to be\n\ |
|
|
1826 cleared.\n\ |
|
|
1827 \n\ |
|
|
1828 @item -variables\n\ |
|
|
1829 List user-defined variables.\n\ |
|
|
1830 @end table\n\ |
|
|
1831 \n\ |
|
|
1832 Valid patterns are the same as described for the @code{clear} command\n\ |
|
|
1833 above. If no patterns are supplied, all symbols from the given category\n\ |
|
|
1834 are listed. By default, only user defined functions and variables\n\ |
|
|
1835 visible in the local scope are displayed.\n\ |
|
|
1836 \n\ |
|
|
1837 The command @kbd{whos} is equivalent to @kbd{who -long}.\n\ |
|
|
1838 @end deffn") |
|
581
|
1839 { |
|
4435
|
1840 octave_value retval; |
|
581
|
1841 |
|
4435
|
1842 if (nargout < 2) |
|
|
1843 { |
|
|
1844 int argc = args.length () + 1; |
|
|
1845 |
|
|
1846 string_vector argv = args.make_argv ("who"); |
|
1755
|
1847 |
|
7336
|
1848 if (! error_state) |
|
|
1849 retval = do_who (argc, argv, nargout == 1); |
|
4435
|
1850 } |
|
|
1851 else |
|
5823
|
1852 print_usage (); |
|
581
|
1853 |
|
529
|
1854 return retval; |
|
|
1855 } |
|
|
1856 |
|
4435
|
1857 DEFCMD (whos, args, nargout, |
|
3458
|
1858 "-*- texinfo -*-\n\ |
|
|
1859 @deffn {Command} whos options pattern @dots{}\n\ |
|
|
1860 See who.\n\ |
|
|
1861 @end deffn") |
|
581
|
1862 { |
|
4435
|
1863 octave_value retval; |
|
712
|
1864 |
|
4435
|
1865 if (nargout < 2) |
|
|
1866 { |
|
7336
|
1867 int argc = args.length () + 1; |
|
|
1868 |
|
|
1869 string_vector argv = args.make_argv ("whos"); |
|
|
1870 |
|
|
1871 if (! error_state) |
|
|
1872 retval = do_who (argc, argv, nargout == 1, true); |
|
4435
|
1873 } |
|
|
1874 else |
|
5823
|
1875 print_usage (); |
|
581
|
1876 |
|
|
1877 return retval; |
|
|
1878 } |
|
|
1879 |
|
593
|
1880 // Defining variables. |
|
|
1881 |
|
1162
|
1882 void |
|
2856
|
1883 bind_ans (const octave_value& val, bool print) |
|
1162
|
1884 { |
|
7336
|
1885 static std::string ans = "ans"; |
|
1162
|
1886 |
|
2978
|
1887 if (val.is_defined ()) |
|
|
1888 { |
|
7336
|
1889 symbol_table::varref (ans) = val; |
|
1162
|
1890 |
|
2978
|
1891 if (print) |
|
7336
|
1892 val.print_with_name (octave_stdout, ans); |
|
2978
|
1893 } |
|
1162
|
1894 } |
|
|
1895 |
|
593
|
1896 void |
|
5794
|
1897 bind_internal_variable (const std::string& fname, const octave_value& val) |
|
593
|
1898 { |
|
5794
|
1899 octave_value_list args; |
|
|
1900 |
|
|
1901 args(0) = val; |
|
|
1902 |
|
|
1903 feval (fname, args, 0); |
|
529
|
1904 } |
|
|
1905 |
|
4319
|
1906 void |
|
7336
|
1907 mlock (void) |
|
4319
|
1908 { |
|
7336
|
1909 octave_function *fcn = octave_call_stack::caller (); |
|
|
1910 |
|
|
1911 if (fcn) |
|
|
1912 fcn->lock (); |
|
|
1913 else |
|
|
1914 error ("mlock: invalid use outside a function"); |
|
4319
|
1915 } |
|
|
1916 |
|
|
1917 void |
|
|
1918 munlock (const std::string& nm) |
|
|
1919 { |
|
7336
|
1920 octave_value val = symbol_table::find_function (nm); |
|
|
1921 |
|
|
1922 if (val.is_defined ()) |
|
|
1923 { |
|
|
1924 octave_function *fcn = val.function_value (); |
|
|
1925 |
|
|
1926 if (fcn) |
|
|
1927 fcn->unlock (); |
|
|
1928 } |
|
4319
|
1929 } |
|
|
1930 |
|
|
1931 bool |
|
|
1932 mislocked (const std::string& nm) |
|
|
1933 { |
|
7336
|
1934 bool retval = false; |
|
|
1935 |
|
|
1936 octave_value val = symbol_table::find_function (nm); |
|
|
1937 |
|
|
1938 if (val.is_defined ()) |
|
|
1939 { |
|
|
1940 octave_function *fcn = val.function_value (); |
|
|
1941 |
|
|
1942 if (fcn) |
|
|
1943 retval = fcn->islocked (); |
|
|
1944 } |
|
|
1945 |
|
|
1946 return retval; |
|
4319
|
1947 } |
|
|
1948 |
|
|
1949 DEFCMD (mlock, args, , |
|
|
1950 "-*- texinfo -*-\n\ |
|
4526
|
1951 @deftypefn {Built-in Function} {} mlock (@var{name})\n\ |
|
7336
|
1952 Lock the current function into memory so that it can't be cleared.\n\ |
|
5642
|
1953 @seealso{munlock, mislocked, persistent}\n\ |
|
|
1954 @end deftypefn") |
|
4319
|
1955 { |
|
|
1956 octave_value_list retval; |
|
|
1957 |
|
7336
|
1958 if (args.length () == 0) |
|
|
1959 mlock (); |
|
4319
|
1960 else |
|
5823
|
1961 print_usage (); |
|
4319
|
1962 |
|
|
1963 return retval; |
|
|
1964 } |
|
|
1965 |
|
|
1966 DEFCMD (munlock, args, , |
|
|
1967 "-*- texinfo -*-\n\ |
|
|
1968 @deftypefn {Built-in Function} {} munlock (@var{fcn})\n\ |
|
|
1969 Unlock the named function. If no function is named\n\ |
|
|
1970 then unlock the current function.\n\ |
|
5642
|
1971 @seealso{mlock, mislocked, persistent}\n\ |
|
|
1972 @end deftypefn") |
|
4319
|
1973 { |
|
|
1974 octave_value_list retval; |
|
|
1975 |
|
|
1976 if (args.length() == 1) |
|
|
1977 { |
|
|
1978 std::string name = args(0).string_value (); |
|
|
1979 |
|
|
1980 if (! error_state) |
|
|
1981 munlock (name); |
|
|
1982 else |
|
|
1983 error ("munlock: expecting argument to be a function name"); |
|
|
1984 } |
|
|
1985 else if (args.length () == 0) |
|
|
1986 { |
|
7336
|
1987 octave_function *fcn = octave_call_stack::caller (); |
|
5743
|
1988 |
|
|
1989 if (fcn) |
|
7336
|
1990 fcn->unlock (); |
|
4319
|
1991 else |
|
|
1992 error ("munlock: invalid use outside a function"); |
|
|
1993 } |
|
|
1994 else |
|
5823
|
1995 print_usage (); |
|
4319
|
1996 |
|
|
1997 return retval; |
|
|
1998 } |
|
|
1999 |
|
|
2000 |
|
|
2001 DEFCMD (mislocked, args, , |
|
|
2002 "-*- texinfo -*-\n\ |
|
|
2003 @deftypefn {Built-in Function} {} mislocked (@var{fcn})\n\ |
|
|
2004 Return true if the named function is locked. If no function is named\n\ |
|
|
2005 then return true if the current function is locked.\n\ |
|
5642
|
2006 @seealso{mlock, munlock, persistent}\n\ |
|
|
2007 @end deftypefn") |
|
4319
|
2008 { |
|
|
2009 octave_value retval; |
|
|
2010 |
|
|
2011 if (args.length() == 1) |
|
|
2012 { |
|
|
2013 std::string name = args(0).string_value (); |
|
|
2014 |
|
|
2015 if (! error_state) |
|
|
2016 retval = mislocked (name); |
|
|
2017 else |
|
|
2018 error ("mislocked: expecting argument to be a function name"); |
|
|
2019 } |
|
|
2020 else if (args.length () == 0) |
|
|
2021 { |
|
7336
|
2022 octave_function *fcn = octave_call_stack::caller (); |
|
5743
|
2023 |
|
|
2024 if (fcn) |
|
7336
|
2025 retval = fcn->islocked (); |
|
4319
|
2026 else |
|
|
2027 error ("mislocked: invalid use outside a function"); |
|
|
2028 } |
|
|
2029 else |
|
5823
|
2030 print_usage (); |
|
4319
|
2031 |
|
|
2032 return retval; |
|
|
2033 } |
|
|
2034 |
|
593
|
2035 // Deleting names from the symbol tables. |
|
|
2036 |
|
3681
|
2037 static inline bool |
|
4009
|
2038 name_matches_any_pattern (const std::string& nm, |
|
|
2039 const string_vector& argv, int argc, int idx) |
|
3681
|
2040 { |
|
|
2041 bool retval = false; |
|
|
2042 |
|
|
2043 for (int k = idx; k < argc; k++) |
|
|
2044 { |
|
|
2045 std::string patstr = argv[k]; |
|
|
2046 |
|
|
2047 if (! patstr.empty ()) |
|
|
2048 { |
|
|
2049 glob_match pattern (patstr); |
|
|
2050 |
|
|
2051 if (pattern.match (nm)) |
|
|
2052 { |
|
|
2053 retval = true; |
|
|
2054 break; |
|
|
2055 } |
|
|
2056 } |
|
|
2057 } |
|
|
2058 |
|
|
2059 return retval; |
|
|
2060 } |
|
|
2061 |
|
4009
|
2062 static inline void |
|
|
2063 maybe_warn_exclusive (bool exclusive) |
|
|
2064 { |
|
|
2065 if (exclusive) |
|
|
2066 warning ("clear: ignoring --exclusive option"); |
|
|
2067 } |
|
|
2068 |
|
7336
|
2069 static void |
|
4009
|
2070 do_clear_functions (const string_vector& argv, int argc, int idx, |
|
|
2071 bool exclusive = false) |
|
|
2072 { |
|
|
2073 if (idx == argc) |
|
7336
|
2074 symbol_table::clear_functions (); |
|
4009
|
2075 else |
|
|
2076 { |
|
|
2077 if (exclusive) |
|
|
2078 { |
|
7336
|
2079 string_vector fcns = symbol_table::user_function_names (); |
|
4009
|
2080 |
|
|
2081 int fcount = fcns.length (); |
|
|
2082 |
|
|
2083 for (int i = 0; i < fcount; i++) |
|
|
2084 { |
|
|
2085 std::string nm = fcns[i]; |
|
|
2086 |
|
|
2087 if (! name_matches_any_pattern (nm, argv, argc, idx)) |
|
7336
|
2088 symbol_table::clear_function (nm); |
|
4009
|
2089 } |
|
|
2090 } |
|
|
2091 else |
|
|
2092 { |
|
|
2093 while (idx < argc) |
|
7336
|
2094 symbol_table::clear_function_pattern (argv[idx++]); |
|
4009
|
2095 } |
|
|
2096 } |
|
|
2097 } |
|
|
2098 |
|
7336
|
2099 static void |
|
4009
|
2100 do_clear_globals (const string_vector& argv, int argc, int idx, |
|
|
2101 bool exclusive = false) |
|
|
2102 { |
|
|
2103 if (idx == argc) |
|
7336
|
2104 symbol_table::clear_variables(symbol_table::global_scope ()); |
|
4009
|
2105 else |
|
|
2106 { |
|
|
2107 if (exclusive) |
|
|
2108 { |
|
7336
|
2109 string_vector gvars |
|
|
2110 = symbol_table::variable_names (symbol_table::global_scope ()); |
|
4009
|
2111 |
|
|
2112 int gcount = gvars.length (); |
|
|
2113 |
|
|
2114 for (int i = 0; i < gcount; i++) |
|
|
2115 { |
|
|
2116 std::string nm = gvars[i]; |
|
|
2117 |
|
|
2118 if (! name_matches_any_pattern (nm, argv, argc, idx)) |
|
7336
|
2119 symbol_table::clear_global (nm); |
|
4009
|
2120 } |
|
|
2121 } |
|
|
2122 else |
|
|
2123 { |
|
|
2124 while (idx < argc) |
|
7336
|
2125 symbol_table::clear_global_pattern (argv[idx++]); |
|
4009
|
2126 } |
|
|
2127 } |
|
|
2128 } |
|
|
2129 |
|
7336
|
2130 static void |
|
4009
|
2131 do_clear_variables (const string_vector& argv, int argc, int idx, |
|
|
2132 bool exclusive = false) |
|
|
2133 { |
|
|
2134 if (idx == argc) |
|
7336
|
2135 symbol_table::clear_variables (); |
|
4009
|
2136 else |
|
|
2137 { |
|
|
2138 if (exclusive) |
|
|
2139 { |
|
7336
|
2140 string_vector lvars = symbol_table::variable_names (); |
|
4009
|
2141 |
|
|
2142 int lcount = lvars.length (); |
|
|
2143 |
|
|
2144 for (int i = 0; i < lcount; i++) |
|
|
2145 { |
|
|
2146 std::string nm = lvars[i]; |
|
|
2147 |
|
|
2148 if (! name_matches_any_pattern (nm, argv, argc, idx)) |
|
7336
|
2149 symbol_table::clear_variable (nm); |
|
4009
|
2150 } |
|
|
2151 } |
|
|
2152 else |
|
|
2153 { |
|
|
2154 while (idx < argc) |
|
7336
|
2155 symbol_table::clear_variable_pattern (argv[idx++]); |
|
4009
|
2156 } |
|
|
2157 } |
|
|
2158 } |
|
|
2159 |
|
7336
|
2160 static void |
|
4009
|
2161 do_clear_symbols (const string_vector& argv, int argc, int idx, |
|
|
2162 bool exclusive = false) |
|
|
2163 { |
|
|
2164 if (idx == argc) |
|
7336
|
2165 symbol_table::clear_variables (); |
|
4009
|
2166 else |
|
|
2167 { |
|
|
2168 if (exclusive) |
|
|
2169 { |
|
5775
|
2170 // FIXME -- is this really what we want, or do we |
|
4009
|
2171 // somehow want to only clear the functions that are not |
|
|
2172 // shadowed by local variables? It seems that would be a |
|
|
2173 // bit harder to do. |
|
|
2174 |
|
|
2175 do_clear_variables (argv, argc, idx, exclusive); |
|
|
2176 do_clear_functions (argv, argc, idx, exclusive); |
|
|
2177 } |
|
|
2178 else |
|
|
2179 { |
|
|
2180 while (idx < argc) |
|
7336
|
2181 symbol_table::clear_symbol_pattern (argv[idx++]); |
|
4009
|
2182 } |
|
|
2183 } |
|
|
2184 } |
|
|
2185 |
|
|
2186 static void |
|
|
2187 do_matlab_compatible_clear (const string_vector& argv, int argc, int idx) |
|
|
2188 { |
|
|
2189 // This is supposed to be mostly Matlab compatible. |
|
|
2190 |
|
|
2191 for (; idx < argc; idx++) |
|
|
2192 { |
|
7336
|
2193 if (argv[idx] == "all" |
|
|
2194 && ! symbol_table::is_local_variable ("all")) |
|
4009
|
2195 { |
|
7336
|
2196 symbol_table::clear_all (); |
|
4009
|
2197 } |
|
7336
|
2198 else if (argv[idx] == "functions" |
|
|
2199 && ! symbol_table::is_local_variable ("functions")) |
|
4009
|
2200 { |
|
|
2201 do_clear_functions (argv, argc, ++idx); |
|
|
2202 } |
|
7336
|
2203 else if (argv[idx] == "global" |
|
|
2204 && ! symbol_table::is_local_variable ("global")) |
|
4009
|
2205 { |
|
|
2206 do_clear_globals (argv, argc, ++idx); |
|
|
2207 } |
|
7336
|
2208 else if (argv[idx] == "variables" |
|
|
2209 && ! symbol_table::is_local_variable ("variables")) |
|
4009
|
2210 { |
|
7336
|
2211 symbol_table::clear_variables (); |
|
4009
|
2212 } |
|
|
2213 else |
|
|
2214 { |
|
7336
|
2215 symbol_table::clear_symbol_pattern (argv[idx]); |
|
4009
|
2216 } |
|
|
2217 } |
|
|
2218 } |
|
|
2219 |
|
|
2220 #define CLEAR_OPTION_ERROR(cond) \ |
|
|
2221 do \ |
|
|
2222 { \ |
|
|
2223 if (cond) \ |
|
|
2224 { \ |
|
5823
|
2225 print_usage (); \ |
|
4009
|
2226 return retval; \ |
|
|
2227 } \ |
|
|
2228 } \ |
|
|
2229 while (0) |
|
|
2230 |
|
4208
|
2231 DEFCMD (clear, args, , |
|
3361
|
2232 "-*- texinfo -*-\n\ |
|
7347
|
2233 @deffn {Command} clear [options] pattern @dots{}\n\ |
|
3361
|
2234 Delete the names matching the given patterns from the symbol table. The\n\ |
|
|
2235 pattern may contain the following special characters:\n\ |
|
4016
|
2236 \n\ |
|
3361
|
2237 @table @code\n\ |
|
|
2238 @item ?\n\ |
|
|
2239 Match any single character.\n\ |
|
668
|
2240 \n\ |
|
3361
|
2241 @item *\n\ |
|
|
2242 Match zero or more characters.\n\ |
|
|
2243 \n\ |
|
|
2244 @item [ @var{list} ]\n\ |
|
|
2245 Match the list of characters specified by @var{list}. If the first\n\ |
|
|
2246 character is @code{!} or @code{^}, match all characters except those\n\ |
|
|
2247 specified by @var{list}. For example, the pattern @samp{[a-zA-Z]} will\n\ |
|
|
2248 match all lower and upper case alphabetic characters.\n\ |
|
|
2249 @end table\n\ |
|
|
2250 \n\ |
|
|
2251 For example, the command\n\ |
|
593
|
2252 \n\ |
|
3361
|
2253 @example\n\ |
|
|
2254 clear foo b*r\n\ |
|
|
2255 @end example\n\ |
|
|
2256 \n\ |
|
|
2257 @noindent\n\ |
|
|
2258 clears the name @code{foo} and all names that begin with the letter\n\ |
|
|
2259 @code{b} and end with the letter @code{r}.\n\ |
|
668
|
2260 \n\ |
|
3361
|
2261 If @code{clear} is called without any arguments, all user-defined\n\ |
|
|
2262 variables (local and global) are cleared from the symbol table. If\n\ |
|
|
2263 @code{clear} is called with at least one argument, only the visible\n\ |
|
|
2264 names matching the arguments are cleared. For example, suppose you have\n\ |
|
|
2265 defined a function @code{foo}, and then hidden it by performing the\n\ |
|
|
2266 assignment @code{foo = 2}. Executing the command @kbd{clear foo} once\n\ |
|
|
2267 will clear the variable definition and restore the definition of\n\ |
|
|
2268 @code{foo} as a function. Executing @kbd{clear foo} a second time will\n\ |
|
|
2269 clear the function definition.\n\ |
|
|
2270 \n\ |
|
7347
|
2271 The following options are available in both long and short form\n\ |
|
|
2272 @table @code\n\ |
|
|
2273 @item -all, -a\n\ |
|
|
2274 Clears all local and global user-defined variables and all functions\n\ |
|
|
2275 from the symbol table.\n\ |
|
|
2276 \n\ |
|
|
2277 @item -exclusive, -x\n\ |
|
|
2278 Clears the variables that don't match the following pattern.\n\ |
|
|
2279 \n\ |
|
|
2280 @item -functions, -f\n\ |
|
|
2281 Clears the function names and the built-in symbols names.\n\ |
|
|
2282 @item -global, -g\n\ |
|
|
2283 Clears the global symbol names.\n\ |
|
|
2284 @item -variables, -v\n\ |
|
|
2285 Clears the local variable names.\n\ |
|
|
2286 @end table\n\ |
|
|
2287 With the execption of @code{exclusive}, all long options can be used \n\ |
|
|
2288 without the dash as well.\n\ |
|
3361
|
2289 @end deffn") |
|
529
|
2290 { |
|
2086
|
2291 octave_value_list retval; |
|
593
|
2292 |
|
1755
|
2293 int argc = args.length () + 1; |
|
593
|
2294 |
|
1968
|
2295 string_vector argv = args.make_argv ("clear"); |
|
1755
|
2296 |
|
4009
|
2297 if (! error_state) |
|
529
|
2298 { |
|
4009
|
2299 if (argc == 1) |
|
593
|
2300 { |
|
7336
|
2301 symbol_table::clear_variables (); |
|
3681
|
2302 } |
|
|
2303 else |
|
|
2304 { |
|
4009
|
2305 int idx = 0; |
|
|
2306 |
|
|
2307 bool clear_all = false; |
|
|
2308 bool clear_functions = false; |
|
|
2309 bool clear_globals = false; |
|
|
2310 bool clear_variables = false; |
|
|
2311 bool exclusive = false; |
|
|
2312 bool have_dash_option = false; |
|
3681
|
2313 |
|
4009
|
2314 while (++idx < argc) |
|
|
2315 { |
|
4010
|
2316 if (argv[idx] == "-all" || argv[idx] == "-a") |
|
593
|
2317 { |
|
4009
|
2318 CLEAR_OPTION_ERROR (have_dash_option && ! exclusive); |
|
3681
|
2319 |
|
4009
|
2320 have_dash_option = true; |
|
|
2321 clear_all = true; |
|
|
2322 } |
|
4010
|
2323 else if (argv[idx] == "-exclusive" || argv[idx] == "-x") |
|
4009
|
2324 { |
|
|
2325 have_dash_option = true; |
|
|
2326 exclusive = true; |
|
|
2327 } |
|
4010
|
2328 else if (argv[idx] == "-functions" || argv[idx] == "-f") |
|
4009
|
2329 { |
|
|
2330 CLEAR_OPTION_ERROR (have_dash_option && ! exclusive); |
|
3681
|
2331 |
|
4009
|
2332 have_dash_option = true; |
|
|
2333 clear_functions = true; |
|
|
2334 } |
|
4010
|
2335 else if (argv[idx] == "-global" || argv[idx] == "-g") |
|
4009
|
2336 { |
|
|
2337 CLEAR_OPTION_ERROR (have_dash_option && ! exclusive); |
|
|
2338 |
|
|
2339 have_dash_option = true; |
|
|
2340 clear_globals = true; |
|
|
2341 } |
|
4010
|
2342 else if (argv[idx] == "-variables" || argv[idx] == "-v") |
|
4009
|
2343 { |
|
|
2344 CLEAR_OPTION_ERROR (have_dash_option && ! exclusive); |
|
3681
|
2345 |
|
4009
|
2346 have_dash_option = true; |
|
|
2347 clear_variables = true; |
|
|
2348 } |
|
|
2349 else |
|
|
2350 break; |
|
|
2351 } |
|
3681
|
2352 |
|
4224
|
2353 if (idx <= argc) |
|
4009
|
2354 { |
|
|
2355 if (! have_dash_option) |
|
|
2356 { |
|
|
2357 do_matlab_compatible_clear (argv, argc, idx); |
|
|
2358 } |
|
|
2359 else |
|
|
2360 { |
|
|
2361 if (clear_all) |
|
3681
|
2362 { |
|
4009
|
2363 maybe_warn_exclusive (exclusive); |
|
3681
|
2364 |
|
4009
|
2365 if (++idx < argc) |
|
|
2366 warning |
|
4010
|
2367 ("clear: ignoring extra arguments after -all"); |
|
3681
|
2368 |
|
7336
|
2369 symbol_table::clear_all (); |
|
4009
|
2370 } |
|
|
2371 else if (clear_functions) |
|
|
2372 { |
|
|
2373 do_clear_functions (argv, argc, idx, exclusive); |
|
|
2374 } |
|
|
2375 else if (clear_globals) |
|
593
|
2376 { |
|
4009
|
2377 do_clear_globals (argv, argc, idx, exclusive); |
|
|
2378 } |
|
|
2379 else if (clear_variables) |
|
|
2380 { |
|
|
2381 do_clear_variables (argv, argc, idx, exclusive); |
|
|
2382 } |
|
|
2383 else |
|
|
2384 { |
|
|
2385 do_clear_symbols (argv, argc, idx, exclusive); |
|
593
|
2386 } |
|
|
2387 } |
|
|
2388 } |
|
|
2389 } |
|
|
2390 } |
|
|
2391 |
|
|
2392 return retval; |
|
529
|
2393 } |
|
|
2394 |
|
3933
|
2395 DEFUN (__print_symtab_info__, args, , |
|
3446
|
2396 "-*- texinfo -*-\n\ |
|
3933
|
2397 @deftypefn {Built-in Function} {} __print_symtab_info__ ()\n\ |
|
6945
|
2398 Undocumented internal function.\n\ |
|
3446
|
2399 @end deftypefn") |
|
3005
|
2400 { |
|
|
2401 octave_value_list retval; |
|
|
2402 |
|
7336
|
2403 // FIXME -- what should this function do now? Print a summary for |
|
|
2404 // each scope? Print the entire symbol table? Accept a scope |
|
|
2405 // argument? |
|
3005
|
2406 |
|
|
2407 return retval; |
|
|
2408 } |
|
|
2409 |
|
3933
|
2410 DEFUN (__print_symbol_info__, args, , |
|
3446
|
2411 "-*- texinfo -*-\n\ |
|
|
2412 @deftypefn {Built-in Function} {} __dump_symbol_info__ (@var{name})\n\ |
|
6945
|
2413 Undocumented internal function.\n\ |
|
3446
|
2414 @end deftypefn") |
|
3239
|
2415 { |
|
|
2416 octave_value_list retval; |
|
|
2417 |
|
7336
|
2418 // FIXME -- what should this function do now? |
|
3239
|
2419 |
|
|
2420 return retval; |
|
|
2421 } |
|
|
2422 |
|
7336
|
2423 DEFUN (whos_line_format, args, nargout, |
|
|
2424 "-*- texinfo -*-\n\ |
|
|
2425 @deftypefn {Built-in Function} {@var{val} =} whos_line_format ()\n\ |
|
|
2426 @deftypefnx {Built-in Function} {@var{old_val} =} whos_line_format (@var{new_val})\n\ |
|
|
2427 Query or set the format string used by the @code{whos}.\n\ |
|
|
2428 \n\ |
|
|
2429 The following escape sequences may be used in the format:\n\ |
|
|
2430 @table @code\n\ |
|
|
2431 @item %a\n\ |
|
|
2432 Prints attributes of variables (g=global, p=persistent,\n\ |
|
|
2433 f=formal parameter, a=automatic variable).\n\ |
|
|
2434 @item %b\n\ |
|
|
2435 Prints number of bytes occupied by variables.\n\ |
|
|
2436 @item %c\n\ |
|
|
2437 Prints class names of variables.\n\ |
|
|
2438 @item %e\n\ |
|
|
2439 Prints elements held by variables.\n\ |
|
|
2440 @item %n\n\ |
|
|
2441 Prints variable names.\n\ |
|
|
2442 @item %s\n\ |
|
|
2443 Prints dimensions of variables.\n\ |
|
|
2444 @item %t\n\ |
|
|
2445 Prints type names of variables.\n\ |
|
|
2446 @end table\n\ |
|
|
2447 \n\ |
|
|
2448 Every command may also have a modifier:\n\ |
|
|
2449 @table @code\n\ |
|
|
2450 @item l\n\ |
|
|
2451 Left alignment.\n\ |
|
|
2452 @item r\n\ |
|
|
2453 Right alignment (this is the default).\n\ |
|
|
2454 @item c\n\ |
|
|
2455 Centered (may only be applied to command %s).\n\ |
|
|
2456 @end table\n\ |
|
|
2457 \n\ |
|
|
2458 A command is composed like this:\n\ |
|
|
2459 \n\ |
|
|
2460 @example\n\ |
|
|
2461 %[modifier]<command>[:size_of_parameter[:center-specific[\n\ |
|
|
2462 :print_dims[:balance]]]];\n\ |
|
|
2463 @end example\n\ |
|
|
2464 \n\ |
|
|
2465 Command and modifier is already explained. Size_of_parameter\n\ |
|
|
2466 tells how many columns the parameter will need for printing.\n\ |
|
|
2467 print_dims tells how many dimensions to print. If number of\n\ |
|
|
2468 dimensions exceeds print_dims, dimensions will be printed like\n\ |
|
|
2469 x-D.\n\ |
|
|
2470 center-specific and print_dims may only be applied to command\n\ |
|
|
2471 %s. A negative value for print_dims will cause Octave to print all\n\ |
|
|
2472 dimensions whatsoever.\n\ |
|
|
2473 balance specifies the offset for printing of the dimensions string.\n\ |
|
|
2474 \n\ |
|
|
2475 The default format is \" %a:4; %ln:6; %cs:16:6:8:1; %rb:12; %lc:-1;\\n\".\n\ |
|
5794
|
2476 @end deftypefn") |
|
|
2477 { |
|
7336
|
2478 return SET_INTERNAL_VARIABLE (whos_line_format); |
|
3016
|
2479 } |
|
|
2480 |
|
1
|
2481 /* |
|
|
2482 ;;; Local Variables: *** |
|
|
2483 ;;; mode: C++ *** |
|
|
2484 ;;; End: *** |
|
|
2485 */ |
