xemacs-beta: src/event-stream.c comparison

comparison src/event-stream.c @ 20:859a2309aef8 r19-15b93

Import from CVS: tag r19-15b93

author	cvs
date	Mon, 13 Aug 2007 08:50:05 +0200
parents	0293115a14e9
children	ec9a17fef872

comparison

equal deleted inserted replaced

-:ac1f612d5250
+:859a2309aef8
 keyboard and mouse events by pushing them here.
 Chained through event_next()
 command_event_queue_tail is a pointer to the last-added element.
 */
+static Lisp_Object process_event_queue;
+static Lisp_Object process_event_queue_tail;
 static Lisp_Object command_event_queue;
 static Lisp_Object command_event_queue_tail;
 /* Nonzero means echo unfinished commands after this many seconds of pause. */
 static int echo_keystrokes;
 	}
 }
 return 0;
 }
-DEFUN ("input-pending-p", Finput_pending_p, Sinput_pending_p, 0, 0, 0 /*
+DEFUN ("input-pending-p", Finput_pending_p, 0, 0, 0, /*
 T if command input is currently available with no waiting.
 Actually, the value is nil only if we can be sure that no input is available.
-*/ )
+*/
-()
+())
 {
 return ((detect_input_pending ()) ? Qt : Qnil);
 }
 signal_simple_error
 ("timeout would exceed 32 bits when represented in milliseconds", secs);
 return msecs;
 }
-DEFUN ("add-timeout", Fadd_timeout, Sadd_timeout, 3, 4, 0 /*
+DEFUN ("add-timeout", Fadd_timeout, 3, 4, 0, /*
 Add a timeout, to be signaled after the timeout period has elapsed.
 SECS is a number of seconds, expressed as an integer or a float.
 FUNCTION will be called after that many seconds have elapsed, with one
 argument, the given OBJECT.  If the optional RESIGNAL argument is provided,
 then after this timeout expires, `add-timeout' will automatically be called
 running Lisp code, use `add-async-timeout'.
 WARNING: if you are thinking of calling add-timeout from inside of a
 callback function as a way of resignalling a timeout, think again.  There
 is a race condition.  That's why the RESIGNAL argument exists.
-*/ )
+*/
-(secs, function, object, resignal)
+(secs, function, object, resignal))
-Lisp_Object secs, function, object, resignal;
 {
 unsigned long msecs = lisp_number_to_milliseconds (secs, 0);
 unsigned long msecs2 = (NILP (resignal) ? 0 :
 			  lisp_number_to_milliseconds (resignal, 0));
 int id;
 lid = make_int (id);
 if (id != XINT (lid)) abort ();
 return lid;
 }
-DEFUN ("disable-timeout", Fdisable_timeout, Sdisable_timeout, 1, 1, 0 /*
+DEFUN ("disable-timeout", Fdisable_timeout, 1, 1, 0, /*
 Disable a timeout from signalling any more.
 ID should be a timeout id number as returned by `add-timeout'.  If ID
 corresponds to a one-shot timeout that has already signalled, nothing
 will happen.
 It will not work to call this function on an id number returned by
 `add-async-timeout'.  Use `disable-async-timeout' for that.
-*/ )
+*/
-(id)
+(id))
-Lisp_Object id;
 {
 CHECK_INT (id);
 event_stream_disable_wakeup (XINT (id), 0);
 return Qnil;
 }
-DEFUN ("add-async-timeout", Fadd_async_timeout, Sadd_async_timeout, 3, 4, 0 /*
+DEFUN ("add-async-timeout", Fadd_async_timeout, 3, 4, 0, /*
 Add an asynchronous timeout, to be signaled after an interval has elapsed.
 SECS is a number of seconds, expressed as an integer or a float.
 FUNCTION will be called after that many seconds have elapsed, with one
 argument, the given OBJECT.  If the optional RESIGNAL argument is provided,
 then after this timeout expires, `add-async-timeout' will automatically be
 to nil.
 WARNING: if you are thinking of calling `add-async-timeout' from inside of a
 callback function as a way of resignalling a timeout, think again.  There
 is a race condition.  That's why the RESIGNAL argument exists.
-*/ )
+*/
-(secs, function, object, resignal)
+(secs, function, object, resignal))
-Lisp_Object secs, function, object, resignal;
 {
 unsigned long msecs = lisp_number_to_milliseconds (secs, 0);
 unsigned long msecs2 = (NILP (resignal) ? 0 :
 			  lisp_number_to_milliseconds (resignal, 0));
 int id;
 lid = make_int (id);
 if (id != XINT (lid)) abort ();
 return lid;
 }
-DEFUN ("disable-async-timeout", Fdisable_async_timeout,
+DEFUN ("disable-async-timeout", Fdisable_async_timeout, 1, 1, 0, /*
-Sdisable_async_timeout, 1, 1, 0 /*
 Disable an asynchronous timeout from signalling any more.
 ID should be a timeout id number as returned by `add-async-timeout'.  If ID
 corresponds to a one-shot timeout that has already signalled, nothing
 will happen.
 It will not work to call this function on an id number returned by
 `add-timeout'.  Use `disable-timeout' for that.
-*/ )
+*/
-(id)
+(id))
-Lisp_Object id;
 {
 CHECK_INT (id);
 event_stream_disable_wakeup (XINT (id), 1);
 return Qnil;
 }
 /**********************************************************************/
 /*                    enqueuing and dequeuing events                  */
 /**********************************************************************/
+/* Add an event to the back of the process_event_queue */
+void
+enqueue_process_event (Lisp_Object event)
+{
+enqueue_event (event, &process_event_queue, &process_event_queue_tail);
+}
+Lisp_Object
+dequeue_process_event (void)
+{
+return dequeue_event (&process_event_queue, &process_event_queue_tail);
+}
 /* Add an event to the back of the command-event queue: it will be the next
 event read after all pending events.   This only works on keyboard,
 mouse-click, misc-user, and eval events.
 */
 XEVENT (event)->event.magic_eval.internal_function = fun;
 XEVENT (event)->event.magic_eval.object = object;
 enqueue_command_event (event);
 }
-DEFUN ("enqueue-eval-event", Fenqueue_eval_event, Senqueue_eval_event,
+DEFUN ("enqueue-eval-event", Fenqueue_eval_event, 2, 2, 0, /*
-2, 2, 0 /*
 Add an eval event to the back of the eval event queue.
 When this event is dispatched, FUNCTION (which should be a function
 of one argument) will be called with OBJECT as its argument.
 See `next-event' for a description of event types and how events
 are received.
-*/ )
+*/
-(function, object)
+(function, object))
-Lisp_Object function, object;
 {
 Lisp_Object event;
 event = Fmake_event ();
 /* the number of keyboard characters read.  callint.c wants this.
 */
 Charcount num_input_chars;
 static void
-next_event_internal (Lisp_Object target_event, int allow_queued)
+next_event_internal (Lisp_Object target_event, int allow_queued,
+int allow_deferred)
 {
 struct gcpro gcpro1;
 /* QUIT;   This is incorrect - the caller must do this because some
 	     callers (ie, Fnext_event()) do not want to QUIT. */
 Fdeallocate_event (event);
 #ifdef DEBUG_XEMACS
 if (debug_emacs_events)
 	{
 	  write_c_string ("(command event queue) ",
+			  Qexternal_debugging_output);
+	  print_internal (target_event, Qexternal_debugging_output, 1);
+	  write_c_string ("\n", Qexternal_debugging_output);
+	}
+#endif
+}
+else if (allow_deferred && !NILP (process_event_queue))
+{
+Lisp_Object event = dequeue_process_event ();
+Fcopy_event (event, target_event);
+Fdeallocate_event (event);
+#ifdef DEBUG_EMACS
+if (debug_emacs_events)
+	{
+	  write_c_string ("(process event queue) ",
 			  Qexternal_debugging_output);
 	  print_internal (target_event, Qexternal_debugging_output, 1);
 	  write_c_string ("\n", Qexternal_debugging_output);
 	}
 #endif
 static void push_this_command_keys (Lisp_Object event);
 static void push_recent_keys (Lisp_Object event);
 static void dribble_out_event (Lisp_Object event);
 static void execute_internal_event (Lisp_Object event);
-DEFUN ("next-event", Fnext_event, Snext_event, 0, 2, 0 /*
+DEFUN ("next-event", Fnext_event, 0, 2, 0, /*
 Return the next available event.
 Pass this object to `dispatch-event' to handle it.
 In most cases, you will want to use `next-command-event', which returns
 the next available \"user\" event (i.e. keypress, button-press,
 button-release, or menu selection) instead of this function.
 or by certain other conditions happening.
 -- a magic event, indicating that some window-system-specific event
 happened (such as an focus-change notification) that must be handled
 synchronously with other events.  `dispatch-event' knows what to do with
 these events.
-*/ )
+*/
-(event, prompt)
+(event, prompt))
-Lisp_Object event, prompt;
 {
 /* This function can GC */
 /* #### We start out using the selected console before an event
 is received, for echoing the partially completed command.
 This is most definitely wrong -- there needs to be a separate
 	 recent-keys. */
 else
 	{
 	  run_pre_idle_hook ();
 	  redisplay ();
-	  next_event_internal (event, 1);
+	  next_event_internal (event, 1, 1);
 	  Vquit_flag = Qnil; /* Read C-g as an event. */
 	  store_this_key = 1;
 	}
 }
 RETURN:
 UNGCPRO;
 return (event);
 }
-DEFUN ("next-command-event", Fnext_command_event, Snext_command_event,
+DEFUN ("next-command-event", Fnext_command_event, 0, 2, 0, /*
-0, 2, 0 /*
 Return the next available \"user\" event.
 Pass this object to `dispatch-event' to handle it.
 If EVENT is non-nil, it should be an event object and will be filled in
 and returned; otherwise a new event object will be created and returned.
 	                  (button-press-event-p event)
 	                  (button-release-event-p event)
 	                  (misc-user-event-p event))))
 	   (dispatch-event event))
-*/ )
+*/
-(event, prompt)
+(event, prompt))
-Lisp_Object event, prompt;
 {
 /* This function can GC */
 struct gcpro gcpro1;
 GCPRO1 (event);
 maybe_echo_keys (XCOMMAND_BUILDER
 reset_command_builder_event_chain (command_builder);
 if (EVENTP (event))
 deallocate_event_chain (event);
 }
-DEFUN ("discard-input", Fdiscard_input, Sdiscard_input, 0, 0, 0 /*
+DEFUN ("discard-input", Fdiscard_input, 0, 0, 0, /*
 Discard any pending \"user\" events.
 Also cancel any kbd macro being defined.
 A user event is a key press, button press, button release, or
 \"other-user\" event (menu selection or scrollbar action).
-*/ )
+*/
-()
+())
 {
 /* This throws away user-input on the queue, but doesn't process any
 events.  Calling dispatch_event() here leads to a race condition.
 */
 Lisp_Object event = Fmake_event ();
 || event_stream_event_pending_p (1))
 {
 /* This will take stuff off the command_event_queue, or read it
 	 from the event_stream, but it will not block.
 */
-next_event_internal (event, 1);
+next_event_internal (event, 1, 1);
 Vquit_flag = Qnil; /* Treat C-g as a user event (ignore it).
 			    It is vitally important that we reset
 			    Vquit_flag here.  Otherwise, if we're
 			    reading from a TTY console,
 			    maybe_read_quit_event() will notice
 /**********************************************************************/
 /* #### Is (accept-process-output nil 3) supposed to be like (sleep-for 3)?
 */
-DEFUN ("accept-process-output", Faccept_process_output, Saccept_process_output,
+DEFUN ("accept-process-output", Faccept_process_output, 0, 3, 0, /*
-0, 3, 0 /*
 Allow any pending output from subprocesses to be read by Emacs.
 It is read into the process' buffers or given to their filter functions.
 Non-nil arg PROCESS means do not return until some output has been received
-from PROCESS.
+from PROCESS. Nil arg PROCESS means do not return until some output has
+been received from any process.
 If the second arg is non-nil, it is the maximum number of seconds to wait:
 this function will return after that much time even if no input has arrived
 from PROCESS.  This argument may be a float, meaning wait some fractional
 part of a second.
 If the third arg is non-nil, it is a number of milliseconds that is added
 to the second arg.  (This exists only for compatibility.)
 Return non-nil iff we received any output before the timeout expired.
-*/ )
+*/
-(process, timeout_secs, timeout_msecs)
+(process, timeout_secs, timeout_msecs))
-Lisp_Object process, timeout_secs, timeout_msecs;
 {
 /* This function can GC */
 struct gcpro gcpro1, gcpro2;
 Lisp_Object event  = Qnil;
 Lisp_Object result = Qnil;
 int timeout_id;
 int timeout_enabled = 0;
+int done = 0;
 struct buffer *old_buffer = current_buffer;
 /* We preserve the current buffer but nothing else.  If a focus
 change alters the selected window then the top level event loop
 will eventually alter current_buffer to match.  In the mean time
 if (!NILP (process))
 CHECK_PROCESS (process);
 GCPRO2 (event, process);
-if (!NILP (process) && (!NILP (timeout_secs) || !NILP (timeout_msecs)))
+if (!NILP (timeout_secs) || !NILP (timeout_msecs))
 {
 unsigned long msecs = 0;
 if (!NILP (timeout_secs))
 	msecs = lisp_number_to_milliseconds (timeout_secs, 1);
 if (!NILP (timeout_msecs))
 }
 }
 event = Fmake_event ();
-while (!NILP (process)
+while (!done &&
+((NILP (process) && timeout_enabled) ||
+(NILP (process) && event_stream_event_pending_p (0)) ||
+(!NILP (process))))
 	 /* Calling detect_input_pending() is the wrong thing here, because
 	    that considers the Vunread_command_events and command_event_queue.
 	    We don't need to look at the command_event_queue because we are
 	    only interested in process events, which don't go on that.  In
 	    fact, we can't read from it anyway, because we put stuff on it.
 	    to dispatch any process events that may be on the queue.  It is
 	    not clear to me that this is important, because the top-level
 	    loop will process it, and I don't think that there is ever a
 	    time when one calls accept-process-output with a nil argument
 	    and really need the processes to be handled. */
-	 || (!EQ (result, Qt) && event_stream_event_pending_p (0)))
 {
 /* If our timeout has arrived, we move along. */
 if (timeout_enabled && !event_stream_wakeup_pending_p (timeout_id, 0))
 	{
 	  timeout_enabled = 0;
-	  process = Qnil;	/* We're  done. */
+done = 1;             /* We're  done. */
+continue;             /* Don't call next_event_internal */
 	}
 QUIT;	/* next_event_internal() does not QUIT, so check for ^G
 		   before reading output from the process - this makes it
 		   less likely that the filter will actually be aborted.
 		 */
-next_event_internal (event, 0);
+next_event_internal (event, 0, 1);
 /* If C-g was pressed while we were waiting, Vquit_flag got
 	 set and next_event_internal() also returns C-g.  When
 	 we enqueue the C-g below, it will get discarded.  The
 	 next time through, QUIT will be called and will signal a quit. */
 switch (XEVENT_TYPE (event))
 	{
 	case process_event:
 	  {
-	    if (EQ (XEVENT (event)->event.process.process, process))
+	    if (NILP (process) ||
+EQ (XEVENT (event)->event.process.process, process))
 	      {
-		process = Qnil;
+done = 1;
 		/* RMS's version always returns nil when proc is nil,
 		   and only returns t if input ever arrived on proc. */
 		result = Qt;
 	      }
 	  /* We execute the event even if it's ours, and notice that it's
 	     happened above. */
 	case pointer_motion_event:
 	case magic_event:
 {
+EXECUTE_INTERNAL:
 execute_internal_event (event);
 break;
 }
 	default:
 {
 UNGCPRO;
 current_buffer = old_buffer;
 return result;
 }
-DEFUN ("sleep-for", Fsleep_for, Ssleep_for, 1, 1, 0 /*
+DEFUN ("sleep-for", Fsleep_for, 1, 1, 0, /*
 Pause, without updating display, for ARG seconds.
 ARG may be a float, meaning pause for some fractional part of a second.
-*/ )
+*/
-(seconds)
+(seconds))
-Lisp_Object seconds;
 {
 /* This function can GC */
 unsigned long msecs = lisp_number_to_milliseconds (seconds, 1);
 int id;
 Lisp_Object event = Qnil;
 		 */
 /* We're a generator of the command_event_queue, so we can't be a
 	 consumer as well.  We don't care about command and eval-events
 	 anyway.
 */
-next_event_internal (event, 0); /* blocks */
+next_event_internal (event, 0, 0); /* blocks */
 /* See the comment in accept-process-output about Vquit_flag */
 switch (XEVENT_TYPE (event))
 	{
+case process_event:
+{
+/* Avoid calling filter functions recursively by squirreling
+away process events */
+enqueue_process_event (Fcopy_event (event, Qnil));
+goto DONE_LABEL;
+}
 	case timeout_event:
 	  /* We execute the event even if it's ours, and notice that it's
 	     happened above. */
 	case pointer_motion_event:
-	case process_event:
 	case magic_event:
 {
 EXECUTE_INTERNAL:
 execute_internal_event (event);
 break;
 Fdeallocate_event (event);
 UNGCPRO;
 return Qnil;
 }
-DEFUN ("sit-for", Fsit_for, Ssit_for, 1, 2, 0 /*
+DEFUN ("sit-for", Fsit_for, 1, 2, 0, /*
 Perform redisplay, then wait ARG seconds or until user input is available.
 ARG may be a float, meaning a fractional part of a second.
 Optional second arg non-nil means don't redisplay, just wait for input.
 Redisplay is preempted as always if user input arrives, and does not
 happen if input is available before it starts.
 Value is t if waited the full time with no input arriving.
-*/ )
+*/
-(seconds, nodisplay)
+(seconds, nodisplay))
-Lisp_Object seconds, nodisplay;
 {
 /* This function can GC */
 unsigned long msecs = lisp_number_to_milliseconds (seconds, 1);
 Lisp_Object event, result;
 struct gcpro gcpro1;
 		 */
 /* We're a generator of the command_event_queue, so we can't be a
 	 consumer as well.  In fact, we know there's nothing on the
 	 command_event_queue that we didn't just put there.
 */
-next_event_internal (event, 0); /* blocks */
+next_event_internal (event, 0, 0); /* blocks */
 /* See the comment in accept-process-output about Vquit_flag */
 if (command_event_p (event))
 	{
 	  result = Qnil;
 	  {
 	    /* eval-events get delayed until later. */
 	    enqueue_command_event (Fcopy_event (event, Qnil));
 	    break;
 	  }
+case process_event:
+{
+/* Avoid recursive calls to process filters */
+enqueue_process_event (Fcopy_event (event, Qnil));
+break;
+}
 	case timeout_event:
 	  /* We execute the event even if it's ours, and notice that it's
 	     happened above. */
 	default:
 	  {
 /* We're a generator of the command_event_queue, so we can't be a
 	 consumer as well.  Also, we have no reason to consult the
 	 command_event_queue; there are only user and eval-events there,
 	 and we'd just have to put them back anyway.
 */
-next_event_internal (event, 0);
+next_event_internal (event, 0, 1);
 /* See the comment in accept-process-output about Vquit_flag */
 if (command_event_p (event)
 || (XEVENT_TYPE (event) == eval_event)
 	  || (XEVENT_TYPE (event) == magic_eval_event))
 enqueue_command_event_1 (event);
 		    get a SIGCHLD). */
 		 || (readstatus == -1 && errno == EIO)
 #endif
 		 )
 	  {
-	    /* Currently, we rely on SIGCHLD to indicate that
+	    /* Currently, we rely on SIGCHLD to indicate that the
-	       the process has terminated.  Unfortunately, it
+	       process has terminated.  Unfortunately, on some systems
-	       appears that on some systems the SIGCHLD gets
+	       the SIGCHLD gets missed some of the time.  So we put an
-	       missed some of the time.  So, we put in am
+	       additional check in status_notify() to see whether a
-	       additional check in status_notify() to see
+	       process has terminated.  We must tell status_notify()
-	       whether a process has terminated.  We have to
+	       to enable that check, and we do so now. */
-	       tell status_notify() to enable that check, and
-	       we do so now. */
 	    kick_status_notify ();
 	  }
 	else
 	  {
 	    /* Deactivate network connection */
 #define RECENT_KEYS_SIZE 100
 Lisp_Object recent_keys_ring;
 int recent_keys_ring_index;
-DEFUN ("recent-keys", Frecent_keys, Srecent_keys, 0, 0, 0 /*
+DEFUN ("recent-keys", Frecent_keys, 0, 0, 0, /*
 Return vector of last 100 or so keyboard or mouse button events read.
 This copies the event objects into a new vector; it is safe to keep and
 modify them.
-*/ )
+*/
-()
+())
 {
 struct gcpro gcpro1;
 Lisp_Object val = Qnil;
 int size = XVECTOR (recent_keys_ring)->size;
 int start, nkeys, i, j;
 #### There should be a cleaner way of handling this. */
 call0 (Qauto_show_make_point_visible);
 }
-DEFUN ("dispatch-event", Fdispatch_event, Sdispatch_event, 1, 1, 0 /*
+DEFUN ("dispatch-event", Fdispatch_event, 1, 1, 0, /*
 Given an event object as returned by `next-event', execute it.
 Key-press, button-press, and button-release events get accumulated
 until a complete key sequence (see `read-key-sequence') is reached,
 at which point the sequence is looked up in the current keymaps and
 Process events cause the subprocess's output to be read and acted upon
 appropriately (see `start-process').
 Magic events are handled as necessary.
-*/ )
+*/
-(event)
+(event))
-Lisp_Object event;
 {
 /* This function can GC */
 struct command_builder *command_builder;
 struct Lisp_Event *ev;
 Lisp_Object console;
 }
 }
 return (Qnil);
 }
-DEFUN ("read-key-sequence", Fread_key_sequence, Sread_key_sequence, 1, 3, 0 /*
+DEFUN ("read-key-sequence", Fread_key_sequence, 1, 3, 0, /*
 Read a sequence of keystrokes or mouse clicks.
 Returns a vector of the event objects read.  The vector and the event
 objects it contains are freshly created (and will not be side-effected
 by subsequent calls to this function).
 related function.
 `read-key-sequence' checks `function-key-map' for function key
 sequences, where they wouldn't conflict with ordinary bindings.  See
 `function-key-map' for more details.
-*/ )
+*/
-(prompt, continue_echo, dont_downcase_last)
+(prompt, continue_echo, dont_downcase_last))
-Lisp_Object prompt, continue_echo, dont_downcase_last;
 {
 /* This function can GC */
 struct console *con = XCONSOLE (Vselected_console); /* #### correct?
 							 Probably not -- see
 							 comment in
 Vquit_flag = Qnil;  /* In case we read a ^G; do not call check_quit() here */
 Fdeallocate_event (event);
 RETURN_UNGCPRO (unbind_to (speccount, result));
 }
-DEFUN ("this-command-keys", Fthis_command_keys, Sthis_command_keys, 0, 0, 0 /*
+DEFUN ("this-command-keys", Fthis_command_keys, 0, 0, 0, /*
 Return a vector of the keyboard or mouse button events that were used
 to invoke this command.  This copies the vector and the events; it is safe
 to keep and modify them.
-*/ )
+*/
-()
+())
 {
 Lisp_Object event;
 Lisp_Object result;
 int len;
 EVENT_CHAIN_LOOP (event, Vthis_command_keys)
 vector_data (XVECTOR (result))[len++] = Fcopy_event (event, Qnil);
 return (result);
 }
-DEFUN ("reset-this-command-lengths", Freset_this_command_lengths,
+DEFUN ("reset-this-command-lengths", Freset_this_command_lengths, 0, 0, 0, /*
-Sreset_this_command_lengths, 0, 0, 0 /*
 Used for complicated reasons in `universal-argument-other-key'.
 `universal-argument-other-key' rereads the event just typed.
 It then gets translated through `function-key-map'.
 The translated event gets included in the echo area and in
 That is not right.
 Calling this function directs the translated event to replace
 the original event, so that only one version of the event actually
 appears in the echo area and in the value of `this-command-keys.'.
-*/ )
+*/
-()
+())
 {
 /* #### I don't understand this at all, so currently it does nothing.
 If there is ever a problem, maybe someone should investigate. */
 return Qnil;
 }
 else
 Fprinc (event, Vdribble_file);
 Lstream_flush (XLSTREAM (Vdribble_file));
 }
-DEFUN ("open-dribble-file", Fopen_dribble_file, Sopen_dribble_file, 1, 1,
+DEFUN ("open-dribble-file", Fopen_dribble_file, 1, 1,
-"FOpen dribble file: " /*
+"FOpen dribble file: ", /*
 Start writing all keyboard characters to a dribble file called FILE.
 If FILE is nil, close any open dribble file.
-*/ )
+*/
-(file)
+(file))
-Lisp_Object file;
 {
 /* This function can GC */
 /* XEmacs change: always close existing dribble file. */
 /* FSFmacs uses FILE *'s here.  With lstreams, that's unnecessary. */
 if (!NILP (Vdribble_file))
 deferror (&Qundefined_keystroke_sequence, "undefined-keystroke-sequence",
 "Undefined keystroke sequence", Qerror);
 defsymbol (&Qcommand_execute, "command-execute");
-defsubr (&Srecent_keys);
+DEFSUBR (Frecent_keys);
-defsubr (&Sinput_pending_p);
+DEFSUBR (Finput_pending_p);
-defsubr (&Senqueue_eval_event);
+DEFSUBR (Fenqueue_eval_event);
-defsubr (&Snext_event);
+DEFSUBR (Fnext_event);
-defsubr (&Snext_command_event);
+DEFSUBR (Fnext_command_event);
-defsubr (&Sdiscard_input);
+DEFSUBR (Fdiscard_input);
-defsubr (&Ssit_for);
+DEFSUBR (Fsit_for);
-defsubr (&Ssleep_for);
+DEFSUBR (Fsleep_for);
-defsubr (&Saccept_process_output);
+DEFSUBR (Faccept_process_output);
-defsubr (&Sadd_timeout);
+DEFSUBR (Fadd_timeout);
-defsubr (&Sdisable_timeout);
+DEFSUBR (Fdisable_timeout);
-defsubr (&Sadd_async_timeout);
+DEFSUBR (Fadd_async_timeout);
-defsubr (&Sdisable_async_timeout);
+DEFSUBR (Fdisable_async_timeout);
-defsubr (&Sdispatch_event);
+DEFSUBR (Fdispatch_event);
-defsubr (&Sread_key_sequence);
+DEFSUBR (Fread_key_sequence);
-defsubr (&Sthis_command_keys);
+DEFSUBR (Fthis_command_keys);
-defsubr (&Sreset_this_command_lengths);
+DEFSUBR (Freset_this_command_lengths);
-defsubr (&Sopen_dribble_file);
+DEFSUBR (Fopen_dribble_file);
 defsymbol (&Qpre_command_hook, "pre-command-hook");
 defsymbol (&Qpost_command_hook, "post-command-hook");
 defsymbol (&Qunread_command_events, "unread-command-events");
 defsymbol (&Qunread_command_event, "unread-command-event");
 num_input_chars = 0;
 command_event_queue = Qnil;
 staticpro (&command_event_queue);
 command_event_queue_tail = Qnil;
+process_event_queue = Qnil;
+staticpro (&process_event_queue);
+process_event_queue_tail = Qnil;
 Vlast_selected_frame = Qnil;
 staticpro (&Vlast_selected_frame);
 pending_timeout_list = Qnil;

Mercurial > hg > xemacs-beta

comparison src/event-stream.c @ 20:859a2309aef8 r19-15b93