s/struct _serial_t/struct serial/
[deliverable/binutils-gdb.git] / gdb / mi / mi-main.c
CommitLineData
fb40c209 1/* MI Command Set.
4e052eda 2 Copyright 2000, 2001 Free Software Foundation, Inc.
ab91fdd5 3 Contributed by Cygnus Solutions (a Red Hat company).
fb40c209
AC
4
5 This file is part of GDB.
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
21
22/* Work in progress */
23
24#include "defs.h"
25#include "target.h"
26#include "inferior.h"
27#include "gdb_string.h"
28#include "top.h"
29#include "gdbthread.h"
30#include "mi-cmds.h"
31#include "mi-parse.h"
32#include "mi-getopt.h"
33#include "mi-console.h"
34#include "ui-out.h"
35#include "mi-out.h"
36#include "event-loop.h"
37#include "event-top.h"
38#include "gdbcore.h" /* for write_memory() */
24e8cecf 39#include "value.h" /* for write_register_bytes() */
4e052eda 40#include "regcache.h"
fb40c209
AC
41#include <ctype.h>
42#include <sys/time.h>
43
44/* Convenience macro for allocting typesafe memory. */
45
46#undef XMALLOC
47#define XMALLOC(TYPE) (TYPE*) xmalloc (sizeof (TYPE))
48
49enum
50 {
51 FROM_TTY = 0
52 };
53
54
55int mi_debug_p;
56struct ui_file *raw_stdout;
57
58/* The token of the last asynchronous command */
59static char *last_async_command;
60static char *previous_async_command;
61static char *mi_error_message;
62static char *old_regs;
63
64extern void _initialize_mi_main (void);
65static char *mi_input (char *);
66static void mi_execute_command (char *cmd, int from_tty);
67static enum mi_cmd_result mi_cmd_execute (struct mi_parse *parse);
68
69static void mi_execute_cli_command (const char *cli, char *args);
70static enum mi_cmd_result mi_execute_async_cli_command (char *mi, char *args, int from_tty);
71static void mi_execute_command_wrapper (char *cmd);
72
73void mi_exec_async_cli_cmd_continuation (struct continuation_arg *arg);
fb40c209
AC
74
75static int register_changed_p (int regnum);
76static int get_register (int regnum, int format);
77static void mi_load_progress (const char *section_name,
78 unsigned long sent_so_far,
79 unsigned long total_section,
80 unsigned long total_sent,
81 unsigned long grand_total);
82
83#ifdef UI_OUT
84/* FIXME: these should go in some .h file, but infcmd.c doesn't have a
85 corresponding .h file. These wrappers will be obsolete anyway, once
86 we pull the plug on the sanitization. */
87extern void interrupt_target_command_wrapper (char *, int);
88extern void return_command_wrapper (char *, int);
89#endif
90
91/* Command implementations. FIXME: Is this libgdb? No. This is the MI
92 layer that calls libgdb. Any operation used in the below should be
93 formalized. */
94
95enum mi_cmd_result
96mi_cmd_gdb_exit (char *command, char **argv, int argc)
97{
98 /* We have to print everything right here because we never return */
99 if (last_async_command)
100 fputs_unfiltered (last_async_command, raw_stdout);
101 fputs_unfiltered ("^exit\n", raw_stdout);
102 mi_out_put (uiout, raw_stdout);
103 /* FIXME: The function called is not yet a formal libgdb function */
104 quit_force (NULL, FROM_TTY);
105 return MI_CMD_DONE;
106}
107
108enum mi_cmd_result
109mi_cmd_exec_run (char *args, int from_tty)
110{
111 /* FIXME: Should call a libgdb function, not a cli wrapper */
112 return mi_execute_async_cli_command ("run", args, from_tty);
113}
114
115enum mi_cmd_result
116mi_cmd_exec_next (char *args, int from_tty)
117{
118 /* FIXME: Should call a libgdb function, not a cli wrapper */
119 return mi_execute_async_cli_command ("next", args, from_tty);
120}
121
122enum mi_cmd_result
123mi_cmd_exec_next_instruction (char *args, int from_tty)
124{
125 /* FIXME: Should call a libgdb function, not a cli wrapper */
126 return mi_execute_async_cli_command ("nexti", args, from_tty);
127}
128
129enum mi_cmd_result
130mi_cmd_exec_step (char *args, int from_tty)
131{
132 /* FIXME: Should call a libgdb function, not a cli wrapper */
133 return mi_execute_async_cli_command ("step", args, from_tty);
134}
135
136enum mi_cmd_result
137mi_cmd_exec_step_instruction (char *args, int from_tty)
138{
139 /* FIXME: Should call a libgdb function, not a cli wrapper */
140 return mi_execute_async_cli_command ("stepi", args, from_tty);
141}
142
143enum mi_cmd_result
144mi_cmd_exec_finish (char *args, int from_tty)
145{
146 /* FIXME: Should call a libgdb function, not a cli wrapper */
147 return mi_execute_async_cli_command ("finish", args, from_tty);
148}
149
150enum mi_cmd_result
151mi_cmd_exec_until (char *args, int from_tty)
152{
153 /* FIXME: Should call a libgdb function, not a cli wrapper */
154 return mi_execute_async_cli_command ("until", args, from_tty);
155}
156
157enum mi_cmd_result
158mi_cmd_exec_return (char *args, int from_tty)
159{
160#ifdef UI_OUT
161 /* This command doesn't really execute the target, it just pops the
162 specified number of frames. */
163 if (*args)
164 /* Call return_command with from_tty argument equal to 0 so as to
165 avoid being queried. */
166 return_command_wrapper (args, 0);
167 else
168 /* Call return_command with from_tty argument equal to 0 so as to
169 avoid being queried. */
170 return_command_wrapper (NULL, 0);
171
172 /* Because we have called return_command with from_tty = 0, we need
173 to print the frame here. */
174 show_and_print_stack_frame (selected_frame,
175 selected_frame_level,
176 LOC_AND_ADDRESS);
177#endif
178
179 return MI_CMD_DONE;
180}
181
182enum mi_cmd_result
183mi_cmd_exec_continue (char *args, int from_tty)
184{
185 /* FIXME: Should call a libgdb function, not a cli wrapper */
186 return mi_execute_async_cli_command ("continue", args, from_tty);
187}
188
189/* Interrupt the execution of the target. Note how we must play around
190 with the token varialbes, in order to display the current token in
191 the result of the interrupt command, and the previous execution
192 token when the target finally stops. See comments in
193 mi_cmd_execute. */
194enum mi_cmd_result
195mi_cmd_exec_interrupt (char *args, int from_tty)
196{
197#ifdef UI_OUT
198 if (!target_executing)
199 {
76995688
AC
200 xasprintf (&mi_error_message,
201 "mi_cmd_exec_interrupt: Inferior not executing.");
fb40c209
AC
202 return MI_CMD_ERROR;
203 }
204 interrupt_target_command_wrapper (args, from_tty);
205 if (last_async_command)
206 fputs_unfiltered (last_async_command, raw_stdout);
207 fputs_unfiltered ("^done", raw_stdout);
b8c9b27d 208 xfree (last_async_command);
fb40c209
AC
209 if (previous_async_command)
210 last_async_command = xstrdup (previous_async_command);
b8c9b27d 211 xfree (previous_async_command);
fb40c209
AC
212 previous_async_command = NULL;
213 mi_out_put (uiout, raw_stdout);
214 mi_out_rewind (uiout);
215 fputs_unfiltered ("\n", raw_stdout);
216#endif
217 return MI_CMD_QUIET;
218}
219
220enum mi_cmd_result
221mi_cmd_thread_select (char *command, char **argv, int argc)
222{
223 enum gdb_rc rc;
224
225 if (argc != 1)
226 {
76995688
AC
227 xasprintf (&mi_error_message,
228 "mi_cmd_thread_select: USAGE: threadnum.");
fb40c209
AC
229 return MI_CMD_ERROR;
230 }
231 else
232 rc = gdb_thread_select (argv[0]);
233
234 if (rc == GDB_RC_FAIL)
235 return MI_CMD_CAUGHT_ERROR;
236 else
237 return MI_CMD_DONE;
238}
239
240enum mi_cmd_result
241mi_cmd_thread_list_ids (char *command, char **argv, int argc)
242{
243 enum gdb_rc rc = MI_CMD_DONE;
244
245 if (argc != 0)
246 {
76995688
AC
247 xasprintf (&mi_error_message,
248 "mi_cmd_thread_list_ids: No arguments required.");
fb40c209
AC
249 return MI_CMD_ERROR;
250 }
251 else
252#ifdef UI_OUT
253 rc = gdb_list_thread_ids ();
254#endif
255
256 if (rc == GDB_RC_FAIL)
257 return MI_CMD_CAUGHT_ERROR;
258 else
259 return MI_CMD_DONE;
260}
261
262enum mi_cmd_result
263mi_cmd_data_list_register_names (char *command, char **argv, int argc)
264{
265 int regnum, numregs;
266 int i;
267
268 /* Note that the test for a valid register must include checking the
269 REGISTER_NAME because NUM_REGS may be allocated for the union of
270 the register sets within a family of related processors. In this
271 case, some entries of REGISTER_NAME will change depending upon
272 the particular processor being debugged. */
273
173d6894 274 numregs = NUM_REGS + NUM_PSEUDO_REGS;
fb40c209 275
173d6894 276 ui_out_list_begin (uiout, "register-names");
fb40c209
AC
277
278 if (argc == 0) /* No args, just do all the regs */
279 {
280 for (regnum = 0;
281 regnum < numregs;
282 regnum++)
283 {
284 if (REGISTER_NAME (regnum) == NULL
285 || *(REGISTER_NAME (regnum)) == '\0')
173d6894
AC
286 ui_out_field_string (uiout, NULL, "");
287 else
288 ui_out_field_string (uiout, NULL, REGISTER_NAME (regnum));
fb40c209
AC
289 }
290 }
291
292 /* Else, list of register #s, just do listed regs */
293 for (i = 0; i < argc; i++)
294 {
295 regnum = atoi (argv[i]);
173d6894 296 if (regnum < 0 || regnum >= numregs)
fb40c209 297 {
76995688 298 xasprintf (&mi_error_message, "bad register number");
fb40c209
AC
299 return MI_CMD_ERROR;
300 }
173d6894
AC
301 if (REGISTER_NAME (regnum) == NULL
302 || *(REGISTER_NAME (regnum)) == '\0')
303 ui_out_field_string (uiout, NULL, "");
304 else
305 ui_out_field_string (uiout, NULL, REGISTER_NAME (regnum));
fb40c209 306 }
173d6894 307 ui_out_list_end (uiout);
fb40c209
AC
308 return MI_CMD_DONE;
309}
310
311enum mi_cmd_result
312mi_cmd_data_list_changed_registers (char *command, char **argv, int argc)
313{
314 int regnum, numregs, changed;
315 int i;
316
317 /* Note that the test for a valid register must include checking the
318 REGISTER_NAME because NUM_REGS may be allocated for the union of
319 the register sets within a family of related processors. In this
320 case, some entries of REGISTER_NAME will change depending upon
321 the particular processor being debugged. */
322
a728f042 323 numregs = NUM_REGS;
fb40c209 324
40d5d7e9 325 ui_out_list_begin (uiout, "changed-registers");
fb40c209
AC
326
327 if (argc == 0) /* No args, just do all the regs */
328 {
329 for (regnum = 0;
330 regnum < numregs;
331 regnum++)
332 {
333 if (REGISTER_NAME (regnum) == NULL
334 || *(REGISTER_NAME (regnum)) == '\0')
335 continue;
336 changed = register_changed_p (regnum);
337 if (changed < 0)
338 {
76995688
AC
339 xasprintf (&mi_error_message,
340 "mi_cmd_data_list_changed_registers: Unable to read register contents.");
fb40c209
AC
341 return MI_CMD_ERROR;
342 }
343 else if (changed)
344 ui_out_field_int (uiout, NULL, regnum);
345 }
346 }
347
348 /* Else, list of register #s, just do listed regs */
349 for (i = 0; i < argc; i++)
350 {
351 regnum = atoi (argv[i]);
352
353 if (regnum >= 0
354 && regnum < numregs
355 && REGISTER_NAME (regnum) != NULL
356 && *REGISTER_NAME (regnum) != '\000')
357 {
358 changed = register_changed_p (regnum);
359 if (changed < 0)
360 {
76995688
AC
361 xasprintf (&mi_error_message,
362 "mi_cmd_data_list_register_change: Unable to read register contents.");
fb40c209
AC
363 return MI_CMD_ERROR;
364 }
365 else if (changed)
366 ui_out_field_int (uiout, NULL, regnum);
367 }
368 else
369 {
76995688 370 xasprintf (&mi_error_message, "bad register number");
fb40c209
AC
371 return MI_CMD_ERROR;
372 }
373 }
40d5d7e9 374 ui_out_list_end (uiout);
fb40c209
AC
375 return MI_CMD_DONE;
376}
377
378static int
379register_changed_p (int regnum)
380{
381 char raw_buffer[MAX_REGISTER_RAW_SIZE];
382
383 if (read_relative_register_raw_bytes (regnum, raw_buffer))
384 return -1;
385
386 if (memcmp (&old_regs[REGISTER_BYTE (regnum)], raw_buffer,
387 REGISTER_RAW_SIZE (regnum)) == 0)
388 return 0;
389
390 /* Found a changed register. Return 1. */
391
392 memcpy (&old_regs[REGISTER_BYTE (regnum)], raw_buffer,
393 REGISTER_RAW_SIZE (regnum));
394
395 return 1;
396}
397
398/* Return a list of register number and value pairs. The valid
399 arguments expected are: a letter indicating the format in which to
400 display the registers contents. This can be one of: x (hexadecimal), d
401 (decimal), N (natural), t (binary), o (octal), r (raw). After the
402 format argumetn there can be a sequence of numbers, indicating which
403 registers to fetch the content of. If the format is the only argument,
404 a list of all the registers with their values is returned. */
405enum mi_cmd_result
406mi_cmd_data_list_register_values (char *command, char **argv, int argc)
407{
408 int regnum, numregs, format, result;
409 int i;
410
411 /* Note that the test for a valid register must include checking the
412 REGISTER_NAME because NUM_REGS may be allocated for the union of
413 the register sets within a family of related processors. In this
414 case, some entries of REGISTER_NAME will change depending upon
415 the particular processor being debugged. */
416
a728f042 417 numregs = NUM_REGS;
fb40c209
AC
418
419 if (argc == 0)
420 {
76995688
AC
421 xasprintf (&mi_error_message,
422 "mi_cmd_data_list_register_values: Usage: -data-list-register-values <format> [<regnum1>...<regnumN>]");
fb40c209
AC
423 return MI_CMD_ERROR;
424 }
425
426 format = (int) argv[0][0];
427
428 if (!target_has_registers)
429 {
76995688
AC
430 xasprintf (&mi_error_message,
431 "mi_cmd_data_list_register_values: No registers.");
fb40c209
AC
432 return MI_CMD_ERROR;
433 }
434
80f43b40 435 ui_out_list_begin (uiout, "register-values");
fb40c209
AC
436
437 if (argc == 1) /* No args, beside the format: do all the regs */
438 {
439 for (regnum = 0;
440 regnum < numregs;
441 regnum++)
442 {
443 if (REGISTER_NAME (regnum) == NULL
444 || *(REGISTER_NAME (regnum)) == '\0')
445 continue;
666547aa 446 ui_out_tuple_begin (uiout, NULL);
fb40c209
AC
447 ui_out_field_int (uiout, "number", regnum);
448 result = get_register (regnum, format);
449 if (result == -1)
450 return MI_CMD_ERROR;
666547aa 451 ui_out_tuple_end (uiout);
fb40c209
AC
452 }
453 }
454
455 /* Else, list of register #s, just do listed regs */
456 for (i = 1; i < argc; i++)
457 {
458 regnum = atoi (argv[i]);
459
460 if (regnum >= 0
461 && regnum < numregs
462 && REGISTER_NAME (regnum) != NULL
463 && *REGISTER_NAME (regnum) != '\000')
464 {
666547aa 465 ui_out_tuple_begin (uiout, NULL);
fb40c209
AC
466 ui_out_field_int (uiout, "number", regnum);
467 result = get_register (regnum, format);
468 if (result == -1)
469 return MI_CMD_ERROR;
666547aa 470 ui_out_tuple_end (uiout);
fb40c209
AC
471 }
472 else
473 {
76995688 474 xasprintf (&mi_error_message, "bad register number");
fb40c209
AC
475 return MI_CMD_ERROR;
476 }
477 }
80f43b40 478 ui_out_list_end (uiout);
fb40c209
AC
479 return MI_CMD_DONE;
480}
481
482/* Output one register's contents in the desired format. */
483static int
484get_register (int regnum, int format)
485{
486 char raw_buffer[MAX_REGISTER_RAW_SIZE];
487 char virtual_buffer[MAX_REGISTER_VIRTUAL_SIZE];
488 int optim;
489 static struct ui_stream *stb = NULL;
490
491 stb = ui_out_stream_new (uiout);
492
493 if (format == 'N')
494 format = 0;
495
496 /* read_relative_register_raw_bytes returns a virtual frame pointer
497 (FRAME_FP (selected_frame)) if regnum == FP_REGNUM instead
498 of the real contents of the register. To get around this,
499 use get_saved_register instead. */
500 get_saved_register (raw_buffer, &optim, (CORE_ADDR *) NULL, selected_frame,
501 regnum, (enum lval_type *) NULL);
502 if (optim)
503 {
76995688 504 xasprintf (&mi_error_message, "Optimized out");
fb40c209
AC
505 return -1;
506 }
507
508 /* Convert raw data to virtual format if necessary. */
509
510 if (REGISTER_CONVERTIBLE (regnum))
511 {
512 REGISTER_CONVERT_TO_VIRTUAL (regnum, REGISTER_VIRTUAL_TYPE (regnum),
513 raw_buffer, virtual_buffer);
514 }
515 else
516 memcpy (virtual_buffer, raw_buffer, REGISTER_VIRTUAL_SIZE (regnum));
517
518 if (format == 'r')
519 {
520 int j;
521 char *ptr, buf[1024];
522
523 strcpy (buf, "0x");
524 ptr = buf + 2;
525 for (j = 0; j < REGISTER_RAW_SIZE (regnum); j++)
526 {
527 register int idx = TARGET_BYTE_ORDER == BIG_ENDIAN ? j
528 : REGISTER_RAW_SIZE (regnum) - 1 - j;
529 sprintf (ptr, "%02x", (unsigned char) raw_buffer[idx]);
530 ptr += 2;
531 }
532 ui_out_field_string (uiout, "value", buf);
533 /*fputs_filtered (buf, gdb_stdout); */
534 }
535 else
536 {
537 val_print (REGISTER_VIRTUAL_TYPE (regnum), virtual_buffer, 0, 0,
538 stb->stream, format, 1, 0, Val_pretty_default);
539 ui_out_field_stream (uiout, "value", stb);
540 ui_out_stream_delete (stb);
541 }
542 return 1;
543}
544
24e8cecf
EZ
545/* Write given values into registers. The registers and values are
546 given as pairs. The corresponding MI command is
547 -data-write-register-values <format> [<regnum1> <value1>...<regnumN> <valueN>]*/
548enum mi_cmd_result
549mi_cmd_data_write_register_values (char *command, char **argv, int argc)
550{
551 int regnum;
552 int i;
553 int numregs;
554 char *buffer;
555 LONGEST value;
556 char format;
557
558 /* Note that the test for a valid register must include checking the
559 REGISTER_NAME because NUM_REGS may be allocated for the union of
560 the register sets within a family of related processors. In this
561 case, some entries of REGISTER_NAME will change depending upon
562 the particular processor being debugged. */
563
a728f042 564 numregs = NUM_REGS;
24e8cecf
EZ
565
566 if (argc == 0)
567 {
76995688
AC
568 xasprintf (&mi_error_message,
569 "mi_cmd_data_write_register_values: Usage: -data-write-register-values <format> [<regnum1> <value1>...<regnumN> <valueN>]");
24e8cecf
EZ
570 return MI_CMD_ERROR;
571 }
572
573 format = (int) argv[0][0];
574
575 if (!target_has_registers)
576 {
76995688
AC
577 xasprintf (&mi_error_message,
578 "mi_cmd_data_write_register_values: No registers.");
24e8cecf
EZ
579 return MI_CMD_ERROR;
580 }
581
582 if (!(argc - 1))
583 {
76995688
AC
584 xasprintf (&mi_error_message,
585 "mi_cmd_data_write_register_values: No regs and values specified.");
24e8cecf
EZ
586 return MI_CMD_ERROR;
587 }
588
589 if ((argc - 1) % 2)
590 {
76995688
AC
591 xasprintf (&mi_error_message,
592 "mi_cmd_data_write_register_values: Regs and vals are not in pairs.");
24e8cecf
EZ
593 return MI_CMD_ERROR;
594 }
595
596 for (i = 1; i < argc; i = i + 2)
597 {
598 regnum = atoi (argv[i]);
599
600 if (regnum >= 0
601 && regnum < numregs
602 && REGISTER_NAME (regnum) != NULL
603 && *REGISTER_NAME (regnum) != '\000')
604 {
605 /* Get the value as a number */
606 value = parse_and_eval_address (argv[i + 1]);
607 /* Get the value into an array */
608 buffer = (unsigned char *) xmalloc (REGISTER_SIZE);
609 store_signed_integer (buffer, REGISTER_SIZE, value);
610 /* Write it down */
611 write_register_bytes (REGISTER_BYTE (regnum), buffer, REGISTER_RAW_SIZE (regnum));
612 /* write_register_bytes (REGISTER_BYTE (regnum), buffer, REGISTER_SIZE); */
613 }
614 else
615 {
76995688 616 xasprintf (&mi_error_message, "bad register number");
24e8cecf
EZ
617 return MI_CMD_ERROR;
618 }
619 }
620 return MI_CMD_DONE;
621}
622
fb40c209
AC
623#if 0
624/*This is commented out because we decided it was not useful. I leave
625 it, just in case. ezannoni:1999-12-08 */
626
627/* Assign a value to a variable. The expression argument must be in
628 the form A=2 or "A = 2" (I.e. if there are spaces it needs to be
629 quoted. */
630enum mi_cmd_result
631mi_cmd_data_assign (char *command, char **argv, int argc)
632{
633 struct expression *expr;
634 struct cleanup *old_chain;
635
636 if (argc != 1)
637 {
76995688
AC
638 xasprintf (&mi_error_message,
639 "mi_cmd_data_assign: Usage: -data-assign expression");
fb40c209
AC
640 return MI_CMD_ERROR;
641 }
642
643 /* NOTE what follows is a clone of set_command(). FIXME: ezannoni
644 01-12-1999: Need to decide what to do with this for libgdb purposes. */
645
646 expr = parse_expression (argv[0]);
47cf603e 647 old_chain = make_cleanup (free_current_contents, &expr);
fb40c209
AC
648 evaluate_expression (expr);
649 do_cleanups (old_chain);
650 return MI_CMD_DONE;
651}
652#endif
653
654/* Evaluate the value of the argument. The argument is an
655 expression. If the expression contains spaces it needs to be
656 included in double quotes. */
657enum mi_cmd_result
658mi_cmd_data_evaluate_expression (char *command, char **argv, int argc)
659{
660 struct expression *expr;
661 struct cleanup *old_chain = NULL;
662 value_ptr val;
663 struct ui_stream *stb = NULL;
664
665 stb = ui_out_stream_new (uiout);
666
667 if (argc != 1)
668 {
76995688
AC
669 xasprintf (&mi_error_message,
670 "mi_cmd_data_evaluate_expression: Usage: -data-evaluate-expression expression");
fb40c209
AC
671 return MI_CMD_ERROR;
672 }
673
674 expr = parse_expression (argv[0]);
675
47cf603e 676 old_chain = make_cleanup (free_current_contents, &expr);
fb40c209
AC
677
678 val = evaluate_expression (expr);
679
680 /* Print the result of the expression evaluation. */
681 val_print (VALUE_TYPE (val), VALUE_CONTENTS (val),
682 VALUE_EMBEDDED_OFFSET (val), VALUE_ADDRESS (val),
683 stb->stream, 0, 0, 0, 0);
684
685 ui_out_field_stream (uiout, "value", stb);
686 ui_out_stream_delete (stb);
687
688 do_cleanups (old_chain);
689
690 return MI_CMD_DONE;
691}
692
693enum mi_cmd_result
694mi_cmd_target_download (char *args, int from_tty)
695{
696 char *run;
697 struct cleanup *old_cleanups = NULL;
698
76995688 699 xasprintf (&run, "load %s", args);
b8c9b27d 700 old_cleanups = make_cleanup (xfree, run);
fb40c209
AC
701 execute_command (run, from_tty);
702
703 do_cleanups (old_cleanups);
704 return MI_CMD_DONE;
705}
706
707/* Connect to the remote target. */
708enum mi_cmd_result
709mi_cmd_target_select (char *args, int from_tty)
710{
711 char *run;
712 struct cleanup *old_cleanups = NULL;
713
76995688 714 xasprintf (&run, "target %s", args);
b8c9b27d 715 old_cleanups = make_cleanup (xfree, run);
fb40c209
AC
716
717 /* target-select is always synchronous. once the call has returned
718 we know that we are connected. */
719 /* NOTE: At present all targets that are connected are also
720 (implicitly) talking to a halted target. In the future this may
721 change. */
722 execute_command (run, from_tty);
723
724 do_cleanups (old_cleanups);
725
726 /* Issue the completion message here. */
727 if (last_async_command)
728 fputs_unfiltered (last_async_command, raw_stdout);
729 fputs_unfiltered ("^connected", raw_stdout);
730 mi_out_put (uiout, raw_stdout);
731 mi_out_rewind (uiout);
732 fputs_unfiltered ("\n", raw_stdout);
733 do_exec_cleanups (ALL_CLEANUPS);
734 return MI_CMD_QUIET;
735}
736
737/* DATA-MEMORY-READ:
738
739 ADDR: start address of data to be dumped.
740 WORD-FORMAT: a char indicating format for the ``word''. See
741 the ``x'' command.
742 WORD-SIZE: size of each ``word''; 1,2,4, or 8 bytes
743 NR_ROW: Number of rows.
744 NR_COL: The number of colums (words per row).
745 ASCHAR: (OPTIONAL) Append an ascii character dump to each row. Use
746 ASCHAR for unprintable characters.
747
748 Reads SIZE*NR_ROW*NR_COL bytes starting at ADDR from memory and
749 displayes them. Returns:
750
751 {addr="...",rowN={wordN="..." ,... [,ascii="..."]}, ...}
752
753 Returns:
754 The number of bytes read is SIZE*ROW*COL. */
755
756enum mi_cmd_result
757mi_cmd_data_read_memory (char *command, char **argv, int argc)
758{
759 struct cleanup *cleanups = make_cleanup (null_cleanup, NULL);
760 CORE_ADDR addr;
761 long total_bytes;
762 long nr_cols;
763 long nr_rows;
764 char word_format;
765 struct type *word_type;
766 long word_size;
767 char word_asize;
768 char aschar;
769 char *mbuf;
770 int nr_bytes;
771 long offset = 0;
772 int optind = 0;
773 char *optarg;
774 enum opt
775 {
776 OFFSET_OPT
777 };
778 static struct mi_opt opts[] =
779 {
780 {"o", OFFSET_OPT, 1},
781 0
782 };
783
784 while (1)
785 {
786 int opt = mi_getopt ("mi_cmd_data_read_memory", argc, argv, opts,
787 &optind, &optarg);
788 if (opt < 0)
789 break;
790 switch ((enum opt) opt)
791 {
792 case OFFSET_OPT:
793 offset = atol (optarg);
794 break;
795 }
796 }
797 argv += optind;
798 argc -= optind;
799
800 if (argc < 5 || argc > 6)
801 {
76995688
AC
802 xasprintf (&mi_error_message,
803 "mi_cmd_data_read_memory: Usage: ADDR WORD-FORMAT WORD-SIZE NR-ROWS NR-COLS [ASCHAR].");
fb40c209
AC
804 return MI_CMD_ERROR;
805 }
806
807 /* Extract all the arguments. */
808
809 /* Start address of the memory dump. */
810 addr = parse_and_eval_address (argv[0]) + offset;
811 /* The format character to use when displaying a memory word. See
812 the ``x'' command. */
813 word_format = argv[1][0];
814 /* The size of the memory word. */
815 word_size = atol (argv[2]);
816 switch (word_size)
817 {
818 case 1:
819 word_type = builtin_type_int8;
820 word_asize = 'b';
821 break;
822 case 2:
823 word_type = builtin_type_int16;
824 word_asize = 'h';
825 break;
826 case 4:
827 word_type = builtin_type_int32;
828 word_asize = 'w';
829 break;
830 case 8:
831 word_type = builtin_type_int64;
832 word_asize = 'g';
833 break;
834 default:
835 word_type = builtin_type_int8;
836 word_asize = 'b';
837 }
838 /* The number of rows */
839 nr_rows = atol (argv[3]);
840 if (nr_rows <= 0)
841 {
76995688
AC
842 xasprintf (&mi_error_message,
843 "mi_cmd_data_read_memory: invalid number of rows.");
fb40c209
AC
844 return MI_CMD_ERROR;
845 }
846 /* number of bytes per row. */
847 nr_cols = atol (argv[4]);
848 if (nr_cols <= 0)
849 {
76995688
AC
850 xasprintf (&mi_error_message,
851 "mi_cmd_data_read_memory: invalid number of columns.");
fb40c209
AC
852 }
853 /* The un-printable character when printing ascii. */
854 if (argc == 6)
855 aschar = *argv[5];
856 else
857 aschar = 0;
858
859 /* create a buffer and read it in. */
860 total_bytes = word_size * nr_rows * nr_cols;
2e94c453 861 mbuf = xcalloc (total_bytes, 1);
b8c9b27d 862 make_cleanup (xfree, mbuf);
fb40c209
AC
863 if (mbuf == NULL)
864 {
76995688
AC
865 xasprintf (&mi_error_message,
866 "mi_cmd_data_read_memory: out of memory.");
fb40c209
AC
867 return MI_CMD_ERROR;
868 }
869 nr_bytes = 0;
870 while (nr_bytes < total_bytes)
871 {
872 int error;
873 long num = target_read_memory_partial (addr + nr_bytes, mbuf + nr_bytes,
874 total_bytes - nr_bytes,
875 &error);
876 if (num <= 0)
877 break;
878 nr_bytes += num;
879 }
880
881 /* output the header information. */
882 ui_out_field_core_addr (uiout, "addr", addr);
883 ui_out_field_int (uiout, "nr-bytes", nr_bytes);
884 ui_out_field_int (uiout, "total-bytes", total_bytes);
885 ui_out_field_core_addr (uiout, "next-row", addr + word_size * nr_cols);
886 ui_out_field_core_addr (uiout, "prev-row", addr - word_size * nr_cols);
887 ui_out_field_core_addr (uiout, "next-page", addr + total_bytes);
888 ui_out_field_core_addr (uiout, "prev-page", addr - total_bytes);
889
890 /* Build the result as a two dimentional table. */
891 {
892 struct ui_stream *stream = ui_out_stream_new (uiout);
893 int row;
894 int row_byte;
45399be4 895 ui_out_list_begin (uiout, "memory");
fb40c209
AC
896 for (row = 0, row_byte = 0;
897 row < nr_rows;
898 row++, row_byte += nr_cols * word_size)
899 {
900 int col;
901 int col_byte;
666547aa 902 ui_out_tuple_begin (uiout, NULL);
fb40c209
AC
903 ui_out_field_core_addr (uiout, "addr", addr + row_byte);
904 /* ui_out_field_core_addr_symbolic (uiout, "saddr", addr + row_byte); */
45399be4 905 ui_out_list_begin (uiout, "data");
fb40c209
AC
906 for (col = 0, col_byte = row_byte;
907 col < nr_cols;
908 col++, col_byte += word_size)
909 {
910 if (col_byte + word_size > nr_bytes)
911 {
912 ui_out_field_string (uiout, NULL, "N/A");
913 }
914 else
915 {
916 ui_file_rewind (stream->stream);
917 print_scalar_formatted (mbuf + col_byte, word_type, word_format,
918 word_asize, stream->stream);
919 ui_out_field_stream (uiout, NULL, stream);
920 }
921 }
45399be4 922 ui_out_list_end (uiout);
fb40c209
AC
923 if (aschar)
924 {
925 int byte;
926 ui_file_rewind (stream->stream);
927 for (byte = row_byte; byte < row_byte + word_size * nr_cols; byte++)
928 {
929 if (byte >= nr_bytes)
930 {
931 fputc_unfiltered ('X', stream->stream);
932 }
933 else if (mbuf[byte] < 32 || mbuf[byte] > 126)
934 {
935 fputc_unfiltered (aschar, stream->stream);
936 }
937 else
938 fputc_unfiltered (mbuf[byte], stream->stream);
939 }
940 ui_out_field_stream (uiout, "ascii", stream);
941 }
666547aa 942 ui_out_tuple_end (uiout);
fb40c209
AC
943 }
944 ui_out_stream_delete (stream);
45399be4 945 ui_out_list_end (uiout);
fb40c209
AC
946 }
947 do_cleanups (cleanups);
948 return MI_CMD_DONE;
949}
950
951/* DATA-MEMORY-WRITE:
952
953 COLUMN_OFFSET: optional argument. Must be preceeded by '-o'. The
954 offset from the beginning of the memory grid row where the cell to
955 be written is.
956 ADDR: start address of the row in the memory grid where the memory
957 cell is, if OFFSET_COLUMN is specified. Otherwise, the address of
958 the location to write to.
959 FORMAT: a char indicating format for the ``word''. See
960 the ``x'' command.
961 WORD_SIZE: size of each ``word''; 1,2,4, or 8 bytes
962 VALUE: value to be written into the memory address.
963
964 Writes VALUE into ADDR + (COLUMN_OFFSET * WORD_SIZE).
965
966 Prints nothing. */
967enum mi_cmd_result
968mi_cmd_data_write_memory (char *command, char **argv, int argc)
969{
970 CORE_ADDR addr;
971 char word_format;
972 long word_size;
973 /* FIXME: ezannoni 2000-02-17 LONGEST could possibly not be big
974 enough when using a compiler other than GCC. */
975 LONGEST value;
976 unsigned char *buffer;
977 long offset = 0;
978 int optind = 0;
979 char *optarg;
980 enum opt
981 {
982 OFFSET_OPT
983 };
984 static struct mi_opt opts[] =
985 {
986 {"o", OFFSET_OPT, 1},
987 0
988 };
989
990 while (1)
991 {
992 int opt = mi_getopt ("mi_cmd_data_write_memory", argc, argv, opts,
993 &optind, &optarg);
994 if (opt < 0)
995 break;
996 switch ((enum opt) opt)
997 {
998 case OFFSET_OPT:
999 offset = atol (optarg);
1000 break;
1001 }
1002 }
1003 argv += optind;
1004 argc -= optind;
1005
1006 if (argc != 4)
1007 {
76995688
AC
1008 xasprintf (&mi_error_message,
1009 "mi_cmd_data_write_memory: Usage: [-o COLUMN_OFFSET] ADDR FORMAT WORD-SIZE VALUE.");
fb40c209
AC
1010 return MI_CMD_ERROR;
1011 }
1012
1013 /* Extract all the arguments. */
1014 /* Start address of the memory dump. */
1015 addr = parse_and_eval_address (argv[0]);
1016 /* The format character to use when displaying a memory word. See
1017 the ``x'' command. */
1018 word_format = argv[1][0];
1019 /* The size of the memory word. */
1020 word_size = atol (argv[2]);
1021
1022 /* Calculate the real address of the write destination. */
1023 addr += (offset * word_size);
1024
1025 /* Get the value as a number */
1026 value = parse_and_eval_address (argv[3]);
1027 /* Get the value into an array */
1028 buffer = (unsigned char *) xmalloc (word_size);
1029 store_signed_integer (buffer, word_size, value);
1030 /* Write it down to memory */
1031 write_memory (addr, buffer, word_size);
1032
1033 return MI_CMD_DONE;
1034}
1035
1036/* Execute a command within a safe environment. Return >0 for
1037 ok. Return <0 for supress prompt. Return 0 to have the error
1038 extracted from error_last_message(). */
1039
1040static int
1041captured_mi_execute_command (void *data)
1042{
1043 struct mi_parse *context = data;
1044 enum mi_cmd_result rc;
1045
1046 switch (context->op)
1047 {
1048
1049 case MI_COMMAND:
1050 /* A MI command was read from the input stream */
1051 if (mi_debug_p)
1052 /* FIXME: gdb_???? */
1053 fprintf_unfiltered (raw_stdout, " token=`%s' command=`%s' args=`%s'\n",
1054 context->token, context->command, context->args);
1055 /* FIXME: cagney/1999-09-25: Rather than this convoluted
1056 condition expression, each function should return an
1057 indication of what action is required and then switch on
1058 that. */
1059 rc = mi_cmd_execute (context);
1060 if (!target_can_async_p () || !target_executing)
1061 {
1062 /* print the result if there were no errors */
1063 if (rc == MI_CMD_DONE)
1064 {
1065 fputs_unfiltered (context->token, raw_stdout);
1066 fputs_unfiltered ("^done", raw_stdout);
1067 mi_out_put (uiout, raw_stdout);
1068 mi_out_rewind (uiout);
1069 fputs_unfiltered ("\n", raw_stdout);
1070 }
1071 else if (rc == MI_CMD_ERROR)
1072 {
1073 if (mi_error_message)
1074 {
1075 fputs_unfiltered (context->token, raw_stdout);
1076 fputs_unfiltered ("^error,msg=\"", raw_stdout);
1077 fputstr_unfiltered (mi_error_message, '"', raw_stdout);
b8c9b27d 1078 xfree (mi_error_message);
fb40c209
AC
1079 fputs_unfiltered ("\"\n", raw_stdout);
1080 }
1081 mi_out_rewind (uiout);
1082 }
1083 else if (rc == MI_CMD_CAUGHT_ERROR)
1084 {
1085 mi_out_rewind (uiout);
1086 return 0;
1087 }
1088 else
1089 mi_out_rewind (uiout);
1090 }
1091 else if (sync_execution)
1092 /* Don't print the prompt. We are executing the target in
1093 synchronous mode. */
1094 return -1;
1095 break;
1096
1097 case CLI_COMMAND:
1098 /* A CLI command was read from the input stream */
1099 /* This will be removed as soon as we have a complete set of
1100 mi commands */
1101 /* echo the command on the console. */
1102 fprintf_unfiltered (gdb_stdlog, "%s\n", context->command);
1103 /* FIXME: If the command string has something that looks like
1104 a format spec (e.g. %s) we will get a core dump */
1105 mi_execute_cli_command ("%s", context->command);
1106 /* print the result */
1107 /* FIXME: Check for errors here. */
1108 fputs_unfiltered (context->token, raw_stdout);
1109 fputs_unfiltered ("^done", raw_stdout);
1110 mi_out_put (uiout, raw_stdout);
1111 mi_out_rewind (uiout);
1112 fputs_unfiltered ("\n", raw_stdout);
1113 break;
1114
1115 }
1116 return 1;
1117}
1118
1119
1120void
1121mi_execute_command (char *cmd, int from_tty)
1122{
1123 struct mi_parse *command;
1124
1125 /* This is to handle EOF (^D). We just quit gdb. */
1126 /* FIXME: we should call some API function here. */
1127 if (cmd == 0)
1128 quit_force (NULL, from_tty);
1129
1130 command = mi_parse (cmd);
1131
1132 if (command != NULL)
1133 {
1134 /* FIXME: cagney/1999-11-04: Can this use of catch_errors either
1135 be pushed even further down or even eliminated? */
1136 int rc = catch_errors (captured_mi_execute_command, command, "",
1137 RETURN_MASK_ALL);
1138 if (rc < 0)
1139 {
1140 /* The command is executing synchronously. Bail out early
1141 suppressing the finished prompt. */
1142 mi_parse_free (command);
1143 return;
1144 }
1145 if (rc == 0)
1146 {
1147 char *msg = error_last_message ();
b8c9b27d 1148 struct cleanup *cleanup = make_cleanup (xfree, msg);
fb40c209
AC
1149 /* The command execution failed and error() was called
1150 somewhere */
1151 fputs_unfiltered (command->token, raw_stdout);
1152 fputs_unfiltered ("^error,msg=\"", raw_stdout);
1153 fputstr_unfiltered (msg, '"', raw_stdout);
1154 fputs_unfiltered ("\"\n", raw_stdout);
1155 }
1156 mi_parse_free (command);
1157 }
1158
1159 gdb_flush (raw_stdout);
1160 fputs_unfiltered ("(gdb) \n", raw_stdout);
1161 /* print any buffered hook code */
1162 /* ..... */
1163}
1164
1165static enum mi_cmd_result
1166mi_cmd_execute (struct mi_parse *parse)
1167{
1168 if (parse->cmd->argv_func != NULL
1169 || parse->cmd->args_func != NULL)
1170 {
1171 /* FIXME: We need to save the token because the command executed
1172 may be asynchronous and need to print the token again.
1173 In the future we can pass the token down to the func
1174 and get rid of the last_async_command */
1175 /* The problem here is to keep the token around when we launch
1176 the target, and we want to interrupt it later on. The
1177 interrupt command will have its own token, but when the
1178 target stops, we must display the token corresponding to the
1179 last execution command given. So we have another string where
1180 we copy the token (previous_async_command), if this was
1181 indeed the token of an execution command, and when we stop we
1182 print that one. This is possible because the interrupt
1183 command, when over, will copy that token back into the
1184 default token string (last_async_command). */
1185
1186 if (target_executing)
1187 {
1188 if (!previous_async_command)
1189 previous_async_command = xstrdup (last_async_command);
1190 if (strcmp (parse->command, "exec-interrupt"))
1191 {
1192 fputs_unfiltered (parse->token, raw_stdout);
1193 fputs_unfiltered ("^error,msg=\"", raw_stdout);
1194 fputs_unfiltered ("Cannot execute command ", raw_stdout);
1195 fputstr_unfiltered (parse->command, '"', raw_stdout);
1196 fputs_unfiltered (" while target running", raw_stdout);
1197 fputs_unfiltered ("\"\n", raw_stdout);
1198 return MI_CMD_ERROR;
1199 }
1200 }
1201 last_async_command = xstrdup (parse->token);
e2f9c474 1202 make_exec_cleanup (free_current_contents, &last_async_command);
fb40c209
AC
1203 /* FIXME: DELETE THIS! */
1204 if (parse->cmd->args_func != NULL)
1205 return parse->cmd->args_func (parse->args, 0 /*from_tty */ );
1206 return parse->cmd->argv_func (parse->command, parse->argv, parse->argc);
1207 }
1208 else if (parse->cmd->cli != 0)
1209 {
1210 /* FIXME: DELETE THIS. */
1211 /* The operation is still implemented by a cli command */
1212 /* Must be a synchronous one */
1213 mi_execute_cli_command (parse->cmd->cli, parse->args);
1214 return MI_CMD_DONE;
1215 }
1216 else
1217 {
1218 /* FIXME: DELETE THIS. */
1219 fputs_unfiltered (parse->token, raw_stdout);
1220 fputs_unfiltered ("^error,msg=\"", raw_stdout);
1221 fputs_unfiltered ("Undefined mi command: ", raw_stdout);
1222 fputstr_unfiltered (parse->command, '"', raw_stdout);
1223 fputs_unfiltered (" (missing implementation)", raw_stdout);
1224 fputs_unfiltered ("\"\n", raw_stdout);
1225 return MI_CMD_ERROR;
1226 }
1227}
1228
fb40c209
AC
1229static void
1230mi_execute_command_wrapper (char *cmd)
1231{
1232 mi_execute_command (cmd, stdin == instream);
1233}
1234
1235/* FIXME: This is just a hack so we can get some extra commands going.
1236 We don't want to channel things through the CLI, but call libgdb directly */
1237/* Use only for synchronous commands */
1238
1239void
1240mi_execute_cli_command (const char *cli, char *args)
1241{
1242 if (cli != 0)
1243 {
1244 struct cleanup *old_cleanups;
1245 char *run;
76995688 1246 xasprintf (&run, cli, args);
fb40c209
AC
1247 if (mi_debug_p)
1248 /* FIXME: gdb_???? */
1249 fprintf_unfiltered (gdb_stdout, "cli=%s run=%s\n",
1250 cli, run);
b8c9b27d 1251 old_cleanups = make_cleanup (xfree, run);
fb40c209
AC
1252 execute_command ( /*ui */ run, 0 /*from_tty */ );
1253 do_cleanups (old_cleanups);
1254 return;
1255 }
1256}
1257
1258enum mi_cmd_result
1259mi_execute_async_cli_command (char *mi, char *args, int from_tty)
1260{
1261 struct cleanup *old_cleanups;
1262 char *run;
1263 char *async_args;
1264
1265 if (target_can_async_p ())
1266 {
1267 async_args = (char *) xmalloc (strlen (args) + 2);
1268 make_exec_cleanup (free, async_args);
1269 strcpy (async_args, args);
1270 strcat (async_args, "&");
76995688 1271 xasprintf (&run, "%s %s", mi, async_args);
fb40c209
AC
1272 make_exec_cleanup (free, run);
1273 add_continuation (mi_exec_async_cli_cmd_continuation, NULL);
6311b07d 1274 old_cleanups = NULL;
fb40c209
AC
1275 }
1276 else
1277 {
76995688 1278 xasprintf (&run, "%s %s", mi, args);
b8c9b27d 1279 old_cleanups = make_cleanup (xfree, run);
fb40c209
AC
1280 }
1281
1282 if (!target_can_async_p ())
1283 {
1284 /* NOTE: For synchronous targets asynchronous behavour is faked by
1285 printing out the GDB prompt before we even try to execute the
1286 command. */
1287 if (last_async_command)
1288 fputs_unfiltered (last_async_command, raw_stdout);
1289 fputs_unfiltered ("^running\n", raw_stdout);
1290 fputs_unfiltered ("(gdb) \n", raw_stdout);
1291 }
1292 else
1293 {
1294 /* FIXME: cagney/1999-11-29: Printing this message before
1295 calling execute_command is wrong. It should only be printed
1296 once gdb has confirmed that it really has managed to send a
1297 run command to the target. */
1298 if (last_async_command)
1299 fputs_unfiltered (last_async_command, raw_stdout);
1300 fputs_unfiltered ("^running\n", raw_stdout);
1301 }
1302
1303 execute_command ( /*ui */ run, 0 /*from_tty */ );
1304
1305 if (!target_can_async_p ())
1306 {
1307 /* Do this before doing any printing. It would appear that some
1308 print code leaves garbage around in the buffer. */
1309 do_cleanups (old_cleanups);
1310 /* If the target was doing the operation synchronously we fake
1311 the stopped message. */
1312 if (last_async_command)
1313 fputs_unfiltered (last_async_command, raw_stdout);
1314 fputs_unfiltered ("*stopped", raw_stdout);
1315 mi_out_put (uiout, raw_stdout);
1316 mi_out_rewind (uiout);
1317 fputs_unfiltered ("\n", raw_stdout);
1318 return MI_CMD_QUIET;
1319 }
1320 return MI_CMD_DONE;
1321}
1322
1323void
1324mi_exec_async_cli_cmd_continuation (struct continuation_arg *arg)
1325{
1326 if (last_async_command)
1327 fputs_unfiltered (last_async_command, raw_stdout);
1328 fputs_unfiltered ("*stopped", raw_stdout);
1329 mi_out_put (uiout, raw_stdout);
1330 fputs_unfiltered ("\n", raw_stdout);
1331 fputs_unfiltered ("(gdb) \n", raw_stdout);
1332 do_exec_cleanups (ALL_CLEANUPS);
1333}
1334
1335static char *
1336mi_input (char *buf)
1337{
1338 return gdb_readline (NULL);
1339}
1340
1341static void
1342mi_load_progress (const char *section_name,
1343 unsigned long sent_so_far,
1344 unsigned long total_section,
1345 unsigned long total_sent,
1346 unsigned long grand_total)
1347{
1348 struct timeval time_now, delta, update_threshold;
1349 static struct timeval last_update;
1350 static char *previous_sect_name = NULL;
1351 int new_section;
1352
b30bf9ee 1353 if (!interpreter_p || strncmp (interpreter_p, "mi", 2) != 0)
fb40c209
AC
1354 return;
1355
1356 update_threshold.tv_sec = 0;
1357 update_threshold.tv_usec = 500000;
1358 gettimeofday (&time_now, NULL);
1359
1360 delta.tv_usec = time_now.tv_usec - last_update.tv_usec;
1361 delta.tv_sec = time_now.tv_sec - last_update.tv_sec;
1362
1363 if (delta.tv_usec < 0)
1364 {
1365 delta.tv_sec -= 1;
1366 delta.tv_usec += 1000000;
1367 }
1368
1369 new_section = (previous_sect_name ?
1370 strcmp (previous_sect_name, section_name) : 1);
1371 if (new_section)
1372 {
b8c9b27d 1373 xfree (previous_sect_name);
fb40c209
AC
1374 previous_sect_name = xstrdup (section_name);
1375
1376 if (last_async_command)
1377 fputs_unfiltered (last_async_command, raw_stdout);
1378 fputs_unfiltered ("+download", raw_stdout);
666547aa 1379 ui_out_tuple_begin (uiout, NULL);
fb40c209
AC
1380 ui_out_field_string (uiout, "section", section_name);
1381 ui_out_field_int (uiout, "section-size", total_section);
1382 ui_out_field_int (uiout, "total-size", grand_total);
666547aa 1383 ui_out_tuple_end (uiout);
fb40c209
AC
1384 mi_out_put (uiout, raw_stdout);
1385 fputs_unfiltered ("\n", raw_stdout);
1386 gdb_flush (raw_stdout);
1387 }
1388
1389 if (delta.tv_sec >= update_threshold.tv_sec &&
1390 delta.tv_usec >= update_threshold.tv_usec)
1391 {
1392 last_update.tv_sec = time_now.tv_sec;
1393 last_update.tv_usec = time_now.tv_usec;
1394 if (last_async_command)
1395 fputs_unfiltered (last_async_command, raw_stdout);
1396 fputs_unfiltered ("+download", raw_stdout);
666547aa 1397 ui_out_tuple_begin (uiout, NULL);
fb40c209
AC
1398 ui_out_field_string (uiout, "section", section_name);
1399 ui_out_field_int (uiout, "section-sent", sent_so_far);
1400 ui_out_field_int (uiout, "section-size", total_section);
1401 ui_out_field_int (uiout, "total-sent", total_sent);
1402 ui_out_field_int (uiout, "total-size", grand_total);
666547aa 1403 ui_out_tuple_end (uiout);
fb40c209
AC
1404 mi_out_put (uiout, raw_stdout);
1405 fputs_unfiltered ("\n", raw_stdout);
1406 gdb_flush (raw_stdout);
1407 }
1408}
1409
1410static void
b30bf9ee 1411mi_command_loop (int mi_version)
fb40c209
AC
1412{
1413 /* HACK: Force stdout/stderr to point at the console. This avoids
1414 any potential side effects caused by legacy code that is still
1415 using the TUI / fputs_unfiltered_hook */
1416 raw_stdout = stdio_fileopen (stdout);
1417 /* Route normal output through the MIx */
1418 gdb_stdout = mi_console_file_new (raw_stdout, "~");
1419 /* Route error and log output through the MI */
1420 gdb_stderr = mi_console_file_new (raw_stdout, "&");
1421 gdb_stdlog = gdb_stderr;
1422 /* Route target output through the MI. */
1423 gdb_stdtarg = mi_console_file_new (raw_stdout, "@");
1424
1425 /* HACK: Poke the ui_out table directly. Should we be creating a
1426 mi_out object wired up to the above gdb_stdout / gdb_stderr? */
b30bf9ee 1427 uiout = mi_out_new (mi_version);
fb40c209
AC
1428
1429 /* HACK: Override any other interpreter hooks. We need to create a
1430 real event table and pass in that. */
1431 init_ui_hook = 0;
1432 /* command_loop_hook = 0; */
1433 print_frame_info_listing_hook = 0;
1434 query_hook = 0;
1435 warning_hook = 0;
1436 create_breakpoint_hook = 0;
1437 delete_breakpoint_hook = 0;
1438 modify_breakpoint_hook = 0;
1439 interactive_hook = 0;
1440 registers_changed_hook = 0;
1441 readline_begin_hook = 0;
1442 readline_hook = 0;
1443 readline_end_hook = 0;
1444 register_changed_hook = 0;
1445 memory_changed_hook = 0;
1446 context_hook = 0;
1447 target_wait_hook = 0;
1448 call_command_hook = 0;
1449 error_hook = 0;
1450 error_begin_hook = 0;
1451 show_load_progress = mi_load_progress;
1452
1453 /* Turn off 8 bit strings in quoted output. Any character with the
1454 high bit set is printed using C's octal format. */
1455 sevenbit_strings = 1;
1456
1457 /* Tell the world that we're alive */
1458 fputs_unfiltered ("(gdb) \n", raw_stdout);
1459
1460 if (!event_loop_p)
1461 simplified_command_loop (mi_input, mi_execute_command);
1462 else
1463 start_event_loop ();
1464}
1465
b30bf9ee
AC
1466static void
1467mi0_command_loop (void)
1468{
1469 mi_command_loop (0);
1470}
1471
1472static void
1473mi1_command_loop (void)
1474{
1475 mi_command_loop (1);
1476}
1477
fb40c209 1478static void
fba45db2 1479setup_architecture_data (void)
fb40c209
AC
1480{
1481 /* don't trust REGISTER_BYTES to be zero. */
1482 old_regs = xmalloc (REGISTER_BYTES + 1);
1483 memset (old_regs, 0, REGISTER_BYTES + 1);
1484}
1485
1486static void
fba45db2 1487mi_init_ui (char *arg0)
fb40c209
AC
1488{
1489 /* Eventually this will contain code that takes control of the
1490 console. */
1491}
1492
1493void
fba45db2 1494_initialize_mi_main (void)
fb40c209 1495{
b30bf9ee
AC
1496 if (interpreter_p == NULL)
1497 return;
1498
fb40c209 1499 /* If we're _the_ interpreter, take control. */
b30bf9ee
AC
1500 if (strcmp (interpreter_p, "mi0") == 0)
1501 command_loop_hook = mi0_command_loop;
1502 else if (strcmp (interpreter_p, "mi") == 0
1503 || strcmp (interpreter_p, "mi1") == 0)
1504 command_loop_hook = mi1_command_loop;
1505 else
1506 return;
1507
1508 init_ui_hook = mi_init_ui;
1509 setup_architecture_data ();
1510 register_gdbarch_swap (&old_regs, sizeof (old_regs), NULL);
1511 register_gdbarch_swap (NULL, 0, setup_architecture_data);
1512 if (event_loop_p)
fb40c209 1513 {
b30bf9ee
AC
1514 /* These overwrite some of the initialization done in
1515 _intialize_event_loop. */
1516 call_readline = gdb_readline2;
1517 input_handler = mi_execute_command_wrapper;
1518 add_file_handler (input_fd, stdin_event_handler, 0);
1519 async_command_editing_p = 0;
fb40c209
AC
1520 }
1521 /* FIXME: Should we notify main that we are here as a possible
1522 interpreter? */
1523}
This page took 0.188992 seconds and 4 git commands to generate.