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

comparison src/event-stream.c @ 173:8eaf7971accc r20-3b13

Import from CVS: tag r20-3b13

author	cvs
date	Mon, 13 Aug 2007 09:49:09 +0200
parents	15872534500d
children	2d532a89d707

comparison

equal deleted inserted replaced

-:a38aed19690b
+:8eaf7971accc
 /* The value of point when the last command was executed.  */
 Bufpos last_point_position;
 /* The frame that was current when the last command was started. */
 Lisp_Object Vlast_selected_frame;
 /* The buffer that was current when the last command was started.  */
 Lisp_Object last_point_position_buffer;
 /* A (16bit . 16bit) representation of the time of the last-command-event.
 */
 Lisp_Object Vlast_input_time;
 /* Character to recognize as the help char.  */
 			  builder is for */
 /* Qnil, or a Lisp_Event representing the first event read
 *  after the last command completed.  Threaded. */
 /* #### NYI */
 Lisp_Object prefix_events;
 /* Qnil, or a Lisp_Event representing event in the current
 *  keymap-lookup sequence.  Subsequent events are threaded via
 *  the event's next slot */
 Lisp_Object current_events;
 /* Last elt of above  */
 Lisp_Object most_current_event;
 clear_echo_area (selected_frame (), Qnil, 0);
 }
 format_event_object (buf, XEVENT (event), 1);
 len = strlen (buf);
 if (len + buf_index + 4 > command_builder->echo_buf_length)
 return;
 e = command_builder->echo_buf + buf_index;
 memcpy (e, buf, len);
 e += len;
 struct frame *f = selected_frame ();
 /* Message turns off echoing unless more keystrokes turn it on again. */
 if (echo_area_active (f) && !EQ (Qcommand, echo_area_status (f)))
 return;
 if (minibuf_level == 0
 && echo_keystrokes > 0)
 {
 if (!no_snooze)
 	{
 	  /* #### C-g here will cause QUIT.  Setting dont_check_for_quit
 void
 record_auto_save (void)
 {
 keystrokes_since_auto_save = 0;
 }
 /* Make an auto save happen as soon as possible at command level.  */
 void
 force_auto_save_soon (void)
 {
 EVENT_CHAIN_LOOP (event, command_event_queue)
 	{
 	  if (XEVENT_TYPE (event) != eval_event
 	      && XEVENT_TYPE (event) != magic_eval_event)
-	    return (1);
+	    return 1;
 	}
 }
 return 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);
+return detect_input_pending () ? Qt : Qnil;
 }
 /**********************************************************************/
 /*                            timeouts                                */
 void
 remove_low_level_timeout (struct low_level_timeout **timeout_list, int id)
 {
 struct low_level_timeout *t, *prev;
 /* find it */
 for (t = *timeout_list, prev = NULL; t && t->id != id; t = t->next)
 prev = t;
 if (!t)
 return; /* couldn't find it */
 if (!prev)
 *timeout_list = t->next;
 if (!timeout_list) /* no timer events; block indefinitely */
 return 0;
 else
 {
 EMACS_TIME current_time;
 /* The time to block is the difference between the first
 	 (earliest) timer on the queue and the current time.
 	 If that is negative, then the timer will fire immediately
 	 but we still have to call select(), with a zero-valued
 	 timeout: user events must have precedence over timer events. */
 /* We make sure to snarf the data out of the timeout object before
 we free it with free_managed_opaque(). */
 id = timeout->id;
 *function = timeout->function;
 *object = timeout->object;
 /* Remove this one from the list of pending timeouts */
 *timeout_list = delq_no_quit_and_free_cons (op, *timeout_list);
 /* If this timeout wants to be resignalled, do it now. */
 if (timeout->resignal_msecs)
 	 list, which is a good thing. */
 *timeout_list = noseeum_cons (op, *timeout_list);
 }
 else
 free_managed_opaque (Vtimeout_free_list, op);
 UNGCPRO;
 return id;
 }
 void
 	}
 }
 }
 /* Called from the window-system-specific code when we receive a
 notification that the focus lies on a particular frame.
 Argument is a cons: (frame . (device . in-p)) where in-p is non-nil
 for focus-in.
 */
 void
 emacs_handle_focus_change_final (Lisp_Object frame_inp_and_dev)
 in_single_console_state (void)
 {
 return in_single_console;
 }
 /* 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)
 assert (NILP (XEVENT_NEXT (target_event)));
 GCPRO1 (target_event);
 investigate_frame_change ();
 if (allow_queued && !NILP (command_event_queue))
 {
 Lisp_Object event = dequeue_command_event ();
 Fcopy_event (event, target_event);
 Fdeallocate_event (event);
 	  Lisp_Object tristan, isolde;
 	  e->event.timeout.id_number =
 	    event_stream_resignal_wakeup (e->event.timeout.interval_id, 0,
 					  &tristan, &isolde);
 	  e->event.timeout.function = tristan;
 	  e->event.timeout.object = isolde;
 #ifdef DEBUG_XEMACS
 	  /* next_event_internal() doesn't print out timeout events
 	     because of the extra info we just set. */
 */
 else if (!NILP (Vunread_command_event))
 {
 Lisp_Object e = Vunread_command_event;
 Vunread_command_event = Qnil;
 if (!EVENTP (e) || !command_event_p (e))
 	{
 	  signal_error (Qwrong_type_argument,
 			list3 (Qeventp, e, Qunread_command_event));
 	}
 	  print_internal (event, Qexternal_debugging_output, 1);
 	  write_c_string ("\n", Qexternal_debugging_output);
 	}
 #endif
 }
 /* If we're executing a keyboard macro, take the next event from that,
 and update this-command-keys and recent-keys.
 Note that the unread-command-events take precedence over kbd macros.
 */
 else
 Vlast_input_event = Fmake_event ();
 error ("Someone deallocated last-input-event!");
 }
 if (! EQ (event, Vlast_input_event))
 Fcopy_event (event, Vlast_input_event);
 /* last-input-char and last-input-time are derived from
 last-input-event.
 Note that last-input-char will never have its high-bit set, in an
 effort to sidestep the ambiguity between M-x and oslash.
 */
 event_matches_key_specifier_p (XEVENT (event), Vhelp_char))
 execute_help_form (command_builder, event);
 RETURN:
 UNGCPRO;
-return (event);
+return event;
 }
 DEFUN ("next-command-event", Fnext_command_event, 0, 2, 0, /*
 Return the next available \"user\" event.
 Pass this object to `dispatch-event' to handle it.
 break;
 else
 execute_internal_event (event);
 }
 UNGCPRO;
-return (event);
+return event;
 }
 static void
 reset_current_events (struct command_builder *command_builder)
 {
 /* This is used in accept-process-output, sleep-for and sit-for.
 Before running any process_events in these routines, we set
 recursive_sit_for to Qt, and use this unwind protect to reset it to
 Qnil upon exit.  When recursive_sit_for is Qt, calling sit-for will
 cause it to return immediately.
 All of these routines install timeouts, so we clear the installed
 timeout as well.
 Note: It's very easy to break the desired behaviours of these
 3 routines.  If you make any changes to anything in this area, run
 the regression tests at the bottom of the file.  -- dmoore */
 static Lisp_Object
 sit_for_unwind (Lisp_Object timeout_id)
 {
 if (!NILP(timeout_id))
 {
 /* This function can GC */
 struct gcpro gcpro1, gcpro2;
 Lisp_Object event  = Qnil;
 Lisp_Object result = Qnil;
-int timeout_id;
+int timeout_id = -1;
 int timeout_enabled = 0;
 int done = 0;
 struct buffer *old_buffer = current_buffer;
 int count;
 if (!NILP (command_event_queue))
 {
 EVENT_CHAIN_LOOP (event, command_event_queue)
 	{
 	  if (command_event_p (event))
-	    return (Qnil);
+	    return Qnil;
 	}
 }
 /* If we're in a macro, or noninteractive, or early in temacs, then
 don't wait. */
 if (noninteractive || !NILP (Vexecuting_macro))
-return (Qnil);
+return Qnil;
 /* Recusive call from a filter function or timeout handler. */
 if (!NILP(recursive_sit_for))
 {
 if (!event_stream_event_pending_p (1) && NILP (nodisplay))
 	  {
 	    /* eval-events get delayed until later. */
 	    enqueue_command_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:
 	  {
 enqueue_command_event (event);
 else
 Fdeallocate_event (event);
 UNGCPRO;
-return (result);
+return result;
 }
 /* This handy little function is used by xselect.c and energize.c to
 wait for replies from processes that aren't really processes (that is,
 the X server and the Energize server).
 /* events on dead channels get silently eaten */
 if (object_dead_p (XEVENT (event)->channel))
 return;
 /* This function can GC */
 switch (XEVENT_TYPE (event))
 {
 case empty_event:
 return;
 case eval_event:
 {
 	call1 (XEVENT (event)->event.eval.function,
 	       XEVENT (event)->event.eval.object);
 	return;
 }
 case magic_eval_event:
 #endif /* EWOULDBLOCK */
 #ifdef EAGAIN
 	else if (readstatus == -1 && errno == EAGAIN)
 	  ;
 #endif /* EAGAIN */
 	else if ((readstatus == 0 &&
 		  /* Note that we cannot distinguish between no input
 		     available now and a closed pipe.
 		     With luck, a closed pipe will be accompanied by
 		     subprocess termination and SIGCHLD.  */
 		  (!network_connection_p (p) ||
 command_builder_find_leaf_1 (struct command_builder *builder)
 {
 Lisp_Object event0 = builder->current_events;
 if (NILP (event0))
-return (Qnil);
+return Qnil;
 return event_binding (event0, 1);
 }
 /* See if we can do function-key-map or key-translation-map translation
 munge_keymap_translate (struct command_builder *builder,
 			enum munge_me_out_the_door munge,
 			int has_normal_binding_p)
 {
 Lisp_Object suffix;
 EVENT_CHAIN_LOOP (suffix, builder->munge_me[munge].first_mungeable_event)
 {
 Lisp_Object result = munging_key_map_event_binding (suffix, munge);
 if (!NILP (result))
 	{
 	  if (KEYMAPP (result))
 	    {
 	      if (NILP (builder->last_non_munged_event)
 	    UNGCPRO;
 	  }
 	  if (KEYMAPP (result))
 	    return result;
 	  if (VECTORP (result) || STRINGP (result))
 	    {
 	      Lisp_Object new_chain =
 		key_sequence_to_event_chain (result);
 	      Lisp_Object tempev;
 && (NILP (XEVENT_NEXT (evee)))
 && (XEVENT_TYPE (evee) == misc_user_event))
 {
 Lisp_Object fn  = XEVENT (evee)->event.eval.function;
 Lisp_Object arg = XEVENT (evee)->event.eval.object;
-return (list2 (fn, arg));
+return list2 (fn, arg);
 }
 else if (XEVENT_TYPE (evee) == misc_user_event)
 return Qnil;
 if (XEVENT_TYPE (builder->most_current_event) == key_press_event
 && !NILP (Vretry_undefined_key_binding_unshifted))
 {
 Lisp_Object terminal = builder->most_current_event;
 struct key_data* key = & XEVENT (terminal)->event.key;
-Emchar c;
+Emchar c = 0;
 if ((key->modifiers & MOD_SHIFT)
 || (CHAR_OR_CHAR_INTP (key->keysym)
 && ((c = XCHAR_OR_CHAR_INT (key->keysym)), c >= 'A' && c <= 'Z')))
 {
 struct Lisp_Event terminal_copy = *XEVENT (terminal);
 if (key->modifiers & MOD_SHIFT)
 key->modifiers &= (~ MOD_SHIFT);
 else
 key->keysym = make_char (c + 'a' - 'A');
 /* help-char is `auto-bound' in every keymap */
 if (!NILP (Vprefix_help_command) &&
 event_matches_key_specifier_p (XEVENT (builder->most_current_event),
 				     Vhelp_char))
-return (Vprefix_help_command);
+return Vprefix_help_command;
 #ifdef HAVE_XIM
 /* If keysym is a non-ASCII char, bind it to self-insert-char by default. */
 if (XEVENT_TYPE (builder->most_current_event) == key_press_event
 && !NILP (Vcomposed_character_default_binding))
 Lisp_Object keysym = XEVENT (builder->most_current_event)->event.key.keysym;
 if (CHARP (keysym) && !CHAR_ASCII_P (XCHAR (keysym)))
 return Vcomposed_character_default_binding;
 }
 #endif /* HAVE_XIM */
 /* If we read extra events attempting to match a function key but end
 up failing, then we release those events back to the command loop
 and fail on the original lookup.  The released events will then be
 reprocessed in the context of the first part having failed. */
 if (!NILP (builder->last_non_munged_event))
 {
 Lisp_Object event0 = builder->last_non_munged_event;
 /* Put the commands back on the event queue. */
 enqueue_event_chain (XEVENT_NEXT (event0),
 			   &command_event_queue,
 			   &command_event_queue_tail);
 /* Then remove them from the command builder. */
 XSET_EVENT_NEXT (event0, Qnil);
 builder->most_current_event = event0;
 builder->last_non_munged_event = Qnil;
 }
 Every time a command is invoked, Vlast_command_event is set to the last
 event in the sequence.
 This means that Vthis_command_keys is really about "input read since the
 last command was executed" rather than about "what keys invoked this
 command."  This is a little counterintuitive, but that's the way it
 has always worked.
 As an extra kink, the function read-key-sequence resets/updates the
 last-command-event and this-command-keys.  It doesn't append to the
 command-keys as read-char does.  Such are the pitfalls of having to
 Vrecent_keys_ring = make_vector (recent_keys_ring_size, Qnil);
 /* And return nothing in particular. */
 return make_vector (0, Qnil);
 }
-if (NILP (vector_data (XVECTOR (Vrecent_keys_ring))[recent_keys_ring_index]))
+if (NILP (XVECTOR_DATA (Vrecent_keys_ring)[recent_keys_ring_index]))
 /* This means the vector has not yet wrapped */
 {
 nkeys = recent_keys_ring_index;
 start = 0;
 }
 val = make_vector (nwanted, Qnil);
 for (i = 0, j = start; i < nkeys; i++)
 {
-Lisp_Object e = vector_data (XVECTOR (Vrecent_keys_ring))[j];
+Lisp_Object e = XVECTOR_DATA (Vrecent_keys_ring)[j];
 if (NILP (e))
 abort ();
-vector_data (XVECTOR (val))[i] = Fcopy_event (e, Qnil);
+XVECTOR_DATA (val)[i] = Fcopy_event (e, Qnil);
 if (++j >= recent_keys_ring_size)
 j = 0;
 }
 UNGCPRO;
-return (val);
+return val;
 }
 DEFUN ("recent-keys-ring-size", Frecent_keys_ring_size, 0, 0, 0, /*
 The maximum number of events `recent-keys' can return.
 {
 Vrecent_keys_ring = new_vector;
 return size;
 }
-if (NILP (vector_data (XVECTOR (Vrecent_keys_ring))[recent_keys_ring_index]))
+if (NILP (XVECTOR_DATA (Vrecent_keys_ring)[recent_keys_ring_index]))
 /* This means the vector has not yet wrapped */
 {
 nkeys = recent_keys_ring_index;
 start = 0;
 }
 else
 min = XINT (size);
 for (i = 0, j = start; i < min; i++)
 {
-vector_data (XVECTOR (new_vector))[i]
+XVECTOR_DATA (new_vector)[i] = XVECTOR_DATA (Vrecent_keys_ring)[j];
-	= vector_data (XVECTOR (Vrecent_keys_ring))[j];
 if (++j >= recent_keys_ring_size)
 	j = 0;
 }
 recent_keys_ring_size = XINT (size);
 recent_keys_ring_index = (i < recent_keys_ring_size) ? i : 0;
 Lisp_Object
 extract_vector_nth_mouse_event (Lisp_Object vector, int n)
 {
 int i;
+int len = XVECTOR_LENGTH (vector);
-for (i = 0; i < vector_length (XVECTOR (vector)); i++)
-{
+for (i = 0; i < len; i++)
-Lisp_Object event = vector_data (XVECTOR (vector))[i];
+{
-if (EVENTP (event)
+Lisp_Object event = XVECTOR_DATA (vector)[i];
-	  && (XEVENT_TYPE (event) == button_press_event
+if (EVENTP (event))
-	      || XEVENT_TYPE (event) == button_release_event
+	switch (XEVENT_TYPE (event))
-	      || XEVENT_TYPE (event) == misc_user_event))
+	  {
-	{
+	  case button_press_event :
-	  if (!n)
+	  case button_release_event :
-	    return event;
+	  case misc_user_event :
-	  n--;
+	    if (n == 0)
-	}
+	      return event;
+	    n--;
+	    break;
+	  default:
+	    continue;
+	  }
 }
 return Qnil;
 }
 Lisp_Object e;
 if (NILP (Vrecent_keys_ring))
 Vrecent_keys_ring = make_vector (recent_keys_ring_size, Qnil);
-e = vector_data (XVECTOR (Vrecent_keys_ring)) [recent_keys_ring_index];
+e = XVECTOR_DATA (Vrecent_keys_ring) [recent_keys_ring_index];
 if (NILP (e))
 {
 e = Fmake_event ();
-vector_data (XVECTOR (Vrecent_keys_ring)) [recent_keys_ring_index] = e;
+XVECTOR_DATA (Vrecent_keys_ring) [recent_keys_ring_index] = e;
 }
 Fcopy_event (event, e);
 if (++recent_keys_ring_index == recent_keys_ring_size)
 recent_keys_ring_index = 0;
 }
 /*  No need to copy the events, since they're already copies, and
 nobody other than the command-builder has pointers to them */
 vector = make_vector (n, Qnil);
 n = 0;
 EVENT_CHAIN_LOOP (event, command_builder->current_events)
-vector_data (XVECTOR (vector))[n++] = event;
+XVECTOR_DATA (vector)[n++] = event;
 reset_command_builder_event_chain (command_builder);
-return (vector);
+return vector;
 }
 /*
 Given the current state of the command builder and a new command event
 	   */
 	Fcopy_event (event, recent);
 	e = XEVENT (recent);
 	if (e->event_type == key_press_event)
 	  e->event.key.modifiers |= MOD_META;
 	else if (e->event_type == button_press_event
 		 || e->event_type == button_release_event)
 	  e->event.button.modifiers |= MOD_META;
 	else
 	  abort ();
 if (XEVENT (Vlast_command_event)->event_type == dead_event)
 {
 Vlast_command_event = Fmake_event ();
 error ("Someone deallocated the last-command-event!");
 }
 if (! EQ (event, Vlast_command_event))
 Fcopy_event (event, Vlast_command_event);
 /* Note that last-command-char will never have its high-bit set, in
 an effort to sidestep the ambiguity between M-x and oslash.
 pre_command_hook ();
 if (XEVENT (event)->event_type == misc_user_event)
 {
 	call1 (XEVENT (event)->event.eval.function,
 	       XEVENT (event)->event.eval.object);
 }
 else
 {
 #if 0
 /* ### This doesn't really fix the problem,
 if delete-frame is called by some hook */
 if (NILP (win))
 return;
 #endif
 if (! zmacs_region_stays
 && (!MINI_WINDOW_P (XWINDOW (win))
 || EQ (zmacs_region_buffer (), WINDOW_BUFFER (XWINDOW (win)))))
 zmacs_deactivate_region ();
 else
 console = Vselected_console;
 else if (!EQ (console, Vselected_console))
 Fselect_console (console);
 command_builder = XCOMMAND_BUILDER (XCONSOLE (console)->command_builder);
 switch (XEVENT (event)->event_type)
 {
 case button_press_event:
 case button_release_event:
 case key_press_event:
 {
 	       kind of sequence that warrants a complaint.
 	       */
 	    XCONSOLE (console)->defining_kbd_macro = Qnil;
 	    XCONSOLE (console)->prefix_arg = Qnil;
 	    /* Don't complain about undefined button-release events */
 	    if (XEVENT_TYPE (terminal) != button_release_event)
 	      {
 		Lisp_Object keys =
 		  current_events_into_vector (command_builder);
 		struct gcpro gcpro1;
 {
 	execute_internal_event (event);
 	break;
 }
 }
-return (Qnil);
+return Qnil;
 }
 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
 Lisp_Object event;
 Lisp_Object result;
 int len;
 if (NILP (Vthis_command_keys))
-return (make_vector (0, Qnil));
+return make_vector (0, Qnil);
 len = event_chain_count (Vthis_command_keys);
 result = make_vector (len, Qnil);
 len = 0;
 EVENT_CHAIN_LOOP (event, Vthis_command_keys)
-vector_data (XVECTOR (result))[len++] = Fcopy_event (event, Qnil);
+XVECTOR_DATA (result)[len++] = Fcopy_event (event, Qnil);
-return (result);
+return result;
 }
 DEFUN ("reset-this-command-lengths", Freset_this_command_lengths, 0, 0, 0, /*
 Used for complicated reasons in `universal-argument-other-key'.
 if (CHARP (XEVENT (event)->event.key.keysym))
 	{
 	  Emchar ch = XCHAR (keysym);
 	  Bufbyte str[MAX_EMCHAR_LEN];
 	  Bytecount len;
 	  len = set_charptr_emchar (str, ch);
 	  Lstream_write (XLSTREAM (Vdribble_file), str, len);
 	}
 else if (string_char_length (XSYMBOL (keysym)->name) == 1)
 	/* one-char key events are printed with just the key name */
 Vthis_command_keys = Qnil;
 staticpro (&Vthis_command_keys);
 Vthis_command_keys_tail = Qnil;
 num_input_chars = 0;
 command_event_queue = Qnil;
 staticpro (&command_event_queue);
 command_event_queue_tail = Qnil;
 Vlast_selected_frame = Qnil;
 */ );
 Vretry_undefined_key_binding_unshifted = Qt;
 #ifdef HAVE_XIM
 DEFVAR_LISP ("Vcomposed_character_default_binding",
 &Vretry_undefined_key_binding_unshifted /*
 The default keybinding to use for key events from composed input.
 Window systems frequently have ways to allow the user to compose
 single characters in a language using multiple keystrokes.
 XEmacs sees these as single character keypress events.
 */ );

Mercurial > hg > xemacs-beta

comparison src/event-stream.c @ 173:8eaf7971accc r20-3b13