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