Home | History | Annotate | Line # | Download | only in mi
mi-cmd-var.c revision 1.9.2.1
      1 /* MI Command Set - varobj commands.
      2    Copyright (C) 2000-2023 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);
     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);
     68     }
     69 
     70   std::string type = varobj_get_type (var);
     71   if (!type.empty ())
     72     uiout->field_string ("type", type);
     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     gdb_printf (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);
    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);
    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->natural_name ());
    462 
    463   std::string exp = varobj_get_expression (var);
    464   uiout->field_string ("exp", exp);
    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);
    549     }
    550   else
    551     {
    552       std::string val = varobj_get_value (var);
    553 
    554       uiout->field_string ("value", val);
    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);
    586 }
    587 
    588 /* Helper for mi_cmd_var_update - update each VAR.  */
    589 
    590 static void
    591 mi_cmd_var_update_iter (struct varobj *var, bool only_floating,
    592 			enum print_values print_values)
    593 {
    594   bool thread_stopped;
    595 
    596   int thread_id = varobj_get_thread_id (var);
    597 
    598   if (thread_id == -1)
    599     {
    600       thread_stopped = (inferior_ptid == null_ptid
    601 			|| inferior_thread ()->state == THREAD_STOPPED);
    602     }
    603   else
    604     {
    605       thread_info *tp = find_thread_global_id (thread_id);
    606 
    607       thread_stopped = (tp == NULL
    608 			|| tp->state == THREAD_STOPPED);
    609     }
    610 
    611   if (thread_stopped
    612       && (!only_floating || varobj_floating_p (var)))
    613     varobj_update_one (var, print_values, false /* implicit */);
    614 }
    615 
    616 void
    617 mi_cmd_var_update (const char *command, char **argv, int argc)
    618 {
    619   struct ui_out *uiout = current_uiout;
    620   char *name;
    621   enum print_values print_values;
    622 
    623   if (argc != 1 && argc != 2)
    624     error (_("-var-update: Usage: [PRINT_VALUES] NAME."));
    625 
    626   if (argc == 1)
    627     name = argv[0];
    628   else
    629     name = argv[1];
    630 
    631   if (argc == 2)
    632     print_values = mi_parse_print_values (argv[0]);
    633   else
    634     print_values = PRINT_NO_VALUES;
    635 
    636   /* For historical reasons this might emit a list or a tuple, so we
    637      construct one or the other.  */
    638   gdb::optional<ui_out_emit_tuple> tuple_emitter;
    639   gdb::optional<ui_out_emit_list> list_emitter;
    640 
    641   if (mi_version (uiout) <= 1)
    642     tuple_emitter.emplace (uiout, "changelist");
    643   else
    644     list_emitter.emplace (uiout, "changelist");
    645 
    646   /* Check if the parameter is a "*", which means that we want to
    647      update all variables.  */
    648 
    649   if ((*name == '*' || *name == '@') && (*(name + 1) == '\0'))
    650     {
    651       /* varobj_update_one automatically updates all the children of
    652 	 VAROBJ.  Therefore update each VAROBJ only once by iterating
    653 	 only the root VAROBJs.  */
    654 
    655       all_root_varobjs ([=] (varobj *var)
    656         {
    657 	  mi_cmd_var_update_iter (var, *name == '0', print_values);
    658 	});
    659     }
    660   else
    661     {
    662       /* Get varobj handle, if a valid var obj name was specified.  */
    663       struct varobj *var = varobj_get_handle (name);
    664 
    665       varobj_update_one (var, print_values, true /* explicit */);
    666     }
    667 }
    668 
    669 /* Helper for mi_cmd_var_update().  */
    670 
    671 static void
    672 varobj_update_one (struct varobj *var, enum print_values print_values,
    673 		   bool is_explicit)
    674 {
    675   struct ui_out *uiout = current_uiout;
    676 
    677   std::vector<varobj_update_result> changes = varobj_update (&var, is_explicit);
    678 
    679   for (const varobj_update_result &r : changes)
    680     {
    681       int from, to;
    682 
    683       gdb::optional<ui_out_emit_tuple> tuple_emitter;
    684       if (mi_version (uiout) > 1)
    685 	tuple_emitter.emplace (uiout, nullptr);
    686       uiout->field_string ("name", varobj_get_objname (r.varobj));
    687 
    688       switch (r.status)
    689 	{
    690 	case VAROBJ_IN_SCOPE:
    691 	  if (mi_print_value_p (r.varobj, print_values))
    692 	    {
    693 	      std::string val = varobj_get_value (r.varobj);
    694 
    695 	      uiout->field_string ("value", val);
    696 	    }
    697 	  uiout->field_string ("in_scope", "true");
    698 	  break;
    699 	case VAROBJ_NOT_IN_SCOPE:
    700 	  uiout->field_string ("in_scope", "false");
    701 	  break;
    702 	case VAROBJ_INVALID:
    703 	  uiout->field_string ("in_scope", "invalid");
    704 	  break;
    705 	}
    706 
    707       if (r.status != VAROBJ_INVALID)
    708 	{
    709 	  if (r.type_changed)
    710 	    uiout->field_string ("type_changed", "true");
    711 	  else
    712 	    uiout->field_string ("type_changed", "false");
    713 	}
    714 
    715       if (r.type_changed)
    716 	{
    717 	  std::string type_name = varobj_get_type (r.varobj);
    718 
    719 	  uiout->field_string ("new_type", type_name);
    720 	}
    721 
    722       if (r.type_changed || r.children_changed)
    723 	uiout->field_signed ("new_num_children",
    724 			     varobj_get_num_children (r.varobj));
    725 
    726       gdb::unique_xmalloc_ptr<char> display_hint
    727 	= varobj_get_display_hint (r.varobj);
    728       if (display_hint)
    729 	uiout->field_string ("displayhint", display_hint.get ());
    730 
    731       if (varobj_is_dynamic_p (r.varobj))
    732 	uiout->field_signed ("dynamic", 1);
    733 
    734       varobj_get_child_range (r.varobj, &from, &to);
    735       uiout->field_signed ("has_more", varobj_has_more (r.varobj, to));
    736 
    737       if (!r.newobj.empty ())
    738 	{
    739 	  ui_out_emit_list list_emitter (uiout, "new_children");
    740 
    741 	  for (varobj *child : r.newobj)
    742 	    {
    743 	      ui_out_emit_tuple inner_tuple_emitter (uiout, NULL);
    744 	      print_varobj (child, print_values, 1 /* print_expression */);
    745 	    }
    746 	}
    747     }
    748 }
    749 
    750 void
    751 mi_cmd_enable_pretty_printing (const char *command, char **argv, 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, char **argv, int argc)
    761 {
    762   struct varobj *var;
    763   int from, to;
    764 
    765   if (argc != 3)
    766     error (_("-var-set-update-range: Usage: VAROBJ FROM TO"));
    767 
    768   var = varobj_get_handle (argv[0]);
    769   from = atoi (argv[1]);
    770   to = atoi (argv[2]);
    771 
    772   varobj_set_child_range (var, from, to);
    773 }
    774