gdb/mi/mi-cmd-var.c

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