OpenCores
URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

[/] [or1k/] [trunk/] [insight/] [gdb/] [event-top.c] - Blame information for rev 1765

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 578 markom
/* Top level stuff for GDB, the GNU debugger.
2
   Copyright 1999, 2000, 2001 Free Software Foundation, Inc.
3
   Written by Elena Zannoni <ezannoni@cygnus.com> of Cygnus Solutions.
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
#include "defs.h"
23
#include "top.h"
24
#include "inferior.h"
25
#include "target.h"
26
#include "terminal.h"           /* for job_control */
27
#include "event-loop.h"
28
#include "event-top.h"
29
#include <signal.h>
30
 
31
/* For dont_repeat() */
32
#include "gdbcmd.h"
33
 
34
/* readline include files */
35
#include <readline/readline.h>
36
#include <readline/history.h>
37
 
38
/* readline defines this.  */
39
#undef savestring
40
 
41
extern void _initialize_event_loop (void);
42
 
43
static void rl_callback_read_char_wrapper (gdb_client_data client_data);
44
static void command_line_handler (char *rl);
45
static void command_line_handler_continuation (struct continuation_arg *arg);
46
static void change_line_handler (void);
47
static void change_annotation_level (void);
48
static void command_handler (char *command);
49
void cli_command_loop (void);
50
static void async_do_nothing (gdb_client_data arg);
51
static void async_disconnect (gdb_client_data arg);
52
static void async_stop_sig (gdb_client_data arg);
53
static void async_float_handler (gdb_client_data arg);
54
 
55
/* Signal handlers. */
56
static void handle_sigquit (int sig);
57
static void handle_sighup (int sig);
58
static void handle_sigfpe (int sig);
59
#if defined(SIGWINCH) && defined(SIGWINCH_HANDLER)
60
static void handle_sigwinch (int sig);
61
#endif
62
 
63
/* Functions to be invoked by the event loop in response to
64
   signals. */
65
static void async_do_nothing (gdb_client_data);
66
static void async_disconnect (gdb_client_data);
67
static void async_float_handler (gdb_client_data);
68
static void async_stop_sig (gdb_client_data);
69
 
70
/* Readline offers an alternate interface, via callback
71
   functions. These are all included in the file callback.c in the
72
   readline distribution.  This file provides (mainly) a function, which
73
   the event loop uses as callback (i.e. event handler) whenever an event
74
   is detected on the standard input file descriptor.
75
   readline_callback_read_char is called (by the GDB event loop) whenever
76
   there is a new character ready on the input stream. This function
77
   incrementally builds a buffer internal to readline where it
78
   accumulates the line read up to the point of invocation.  In the
79
   special case in which the character read is newline, the function
80
   invokes a GDB supplied callback routine, which does the processing of
81
   a full command line.  This latter routine is the asynchronous analog
82
   of the old command_line_input in gdb. Instead of invoking (and waiting
83
   for) readline to read the command line and pass it back to
84
   command_loop for processing, the new command_line_handler function has
85
   the command line already available as its parameter.  INPUT_HANDLER is
86
   to be set to the function that readline will invoke when a complete
87
   line of input is ready.  CALL_READLINE is to be set to the function
88
   that readline offers as callback to the event_loop. */
89
 
90
void (*input_handler) (char *);
91
void (*call_readline) (gdb_client_data);
92
 
93
/* Important variables for the event loop. */
94
 
95
/* This is used to determine if GDB is using the readline library or
96
   its own simplified form of readline. It is used by the asynchronous
97
   form of the set editing command.
98
   ezannoni: as of 1999-04-29 I expect that this
99
   variable will not be used after gdb is changed to use the event
100
   loop as default engine, and event-top.c is merged into top.c. */
101
int async_command_editing_p;
102
 
103
/* This variable contains the new prompt that the user sets with the
104
   set prompt command. */
105
char *new_async_prompt;
106
 
107
/* This is the annotation suffix that will be used when the
108
   annotation_level is 2. */
109
char *async_annotation_suffix;
110
 
111
/* This is used to display the notification of the completion of an
112
   asynchronous execution command. */
113
int exec_done_display_p = 0;
114
 
115
/* This is the file descriptor for the input stream that GDB uses to
116
   read commands from. */
117
int input_fd;
118
 
119
/* This is the prompt stack. Prompts will be pushed on the stack as
120
   needed by the different 'kinds' of user inputs GDB is asking
121
   for. See event-loop.h. */
122
struct prompts the_prompts;
123
 
124
/* signal handling variables */
125
/* Each of these is a pointer to a function that the event loop will
126
   invoke if the corresponding signal has received. The real signal
127
   handlers mark these functions as ready to be executed and the event
128
   loop, in a later iteration, calls them. See the function
129
   invoke_async_signal_handler. */
130
void *sigint_token;
131
#ifdef SIGHUP
132
void *sighup_token;
133
#endif
134
void *sigquit_token;
135
void *sigfpe_token;
136
#if defined(SIGWINCH) && defined(SIGWINCH_HANDLER)
137
void *sigwinch_token;
138
#endif
139
#ifdef STOP_SIGNAL
140
void *sigtstp_token;
141
#endif
142
 
143
/* Structure to save a partially entered command.  This is used when
144
   the user types '\' at the end of a command line. This is necessary
145
   because each line of input is handled by a different call to
146
   command_line_handler, and normally there is no state retained
147
   between different calls. */
148
int more_to_come = 0;
149
 
150
struct readline_input_state
151
  {
152
    char *linebuffer;
153
    char *linebuffer_ptr;
154
  }
155
readline_input_state;
156
 
157
 
158
/* Wrapper function for calling into the readline library. The event
159
   loop expects the callback function to have a paramter, while readline
160
   expects none. */
161
static void
162
rl_callback_read_char_wrapper (gdb_client_data client_data)
163
{
164
  rl_callback_read_char ();
165
}
166
 
167
/* Initialize all the necessary variables, start the event loop,
168
   register readline, and stdin, start the loop. */
169
void
170
cli_command_loop (void)
171
{
172
  int length;
173
  char *a_prompt;
174
  char *gdb_prompt = get_prompt ();
175
 
176
  /* If we are using readline, set things up and display the first
177
     prompt, otherwise just print the prompt. */
178
  if (async_command_editing_p)
179
    {
180
      /* Tell readline what the prompt to display is and what function it
181
         will need to call after a whole line is read. This also displays
182
         the first prompt. */
183
      length = strlen (PREFIX (0)) + strlen (gdb_prompt) + strlen (SUFFIX (0)) + 1;
184
      a_prompt = (char *) xmalloc (length);
185
      strcpy (a_prompt, PREFIX (0));
186
      strcat (a_prompt, gdb_prompt);
187
      strcat (a_prompt, SUFFIX (0));
188
      rl_callback_handler_install (a_prompt, input_handler);
189
    }
190
  else
191
    display_gdb_prompt (0);
192
 
193
  /* Now it's time to start the event loop. */
194
  start_event_loop ();
195
}
196
 
197
/* Change the function to be invoked every time there is a character
198
   ready on stdin. This is used when the user sets the editing off,
199
   therefore bypassing readline, and letting gdb handle the input
200
   itself, via gdb_readline2. Also it is used in the opposite case in
201
   which the user sets editing on again, by restoring readline
202
   handling of the input. */
203
static void
204
change_line_handler (void)
205
{
206
  /* NOTE: this operates on input_fd, not instream. If we are reading
207
     commands from a file, instream will point to the file. However in
208
     async mode, we always read commands from a file with editing
209
     off. This means that the 'set editing on/off' will have effect
210
     only on the interactive session. */
211
 
212
  if (async_command_editing_p)
213
    {
214
      /* Turn on editing by using readline. */
215
      call_readline = rl_callback_read_char_wrapper;
216
      input_handler = command_line_handler;
217
    }
218
  else
219
    {
220
      /* Turn off editing by using gdb_readline2. */
221
      rl_callback_handler_remove ();
222
      call_readline = gdb_readline2;
223
 
224
      /* Set up the command handler as well, in case we are called as
225
         first thing from .gdbinit. */
226
      input_handler = command_line_handler;
227
    }
228
}
229
 
230
/* Displays the prompt. The prompt that is displayed is the current
231
   top of the prompt stack, if the argument NEW_PROMPT is
232
   0. Otherwise, it displays whatever NEW_PROMPT is. This is used
233
   after each gdb command has completed, and in the following cases:
234
   1. when the user enters a command line which is ended by '\'
235
   indicating that the command will continue on the next line.
236
   In that case the prompt that is displayed is the empty string.
237
   2. When the user is entering 'commands' for a breakpoint, or
238
   actions for a tracepoint. In this case the prompt will be '>'
239
   3. Other????
240
   FIXME: 2. & 3. not implemented yet for async. */
241
void
242
display_gdb_prompt (char *new_prompt)
243
{
244
  int prompt_length = 0;
245
  char *gdb_prompt = get_prompt ();
246
 
247
#ifdef UI_OUT
248
  /* When an alternative interpreter has been installed, do not
249
     display the comand prompt. */
250
  if (interpreter_p)
251
    return;
252
#endif
253
 
254
  if (target_executing && sync_execution)
255
    {
256
      /* This is to trick readline into not trying to display the
257
         prompt.  Even though we display the prompt using this
258
         function, readline still tries to do its own display if we
259
         don't call rl_callback_handler_install and
260
         rl_callback_handler_remove (which readline detects because a
261
         global variable is not set). If readline did that, it could
262
         mess up gdb signal handlers for SIGINT.  Readline assumes
263
         that between calls to rl_set_signals and rl_clear_signals gdb
264
         doesn't do anything with the signal handlers. Well, that's
265
         not the case, because when the target executes we change the
266
         SIGINT signal handler. If we allowed readline to display the
267
         prompt, the signal handler change would happen exactly
268
         between the calls to the above two functions.
269
         Calling rl_callback_handler_remove(), does the job. */
270
 
271
      rl_callback_handler_remove ();
272
      return;
273
    }
274
 
275
  if (!new_prompt)
276
    {
277
      /* Just use the top of the prompt stack. */
278
      prompt_length = strlen (PREFIX (0)) +
279
        strlen (SUFFIX (0)) +
280
        strlen (gdb_prompt) + 1;
281
 
282
      new_prompt = (char *) alloca (prompt_length);
283
 
284
      /* Prefix needs to have new line at end. */
285
      strcpy (new_prompt, PREFIX (0));
286
      strcat (new_prompt, gdb_prompt);
287
      /* Suffix needs to have a new line at end and \032 \032 at
288
         beginning. */
289
      strcat (new_prompt, SUFFIX (0));
290
    }
291
 
292
  if (async_command_editing_p)
293
    {
294
      rl_callback_handler_remove ();
295
      rl_callback_handler_install (new_prompt, input_handler);
296
    }
297
  /* new_prompt at this point can be the top of the stack or the one passed in */
298
  else if (new_prompt)
299
    {
300
      /* Don't use a _filtered function here.  It causes the assumed
301
         character position to be off, since the newline we read from
302
         the user is not accounted for.  */
303
      fputs_unfiltered (new_prompt, gdb_stdout);
304
 
305
      /* OBSOLETE #ifdef MPW */
306
      /* OBSOLETE        *//* Move to a new line so the entered line doesn't have a prompt */
307
      /* OBSOLETE          on the front of it. */
308
      /* OBSOLETE       fputs_unfiltered ("\n", gdb_stdout); */
309
      /* OBSOLETE #endif  *//* MPW */
310
      gdb_flush (gdb_stdout);
311
    }
312
}
313
 
314
/* Used when the user requests a different annotation level, with
315
   'set annotate'. It pushes a new prompt (with prefix and suffix) on top
316
   of the prompt stack, if the annotation level desired is 2, otherwise
317
   it pops the top of the prompt stack when we want the annotation level
318
   to be the normal ones (1 or 0). */
319
static void
320
change_annotation_level (void)
321
{
322
  char *prefix, *suffix;
323
 
324
  if (!PREFIX (0) || !PROMPT (0) || !SUFFIX (0))
325
    {
326
      /* The prompt stack has not been initialized to "", we are
327
         using gdb w/o the --async switch */
328
      warning ("Command has same effect as set annotate");
329
      return;
330
    }
331
 
332
  if (annotation_level > 1)
333
    {
334
      if (!strcmp (PREFIX (0), "") && !strcmp (SUFFIX (0), ""))
335
        {
336
          /* Push a new prompt if the previous annotation_level was not >1. */
337
          prefix = (char *) alloca (strlen (async_annotation_suffix) + 10);
338
          strcpy (prefix, "\n\032\032pre-");
339
          strcat (prefix, async_annotation_suffix);
340
          strcat (prefix, "\n");
341
 
342
          suffix = (char *) alloca (strlen (async_annotation_suffix) + 6);
343
          strcpy (suffix, "\n\032\032");
344
          strcat (suffix, async_annotation_suffix);
345
          strcat (suffix, "\n");
346
 
347
          push_prompt (prefix, (char *) 0, suffix);
348
        }
349
    }
350
  else
351
    {
352
      if (strcmp (PREFIX (0), "") && strcmp (SUFFIX (0), ""))
353
        {
354
          /* Pop the top of the stack, we are going back to annotation < 1. */
355
          pop_prompt ();
356
        }
357
    }
358
}
359
 
360
/* Pushes a new prompt on the prompt stack. Each prompt has three
361
   parts: prefix, prompt, suffix. Usually prefix and suffix are empty
362
   strings, except when the annotation level is 2. Memory is allocated
363
   within savestring for the new prompt. */
364
void
365
push_prompt (char *prefix, char *prompt, char *suffix)
366
{
367
  the_prompts.top++;
368
  PREFIX (0) = savestring (prefix, strlen (prefix));
369
 
370
  /* Note that this function is used by the set annotate 2
371
     command. This is why we take care of saving the old prompt
372
     in case a new one is not specified. */
373
  if (prompt)
374
    PROMPT (0) = savestring (prompt, strlen (prompt));
375
  else
376
    PROMPT (0) = savestring (PROMPT (-1), strlen (PROMPT (-1)));
377
 
378
  SUFFIX (0) = savestring (suffix, strlen (suffix));
379
}
380
 
381
/* Pops the top of the prompt stack, and frees the memory allocated for it. */
382
void
383
pop_prompt (void)
384
{
385
  /* If we are not during a 'synchronous' execution command, in which
386
     case, the top prompt would be empty. */
387
  if (strcmp (PROMPT (0), ""))
388
    /* This is for the case in which the prompt is set while the
389
       annotation level is 2. The top prompt will be changed, but when
390
       we return to annotation level < 2, we want that new prompt to be
391
       in effect, until the user does another 'set prompt'. */
392
    if (strcmp (PROMPT (0), PROMPT (-1)))
393
      {
394
        xfree (PROMPT (-1));
395
        PROMPT (-1) = savestring (PROMPT (0), strlen (PROMPT (0)));
396
      }
397
 
398
  xfree (PREFIX (0));
399
  xfree (PROMPT (0));
400
  xfree (SUFFIX (0));
401
  the_prompts.top--;
402
}
403
 
404
/* When there is an event ready on the stdin file desriptor, instead
405
   of calling readline directly throught the callback function, or
406
   instead of calling gdb_readline2, give gdb a chance to detect
407
   errors and do something. */
408
void
409
stdin_event_handler (int error, gdb_client_data client_data)
410
{
411
  if (error)
412
    {
413
      printf_unfiltered ("error detected on stdin\n");
414
      delete_file_handler (input_fd);
415
      discard_all_continuations ();
416
      /* If stdin died, we may as well kill gdb. */
417
      quit_command ((char *) 0, stdin == instream);
418
    }
419
  else
420
    (*call_readline) (client_data);
421
}
422
 
423
/* Re-enable stdin after the end of an execution command in
424
   synchronous mode, or after an error from the target, and we aborted
425
   the exec operation. */
426
 
427
void
428
async_enable_stdin (void *dummy)
429
{
430
  /* See NOTE in async_disable_stdin() */
431
  /* FIXME: cagney/1999-09-27: Call this before clearing
432
     sync_execution.  Current target_terminal_ours() implementations
433
     check for sync_execution before switching the terminal. */
434
  target_terminal_ours ();
435
  pop_prompt ();
436
  sync_execution = 0;
437
}
438
 
439
/* Disable reads from stdin (the console) marking the command as
440
   synchronous. */
441
 
442
void
443
async_disable_stdin (void)
444
{
445
  sync_execution = 1;
446
  push_prompt ("", "", "");
447
  /* FIXME: cagney/1999-09-27: At present this call is technically
448
     redundant since infcmd.c and infrun.c both already call
449
     target_terminal_inferior().  As the terminal handling (in
450
     sync/async mode) is refined, the duplicate calls can be
451
     eliminated (Here or in infcmd.c/infrun.c). */
452
  target_terminal_inferior ();
453
  /* Add the reinstate of stdin to the list of cleanups to be done
454
     in case the target errors out and dies. These cleanups are also
455
     done in case of normal successful termination of the execution
456
     command, by complete_execution(). */
457
  make_exec_error_cleanup (async_enable_stdin, NULL);
458
}
459
 
460
 
461
/* Handles a gdb command. This function is called by
462
   command_line_handler, which has processed one or more input lines
463
   into COMMAND. */
464
/* NOTE: 1999-04-30 This is the asynchronous version of the command_loop
465
   function.  The command_loop function will be obsolete when we
466
   switch to use the event loop at every execution of gdb. */
467
static void
468
command_handler (char *command)
469
{
470
  struct cleanup *old_chain;
471
  int stdin_is_tty = ISATTY (stdin);
472
  struct continuation_arg *arg1;
473
  struct continuation_arg *arg2;
474
  long time_at_cmd_start;
475
#ifdef HAVE_SBRK
476
  long space_at_cmd_start = 0;
477
#endif
478
  extern int display_time;
479
  extern int display_space;
480
 
481
#if defined(TUI)
482
  extern int insert_mode;
483
#endif
484
 
485
  quit_flag = 0;
486
  if (instream == stdin && stdin_is_tty)
487
    reinitialize_more_filter ();
488
  old_chain = make_cleanup (null_cleanup, 0);
489
 
490
#if defined(TUI)
491
  insert_mode = 0;
492
#endif
493
  /* If readline returned a NULL command, it means that the
494
     connection with the terminal is gone. This happens at the
495
     end of a testsuite run, after Expect has hung up
496
     but GDB is still alive. In such a case, we just quit gdb
497
     killing the inferior program too. */
498
  if (command == 0)
499
    quit_command ((char *) 0, stdin == instream);
500
 
501
  time_at_cmd_start = get_run_time ();
502
 
503
  if (display_space)
504
    {
505
#ifdef HAVE_SBRK
506
      extern char **environ;
507
      char *lim = (char *) sbrk (0);
508
 
509
      space_at_cmd_start = (long) (lim - (char *) &environ);
510
#endif
511
    }
512
 
513
  execute_command (command, instream == stdin);
514
 
515
  /* Set things up for this function to be compete later, once the
516
     execution has completed, if we are doing an execution command,
517
     otherwise, just go ahead and finish. */
518
  if (target_can_async_p () && target_executing)
519
    {
520
      arg1 =
521
        (struct continuation_arg *) xmalloc (sizeof (struct continuation_arg));
522
      arg2 =
523
        (struct continuation_arg *) xmalloc (sizeof (struct continuation_arg));
524
      arg1->next = arg2;
525
      arg2->next = NULL;
526
      arg1->data.integer = time_at_cmd_start;
527
      arg2->data.integer = space_at_cmd_start;
528
      add_continuation (command_line_handler_continuation, arg1);
529
    }
530
 
531
  /* Do any commands attached to breakpoint we stopped at. Only if we
532
     are always running synchronously. Or if we have just executed a
533
     command that doesn't start the target. */
534
  if (!target_can_async_p () || !target_executing)
535
    {
536
      bpstat_do_actions (&stop_bpstat);
537
      do_cleanups (old_chain);
538
 
539
      if (display_time)
540
        {
541
          long cmd_time = get_run_time () - time_at_cmd_start;
542
 
543
          printf_unfiltered ("Command execution time: %ld.%06ld\n",
544
                             cmd_time / 1000000, cmd_time % 1000000);
545
        }
546
 
547
      if (display_space)
548
        {
549
#ifdef HAVE_SBRK
550
          extern char **environ;
551
          char *lim = (char *) sbrk (0);
552
          long space_now = lim - (char *) &environ;
553
          long space_diff = space_now - space_at_cmd_start;
554
 
555
          printf_unfiltered ("Space used: %ld (%c%ld for this command)\n",
556
                             space_now,
557
                             (space_diff >= 0 ? '+' : '-'),
558
                             space_diff);
559
#endif
560
        }
561
    }
562
}
563
 
564
/* Do any commands attached to breakpoint we stopped at. Only if we
565
   are always running synchronously. Or if we have just executed a
566
   command that doesn't start the target. */
567
void
568
command_line_handler_continuation (struct continuation_arg *arg)
569
{
570
  extern int display_time;
571
  extern int display_space;
572
 
573
  long time_at_cmd_start  = arg->data.longint;
574
  long space_at_cmd_start = arg->next->data.longint;
575
 
576
  bpstat_do_actions (&stop_bpstat);
577
  /*do_cleanups (old_chain); *//*?????FIXME????? */
578
 
579
  if (display_time)
580
    {
581
      long cmd_time = get_run_time () - time_at_cmd_start;
582
 
583
      printf_unfiltered ("Command execution time: %ld.%06ld\n",
584
                         cmd_time / 1000000, cmd_time % 1000000);
585
    }
586
  if (display_space)
587
    {
588
#ifdef HAVE_SBRK
589
      extern char **environ;
590
      char *lim = (char *) sbrk (0);
591
      long space_now = lim - (char *) &environ;
592
      long space_diff = space_now - space_at_cmd_start;
593
 
594
      printf_unfiltered ("Space used: %ld (%c%ld for this command)\n",
595
                         space_now,
596
                         (space_diff >= 0 ? '+' : '-'),
597
                         space_diff);
598
#endif
599
    }
600
}
601
 
602
/* Handle a complete line of input. This is called by the callback
603
   mechanism within the readline library.  Deal with incomplete commands
604
   as well, by saving the partial input in a global buffer.  */
605
 
606
/* NOTE: 1999-04-30 This is the asynchronous version of the
607
   command_line_input function. command_line_input will become
608
   obsolete once we use the event loop as the default mechanism in
609
   GDB. */
610
static void
611
command_line_handler (char *rl)
612
{
613
  static char *linebuffer = 0;
614
  static unsigned linelength = 0;
615
  register char *p;
616
  char *p1;
617
  extern char *line;
618
  extern int linesize;
619
  char *nline;
620
  char got_eof = 0;
621
 
622
 
623
  int repeat = (instream == stdin);
624
 
625
  if (annotation_level > 1 && instream == stdin)
626
    {
627
      printf_unfiltered ("\n\032\032post-");
628
      printf_unfiltered (async_annotation_suffix);
629
      printf_unfiltered ("\n");
630
    }
631
 
632
  if (linebuffer == 0)
633
    {
634
      linelength = 80;
635
      linebuffer = (char *) xmalloc (linelength);
636
    }
637
 
638
  p = linebuffer;
639
 
640
  if (more_to_come)
641
    {
642
      strcpy (linebuffer, readline_input_state.linebuffer);
643
      p = readline_input_state.linebuffer_ptr;
644
      xfree (readline_input_state.linebuffer);
645
      more_to_come = 0;
646
      pop_prompt ();
647
    }
648
 
649
#ifdef STOP_SIGNAL
650
  if (job_control)
651
    signal (STOP_SIGNAL, handle_stop_sig);
652
#endif
653
 
654
  /* Make sure that all output has been output.  Some machines may let
655
     you get away with leaving out some of the gdb_flush, but not all.  */
656
  wrap_here ("");
657
  gdb_flush (gdb_stdout);
658
  gdb_flush (gdb_stderr);
659
 
660
  if (source_file_name != NULL)
661
    {
662
      ++source_line_number;
663
      sprintf (source_error,
664
               "%s%s:%d: Error in sourced command file:\n",
665
               source_pre_error,
666
               source_file_name,
667
               source_line_number);
668
      error_pre_print = source_error;
669
    }
670
 
671
  /* If we are in this case, then command_handler will call quit
672
     and exit from gdb. */
673
  if (!rl || rl == (char *) EOF)
674
    {
675
      got_eof = 1;
676
      command_handler (0);
677
    }
678
  if (strlen (rl) + 1 + (p - linebuffer) > linelength)
679
    {
680
      linelength = strlen (rl) + 1 + (p - linebuffer);
681
      nline = (char *) xrealloc (linebuffer, linelength);
682
      p += nline - linebuffer;
683
      linebuffer = nline;
684
    }
685
  p1 = rl;
686
  /* Copy line.  Don't copy null at end.  (Leaves line alone
687
     if this was just a newline)  */
688
  while (*p1)
689
    *p++ = *p1++;
690
 
691
  xfree (rl);                   /* Allocated in readline.  */
692
 
693
  if (*(p - 1) == '\\')
694
    {
695
      p--;                      /* Put on top of '\'.  */
696
 
697
      if (*p == '\\')
698
        {
699
          readline_input_state.linebuffer = savestring (linebuffer,
700
                                                        strlen (linebuffer));
701
          readline_input_state.linebuffer_ptr = p;
702
 
703
          /* We will not invoke a execute_command if there is more
704
             input expected to complete the command. So, we need to
705
             print an empty prompt here. */
706
          more_to_come = 1;
707
          push_prompt ("", "", "");
708
          display_gdb_prompt (0);
709
          return;
710
        }
711
    }
712
 
713
#ifdef STOP_SIGNAL
714
  if (job_control)
715
    signal (STOP_SIGNAL, SIG_DFL);
716
#endif
717
 
718
#define SERVER_COMMAND_LENGTH 7
719
  server_command =
720
    (p - linebuffer > SERVER_COMMAND_LENGTH)
721
    && STREQN (linebuffer, "server ", SERVER_COMMAND_LENGTH);
722
  if (server_command)
723
    {
724
      /* Note that we don't set `line'.  Between this and the check in
725
         dont_repeat, this insures that repeating will still do the
726
         right thing.  */
727
      *p = '\0';
728
      command_handler (linebuffer + SERVER_COMMAND_LENGTH);
729
      display_gdb_prompt (0);
730
      return;
731
    }
732
 
733
  /* Do history expansion if that is wished.  */
734
  if (history_expansion_p && instream == stdin
735
      && ISATTY (instream))
736
    {
737
      char *history_value;
738
      int expanded;
739
 
740
      *p = '\0';                /* Insert null now.  */
741
      expanded = history_expand (linebuffer, &history_value);
742
      if (expanded)
743
        {
744
          /* Print the changes.  */
745
          printf_unfiltered ("%s\n", history_value);
746
 
747
          /* If there was an error, call this function again.  */
748
          if (expanded < 0)
749
            {
750
              xfree (history_value);
751
              return;
752
            }
753
          if (strlen (history_value) > linelength)
754
            {
755
              linelength = strlen (history_value) + 1;
756
              linebuffer = (char *) xrealloc (linebuffer, linelength);
757
            }
758
          strcpy (linebuffer, history_value);
759
          p = linebuffer + strlen (linebuffer);
760
          xfree (history_value);
761
        }
762
    }
763
 
764
  /* If we just got an empty line, and that is supposed
765
     to repeat the previous command, return the value in the
766
     global buffer.  */
767
  if (repeat && p == linebuffer && *p != '\\')
768
    {
769
      command_handler (line);
770
      display_gdb_prompt (0);
771
      return;
772
    }
773
 
774
  for (p1 = linebuffer; *p1 == ' ' || *p1 == '\t'; p1++);
775
  if (repeat && !*p1)
776
    {
777
      command_handler (line);
778
      display_gdb_prompt (0);
779
      return;
780
    }
781
 
782
  *p = 0;
783
 
784
  /* Add line to history if appropriate.  */
785
  if (instream == stdin
786
      && ISATTY (stdin) && *linebuffer)
787
    add_history (linebuffer);
788
 
789
  /* Note: lines consisting solely of comments are added to the command
790
     history.  This is useful when you type a command, and then
791
     realize you don't want to execute it quite yet.  You can comment
792
     out the command and then later fetch it from the value history
793
     and remove the '#'.  The kill ring is probably better, but some
794
     people are in the habit of commenting things out.  */
795
  if (*p1 == '#')
796
    *p1 = '\0';                 /* Found a comment. */
797
 
798
  /* Save into global buffer if appropriate.  */
799
  if (repeat)
800
    {
801
      if (linelength > linesize)
802
        {
803
          line = xrealloc (line, linelength);
804
          linesize = linelength;
805
        }
806
      strcpy (line, linebuffer);
807
      if (!more_to_come)
808
        {
809
          command_handler (line);
810
          display_gdb_prompt (0);
811
        }
812
      return;
813
    }
814
 
815
  command_handler (linebuffer);
816
  display_gdb_prompt (0);
817
  return;
818
}
819
 
820
/* Does reading of input from terminal w/o the editing features
821
   provided by the readline library. */
822
 
823
/* NOTE: 1999-04-30 Asynchronous version of gdb_readline. gdb_readline
824
   will become obsolete when the event loop is made the default
825
   execution for gdb. */
826
void
827
gdb_readline2 (gdb_client_data client_data)
828
{
829
  int c;
830
  char *result;
831
  int input_index = 0;
832
  int result_size = 80;
833
  static int done_once = 0;
834
 
835
  /* Unbuffer the input stream, so that, later on, the calls to fgetc
836
     fetch only one char at the time from the stream. The fgetc's will
837
     get up to the first newline, but there may be more chars in the
838
     stream after '\n'. If we buffer the input and fgetc drains the
839
     stream, getting stuff beyond the newline as well, a select, done
840
     afterwards will not trigger. */
841
  if (!done_once && !ISATTY (instream))
842
    {
843
      setbuf (instream, NULL);
844
      done_once = 1;
845
    }
846
 
847
  result = (char *) xmalloc (result_size);
848
 
849
  /* We still need the while loop here, even though it would seem
850
     obvious to invoke gdb_readline2 at every character entered.  If
851
     not using the readline library, the terminal is in cooked mode,
852
     which sends the characters all at once. Poll will notice that the
853
     input fd has changed state only after enter is pressed. At this
854
     point we still need to fetch all the chars entered. */
855
 
856
  while (1)
857
    {
858
      /* Read from stdin if we are executing a user defined command.
859
         This is the right thing for prompt_for_continue, at least.  */
860
      c = fgetc (instream ? instream : stdin);
861
 
862
      if (c == EOF)
863
        {
864
          if (input_index > 0)
865
            /* The last line does not end with a newline.  Return it, and
866
               if we are called again fgetc will still return EOF and
867
               we'll return NULL then.  */
868
            break;
869
          xfree (result);
870
          (*input_handler) (0);
871
        }
872
 
873
      if (c == '\n')
874
#ifndef CRLF_SOURCE_FILES
875
        break;
876
#else
877
        {
878
          if (input_index > 0 && result[input_index - 1] == '\r')
879
            input_index--;
880
          break;
881
        }
882
#endif
883
 
884
      result[input_index++] = c;
885
      while (input_index >= result_size)
886
        {
887
          result_size *= 2;
888
          result = (char *) xrealloc (result, result_size);
889
        }
890
    }
891
 
892
  result[input_index++] = '\0';
893
  (*input_handler) (result);
894
}
895
 
896
 
897
/* Initialization of signal handlers and tokens.  There is a function
898
   handle_sig* for each of the signals GDB cares about. Specifically:
899
   SIGINT, SIGFPE, SIGQUIT, SIGTSTP, SIGHUP, SIGWINCH.  These
900
   functions are the actual signal handlers associated to the signals
901
   via calls to signal().  The only job for these functions is to
902
   enqueue the appropriate event/procedure with the event loop.  Such
903
   procedures are the old signal handlers. The event loop will take
904
   care of invoking the queued procedures to perform the usual tasks
905
   associated with the reception of the signal. */
906
/* NOTE: 1999-04-30 This is the asynchronous version of init_signals.
907
   init_signals will become obsolete as we move to have to event loop
908
   as the default for gdb. */
909
void
910
async_init_signals (void)
911
{
912
  signal (SIGINT, handle_sigint);
913
  sigint_token =
914
    create_async_signal_handler (async_request_quit, NULL);
915
 
916
  /* If SIGTRAP was set to SIG_IGN, then the SIG_IGN will get passed
917
     to the inferior and breakpoints will be ignored.  */
918
#ifdef SIGTRAP
919
  signal (SIGTRAP, SIG_DFL);
920
#endif
921
 
922
  /* If we initialize SIGQUIT to SIG_IGN, then the SIG_IGN will get
923
     passed to the inferior, which we don't want.  It would be
924
     possible to do a "signal (SIGQUIT, SIG_DFL)" after we fork, but
925
     on BSD4.3 systems using vfork, that can affect the
926
     GDB process as well as the inferior (the signal handling tables
927
     might be in memory, shared between the two).  Since we establish
928
     a handler for SIGQUIT, when we call exec it will set the signal
929
     to SIG_DFL for us.  */
930
  signal (SIGQUIT, handle_sigquit);
931
  sigquit_token =
932
    create_async_signal_handler (async_do_nothing, NULL);
933
#ifdef SIGHUP
934
  if (signal (SIGHUP, handle_sighup) != SIG_IGN)
935
    sighup_token =
936
      create_async_signal_handler (async_disconnect, NULL);
937
  else
938
    sighup_token =
939
      create_async_signal_handler (async_do_nothing, NULL);
940
#endif
941
  signal (SIGFPE, handle_sigfpe);
942
  sigfpe_token =
943
    create_async_signal_handler (async_float_handler, NULL);
944
 
945
#if defined(SIGWINCH) && defined(SIGWINCH_HANDLER)
946
  signal (SIGWINCH, handle_sigwinch);
947
  sigwinch_token =
948
    create_async_signal_handler (SIGWINCH_HANDLER, NULL);
949
#endif
950
#ifdef STOP_SIGNAL
951
  sigtstp_token =
952
    create_async_signal_handler (async_stop_sig, NULL);
953
#endif
954
 
955
}
956
 
957
void
958
mark_async_signal_handler_wrapper (void *token)
959
{
960
  mark_async_signal_handler ((struct async_signal_handler *) token);
961
}
962
 
963
/* Tell the event loop what to do if SIGINT is received.
964
   See event-signal.c. */
965
void
966
handle_sigint (int sig)
967
{
968
  signal (sig, handle_sigint);
969
 
970
  /* If immediate_quit is set, we go ahead and process the SIGINT right
971
     away, even if we usually would defer this to the event loop. The
972
     assumption here is that it is safe to process ^C immediately if
973
     immediate_quit is set. If we didn't, SIGINT would be really
974
     processed only the next time through the event loop.  To get to
975
     that point, though, the command that we want to interrupt needs to
976
     finish first, which is unacceptable. */
977
  if (immediate_quit)
978
    async_request_quit (0);
979
  else
980
    /* If immediate quit is not set, we process SIGINT the next time
981
       through the loop, which is fine. */
982
    mark_async_signal_handler_wrapper (sigint_token);
983
}
984
 
985
/* Do the quit. All the checks have been done by the caller. */
986
void
987
async_request_quit (gdb_client_data arg)
988
{
989
  quit_flag = 1;
990
#ifdef REQUEST_QUIT
991
  REQUEST_QUIT;
992
#else
993
  quit ();
994
#endif
995
}
996
 
997
/* Tell the event loop what to do if SIGQUIT is received.
998
   See event-signal.c. */
999
static void
1000
handle_sigquit (int sig)
1001
{
1002
  mark_async_signal_handler_wrapper (sigquit_token);
1003
  signal (sig, handle_sigquit);
1004
}
1005
 
1006
/* Called by the event loop in response to a SIGQUIT. */
1007
static void
1008
async_do_nothing (gdb_client_data arg)
1009
{
1010
  /* Empty function body. */
1011
}
1012
 
1013
#ifdef SIGHUP
1014
/* Tell the event loop what to do if SIGHUP is received.
1015
   See event-signal.c. */
1016
static void
1017
handle_sighup (int sig)
1018
{
1019
  mark_async_signal_handler_wrapper (sighup_token);
1020
  signal (sig, handle_sighup);
1021
}
1022
 
1023
/* Called by the event loop to process a SIGHUP */
1024
static void
1025
async_disconnect (gdb_client_data arg)
1026
{
1027
  catch_errors (quit_cover, NULL,
1028
                "Could not kill the program being debugged",
1029
                RETURN_MASK_ALL);
1030
  signal (SIGHUP, SIG_DFL);     /*FIXME: ??????????? */
1031
  kill (getpid (), SIGHUP);
1032
}
1033
#endif
1034
 
1035
#ifdef STOP_SIGNAL
1036
void
1037
handle_stop_sig (int sig)
1038
{
1039
  mark_async_signal_handler_wrapper (sigtstp_token);
1040
  signal (sig, handle_stop_sig);
1041
}
1042
 
1043
static void
1044
async_stop_sig (gdb_client_data arg)
1045
{
1046
  char *prompt = get_prompt ();
1047
#if STOP_SIGNAL == SIGTSTP
1048
  signal (SIGTSTP, SIG_DFL);
1049
#if HAVE_SIGPROCMASK
1050
  {
1051
    sigset_t zero;
1052
    sigemptyset (&zero);
1053
    sigprocmask (SIG_SETMASK, &zero, 0);
1054
  }
1055
#else
1056
  sigsetmask (0);
1057
#endif
1058
  kill (getpid (), SIGTSTP);
1059
  signal (SIGTSTP, handle_stop_sig);
1060
#else
1061
  signal (STOP_SIGNAL, handle_stop_sig);
1062
#endif
1063
  printf_unfiltered ("%s", prompt);
1064
  gdb_flush (gdb_stdout);
1065
 
1066
  /* Forget about any previous command -- null line now will do nothing.  */
1067
  dont_repeat ();
1068
}
1069
#endif /* STOP_SIGNAL */
1070
 
1071
/* Tell the event loop what to do if SIGFPE is received.
1072
   See event-signal.c. */
1073
static void
1074
handle_sigfpe (int sig)
1075
{
1076
  mark_async_signal_handler_wrapper (sigfpe_token);
1077
  signal (sig, handle_sigfpe);
1078
}
1079
 
1080
/* Event loop will call this functin to process a SIGFPE. */
1081
static void
1082
async_float_handler (gdb_client_data arg)
1083
{
1084
  /* This message is based on ANSI C, section 4.7. Note that integer
1085
     divide by zero causes this, so "float" is a misnomer. */
1086
  error ("Erroneous arithmetic operation.");
1087
}
1088
 
1089
/* Tell the event loop what to do if SIGWINCH is received.
1090
   See event-signal.c. */
1091
#if defined(SIGWINCH) && defined(SIGWINCH_HANDLER)
1092
static void
1093
handle_sigwinch (int sig)
1094
{
1095
  mark_async_signal_handler_wrapper (sigwinch_token);
1096
  signal (sig, handle_sigwinch);
1097
}
1098
#endif
1099
 
1100
 
1101
/* Called by do_setshow_command.  */
1102
/* ARGSUSED */
1103
void
1104
set_async_editing_command (char *args, int from_tty, struct cmd_list_element *c)
1105
{
1106
  change_line_handler ();
1107
}
1108
 
1109
/* Called by do_setshow_command.  */
1110
/* ARGSUSED */
1111
void
1112
set_async_annotation_level (char *args, int from_tty, struct cmd_list_element *c)
1113
{
1114
  change_annotation_level ();
1115
}
1116
 
1117
/* Called by do_setshow_command.  */
1118
/* ARGSUSED */
1119
void
1120
set_async_prompt (char *args, int from_tty, struct cmd_list_element *c)
1121
{
1122
  PROMPT (0) = savestring (new_async_prompt, strlen (new_async_prompt));
1123
}
1124
 
1125
/* Set things up for readline to be invoked via the alternate
1126
   interface, i.e. via a callback function (rl_callback_read_char),
1127
   and hook up instream to the event loop. */
1128
void
1129
_initialize_event_loop (void)
1130
{
1131
  if (event_loop_p)
1132
    {
1133
      /* If the input stream is connected to a terminal, turn on
1134
         editing.  */
1135
      if (ISATTY (instream))
1136
        {
1137
          /* Tell gdb that we will be using the readline library. This
1138
             could be overwritten by a command in .gdbinit like 'set
1139
             editing on' or 'off'. */
1140
          async_command_editing_p = 1;
1141
 
1142
          /* When a character is detected on instream by select or
1143
             poll, readline will be invoked via this callback
1144
             function. */
1145
          call_readline = rl_callback_read_char_wrapper;
1146
        }
1147
      else
1148
        {
1149
          async_command_editing_p = 0;
1150
          call_readline = gdb_readline2;
1151
        }
1152
 
1153
      /* When readline has read an end-of-line character, it passes
1154
         the complete line to gdb for processing. command_line_handler
1155
         is the function that does this. */
1156
      input_handler = command_line_handler;
1157
 
1158
      /* Tell readline to use the same input stream that gdb uses. */
1159
      rl_instream = instream;
1160
 
1161
      /* Get a file descriptor for the input stream, so that we can
1162
         register it with the event loop. */
1163
      input_fd = fileno (instream);
1164
 
1165
      /* Tell gdb to use the cli_command_loop as the main loop. */
1166
      command_loop_hook = cli_command_loop;
1167
 
1168
      /* Now we need to create the event sources for the input file
1169
         descriptor. */
1170
      /* At this point in time, this is the only event source that we
1171
         register with the even loop. Another source is going to be
1172
         the target program (inferior), but that must be registered
1173
         only when it actually exists (I.e. after we say 'run' or
1174
         after we connect to a remote target. */
1175
      add_file_handler (input_fd, stdin_event_handler, 0);
1176
    }
1177
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.