gdb/mi/mi-cmd-var.c

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