自学教程：C++ ui_out_field_int函数代码示例

enum mi_cmd_resultmi_cmd_file_list_exec_source_file (char *command, char **argv, int argc){  struct symtab_and_line st;  int optind = 0;  char *optarg;    if (!mi_valid_noargs ("mi_cmd_file_list_exec_source_file", argc, argv))    error (_("mi_cmd_file_list_exec_source_file: Usage: No args"));  /* Set the default file and line, also get them */  set_default_source_symtab_and_line ();  st = get_current_source_symtab_and_line ();  /* We should always get a symtab.      Apparently, filename does not need to be tested for NULL.     The documentation in symtab.h suggests it will always be correct */  if (!st.symtab)    error (_("mi_cmd_file_list_exec_source_file: No symtab"));  /* Extract the fullname if it is not known yet */  symtab_to_fullname (st.symtab);  /* Print to the user the line, filename and fullname */  ui_out_field_int (uiout, "line", st.line);  ui_out_field_string (uiout, "file", st.symtab->filename);  /* We may not be able to open the file (not available). */  if (st.symtab->fullname)  ui_out_field_string (uiout, "fullname", st.symtab->fullname);  ui_out_field_int (uiout, "macro-info", st.symtab->macro_table ? 1 : 0);  return MI_CMD_DONE;}

voidmi_cmd_file_list_exec_source_file (char *command, char **argv, int argc){  struct symtab_and_line st;  struct ui_out *uiout = current_uiout;    if (!mi_valid_noargs ("-file-list-exec-source-file", argc, argv))    error (_("-file-list-exec-source-file: Usage: No args"));  /* Set the default file and line, also get them.  */  set_default_source_symtab_and_line ();  st = get_current_source_symtab_and_line ();  /* We should always get a symtab.  Apparently, filename does not     need to be tested for NULL.  The documentation in symtab.h     suggests it will always be correct.  */  if (!st.symtab)    error (_("-file-list-exec-source-file: No symtab"));  /* Print to the user the line, filename and fullname.  */  ui_out_field_int (uiout, "line", st.line);  ui_out_field_string (uiout, "file",		       symtab_to_filename_for_display (st.symtab));  ui_out_field_string (uiout, "fullname", symtab_to_fullname (st.symtab));  ui_out_field_int (uiout, "macro-info",		    COMPUNIT_MACRO_TABLE		      (SYMTAB_COMPUNIT (st.symtab)) != NULL);}

static voidbtrace_call_history_src_line (struct ui_out *uiout,			      const struct btrace_function *bfun){  struct symbol *sym;  int begin, end;  sym = bfun->sym;  if (sym == NULL)    return;  ui_out_field_string (uiout, "file",		       symtab_to_filename_for_display (sym->symtab));  begin = bfun->lbegin;  end = bfun->lend;  if (end < begin)    return;  ui_out_text (uiout, ":");  ui_out_field_int (uiout, "min line", begin);  if (end == begin)    return;  ui_out_text (uiout, ",");  ui_out_field_int (uiout, "max line", end);}

static voidmi_on_normal_stop (struct bpstats *bs, int print_frame){    /* Since this can be called when CLI command is executing,       using cli interpreter, be sure to use MI uiout for output,       not the current one.  */    struct ui_out *mi_uiout = interp_ui_out (top_level_interpreter ());    if (print_frame)    {        int core;        if (current_uiout != mi_uiout)        {            /* The normal_stop function has printed frame information               into CLI uiout, or some other non-MI uiout.  There's no               way we can extract proper fields from random uiout               object, so we print the frame again.  In practice, this               can only happen when running a CLI command in MI.  */            struct ui_out *saved_uiout = current_uiout;            struct target_waitstatus last;            ptid_t last_ptid;            current_uiout = mi_uiout;            get_last_target_status (&last_ptid, &last);            bpstat_print (bs, last.kind);            print_stack_frame (get_selected_frame (NULL), 0, SRC_AND_LOC, 1);            current_uiout = saved_uiout;        }        ui_out_field_int (mi_uiout, "thread-id",                          pid_to_thread_id (inferior_ptid));        if (non_stop)        {            struct cleanup *back_to = make_cleanup_ui_out_list_begin_end                                      (mi_uiout, "stopped-threads");            ui_out_field_int (mi_uiout, NULL,                              pid_to_thread_id (inferior_ptid));            do_cleanups (back_to);        }        else            ui_out_field_string (mi_uiout, "stopped-threads", "all");        core = target_core_of_thread (inferior_ptid);        if (core != -1)            ui_out_field_int (mi_uiout, "core", core);    }    fputs_unfiltered ("*stopped", raw_stdout);    mi_out_put (mi_uiout, raw_stdout);    mi_out_rewind (mi_uiout);    mi_print_timing_maybe ();    fputs_unfiltered ("/n", raw_stdout);    gdb_flush (raw_stdout);}

enum mi_cmd_resultmi_cmd_var_list_children (char *command, char **argv, int argc){  struct varobj *var;  struct varobj **childlist;  struct varobj **cc;  struct cleanup *cleanup_children;  int numchild;  char *type;  enum print_values print_values;  if (argc != 1 && argc != 2)    error (_("mi_cmd_var_list_children: Usage: [PRINT_VALUES] NAME"));  /* Get varobj handle, if a valid var obj name was specified */  if (argc == 1)    var = varobj_get_handle (argv[0]);  else    var = varobj_get_handle (argv[1]);  if (var == NULL)    error (_("Variable object not found"));  numchild = varobj_list_children (var, &childlist);  ui_out_field_int (uiout, "numchild", numchild);  if (argc == 2)    print_values = mi_parse_values_option (argv[0]);  else    print_values = PRINT_NO_VALUES;  if (numchild <= 0)    return MI_CMD_DONE;  if (mi_version (uiout) == 1)    cleanup_children = make_cleanup_ui_out_tuple_begin_end (uiout, "children");  else    cleanup_children = make_cleanup_ui_out_list_begin_end (uiout, "children");  cc = childlist;  while (*cc != NULL)    {      struct cleanup *cleanup_child;      cleanup_child = make_cleanup_ui_out_tuple_begin_end (uiout, "child");      ui_out_field_string (uiout, "name", varobj_get_objname (*cc));      ui_out_field_string (uiout, "exp", varobj_get_expression (*cc));      ui_out_field_int (uiout, "numchild", varobj_get_num_children (*cc));      if (mi_print_value_p (varobj_get_gdb_type (*cc), print_values))	ui_out_field_string (uiout, "value", varobj_get_value (*cc));      type = varobj_get_type (*cc);      /* C++ pseudo-variables (public, private, protected) do not have a type */      if (type)	ui_out_field_string (uiout, "type", type);      do_cleanups (cleanup_child);      cc++;    }  do_cleanups (cleanup_children);  xfree (childlist);  return MI_CMD_DONE;}

static void print_varobj (struct varobj *var, enum print_values print_values,	      int print_expression){  struct ui_out *uiout = current_uiout;  char *type;  int thread_id;  char *display_hint;  ui_out_field_string (uiout, "name", varobj_get_objname (var));  if (print_expression)    {      char *exp = varobj_get_expression (var);      ui_out_field_string (uiout, "exp", exp);      xfree (exp);    }  ui_out_field_int (uiout, "numchild", varobj_get_num_children (var));    if (mi_print_value_p (var, print_values))    {      char *val = varobj_get_value (var);      ui_out_field_string (uiout, "value", val);      xfree (val);    }  type = varobj_get_type (var);  if (type != NULL)    {      ui_out_field_string (uiout, "type", type);      xfree (type);    }  thread_id = varobj_get_thread_id (var);  if (thread_id > 0)    ui_out_field_int (uiout, "thread-id", thread_id);  if (varobj_get_frozen (var))    ui_out_field_int (uiout, "frozen", 1);  display_hint = varobj_get_display_hint (var);  if (display_hint)    {      ui_out_field_string (uiout, "displayhint", display_hint);      xfree (display_hint);    }  if (varobj_is_dynamic_p (var))    ui_out_field_int (uiout, "dynamic", 1);}

static intvarobj_update_one (struct varobj *var, enum print_values print_values){  struct varobj **changelist;  struct varobj **cc;  struct cleanup *cleanup = NULL;  int nc;  nc = varobj_update (&var, &changelist);  /* nc == 0 means that nothing has changed.     nc == -1 means that an error occured in updating the variable.     nc == -2 means the variable has changed type. */    if (nc == 0)    return 1;  else if (nc == -1)    {      if (mi_version (uiout) > 1)        cleanup = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);      ui_out_field_string (uiout, "name", varobj_get_objname(var));      ui_out_field_string (uiout, "in_scope", "false");      if (mi_version (uiout) > 1)        do_cleanups (cleanup);      return -1;    }  else if (nc == -2)    {      if (mi_version (uiout) > 1)        cleanup = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);      ui_out_field_string (uiout, "name", varobj_get_objname (var));      ui_out_field_string (uiout, "in_scope", "true");      ui_out_field_string (uiout, "new_type", varobj_get_type(var));      ui_out_field_int (uiout, "new_num_children", 			   varobj_get_num_children(var));      if (mi_version (uiout) > 1)        do_cleanups (cleanup);    }  else    {            cc = changelist;      while (*cc != NULL)	{	  if (mi_version (uiout) > 1)	    cleanup = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);	  ui_out_field_string (uiout, "name", varobj_get_objname (*cc));	  if (mi_print_value_p (varobj_get_gdb_type (*cc), print_values))	    ui_out_field_string (uiout, "value", varobj_get_value (*cc));	  ui_out_field_string (uiout, "in_scope", "true");	  ui_out_field_string (uiout, "type_changed", "false");	  if (mi_version (uiout) > 1)	    do_cleanups (cleanup);	  cc++;	}      xfree (changelist);      return 1;    }  return 1;}

static voidmi_solib_loaded (struct so_list *solib){  struct mi_interp *mi = top_level_interpreter_data ();  struct ui_out *uiout = interp_ui_out (top_level_interpreter ());  target_terminal_ours ();  fprintf_unfiltered (mi->event_channel, "library-loaded");  ui_out_redirect (uiout, mi->event_channel);  ui_out_field_string (uiout, "id", solib->so_original_name);  ui_out_field_string (uiout, "target-name", solib->so_original_name);  ui_out_field_string (uiout, "host-name", solib->so_name);  ui_out_field_int (uiout, "symbols-loaded", solib->symbols_loaded);  if (!gdbarch_has_global_solist (target_gdbarch ()))    {      ui_out_field_fmt (uiout, "thread-group", "i%d", current_inferior ()->num);    }  ui_out_redirect (uiout, NULL);  gdb_flush (mi->event_channel);}

voidmacosx_print_extra_stop_info(int code, CORE_ADDR address){  ui_out_text(uiout, "Reason: ");  switch (code)    {    case KERN_PROTECTION_FAILURE:      ui_out_field_string(uiout, "access-reason", "KERN_PROTECTION_FAILURE");      break;    case KERN_INVALID_ADDRESS:      ui_out_field_string(uiout, "access-reason", "KERN_INVALID_ADDRESS");      break;#if defined(TARGET_ARM)    case 0x101:      ui_out_field_string(uiout, "access-reason", "EXC_ARM_DA_ALIGN");      break;    case 0x102:      ui_out_field_string(uiout, "access-reason", "EXC_ARM_DA_DEBUG");      break;#endif /* TARGET_ARM */    default:      ui_out_field_int(uiout, "access-reason", code);    }  ui_out_text(uiout, " at address: ");  ui_out_field_core_addr(uiout, "address", address);  ui_out_text(uiout, "/n");}

enum mi_cmd_resultmi_cmd_stack_info_depth (char *command, char **argv, int argc){  int frame_high;  int i;  struct frame_info *fi;  if (!target_has_stack)    error ("mi_cmd_stack_info_depth: No stack.");  if (argc > 1)    error ("mi_cmd_stack_info_depth: Usage: [MAX_DEPTH]");  if (argc == 1)    frame_high = atoi (argv[0]);  else    /* Called with no arguments, it means we want the real depth of       the stack. */    frame_high = -1;  for (i = 0, fi = get_current_frame ();       fi && (i < frame_high || frame_high == -1);       i++, fi = get_prev_frame (fi))    QUIT;  ui_out_field_int (uiout, "depth", i);  return MI_CMD_DONE;}

voidmi_cmd_var_create (char *command, char **argv, int argc){  struct ui_out *uiout = current_uiout;  CORE_ADDR frameaddr = 0;  struct varobj *var;  char *name;  char *frame;  char *expr;  struct cleanup *old_cleanups;  enum varobj_type var_type;  if (argc != 3)    error (_("-var-create: Usage: NAME FRAME EXPRESSION."));  name = xstrdup (argv[0]);  /* Add cleanup for name. Must be free_current_contents as name can     be reallocated.  */  old_cleanups = make_cleanup (free_current_contents, &name);  frame = xstrdup (argv[1]);  make_cleanup (xfree, frame);  expr = xstrdup (argv[2]);  make_cleanup (xfree, expr);  if (strcmp (name, "-") == 0)    {      xfree (name);      name = varobj_gen_name ();    }  else if (!isalpha (*name))    error (_("-var-create: name of object must begin with a letter"));  if (strcmp (frame, "*") == 0)    var_type = USE_CURRENT_FRAME;  else if (strcmp (frame, "@") == 0)    var_type = USE_SELECTED_FRAME;    else    {      var_type = USE_SPECIFIED_FRAME;      frameaddr = string_to_core_addr (frame);    }  if (varobjdebug)    fprintf_unfiltered (gdb_stdlog,		    "Name=/"%s/", Frame=/"%s/" (%s), Expression=/"%s/"/n",			name, frame, hex_string (frameaddr), expr);  var = varobj_create (name, expr, frameaddr, var_type);  if (var == NULL)    error (_("-var-create: unable to create variable object"));  print_varobj (var, PRINT_ALL_VALUES, 0 /* don't print expression */);  ui_out_field_int (uiout, "has_more", varobj_has_more (var, 0));  do_cleanups (old_cleanups);}

static intdump_insns(struct ui_out *uiout, struct disassemble_info * di,	   CORE_ADDR low, CORE_ADDR high,	   int how_many, struct ui_stream *stb){  int num_displayed = 0;  CORE_ADDR pc;  /* parts of the symbolic representation of the address */  int unmapped;  int offset;  int line;  struct cleanup *ui_out_chain;  for (pc = low; pc < high;)    {      char *filename = NULL;      char *name = NULL;      QUIT;      if (how_many >= 0)	{	  if (num_displayed >= how_many)	    break;	  else	    num_displayed++;	}      ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);      ui_out_field_core_addr (uiout, "address", pc);      if (!build_address_symbolic (pc, 0, &name, &offset, &filename,				   &line, &unmapped))	{	  /* We don't care now about line, filename and	     unmapped. But we might in the future. */	  ui_out_text (uiout, " <");	  ui_out_field_string (uiout, "func-name", name);	  ui_out_text (uiout, "+");	  ui_out_field_int (uiout, "offset", offset);	  ui_out_text (uiout, ">:/t");	}      else	ui_out_text (uiout, ":/t");      if (filename != NULL)	xfree (filename);      if (name != NULL)	xfree (name);      ui_file_rewind (stb->stream);      pc += TARGET_PRINT_INSN (pc, di);      ui_out_field_stream (uiout, "inst", stb);      ui_file_rewind (stb->stream);      do_cleanups (ui_out_chain);      ui_out_text (uiout, "/n");    }  return num_displayed;}

/* Print a list of the arguments for the current frame. With argument   of 0, print only the names, with argument of 1 print also the   values. */enum mi_cmd_resultmi_cmd_stack_list_args (char *command, char **argv, int argc){  int frame_low;  int frame_high;  int i;  struct frame_info *fi;  struct cleanup *cleanup_stack_args;  if (argc < 1 || argc > 3 || argc == 2)    error ("mi_cmd_stack_list_args: Usage: PRINT_VALUES [FRAME_LOW FRAME_HIGH]");  if (argc == 3)    {      frame_low = atoi (argv[1]);      frame_high = atoi (argv[2]);    }  else    {      /* Called with no arguments, it means we want args for the whole         backtrace. */      frame_low = -1;      frame_high = -1;    }  /* Let's position fi on the frame at which to start the     display. Could be the innermost frame if the whole stack needs     displaying, or if frame_low is 0. */  for (i = 0, fi = get_current_frame ();       fi && i < frame_low;       i++, fi = get_prev_frame (fi));  if (fi == NULL)    error ("mi_cmd_stack_list_args: Not enough frames in stack.");  cleanup_stack_args = make_cleanup_ui_out_list_begin_end (uiout, "stack-args");  /* Now let's print the frames up to frame_high, or until there are     frames in the stack. */  for (;       fi && (i <= frame_high || frame_high == -1);       i++, fi = get_prev_frame (fi))    {      struct cleanup *cleanup_frame;      QUIT;      cleanup_frame = make_cleanup_ui_out_tuple_begin_end (uiout, "frame");      ui_out_field_int (uiout, "level", i);      list_args_or_locals (0, atoi (argv[0]), fi);      do_cleanups (cleanup_frame);    }  do_cleanups (cleanup_stack_args);  if (i < frame_high)    error ("mi_cmd_stack_list_args: Not enough frames in stack.");  return MI_CMD_DONE;}

enum mi_cmd_resultmi_cmd_var_delete (char *command, char **argv, int argc){  char *name;  char *expr;  struct varobj *var;  int numdel;  int children_only_p = 0;  struct cleanup *old_cleanups;  if (argc < 1 || argc > 2)    error ("mi_cmd_var_delete: Usage: [-c] EXPRESSION.");  name = xstrdup (argv[0]);  /* Add cleanup for name. Must be free_current_contents as     name can be reallocated */  old_cleanups = make_cleanup (free_current_contents, &name);  /* If we have one single argument it cannot be '-c' or any string     starting with '-'. */  if (argc == 1)    {      if (strcmp (name, "-c") == 0)	error ("mi_cmd_var_delete: Missing required argument after '-c': variable object name");      if (*name == '-')	error ("mi_cmd_var_delete: Illegal variable object name");    }  /* If we have 2 arguments they must be '-c' followed by a string     which would be the variable name. */  if (argc == 2)    {      expr = xstrdup (argv[1]);      if (strcmp (name, "-c") != 0)	error ("mi_cmd_var_delete: Invalid option.");      children_only_p = 1;      xfree (name);      name = xstrdup (expr);      xfree (expr);    }  /* If we didn't error out, now NAME contains the name of the     variable. */  var = varobj_get_handle (name);  if (var == NULL)    error ("mi_cmd_var_delete: Variable object not found.");  numdel = varobj_delete (var, NULL, children_only_p);  ui_out_field_int (uiout, "ndeleted", numdel);  do_cleanups (old_cleanups);  return MI_CMD_DONE;}

voidmi_cmd_var_info_num_children (char *command, char **argv, int argc){  struct ui_out *uiout = current_uiout;  struct varobj *var;  if (argc != 1)    error (_("-var-info-num-children: Usage: NAME."));  /* Get varobj handle, if a valid var obj name was specified.  */  var = varobj_get_handle (argv[0]);  ui_out_field_int (uiout, "numchild", varobj_get_num_children (var));}

static voidbtrace_func_history_src_line (struct ui_out *uiout, struct btrace_func *bfun){  struct symbol *sym;  sym = bfun->sym;  if (sym == NULL)    return;  ui_out_field_string (uiout, "file",		       symtab_to_filename_for_display (sym->symtab));  if (bfun->lend == 0)    return;  ui_out_text (uiout, ":");  ui_out_field_int (uiout, "min line", bfun->lbegin);  if (bfun->lend == bfun->lbegin)    return;  ui_out_text (uiout, "-");  ui_out_field_int (uiout, "max line", bfun->lend);}

enum mi_cmd_resultmi_cmd_var_info_num_children (char *command, char **argv, int argc){  struct varobj *var;  if (argc != 1)    error ("mi_cmd_var_info_num_children: Usage: NAME.");  /* Get varobj handle, if a valid var obj name was specified */  var = varobj_get_handle (argv[0]);  if (var == NULL)    error ("mi_cmd_var_info_num_children: Variable object not found");  ui_out_field_int (uiout, "numchild", varobj_get_num_children (var));  return MI_CMD_DONE;}

voidmi_cmd_symbol_list_lines (char *command, char **argv, int argc){  struct gdbarch *gdbarch;  char *filename;  struct symtab *s;  int i;  struct cleanup *cleanup_stack, *cleanup_tuple;  struct ui_out *uiout = current_uiout;  if (argc != 1)    error (_("-symbol-list-lines: Usage: SOURCE_FILENAME"));  filename = argv[0];  s = lookup_symtab (filename);  if (s == NULL)    error (_("-symbol-list-lines: Unknown source file name."));  /* Now, dump the associated line table.  The pc addresses are     already sorted by increasing values in the symbol table, so no     need to perform any other sorting.  */  gdbarch = get_objfile_arch (s->objfile);  cleanup_stack = make_cleanup_ui_out_list_begin_end (uiout, "lines");  if (LINETABLE (s) != NULL && LINETABLE (s)->nitems > 0)    for (i = 0; i < LINETABLE (s)->nitems; i++)    {      cleanup_tuple = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);      ui_out_field_core_addr (uiout, "pc", gdbarch, LINETABLE (s)->item[i].pc);      ui_out_field_int (uiout, "line", LINETABLE (s)->item[i].line);      do_cleanups (cleanup_tuple);    }  do_cleanups (cleanup_stack);}

voidmi_cmd_stack_info_depth (char *command, char **argv, int argc){  int frame_high;  int i;  struct frame_info *fi;  if (argc > 1)    error (_("-stack-info-depth: Usage: [MAX_DEPTH]"));  if (argc == 1)    frame_high = atoi (argv[0]);  else    /* Called with no arguments, it means we want the real depth of       the stack.  */    frame_high = -1;  for (i = 0, fi = get_current_frame ();       fi && (i < frame_high || frame_high == -1);       i++, fi = get_prev_frame (fi))    QUIT;  ui_out_field_int (current_uiout, "depth", i);}

static intdump_insns (struct gdbarch *gdbarch, struct ui_out *uiout,	    struct disassemble_info * di,	    CORE_ADDR low, CORE_ADDR high,	    int how_many, int flags, struct ui_stream *stb){  int num_displayed = 0;  CORE_ADDR pc;  /* parts of the symbolic representation of the address */  int unmapped;  int offset;  int line;  struct cleanup *ui_out_chain;  for (pc = low; pc < high;)    {      char *filename = NULL;      char *name = NULL;      QUIT;      if (how_many >= 0)	{	  if (num_displayed >= how_many)	    break;	  else	    num_displayed++;	}      ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);      ui_out_field_core_addr (uiout, "address", gdbarch, pc);      if (!build_address_symbolic (pc, 0, &name, &offset, &filename,				   &line, &unmapped))	{	  /* We don't care now about line, filename and	     unmapped. But we might in the future. */	  ui_out_text (uiout, " <");	  ui_out_field_string (uiout, "func-name", name);	  ui_out_text (uiout, "+");	  ui_out_field_int (uiout, "offset", offset);	  ui_out_text (uiout, ">:/t");	}      else	ui_out_text (uiout, ":/t");      if (filename != NULL)	xfree (filename);      if (name != NULL)	xfree (name);      ui_file_rewind (stb->stream);      if (flags & DISASSEMBLY_RAW_INSN)        {          CORE_ADDR old_pc = pc;          bfd_byte data;          int status;          pc += gdbarch_print_insn (gdbarch, pc, di);          for (;old_pc < pc; old_pc++)            {              status = (*di->read_memory_func) (old_pc, &data, 1, di);              if (status != 0)                (*di->memory_error_func) (status, old_pc, di);              ui_out_message (uiout, 0, " %02x", (unsigned)data);            }          ui_out_text (uiout, "/t");        }      else        pc += gdbarch_print_insn (gdbarch, pc, di);      ui_out_field_stream (uiout, "inst", stb);      ui_file_rewind (stb->stream);      do_cleanups (ui_out_chain);      ui_out_text (uiout, "/n");    }  return num_displayed;}

voidmi_load_progress (const char *section_name,		  unsigned long sent_so_far,		  unsigned long total_section,		  unsigned long total_sent,		  unsigned long grand_total){  struct timeval time_now, delta, update_threshold;  static struct timeval last_update;  static char *previous_sect_name = NULL;  int new_section;  struct ui_out *saved_uiout;  /* This function is called through deprecated_show_load_progress     which means uiout may not be correct.  Fix it for the duration     of this function.  */  saved_uiout = uiout;  if (current_interp_named_p (INTERP_MI))    uiout = mi_out_new (2);  else if (current_interp_named_p (INTERP_MI1))    uiout = mi_out_new (1);  else    return;  update_threshold.tv_sec = 0;  update_threshold.tv_usec = 500000;  gettimeofday (&time_now, NULL);  delta.tv_usec = time_now.tv_usec - last_update.tv_usec;  delta.tv_sec = time_now.tv_sec - last_update.tv_sec;  if (delta.tv_usec < 0)    {      delta.tv_sec -= 1;      delta.tv_usec += 1000000;    }  new_section = (previous_sect_name ?		 strcmp (previous_sect_name, section_name) : 1);  if (new_section)    {      struct cleanup *cleanup_tuple;      xfree (previous_sect_name);      previous_sect_name = xstrdup (section_name);      if (last_async_command)	fputs_unfiltered (last_async_command, raw_stdout);      fputs_unfiltered ("+download", raw_stdout);      cleanup_tuple = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);      ui_out_field_string (uiout, "section", section_name);      ui_out_field_int (uiout, "section-size", total_section);      ui_out_field_int (uiout, "total-size", grand_total);      do_cleanups (cleanup_tuple);      mi_out_put (uiout, raw_stdout);      fputs_unfiltered ("/n", raw_stdout);      gdb_flush (raw_stdout);    }  if (delta.tv_sec >= update_threshold.tv_sec &&      delta.tv_usec >= update_threshold.tv_usec)    {      struct cleanup *cleanup_tuple;      last_update.tv_sec = time_now.tv_sec;      last_update.tv_usec = time_now.tv_usec;      if (last_async_command)	fputs_unfiltered (last_async_command, raw_stdout);      fputs_unfiltered ("+download", raw_stdout);      cleanup_tuple = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);      ui_out_field_string (uiout, "section", section_name);      ui_out_field_int (uiout, "section-sent", sent_so_far);      ui_out_field_int (uiout, "section-size", total_section);      ui_out_field_int (uiout, "total-sent", total_sent);      ui_out_field_int (uiout, "total-size", grand_total);      do_cleanups (cleanup_tuple);      mi_out_put (uiout, raw_stdout);      fputs_unfiltered ("/n", raw_stdout);      gdb_flush (raw_stdout);    }  xfree (uiout);  uiout = saved_uiout;}

enum mi_cmd_resultmi_cmd_data_list_changed_registers (char *command, char **argv, int argc){  int regnum, numregs, changed;  int i;  struct cleanup *cleanup;  /* Note that the test for a valid register must include checking the     REGISTER_NAME because NUM_REGS may be allocated for the union of     the register sets within a family of related processors.  In this     case, some entries of REGISTER_NAME will change depending upon     the particular processor being debugged.  */  numregs = NUM_REGS + NUM_PSEUDO_REGS;  cleanup = make_cleanup_ui_out_list_begin_end (uiout, "changed-registers");  if (argc == 0)		/* No args, just do all the regs */    {      for (regnum = 0;	   regnum < numregs;	   regnum++)	{	  if (REGISTER_NAME (regnum) == NULL	      || *(REGISTER_NAME (regnum)) == '/0')	    continue;	  changed = register_changed_p (regnum);	  if (changed < 0)	    {	      do_cleanups (cleanup);	      mi_error_message = xstrprintf ("mi_cmd_data_list_changed_registers: Unable to read register contents.");	      return MI_CMD_ERROR;	    }	  else if (changed)	    ui_out_field_int (uiout, NULL, regnum);	}    }  /* Else, list of register #s, just do listed regs */  for (i = 0; i < argc; i++)    {      regnum = atoi (argv[i]);      if (regnum >= 0	  && regnum < numregs	  && REGISTER_NAME (regnum) != NULL	  && *REGISTER_NAME (regnum) != '/000')	{	  changed = register_changed_p (regnum);	  if (changed < 0)	    {	      do_cleanups (cleanup);	      mi_error_message = xstrprintf ("mi_cmd_data_list_register_change: Unable to read register contents.");	      return MI_CMD_ERROR;	    }	  else if (changed)	    ui_out_field_int (uiout, NULL, regnum);	}      else	{	  do_cleanups (cleanup);	  mi_error_message = xstrprintf ("bad register number");	  return MI_CMD_ERROR;	}    }  do_cleanups (cleanup);  return MI_CMD_DONE;}

/* Return a list of register number and value pairs. The valid   arguments expected are: a letter indicating the format in which to   display the registers contents. This can be one of: x (hexadecimal), d   (decimal), N (natural), t (binary), o (octal), r (raw).  After the   format argumetn there can be a sequence of numbers, indicating which   registers to fetch the content of. If the format is the only argument,   a list of all the registers with their values is returned. */enum mi_cmd_resultmi_cmd_data_list_register_values (char *command, char **argv, int argc){  int regnum, numregs, format, result;  int i;  struct cleanup *list_cleanup, *tuple_cleanup;  /* Note that the test for a valid register must include checking the     REGISTER_NAME because NUM_REGS may be allocated for the union of     the register sets within a family of related processors.  In this     case, some entries of REGISTER_NAME will change depending upon     the particular processor being debugged.  */  numregs = NUM_REGS + NUM_PSEUDO_REGS;  if (argc == 0)    {      mi_error_message = xstrprintf ("mi_cmd_data_list_register_values: Usage: -data-list-register-values <format> [<regnum1>...<regnumN>]");      return MI_CMD_ERROR;    }  format = (int) argv[0][0];  list_cleanup = make_cleanup_ui_out_list_begin_end (uiout, "register-values");  if (argc == 1)		/* No args, beside the format: do all the regs */    {      for (regnum = 0;	   regnum < numregs;	   regnum++)	{	  if (REGISTER_NAME (regnum) == NULL	      || *(REGISTER_NAME (regnum)) == '/0')	    continue;	  tuple_cleanup = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);	  ui_out_field_int (uiout, "number", regnum);	  result = get_register (regnum, format);	  if (result == -1)	    {	      do_cleanups (list_cleanup);	      return MI_CMD_ERROR;	    }	  do_cleanups (tuple_cleanup);	}    }  /* Else, list of register #s, just do listed regs */  for (i = 1; i < argc; i++)    {      regnum = atoi (argv[i]);      if (regnum >= 0	  && regnum < numregs	  && REGISTER_NAME (regnum) != NULL	  && *REGISTER_NAME (regnum) != '/000')	{	  tuple_cleanup = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);	  ui_out_field_int (uiout, "number", regnum);	  result = get_register (regnum, format);	  if (result == -1)	    {	      do_cleanups (list_cleanup);	      return MI_CMD_ERROR;	    }	  do_cleanups (tuple_cleanup);	}      else	{	  do_cleanups (list_cleanup);	  mi_error_message = xstrprintf ("bad register number");	  return MI_CMD_ERROR;	}    }  do_cleanups (list_cleanup);  return MI_CMD_DONE;}

static voidmi_on_normal_stop (struct bpstats *bs, int print_frame){  /* Since this can be called when CLI command is executing,     using cli interpreter, be sure to use MI uiout for output,     not the current one.  */  struct ui_out *mi_uiout = interp_ui_out (top_level_interpreter ());  if (print_frame)    {      int core;      if (current_uiout != mi_uiout)	{	  /* The normal_stop function has printed frame information	     into CLI uiout, or some other non-MI uiout.  There's no	     way we can extract proper fields from random uiout	     object, so we print the frame again.  In practice, this	     can only happen when running a CLI command in MI.  */	  struct ui_out *saved_uiout = current_uiout;	  struct target_waitstatus last;	  ptid_t last_ptid;	  current_uiout = mi_uiout;	  get_last_target_status (&last_ptid, &last);	  print_stop_event (&last);	  current_uiout = saved_uiout;	}      /* Otherwise, frame information has already been printed by	 normal_stop.  */      else	{	  /* Breakpoint hits should always be mirrored to the console.	     Deciding what to mirror to the console wrt to breakpoints	     and random stops gets messy real fast.  E.g., say "s"	     trips on a breakpoint.  We'd clearly want to mirror the	     event to the console in this case.  But what about more	     complicated cases like "s&; thread n; s&", and one of	     those steps spawning a new thread, and that thread	     hitting a breakpoint?  It's impossible in general to	     track whether the thread had any relation to the commands	     that had been executed.  So we just simplify and always	     mirror breakpoints and random events to the console.	     Also, CLI execution commands (-interpreter-exec console	     "next", for example) in async mode have the opposite	     issue as described in the "then" branch above --	     normal_stop has already printed frame information to MI	     uiout, but nothing has printed the same information to	     the CLI channel.  We should print the source line to the	     console when stepping or other similar commands, iff the	     step was started by a console command (but not if it was	     started with -exec-step or similar).  */	  struct thread_info *tp = inferior_thread ();	  if ((!tp->control.stop_step		  && !tp->control.proceed_to_finish)	      || (tp->control.command_interp != NULL		  && tp->control.command_interp != top_level_interpreter ()))	    {	      struct mi_interp *mi = top_level_interpreter_data ();	      struct target_waitstatus last;	      ptid_t last_ptid;	      struct cleanup *old_chain;	      /* Set the current uiout to CLI uiout temporarily.  */	      old_chain = make_cleanup (restore_current_uiout_cleanup,					current_uiout);	      current_uiout = mi->cli_uiout;	      get_last_target_status (&last_ptid, &last);	      print_stop_event (&last);	      do_cleanups (old_chain);	    }	}      ui_out_field_int (mi_uiout, "thread-id",			pid_to_thread_id (inferior_ptid));      if (non_stop)	{	  struct cleanup *back_to = make_cleanup_ui_out_list_begin_end 	    (mi_uiout, "stopped-threads");	  ui_out_field_int (mi_uiout, NULL,			    pid_to_thread_id (inferior_ptid));	  do_cleanups (back_to);	}      else	ui_out_field_string (mi_uiout, "stopped-threads", "all");      core = target_core_of_thread (inferior_ptid);      if (core != -1)	ui_out_field_int (mi_uiout, "core", core);    }    fputs_unfiltered ("*stopped", raw_stdout);  mi_out_put (mi_uiout, raw_stdout);//.........这里部分代码省略.........

//.........这里部分代码省略.........    {      mi_error_message = xstrprintf ("mi_cmd_data_read_memory: invalid number of rows.");      return MI_CMD_ERROR;    }  /* number of bytes per row. */  nr_cols = atol (argv[4]);  if (nr_cols <= 0)    {      mi_error_message = xstrprintf ("mi_cmd_data_read_memory: invalid number of columns.");      return MI_CMD_ERROR;    }  /* The un-printable character when printing ascii. */  if (argc == 6)    aschar = *argv[5];  else    aschar = 0;  /* create a buffer and read it in. */  total_bytes = word_size * nr_rows * nr_cols;  mbuf = xcalloc (total_bytes, 1);  make_cleanup (xfree, mbuf);  nr_bytes = target_read (&current_target, TARGET_OBJECT_MEMORY, NULL,			  mbuf, addr, total_bytes);  if (nr_bytes <= 0)    {      do_cleanups (cleanups);      mi_error_message = xstrdup ("Unable to read memory.");      return MI_CMD_ERROR;    }  /* output the header information. */  ui_out_field_core_addr (uiout, "addr", addr);  ui_out_field_int (uiout, "nr-bytes", nr_bytes);  ui_out_field_int (uiout, "total-bytes", total_bytes);  ui_out_field_core_addr (uiout, "next-row", addr + word_size * nr_cols);  ui_out_field_core_addr (uiout, "prev-row", addr - word_size * nr_cols);  ui_out_field_core_addr (uiout, "next-page", addr + total_bytes);  ui_out_field_core_addr (uiout, "prev-page", addr - total_bytes);  /* Build the result as a two dimentional table. */  {    struct ui_stream *stream = ui_out_stream_new (uiout);    struct cleanup *cleanup_list_memory;    int row;    int row_byte;    cleanup_list_memory = make_cleanup_ui_out_list_begin_end (uiout, "memory");    for (row = 0, row_byte = 0;	 row < nr_rows;	 row++, row_byte += nr_cols * word_size)      {	int col;	int col_byte;	struct cleanup *cleanup_tuple;	struct cleanup *cleanup_list_data;	cleanup_tuple = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);	ui_out_field_core_addr (uiout, "addr", addr + row_byte);	/* ui_out_field_core_addr_symbolic (uiout, "saddr", addr + row_byte); */	cleanup_list_data = make_cleanup_ui_out_list_begin_end (uiout, "data");	for (col = 0, col_byte = row_byte;	     col < nr_cols;	     col++, col_byte += word_size)	  {	    if (col_byte + word_size > nr_bytes)	      {		ui_out_field_string (uiout, NULL, "N/A");

//.........这里部分代码省略.........	// Annotate the context of each instruction	for (insn_index = 0; insn_index < g_num_insns; insn_index++)	{		int cur_insn = 0;		struct ca_dis_insn* insn = &g_insns_buffer[insn_index];		// update program counter for RIP-relative instruction		// RIP points to the address of the next instruction before executing current one		if (insn_index + 1 < g_num_insns)			set_reg_value_at_pc(RIP, (insn+1)->pc, insn->pc);		// user may set some register values deliberately		if (decode_cb->user_regs)		{			if (insn->pc == decode_cb->low				|| (insn_index + 1 < g_num_insns && g_insns_buffer[insn_index + 1].pc > decode_cb->low) )			{				if (insn->pc == decode_cb->func_start)					set_reg_table_at_pc(decode_cb->user_regs, 0);				else					set_reg_table_at_pc(decode_cb->user_regs, insn->pc);			}		}		// analyze and update register context affected by this instruction		if (decode_cb->innermost_frame)		{			if (insn->pc == decode_cb->current)				cur_insn = 1;		}		else if (insn_index + 1 < g_num_insns && g_insns_buffer[insn_index + 1].pc == decode_cb->current)			cur_insn = 1;		process_one_insn(insn, cur_insn);		if (cur_insn)		{			// return the register context back to caller			for (i = 0; i < TOTAL_REGS; i++)			{				struct ca_reg_value* reg = g_reg_table.cur_regs[i];				if (reg->has_value)				{					// only pass on values, symbol may be out of context in another function					struct ca_reg_value* dst = &decode_cb->param_regs[i];					memcpy(dst, reg, sizeof(struct ca_reg_value));					dst->sym_name = NULL;				}			}		}	}	if (decode_cb->verbose)		validate_reg_table();	// display disassembled insns	for (insn_index = 0; insn_index < g_num_insns; insn_index++)	{		struct ca_dis_insn* insn = &g_insns_buffer[insn_index];		// parts of the symbolic representation of the address		int unmapped;		int offset;		int line;		char *filename = NULL;		char *name = NULL;		if (insn->pc >= decode_cb->high)			break;		else if (insn->pc >= decode_cb->low)		{			// instruction address + offset			ui_out_text(uiout, pc_prefix(insn->pc));			ui_out_field_core_addr(uiout, "address", gdbarch, insn->pc);			if (!build_address_symbolic(gdbarch, insn->pc, 0, &name, &offset, &filename,					&line, &unmapped))			{				ui_out_text(uiout, " <");				//if (decode_cb->verbose)				//	ui_out_field_string(uiout, "func-name", name);				ui_out_text(uiout, "+");				ui_out_field_int(uiout, "offset", offset);				ui_out_text(uiout, ">:/t");			} else				ui_out_message(uiout, 0, "<+%ld>:/t", insn->pc - decode_cb->func_start);			// disassembled instruction with annotation			print_one_insn(insn, uiout);			if (filename != NULL)				free(filename);			if (name != NULL)				free(name);		}	}	reset_reg_table();	reset_stack_vars();	return num_insns;}

static voidlist_arg_or_local (const struct frame_arg *arg, enum what_to_list what,		   enum print_values values, int skip_unavailable){  struct cleanup *old_chain;  struct ui_out *uiout = current_uiout;  struct ui_file *stb;  gdb_assert (!arg->val || !arg->error);  gdb_assert ((values == PRINT_NO_VALUES && arg->val == NULL	       && arg->error == NULL)	      || values == PRINT_SIMPLE_VALUES	      || (values == PRINT_ALL_VALUES		  && (arg->val != NULL || arg->error != NULL)));  gdb_assert (arg->entry_kind == print_entry_values_no	      || (arg->entry_kind == print_entry_values_only	          && (arg->val || arg->error)));  if (skip_unavailable && arg->val != NULL      && (value_entirely_unavailable (arg->val)	  /* A scalar object that does not have all bits available is	     also considered unavailable, because all bits contribute	     to its representation.  */	  || (val_print_scalar_type_p (value_type (arg->val))	      && !value_bytes_available (arg->val,					 value_embedded_offset (arg->val),					 TYPE_LENGTH (value_type (arg->val))))))    return;  stb = mem_fileopen ();  old_chain = make_cleanup_ui_file_delete (stb);  if (values != PRINT_NO_VALUES || what == all)    make_cleanup_ui_out_tuple_begin_end (uiout, NULL);  fputs_filtered (SYMBOL_PRINT_NAME (arg->sym), stb);  if (arg->entry_kind == print_entry_values_only)    fputs_filtered ("@entry", stb);  ui_out_field_stream (uiout, "name", stb);  if (what == all && SYMBOL_IS_ARGUMENT (arg->sym))    ui_out_field_int (uiout, "arg", 1);  if (values == PRINT_SIMPLE_VALUES)    {      check_typedef (arg->sym->type);      type_print (arg->sym->type, "", stb, -1);      ui_out_field_stream (uiout, "type", stb);    }  if (arg->val || arg->error)    {      const char *error_message = NULL;      if (arg->error)	error_message = arg->error;      else	{	  TRY	    {	      struct value_print_options opts;	      get_no_prettyformat_print_options (&opts);	      opts.deref_ref = 1;	      common_val_print (arg->val, stb, 0, &opts,				language_def (SYMBOL_LANGUAGE (arg->sym)));	    }	  CATCH (except, RETURN_MASK_ERROR)	    {	      error_message = except.message;	    }	  END_CATCH	}      if (error_message != NULL)	fprintf_filtered (stb, _("<error reading variable: %s>"),			  error_message);      ui_out_field_stream (uiout, "value", stb);    }  do_cleanups (old_chain);}

//.........这里部分代码省略.........  {    NO_FRAME_FILTERS,    SKIP_UNAVAILABLE,  };  static const struct mi_opt opts[] =    {      {"-no-frame-filters", NO_FRAME_FILTERS, 0},      {"-skip-unavailable", SKIP_UNAVAILABLE, 0},      { 0, 0, 0 }    };  while (1)    {      char *oarg;      int opt = mi_getopt_allow_unknown ("-stack-list-args", argc, argv,					 opts, &oind, &oarg);      if (opt < 0)	break;      switch ((enum opt) opt)	{	case NO_FRAME_FILTERS:	  raw_arg = oind;	  break;	case SKIP_UNAVAILABLE:	  skip_unavailable = 1;	  break;	}    }  if (argc - oind != 1 && argc - oind != 3)    error (_("-stack-list-arguments: Usage: "	/	     "[--no-frame-filters] [--skip-unavailable] "	     "PRINT_VALUES [FRAME_LOW FRAME_HIGH]"));  if (argc - oind == 3)    {      frame_low = atoi (argv[1 + oind]);      frame_high = atoi (argv[2 + oind]);    }  else    {      /* Called with no arguments, it means we want args for the whole         backtrace.  */      frame_low = -1;      frame_high = -1;    }  print_values = mi_parse_print_values (argv[oind]);  /* Let's position fi on the frame at which to start the     display. Could be the innermost frame if the whole stack needs     displaying, or if frame_low is 0.  */  for (i = 0, fi = get_current_frame ();       fi && i < frame_low;       i++, fi = get_prev_frame (fi));  if (fi == NULL)    error (_("-stack-list-arguments: Not enough frames in stack."));  cleanup_stack_args    = make_cleanup_ui_out_list_begin_end (uiout, "stack-args");  if (! raw_arg && frame_filters)    {      int flags = PRINT_LEVEL | PRINT_ARGS;      int py_frame_low = frame_low;      /* We cannot pass -1 to frame_low, as that would signify a      relative backtrace from the tail of the stack.  So, in the case      of frame_low == -1, assign and increment it.  */      if (py_frame_low == -1)	py_frame_low++;      result = mi_apply_ext_lang_frame_filter (get_current_frame (), flags,					       print_values, current_uiout,					       py_frame_low, frame_high);    }     /* Run the inbuilt backtrace if there are no filters registered, or      if "--no-frame-filters" has been specified from the command.  */   if (! frame_filters || raw_arg  || result == EXT_LANG_BT_NO_FILTERS)     {      /* Now let's print the frames up to frame_high, or until there are	 frames in the stack.  */      for (;	   fi && (i <= frame_high || frame_high == -1);	   i++, fi = get_prev_frame (fi))	{	  struct cleanup *cleanup_frame;	  QUIT;	  cleanup_frame = make_cleanup_ui_out_tuple_begin_end (uiout, "frame");	  ui_out_field_int (uiout, "level", i);	  list_args_or_locals (arguments, print_values, fi, skip_unavailable);	  do_cleanups (cleanup_frame);	}    }  do_cleanups (cleanup_stack_args);}

static intdump_insns (struct gdbarch *gdbarch, struct ui_out *uiout,	    struct disassemble_info * di,	    CORE_ADDR low, CORE_ADDR high,	    int how_many, int flags, struct ui_stream *stb){  int num_displayed = 0;  CORE_ADDR pc;  /* parts of the symbolic representation of the address */  int unmapped;  int offset;  int line;  struct cleanup *ui_out_chain;  for (pc = low; pc < high;)    {      char *filename = NULL;      char *name = NULL;      QUIT;      if (how_many >= 0)	{	  if (num_displayed >= how_many)	    break;	  else	    num_displayed++;	}      ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);      ui_out_text (uiout, pc_prefix (pc));      ui_out_field_core_addr (uiout, "address", gdbarch, pc);      if (!build_address_symbolic (gdbarch, pc, 0, &name, &offset, &filename,				   &line, &unmapped))	{	  /* We don't care now about line, filename and	     unmapped. But we might in the future.  */	  ui_out_text (uiout, " <");	  if ((flags & DISASSEMBLY_OMIT_FNAME) == 0)	    ui_out_field_string (uiout, "func-name", name);	  ui_out_text (uiout, "+");	  ui_out_field_int (uiout, "offset", offset);	  ui_out_text (uiout, ">:/t");	}      else	ui_out_text (uiout, ":/t");      if (filename != NULL)	xfree (filename);      if (name != NULL)	xfree (name);      ui_file_rewind (stb->stream);      if (flags & DISASSEMBLY_RAW_INSN)        {          CORE_ADDR old_pc = pc;          bfd_byte data;          int status;          const char *spacer = "";          /* Build the opcodes using a temporary stream so we can             write them out in a single go for the MI.  */          struct ui_stream *opcode_stream = ui_out_stream_new (uiout);          struct cleanup *cleanups =            make_cleanup_ui_out_stream_delete (opcode_stream);          pc += gdbarch_print_insn (gdbarch, pc, di);          for (;old_pc < pc; old_pc++)            {              status = (*di->read_memory_func) (old_pc, &data, 1, di);              if (status != 0)                (*di->memory_error_func) (status, old_pc, di);              fprintf_filtered (opcode_stream->stream, "%s%02x",                                spacer, (unsigned) data);              spacer = " ";            }          ui_out_field_stream (uiout, "opcodes", opcode_stream);          ui_out_text (uiout, "/t");          do_cleanups (cleanups);        }      else        pc += gdbarch_print_insn (gdbarch, pc, di);      ui_out_field_stream (uiout, "inst", stb);      ui_file_rewind (stb->stream);      do_cleanups (ui_out_chain);      ui_out_text (uiout, "/n");    }  return num_displayed;}

enum mi_cmd_resultmi_cmd_var_create (char *command, char **argv, int argc){  CORE_ADDR frameaddr = 0;  struct varobj *var;  char *name;  char *frame;  char *expr;  char *type;  struct cleanup *old_cleanups;  enum varobj_type var_type;  if (argc != 3)    {      /* mi_error_message = xstrprintf ("mi_cmd_var_create: Usage:         ...."); return MI_CMD_ERROR; */      error ("mi_cmd_var_create: Usage: NAME FRAME EXPRESSION.");    }  name = xstrdup (argv[0]);  /* Add cleanup for name. Must be free_current_contents as     name can be reallocated */  old_cleanups = make_cleanup (free_current_contents, &name);  frame = xstrdup (argv[1]);  old_cleanups = make_cleanup (xfree, frame);  expr = xstrdup (argv[2]);  if (strcmp (name, "-") == 0)    {      xfree (name);      name = varobj_gen_name ();    }  else if (!isalpha (*name))    error ("mi_cmd_var_create: name of object must begin with a letter");  if (strcmp (frame, "*") == 0)    var_type = USE_CURRENT_FRAME;  else if (strcmp (frame, "@") == 0)    var_type = USE_SELECTED_FRAME;    else    {      var_type = USE_SPECIFIED_FRAME;      frameaddr = string_to_core_addr (frame);    }  if (varobjdebug)    fprintf_unfiltered (gdb_stdlog,		    "Name=/"%s/", Frame=/"%s/" (0x%s), Expression=/"%s/"/n",			name, frame, paddr (frameaddr), expr);  var = varobj_create (name, expr, frameaddr, var_type);  if (var == NULL)    error ("mi_cmd_var_create: unable to create variable object");  ui_out_field_string (uiout, "name", name);  ui_out_field_int (uiout, "numchild", varobj_get_num_children (var));  type = varobj_get_type (var);  if (type == NULL)    ui_out_field_string (uiout, "type", "");  else    {      ui_out_field_string (uiout, "type", type);      xfree (type);    }  do_cleanups (old_cleanups);  return MI_CMD_DONE;}