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