(SEC_HAS_GOT_REF): Define new flag for asection.

[deliverable/binutils-gdb.git] / gdb / event-top.c

diff --git a/gdb/event-top.c b/gdb/event-top.c
index 7e6cf8351ae869c92821c0771614120eac89b581..f37ff7577ae9e2efb77a609f891f297ce88c9482 100644 (file)
--- a/gdb/event-top.c
+++ b/gdb/event-top.c
@@ -22,6 +22,7 @@
 #include "defs.h"
 #include "top.h"
 #include "inferior.h"
+#include "target.h"
 #include "terminal.h"          /* for job_control */
 #include "signals.h"
 #include "event-loop.h"
@@ -128,17 +129,17 @@ struct prompts the_prompts;
    handlers mark these functions as ready to be executed and the event
    loop, in a later iteration, calls them. See the function
    invoke_async_signal_handler. */
-PTR sigint_token;
+void *sigint_token;
 #ifdef SIGHUP
-PTR sighup_token;
+void *sighup_token;
 #endif
-PTR sigquit_token;
-PTR sigfpe_token;
+void *sigquit_token;
+void *sigfpe_token;
 #if defined(SIGWINCH) && defined(SIGWINCH_HANDLER)
-PTR sigwinch_token;
+void *sigwinch_token;
 #endif
 #ifdef STOP_SIGNAL
-PTR sigtstp_token;
+void *sigtstp_token;
 #endif
 
 /* Structure to save a partially entered command.  This is used when
@@ -156,7 +157,7 @@ struct readline_input_state
 readline_input_state;
 \f
 
-/* Wrapper function foe calling into the readline library. The event
+/* Wrapper function for calling into the readline library. The event
    loop expects the callback function to have a paramter, while readline 
    expects none. */
 static void
@@ -245,6 +246,12 @@ display_gdb_prompt (char *new_prompt)
   int prompt_length = 0;
   char *gdb_prompt = get_prompt ();
 
+#ifdef UI_OUT
+  /* When an alternative interpreter has been installed, do not
+     display the comand prompt. */
+  if (interpreter_p)
+    return;
+#endif
 
   if (target_executing && sync_execution)
     {
@@ -409,7 +416,7 @@ stdin_event_handler (int error, gdb_client_data client_data)
       delete_file_handler (input_fd);
       discard_all_continuations ();
       /* If stdin died, we may as well kill gdb. */
-      exit (1);
+      quit_command ((char *) 0, stdin == instream);
     }
   else
     (*call_readline) (client_data);
@@ -480,7 +487,7 @@ command_handler (char *command)
   quit_flag = 0;
   if (instream == stdin && stdin_is_tty)
     reinitialize_more_filter ();
-  old_chain = make_cleanup ((make_cleanup_func) command_loop_marker, 0);
+  old_chain = make_cleanup (null_cleanup, 0);
 
 #if defined(TUI)
   insert_mode = 0;
@@ -508,7 +515,7 @@ command_handler (char *command)
   execute_command (command, instream == stdin);
 
   /* Set things up for this function to be compete later, once the
-     executin has completed, if we are doing an execution command,
+     execution has completed, if we are doing an execution command,
      otherwise, just go ahead and finish. */
   if (target_can_async_p () && target_executing)
     {
@@ -518,8 +525,8 @@ command_handler (char *command)
        (struct continuation_arg *) xmalloc (sizeof (struct continuation_arg));
       arg1->next = arg2;
       arg2->next = NULL;
-      arg1->data = (PTR) time_at_cmd_start;
-      arg2->data = (PTR) space_at_cmd_start;
+      arg1->data.integer = time_at_cmd_start;
+      arg2->data.integer = space_at_cmd_start;
       add_continuation (command_line_handler_continuation, arg1);
     }
 
@@ -565,8 +572,8 @@ command_line_handler_continuation (struct continuation_arg *arg)
   extern int display_time;
   extern int display_space;
 
-  long time_at_cmd_start = (long) arg->data;
-  long space_at_cmd_start = (long) arg->next->data;
+  long time_at_cmd_start  = arg->data.longint;
+  long space_at_cmd_start = arg->next->data.longint;
 
   bpstat_do_actions (&stop_bpstat);
   /*do_cleanups (old_chain); *//*?????FIXME????? */
@@ -950,7 +957,7 @@ async_init_signals (void)
 }
 
 void
-mark_async_signal_handler_wrapper (PTR token)
+mark_async_signal_handler_wrapper (void *token)
 {
   mark_async_signal_handler ((struct async_signal_handler *) token);
 }
@@ -1009,8 +1016,7 @@ async_do_nothing (gdb_client_data arg)
 /* Tell the event loop what to do if SIGHUP is received. 
    See event-signal.c. */
 static void
-handle_sighup (sig)
-     int sig;
+handle_sighup (int sig)
 {
   mark_async_signal_handler_wrapper (sighup_token);
   signal (sig, handle_sighup);
@@ -1126,9 +1132,25 @@ _initialize_event_loop (void)
 {
   if (event_loop_p)
     {
-      /* When a character is detected on instream by select or poll,
-         readline will be invoked via this callback function. */
-      call_readline = rl_callback_read_char_wrapper;
+      /* If the input stream is connected to a terminal, turn on
+         editing.  */
+      if (ISATTY (instream))
+       {
+         /* Tell gdb that we will be using the readline library. This
+            could be overwritten by a command in .gdbinit like 'set
+            editing on' or 'off'. */
+         async_command_editing_p = 1;
+         
+         /* When a character is detected on instream by select or
+            poll, readline will be invoked via this callback
+            function. */
+         call_readline = rl_callback_read_char_wrapper;
+       }
+      else
+       {
+         async_command_editing_p = 0;
+         call_readline = gdb_readline2;
+       }
 
       /* When readline has read an end-of-line character, it passes
          the complete line to gdb for processing. command_line_handler
@@ -1153,10 +1175,5 @@ _initialize_event_loop (void)
          only when it actually exists (I.e. after we say 'run' or
          after we connect to a remote target. */
       add_file_handler (input_fd, stdin_event_handler, 0);
-
-      /* Tell gdb that we will be using the readline library. This
-         could be overwritten by a command in .gdbinit like 'set
-         editing on' or 'off'. */
-      async_command_editing_p = 1;
     }
 }