gdb/mi/mi-cmd-var.c

   1 /* MI Command Set - varobj commands.
   2    Copyright (C) 2000-2024 Free Software Foundation, Inc.
   3
   4    Contributed by Cygnus Solutions (a Red Hat company).
   5
   6    This file is part of GDB.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  20
  21 #include "mi-cmds.h"
  22 #include "mi-main.h"
  23 #include "ui-out.h"
  24 #include "mi-out.h"
  25 #include "varobj.h"
  26 #include "language.h"
  27 #include "value.h"
  28 #include <ctype.h>
  29 #include "mi-getopt.h"
  30 #include "gdbthread.h"
  31 #include "mi-parse.h"
  32 #include <optional>
  33 #include "inferior.h"
  34
  35 static void varobj_update_one (struct varobj *var,
  36                                enum print_values print_values,
  37                                bool is_explicit);
  38
  39 static int mi_print_value_p (struct varobj *var,
  40                              enum print_values print_values);
  41
  42 /* Print variable object VAR.  The PRINT_VALUES parameter controls
  43    if the value should be printed.  The PRINT_EXPRESSION parameter
  44    controls if the expression should be printed.  */
  45
  46 static void
  47 print_varobj (struct varobj *var, enum print_values print_values,
  48               int print_expression)
  49 {
  50   struct ui_out *uiout = current_uiout;
  51   int thread_id;
  52
  53   uiout->field_string ("name", varobj_get_objname (var));
  54   if (print_expression)
  55     {
  56       std::string exp = varobj_get_expression (var);
  57
  58       uiout->field_string ("exp", exp);
  59     }
  60   uiout->field_signed ("numchild", varobj_get_num_children (var));
  61
  62   if (mi_print_value_p (var, print_values))
  63     {
  64       std::string val = varobj_get_value (var);
  65
  66       uiout->field_string ("value", val);
  67     }
  68
  69   std::string type = varobj_get_type (var);
  70   if (!type.empty ())
  71     uiout->field_string ("type", type);
  72
  73   thread_id = varobj_get_thread_id (var);
  74   if (thread_id > 0)
  75     uiout->field_signed ("thread-id", thread_id);
  76
  77   if (varobj_get_frozen (var))
  78     uiout->field_signed ("frozen", 1);
  79
  80   gdb::unique_xmalloc_ptr<char> display_hint = varobj_get_display_hint (var);
  81   if (display_hint)
  82     uiout->field_string ("displayhint", display_hint.get ());
  83
  84   if (varobj_is_dynamic_p (var))
  85     uiout->field_signed ("dynamic", 1);
  86 }
  87
  88 /* VAROBJ operations */
  89
  90 void
  91 mi_cmd_var_create (const char *command, const char *const *argv, int argc)
  92 {
  93   struct ui_out *uiout = current_uiout;
  94   CORE_ADDR frameaddr = 0;
  95   struct varobj *var;
  96   const char *frame;
  97   const char *expr;
  98   enum varobj_type var_type;
  99
 100   if (argc != 3)
 101     error (_("-var-create: Usage: NAME FRAME EXPRESSION."));
 102
 103   frame = argv[1];
 104   expr = argv[2];
 105
 106   const char *name = argv[0];
 107   std::string gen_name;
 108   if (strcmp (name, "-") == 0)
 109     {
 110       gen_name = varobj_gen_name ();
 111       name = gen_name.c_str ();
 112     }
 113   else if (!isalpha (name[0]))
 114     error (_("-var-create: name of object must begin with a letter"));
 115
 116   if (strcmp (frame, "*") == 0)
 117     var_type = USE_CURRENT_FRAME;
 118   else if (strcmp (frame, "@") == 0)
 119     var_type = USE_SELECTED_FRAME;
 120   else
 121     {
 122       var_type = USE_SPECIFIED_FRAME;
 123       frameaddr = string_to_core_addr (frame);
 124     }
 125
 126   if (varobjdebug)
 127     gdb_printf (gdb_stdlog,
 128                 "Name=\"%s\", Frame=\"%s\" (%s), Expression=\"%s\"\n",
 129                 name, frame, hex_string (frameaddr), expr);
 130
 131   var = varobj_create (name, expr, frameaddr, var_type);
 132
 133   if (var == NULL)
 134     error (_("-var-create: unable to create variable object"));
 135
 136   print_varobj (var, PRINT_ALL_VALUES, 0 /* don't print expression */);
 137
 138   uiout->field_signed ("has_more", varobj_has_more (var, 0));
 139 }
 140
 141 void
 142 mi_cmd_var_delete (const char *command, const char *const *argv, int argc)
 143 {
 144   const char *name;
 145   struct varobj *var;
 146   int numdel;
 147   int children_only_p = 0;
 148   struct ui_out *uiout = current_uiout;
 149
 150   if (argc < 1 || argc > 2)
 151     error (_("-var-delete: Usage: [-c] EXPRESSION."));
 152
 153   name = argv[0];
 154
 155   /* If we have one single argument it cannot be '-c' or any string
 156      starting with '-'.  */
 157   if (argc == 1)
 158     {
 159       if (strcmp (name, "-c") == 0)
 160         error (_("-var-delete: Missing required "
 161                  "argument after '-c': variable object name"));
 162       if (*name == '-')
 163         error (_("-var-delete: Illegal variable object name"));
 164     }
 165
 166   /* If we have 2 arguments they must be '-c' followed by a string
 167      which would be the variable name.  */
 168   if (argc == 2)
 169     {
 170       if (strcmp (name, "-c") != 0)
 171         error (_("-var-delete: Invalid option."));
 172       children_only_p = 1;
 173       name = argv[1];
 174     }
 175
 176   /* If we didn't error out, now NAME contains the name of the
 177      variable.  */
 178
 179   var = varobj_get_handle (name);
 180
 181   numdel = varobj_delete (var, children_only_p);
 182
 183   uiout->field_signed ("ndeleted", numdel);
 184 }
 185
 186 /* Parse a string argument into a format value.  */
 187
 188 static enum varobj_display_formats
 189 mi_parse_format (const char *arg)
 190 {
 191   if (arg != NULL)
 192     {
 193       int len;
 194
 195       len = strlen (arg);
 196
 197       if (strncmp (arg, "natural", len) == 0)
 198         return FORMAT_NATURAL;
 199       else if (strncmp (arg, "binary", len) == 0)
 200         return FORMAT_BINARY;
 201       else if (strncmp (arg, "decimal", len) == 0)
 202         return FORMAT_DECIMAL;
 203       else if (strncmp (arg, "hexadecimal", len) == 0)
 204         return FORMAT_HEXADECIMAL;
 205       else if (strncmp (arg, "octal", len) == 0)
 206         return FORMAT_OCTAL;
 207       else if (strncmp (arg, "zero-hexadecimal", len) == 0)
 208         return FORMAT_ZHEXADECIMAL;
 209     }
 210
 211   error (_("Must specify the format as: \"natural\", "
 212            "\"binary\", \"decimal\", \"hexadecimal\", \"octal\" or \"zero-hexadecimal\""));
 213 }
 214
 215 void
 216 mi_cmd_var_set_format (const char *command, const char *const *argv, int argc)
 217 {
 218   enum varobj_display_formats format;
 219   struct varobj *var;
 220   struct ui_out *uiout = current_uiout;
 221
 222   if (argc != 2)
 223     error (_("-var-set-format: Usage: NAME FORMAT."));
 224
 225   /* Get varobj handle, if a valid var obj name was specified.  */
 226   var = varobj_get_handle (argv[0]);
 227
 228   format = mi_parse_format (argv[1]);
 229
 230   /* Set the format of VAR to the given format.  */
 231   varobj_set_display_format (var, format);
 232
 233   /* Report the new current format.  */
 234   uiout->field_string ("format", varobj_format_string[(int) format]);
 235
 236   /* Report the value in the new format.  */
 237   std::string val = varobj_get_value (var);
 238   uiout->field_string ("value", val);
 239 }
 240
 241 void
 242 mi_cmd_var_set_visualizer (const char *command, const char *const *argv,
 243                            int argc)
 244 {
 245   struct varobj *var;
 246
 247   if (argc != 2)
 248     error (_("-var-set-visualizer: Usage: NAME VISUALIZER_FUNCTION."));
 249
 250   var = varobj_get_handle (argv[0]);
 251
 252   if (var == NULL)
 253     error (_("Variable object not found"));
 254
 255   varobj_set_visualizer (var, argv[1]);
 256 }
 257
 258 void
 259 mi_cmd_var_set_frozen (const char *command, const char *const *argv, int argc)
 260 {
 261   struct varobj *var;
 262   bool frozen;
 263
 264   if (argc != 2)
 265     error (_("-var-set-frozen: Usage: NAME FROZEN_FLAG."));
 266
 267   var = varobj_get_handle (argv[0]);
 268
 269   if (strcmp (argv[1], "0") == 0)
 270     frozen = false;
 271   else if (strcmp (argv[1], "1") == 0)
 272     frozen = true;
 273   else
 274     error (_("Invalid flag value"));
 275
 276   varobj_set_frozen (var, frozen);
 277
 278   /* We don't automatically return the new value, or what varobjs got
 279      new values during unfreezing.  If this information is required,
 280      client should call -var-update explicitly.  */
 281 }
 282
 283 void
 284 mi_cmd_var_show_format (const char *command, const char *const *argv, int argc)
 285 {
 286   struct ui_out *uiout = current_uiout;
 287   enum varobj_display_formats format;
 288   struct varobj *var;
 289
 290   if (argc != 1)
 291     error (_("-var-show-format: Usage: NAME."));
 292
 293   /* Get varobj handle, if a valid var obj name was specified.  */
 294   var = varobj_get_handle (argv[0]);
 295
 296   format = varobj_get_display_format (var);
 297
 298   /* Report the current format.  */
 299   uiout->field_string ("format", varobj_format_string[(int) format]);
 300 }
 301
 302 void
 303 mi_cmd_var_info_num_children (const char *command, const char *const *argv,
 304                               int argc)
 305 {
 306   struct ui_out *uiout = current_uiout;
 307   struct varobj *var;
 308
 309   if (argc != 1)
 310     error (_("-var-info-num-children: Usage: NAME."));
 311
 312   /* Get varobj handle, if a valid var obj name was specified.  */
 313   var = varobj_get_handle (argv[0]);
 314
 315   uiout->field_signed ("numchild", varobj_get_num_children (var));
 316 }
 317
 318 /* Return 1 if given the argument PRINT_VALUES we should display
 319    the varobj VAR.  */
 320
 321 static int
 322 mi_print_value_p (struct varobj *var, enum print_values print_values)
 323 {
 324   struct type *type;
 325
 326   if (print_values == PRINT_NO_VALUES)
 327     return 0;
 328
 329   if (print_values == PRINT_ALL_VALUES)
 330     return 1;
 331
 332   if (varobj_is_dynamic_p (var))
 333     return 1;
 334
 335   type = varobj_get_gdb_type (var);
 336   if (type == NULL)
 337     return 1;
 338   else
 339     return mi_simple_type_p (type);
 340 }
 341
 342 /* See mi-cmds.h.  */
 343
 344 bool
 345 mi_simple_type_p (struct type *type)
 346 {
 347   type = check_typedef (type);
 348
 349   if (TYPE_IS_REFERENCE (type))
 350     type = check_typedef (type->target_type ());
 351
 352   switch (type->code ())
 353     {
 354     case TYPE_CODE_ARRAY:
 355     case TYPE_CODE_STRUCT:
 356     case TYPE_CODE_UNION:
 357       return false;
 358     default:
 359       return true;
 360     }
 361 }
 362
 363 void
 364 mi_cmd_var_list_children (const char *command, const char *const *argv,
 365                           int argc)
 366 {
 367   struct ui_out *uiout = current_uiout;
 368   struct varobj *var;
 369   enum print_values print_values;
 370   int from, to;
 371
 372   if (argc < 1 || argc > 4)
 373     error (_("-var-list-children: Usage: "
 374              "[PRINT_VALUES] NAME [FROM TO]"));
 375
 376   /* Get varobj handle, if a valid var obj name was specified.  */
 377   if (argc == 1 || argc == 3)
 378     var = varobj_get_handle (argv[0]);
 379   else
 380     var = varobj_get_handle (argv[1]);
 381
 382   if (argc > 2)
 383     {
 384       from = atoi (argv[argc - 2]);
 385       to = atoi (argv[argc - 1]);
 386     }
 387   else
 388     {
 389       from = -1;
 390       to = -1;
 391     }
 392
 393   const std::vector<varobj *> &children
 394     = varobj_list_children (var, &from, &to);
 395
 396   uiout->field_signed ("numchild", to - from);
 397   if (argc == 2 || argc == 4)
 398     print_values = mi_parse_print_values (argv[0]);
 399   else
 400     print_values = PRINT_NO_VALUES;
 401
 402   gdb::unique_xmalloc_ptr<char> display_hint = varobj_get_display_hint (var);
 403   if (display_hint)
 404     uiout->field_string ("displayhint", display_hint.get ());
 405
 406   if (from < to)
 407     {
 408       ui_out_emit_list list_emitter (uiout, "children");
 409       for (int ix = from; ix < to && ix < children.size (); ix++)
 410         {
 411           ui_out_emit_tuple child_emitter (uiout, "child");
 412
 413           print_varobj (children[ix], print_values, 1 /* print expression */);
 414         }
 415     }
 416
 417   uiout->field_signed ("has_more", varobj_has_more (var, to));
 418 }
 419
 420 void
 421 mi_cmd_var_info_type (const char *command, const char *const *argv, int argc)
 422 {
 423   struct ui_out *uiout = current_uiout;
 424   struct varobj *var;
 425
 426   if (argc != 1)
 427     error (_("-var-info-type: Usage: NAME."));
 428
 429   /* Get varobj handle, if a valid var obj name was specified.  */
 430   var = varobj_get_handle (argv[0]);
 431
 432   std::string type_name = varobj_get_type (var);
 433   uiout->field_string ("type", type_name);
 434 }
 435
 436 void
 437 mi_cmd_var_info_path_expression (const char *command, const char *const *argv,
 438                                  int argc)
 439 {
 440   struct ui_out *uiout = current_uiout;
 441   struct varobj *var;
 442
 443   if (argc != 1)
 444     error (_("-var-info-path-expression: Usage: NAME."));
 445
 446   /* Get varobj handle, if a valid var obj name was specified.  */
 447   var = varobj_get_handle (argv[0]);
 448
 449   const char *path_expr = varobj_get_path_expr (var);
 450
 451   uiout->field_string ("path_expr", path_expr);
 452 }
 453
 454 void
 455 mi_cmd_var_info_expression (const char *command, const char *const *argv,
 456                             int argc)
 457 {
 458   struct ui_out *uiout = current_uiout;
 459   const struct language_defn *lang;
 460   struct varobj *var;
 461
 462   if (argc != 1)
 463     error (_("-var-info-expression: Usage: NAME."));
 464
 465   /* Get varobj handle, if a valid var obj name was specified.  */
 466   var = varobj_get_handle (argv[0]);
 467
 468   lang = varobj_get_language (var);
 469
 470   uiout->field_string ("lang", lang->natural_name ());
 471
 472   std::string exp = varobj_get_expression (var);
 473   uiout->field_string ("exp", exp);
 474 }
 475
 476 void
 477 mi_cmd_var_show_attributes (const char *command, const char *const *argv,
 478                             int argc)
 479 {
 480   struct ui_out *uiout = current_uiout;
 481   int attr;
 482   const char *attstr;
 483   struct varobj *var;
 484
 485   if (argc != 1)
 486     error (_("-var-show-attributes: Usage: NAME."));
 487
 488   /* Get varobj handle, if a valid var obj name was specified */
 489   var = varobj_get_handle (argv[0]);
 490
 491   attr = varobj_get_attributes (var);
 492   /* FIXME: define masks for attributes */
 493   if (attr & 0x00000001)
 494     attstr = "editable";
 495   else
 496     attstr = "noneditable";
 497
 498   uiout->field_string ("attr", attstr);
 499 }
 500
 501 void
 502 mi_cmd_var_evaluate_expression (const char *command, const char *const *argv,
 503                                 int argc)
 504 {
 505   struct ui_out *uiout = current_uiout;
 506   struct varobj *var;
 507
 508   enum varobj_display_formats format;
 509   int formatFound;
 510   int oind;
 511   const char *oarg;
 512
 513   enum opt
 514   {
 515     OP_FORMAT
 516   };
 517   static const struct mi_opt opts[] =
 518     {
 519       {"f", OP_FORMAT, 1},
 520       { 0, 0, 0 }
 521     };
 522
 523   /* Parse arguments.  */
 524   format = FORMAT_NATURAL;
 525   formatFound = 0;
 526   oind = 0;
 527   while (1)
 528     {
 529       int opt = mi_getopt ("-var-evaluate-expression", argc, argv,
 530                            opts, &oind, &oarg);
 531
 532       if (opt < 0)
 533         break;
 534       switch ((enum opt) opt)
 535         {
 536         case OP_FORMAT:
 537           if (formatFound)
 538             error (_("Cannot specify format more than once"));
 539
 540           format = mi_parse_format (oarg);
 541           formatFound = 1;
 542           break;
 543         }
 544     }
 545
 546   if (oind >= argc)
 547     error (_("Usage: [-f FORMAT] NAME"));
 548
 549   if (oind < argc - 1)
 550     error (_("Garbage at end of command"));
 551
 552   /* Get varobj handle, if a valid var obj name was specified.  */
 553   var = varobj_get_handle (argv[oind]);
 554
 555   if (formatFound)
 556     {
 557       std::string val = varobj_get_formatted_value (var, format);
 558
 559       uiout->field_string ("value", val);
 560     }
 561   else
 562     {
 563       std::string val = varobj_get_value (var);
 564
 565       uiout->field_string ("value", val);
 566     }
 567 }
 568
 569 void
 570 mi_cmd_var_assign (const char *command, const char *const *argv, int argc)
 571 {
 572   struct ui_out *uiout = current_uiout;
 573   struct varobj *var;
 574
 575   if (argc != 2)
 576     error (_("-var-assign: Usage: NAME EXPRESSION."));
 577
 578   /* Get varobj handle, if a valid var obj name was specified.  */
 579   var = varobj_get_handle (argv[0]);
 580
 581   if (!varobj_editable_p (var))
 582     error (_("-var-assign: Variable object is not editable"));
 583
 584   const char *expression = argv[1];
 585
 586   /* MI command '-var-assign' may write memory, so suppress memory
 587      changed notification if it does.  */
 588   scoped_restore save_suppress
 589     = make_scoped_restore (&mi_suppress_notification.memory, 1);
 590
 591   if (!varobj_set_value (var, expression))
 592     error (_("-var-assign: Could not assign "
 593              "expression to variable object"));
 594
 595   std::string val = varobj_get_value (var);
 596   uiout->field_string ("value", val);
 597 }
 598
 599 /* Helper for mi_cmd_var_update - update each VAR.  */
 600
 601 static void
 602 mi_cmd_var_update_iter (struct varobj *var, bool only_floating,
 603                         enum print_values print_values)
 604 {
 605   bool thread_stopped;
 606
 607   int thread_id = varobj_get_thread_id (var);
 608
 609   if (thread_id == -1)
 610     {
 611       thread_stopped = (inferior_ptid == null_ptid
 612                         || inferior_thread ()->state == THREAD_STOPPED);
 613     }
 614   else
 615     {
 616       thread_info *tp = find_thread_global_id (thread_id);
 617
 618       thread_stopped = (tp == NULL
 619                         || tp->state == THREAD_STOPPED);
 620     }
 621
 622   if (thread_stopped
 623       && (!only_floating || varobj_floating_p (var)))
 624     varobj_update_one (var, print_values, false /* implicit */);
 625 }
 626
 627 void
 628 mi_cmd_var_update (const char *command, const char *const *argv, int argc)
 629 {
 630   struct ui_out *uiout = current_uiout;
 631   const char *name;
 632   enum print_values print_values;
 633
 634   if (argc != 1 && argc != 2)
 635     error (_("-var-update: Usage: [PRINT_VALUES] NAME."));
 636
 637   if (argc == 1)
 638     name = argv[0];
 639   else
 640     name = argv[1];
 641
 642   if (argc == 2)
 643     print_values = mi_parse_print_values (argv[0]);
 644   else
 645     print_values = PRINT_NO_VALUES;
 646
 647   ui_out_emit_list list_emitter (uiout, "changelist");
 648
 649   /* Check if the parameter is a "*", which means that we want to
 650      update all variables.  */
 651
 652   if ((*name == '*' || *name == '@') && (*(name + 1) == '\0'))
 653     {
 654       /* varobj_update_one automatically updates all the children of
 655          VAROBJ.  Therefore update each VAROBJ only once by iterating
 656          only the root VAROBJs.  */
 657
 658       all_root_varobjs ([=] (varobj *var)
 659         { mi_cmd_var_update_iter (var, *name == '0', print_values); });
 660     }
 661   else
 662     {
 663       /* Get varobj handle, if a valid var obj name was specified.  */
 664       struct varobj *var = varobj_get_handle (name);
 665
 666       varobj_update_one (var, print_values, true /* explicit */);
 667     }
 668 }
 669
 670 /* Helper for mi_cmd_var_update().  */
 671
 672 static void
 673 varobj_update_one (struct varobj *var, enum print_values print_values,
 674                    bool is_explicit)
 675 {
 676   struct ui_out *uiout = current_uiout;
 677
 678   std::vector<varobj_update_result> changes = varobj_update (&var, is_explicit);
 679
 680   for (const varobj_update_result &r : changes)
 681     {
 682       int from, to;
 683
 684       ui_out_emit_tuple tuple_emitter (uiout, nullptr);
 685       uiout->field_string ("name", varobj_get_objname (r.varobj));
 686
 687       switch (r.status)
 688         {
 689         case VAROBJ_IN_SCOPE:
 690           if (mi_print_value_p (r.varobj, print_values))
 691             {
 692               std::string val = varobj_get_value (r.varobj);
 693
 694               uiout->field_string ("value", val);
 695             }
 696           uiout->field_string ("in_scope", "true");
 697           break;
 698         case VAROBJ_NOT_IN_SCOPE:
 699           uiout->field_string ("in_scope", "false");
 700           break;
 701         case VAROBJ_INVALID:
 702           uiout->field_string ("in_scope", "invalid");
 703           break;
 704         }
 705
 706       if (r.status != VAROBJ_INVALID)
 707         {
 708           if (r.type_changed)
 709             uiout->field_string ("type_changed", "true");
 710           else
 711             uiout->field_string ("type_changed", "false");
 712         }
 713
 714       if (r.type_changed)
 715         {
 716           std::string type_name = varobj_get_type (r.varobj);
 717
 718           uiout->field_string ("new_type", type_name);
 719         }
 720
 721       if (r.type_changed || r.children_changed)
 722         uiout->field_signed ("new_num_children",
 723                              varobj_get_num_children (r.varobj));
 724
 725       gdb::unique_xmalloc_ptr<char> display_hint
 726         = varobj_get_display_hint (r.varobj);
 727       if (display_hint)
 728         uiout->field_string ("displayhint", display_hint.get ());
 729
 730       if (varobj_is_dynamic_p (r.varobj))
 731         uiout->field_signed ("dynamic", 1);
 732
 733       varobj_get_child_range (r.varobj, &from, &to);
 734       uiout->field_signed ("has_more", varobj_has_more (r.varobj, to));
 735
 736       if (!r.newobj.empty ())
 737         {
 738           ui_out_emit_list list_emitter (uiout, "new_children");
 739
 740           for (varobj *child : r.newobj)
 741             {
 742               ui_out_emit_tuple inner_tuple_emitter (uiout, NULL);
 743               print_varobj (child, print_values, 1 /* print_expression */);
 744             }
 745         }
 746     }
 747 }
 748
 749 void
 750 mi_cmd_enable_pretty_printing (const char *command, const char *const *argv,
 751                                int argc)
 752 {
 753   if (argc != 0)
 754     error (_("-enable-pretty-printing: no arguments allowed"));
 755
 756   varobj_enable_pretty_printing ();
 757 }
 758
 759 void
 760 mi_cmd_var_set_update_range (const char *command, const char *const *argv,
 761                              int argc)
 762 {
 763   struct varobj *var;
 764   int from, to;
 765
 766   if (argc != 3)
 767     error (_("-var-set-update-range: Usage: VAROBJ FROM TO"));
 768
 769   var = varobj_get_handle (argv[0]);
 770   from = atoi (argv[1]);
 771   to = atoi (argv[2]);
 772
 773   varobj_set_child_range (var, from, to);
 774 }