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

comparison src/event-stream.c @ 771:943eaba38521

[xemacs-hg @ 2002-03-13 08:51:24 by ben] The big ben-mule-21-5 check-in! Various files were added and deleted. See CHANGES-ben-mule. There are still some test suite failures. No crashes, though. Many of the failures have to do with problems in the test suite itself rather than in the actual code. I'll be addressing these in the next day or so -- none of the test suite failures are at all critical. Meanwhile I'll be trying to address the biggest issues -- i.e. build or run failures, which will almost certainly happen on various platforms. All comments should be sent to ben@xemacs.org -- use a Cc: if necessary when sending to mailing lists. There will be pre- and post- tags, something like pre-ben-mule-21-5-merge-in, and post-ben-mule-21-5-merge-in.

author	ben
date	Wed, 13 Mar 2002 08:54:06 +0000
parents	516c347c4479
children	026c5bf9c134

comparison

equal deleted inserted replaced

-:336a418893b5
+:943eaba38521
 /* The portable interface to event streams.
 Copyright (C) 1991, 1992, 1993, 1994, 1995 Free Software Foundation, Inc.
 Copyright (C) 1995 Board of Trustees, University of Illinois.
 Copyright (C) 1995 Sun Microsystems, Inc.
-Copyright (C) 1995, 1996 Ben Wing.
+Copyright (C) 1995, 1996, 2001, 2002 Ben Wing.
 This file is part of XEmacs.
 XEmacs is free software; you can redistribute it and/or modify it
 under the terms of the GNU General Public License as published by the
 #include "sysdep.h"		/* init_poll_for_quit() */
 #include "syssignal.h"		/* SIGCHLD, etc. */
 #include "sysfile.h"
 #include "systime.h"		/* to set Vlast_input_time */
-#ifdef FILE_CODING
 #include "file-coding.h"
-#endif
 #include <errno.h>
 /* The number of keystrokes between auto-saves. */
 static Fixnum auto_save_interval;
 /* If control-meta-super-shift-X is undefined, try control-meta-super-x */
 Lisp_Object Vretry_undefined_key_binding_unshifted;
 Lisp_Object Qretry_undefined_key_binding_unshifted;
-#ifdef HAVE_XIM
+#ifdef MULE
 /* If composed input is undefined, use self-insert-char */
 Lisp_Object Vcomposed_character_default_binding;
-#endif /* HAVE_XIM */
+#endif
 /* Console that corresponds to our controlling terminal */
 Lisp_Object Vcontrolling_terminal;
 /* An event (actually an event chain linked through event_next) or Qnil.
 /**********************************************************************/
 #define XCOMMAND_BUILDER(x) \
 XRECORD (x, command_builder, struct command_builder)
 #define XSETCOMMAND_BUILDER(x, p) XSETRECORD (x, p, command_builder)
+#define wrap_command_builder(p) wrap_record (p, command_builder)
 #define COMMAND_BUILDERP(x) RECORDP (x, command_builder)
 #define CHECK_COMMAND_BUILDER(x) CHECK_RECORD (x, command_builder)
+#define CONCHECK_COMMAND_BUILDER(x) CONCHECK_RECORD (x, command_builder)
+static Lisp_Object Vcommand_builder_free_list;
 static Lisp_Object
 mark_command_builder (Lisp_Object obj)
 {
 struct command_builder *builder = XCOMMAND_BUILDER (obj);
-mark_object (builder->prefix_events);
 mark_object (builder->current_events);
 mark_object (builder->most_current_event);
 mark_object (builder->last_non_munged_event);
 mark_object (builder->munge_me[0].first_mungeable_event);
 mark_object (builder->munge_me[1].first_mungeable_event);
 static void
 finalize_command_builder (void *header, int for_disksave)
 {
 if (!for_disksave)
 {
-xfree (((struct command_builder *) header)->echo_buf);
+struct command_builder *b = (struct command_builder *) header;
-((struct command_builder *) header)->echo_buf = 0;
+if (b->echo_buf)
+	{
+	  xfree (b->echo_buf);
+	  b->echo_buf = 0;
+	}
 }
 }
 DEFINE_LRECORD_IMPLEMENTATION ("command-builder", command_builder,
 mark_command_builder, internal_object_printer,
 			       finalize_command_builder, 0, 0, 0,
 			       struct command_builder);
 static void
 reset_command_builder_event_chain (struct command_builder *builder)
 {
-builder->prefix_events = Qnil;
 builder->current_events = Qnil;
 builder->most_current_event = Qnil;
 builder->last_non_munged_event = Qnil;
 builder->munge_me[0].first_mungeable_event = Qnil;
 builder->munge_me[1].first_mungeable_event = Qnil;
 }
 Lisp_Object
-allocate_command_builder (Lisp_Object console)
+allocate_command_builder (Lisp_Object console, int with_echo_buf)
 {
-Lisp_Object builder_obj;
+Lisp_Object builder_obj =
-struct command_builder *builder =
+allocate_managed_lcrecord (Vcommand_builder_free_list);
-alloc_lcrecord_type (struct command_builder, &lrecord_command_builder);
+struct command_builder *builder = XCOMMAND_BUILDER (builder_obj);
 builder->console = console;
 reset_command_builder_event_chain (builder);
-builder->echo_buf_length = 300; /* #### Kludge */
+if (with_echo_buf)
-builder->echo_buf = xnew_array (Intbyte, builder->echo_buf_length);
+{
-builder->echo_buf[0] = 0;
+/* #### This badly needs to be turned into a Dynarr */
-builder->echo_buf_index = -1;
+builder->echo_buf_length = 300; /* #### Kludge */
+builder->echo_buf = xnew_array (Intbyte, builder->echo_buf_length);
+builder->echo_buf[0] = 0;
+}
+else
+{
+builder->echo_buf_length = 0;
+builder->echo_buf = NULL;
+}
 builder->echo_buf_index = -1;
 builder->self_insert_countdown = 0;
-XSETCOMMAND_BUILDER (builder_obj, builder);
 return builder_obj;
+}
+/* Copy or clone COLLAPSING (copy to NEW_BUILDINGS if non-zero,
+otherwise clone); but don't copy the echo-buf stuff. (The calling
+routines don't need it and will reset it, and we would rather avoid
+malloc.) */
+static Lisp_Object
+copy_command_builder (struct command_builder *collapsing,
+		      struct command_builder *new_buildings)
+{
+if (!new_buildings)
+new_buildings = XCOMMAND_BUILDER (allocate_command_builder (Qnil, 0));
+new_buildings->self_insert_countdown = collapsing->self_insert_countdown;
+deallocate_event_chain (new_buildings->current_events);
+new_buildings->current_events =
+copy_event_chain (collapsing->current_events);
+new_buildings->most_current_event =
+transfer_event_chain_pointer (collapsing->most_current_event,
+				  collapsing->current_events,
+				  new_buildings->current_events);
+new_buildings->last_non_munged_event =
+transfer_event_chain_pointer (collapsing->last_non_munged_event,
+				  collapsing->current_events,
+				  new_buildings->current_events);
+new_buildings->munge_me[0].first_mungeable_event =
+transfer_event_chain_pointer (collapsing->munge_me[0].
+				  first_mungeable_event,
+				  collapsing->current_events,
+				  new_buildings->current_events);
+new_buildings->munge_me[1].first_mungeable_event =
+transfer_event_chain_pointer (collapsing->munge_me[1].
+				  first_mungeable_event,
+				  collapsing->current_events,
+				  new_buildings->current_events);
+return wrap_command_builder (new_buildings);
+}
+static void
+free_command_builder (struct command_builder *builder)
+{
+if (builder->echo_buf)
+{
+xfree (builder->echo_buf);
+builder->echo_buf = NULL;
+}
+free_managed_lcrecord (Vcommand_builder_free_list,
+			 wrap_command_builder (builder));
 }
 static void
 command_builder_append_event (struct command_builder *builder,
 			      Lisp_Object event)
 {
 assert (EVENTP (event));
+event = Fcopy_event (event, Qnil);
 if (EVENTP (builder->most_current_event))
 XSET_EVENT_NEXT (builder->most_current_event, event);
 else
 builder->current_events = event;
 {
 return event_stream && event_stream->event_pending_p (user);
 }
 static void
-event_stream_force_event_pending (struct frame* f)
+event_stream_force_event_pending (struct frame *f)
 {
 if (event_stream->force_event_pending)
 event_stream->force_event_pending (f);
 }
 {
 int ch = CONSOLE_QUIT_CHAR (con);
 sigint_happened = 0;
 Vquit_flag = Qnil;
 character_to_event (ch, event, con, 1, 1);
-event->channel = make_console (con);
+event->channel = wrap_console (con);
 return 1;
 }
 return 0;
 }
 set_process_selected_p (proc, 0);
 }
 }
 USID
-event_stream_create_stream_pair (void* inhandle, void* outhandle,
+event_stream_create_stream_pair (void *inhandle, void *outhandle,
-		Lisp_Object* instream, Lisp_Object* outstream, int flags)
+		Lisp_Object *instream, Lisp_Object *outstream, int flags)
 {
 check_event_stream_ok (EVENT_STREAM_PROCESS);
 return event_stream->create_stream_pair_cb
 		(inhandle, outhandle, instream, outstream, flags);
 }
 if (STRINGP (help))
 internal_with_output_to_temp_buffer (build_string ("*Help*"),
 					 print_help, help, Qnil);
 Fnext_command_event (event, Qnil);
 /* Remove the help from the frame */
-unbind_to (speccount, Qnil);
+unbind_to (speccount);
 /* Hmmmm.  Tricky.  The unbind restores an old window configuration,
 apparently bypassing any setting of windows_structure_changed.
 So we need to set it so that things get redrawn properly. */
 /* #### This is massive overkill.  Look at doing it better once the
 new redisplay is fully in place. */
 	  /* Do an unwind-protect in case an error occurs in
 	     the deselect-frame-hook */
 	  count = specpdl_depth ();
 	  record_unwind_protect (cleanup_after_missed_defocusing, frame);
 	  run_deselect_frame_hook ();
-	  unbind_to (count, Qnil);
+	  unbind_to (count);
 	  /* the cleanup method changed the focus frame to nil, so
 	     we need to reflect this */
 	  focus_frame = Qnil;
 	}
 else
 break;
 	  }
 	}
 }
-unbind_to (count, timeout_enabled ? make_int (timeout_id) : Qnil);
+unbind_to_1 (count, timeout_enabled ? make_int (timeout_id) : Qnil);
 Fdeallocate_event (event);
 UNGCPRO;
 current_buffer = old_buffer;
 return result;
 break;
 }
 	}
 }
 DONE_LABEL:
-unbind_to (count, make_int (id));
+unbind_to_1 (count, make_int (id));
 Fdeallocate_event (event);
 UNGCPRO;
 return Qnil;
 }
 	  }
 	}
 }
 DONE_LABEL:
-unbind_to (count, make_int (id));
+unbind_to_1 (count, make_int (id));
 /* Put back the event (if any) that made Fsit_for() exit before the
 timeout.  Note that it is being added to the back of the queue, which
 would be inappropriate if there were any user events on the queue
 already: we would be misordering them.  But we know that there are
 return event_binding (event0, 1);
 }
 /* See if we can do function-key-map or key-translation-map translation
 on the current events in the command builder.  If so, do this, and
-return the resulting binding, if any. */
+return the resulting binding, if any.
+DID_MUNGE must be initialized before calling this function.  If munging
+happened, DID_MUNGE will be non-zero; otherwise, it will be left alone.
+*/
 static Lisp_Object
 munge_keymap_translate (struct command_builder *builder,
 			enum munge_me_out_the_door munge,
-			int has_normal_binding_p)
+			int has_normal_binding_p, int *did_munge)
 {
 Lisp_Object suffix;
 EVENT_CHAIN_LOOP (suffix, builder->munge_me[munge].first_mungeable_event)
 {
 if (VECTORP (result) || STRINGP (result))
 	{
 	  Lisp_Object new_chain = key_sequence_to_event_chain (result);
 	  Lisp_Object tempev;
-	  int n, tckn;
+	  int n;
 	  /* If the first_mungeable_event of the other munger is
 	     within the events we're munging, then it will point to
 	     deallocated events afterwards, which is bad -- so make it
 	     point at the beginning of the munged events. */
 		  *mungeable_event = new_chain;
 		  break;
 		}
 	    }
+	  /* Now munge the current event chain in the command builder. */
 	  n = event_chain_count (suffix);
 	  command_builder_replace_suffix (builder, suffix, new_chain);
 	  builder->munge_me[munge].first_mungeable_event = Qnil;
-	  /* Now hork this-command-keys as well. */
+	  *did_munge = 1;
-	  /* We just assume that the events we just replaced are
-	     sitting in copied form at the end of this-command-keys.
-	     If the user did weird things with `dispatch-event' this
-	     may not be the case, but at least we make sure we won't
-	     crash. */
-	  new_chain = copy_event_chain (new_chain);
-	  tckn = event_chain_count (Vthis_command_keys);
-	  if (tckn >= n)
-	    {
-	      this_command_keys_replace_suffix
-		(event_chain_nth (Vthis_command_keys, tckn - n),
-		 new_chain);
-	    }
 	  result = command_builder_find_leaf_1 (builder);
 	  return result;
 	}
 }
 return Qnil;
 }
-/* Compare the current state of the command builder against the local and
+/* Same as command_builder_find_leaf() below but no Russian C-x
-global keymaps, and return the binding.  If there is no match, try again,
+processing and no defaulting to self-insert-command.
-case-insensitively.  The return value will be one of:
--- nil (there is no binding)
--- a keymap (part of a command has been specified)
--- a command (anything that satisfies `commandp'; this includes
-some symbols, lists, subrs, strings, vectors, and
-		    compiled-function objects)
 */
 static Lisp_Object
-command_builder_find_leaf (struct command_builder *builder,
+command_builder_find_leaf_no_mule_processing (struct command_builder *builder,
-int allow_misc_user_events_p)
+					      int allow_misc_user_events_p,
+					      int *did_munge)
 {
 /* This function can GC */
 Lisp_Object result;
 Lisp_Object evee = builder->current_events;
 }
 /* if we're currently in a menu accelerator, check there for further
 events */
 /* #### fuck me!  who wrote this crap?  think "abstraction", baby. */
+/* #### this horribly-written crap can mess with global state, which
+this function should not do.  i'm not fixing it now.  someone
+needs to go and rewrite that shit correctly. --ben */
 #if defined(HAVE_X_WINDOWS) && defined(LWLIB_MENUBARS_LUCID)
 if (x_kludge_lw_menu_active ())
 {
 return command_builder_operate_menu_accelerator (builder);
 }
 }
 #endif
 /* Check to see if we have a potential function-key-map match. */
 if (NILP (result))
-{
+result = munge_keymap_translate (builder, MUNGE_ME_FUNCTION_KEY, 0,
-result = munge_keymap_translate (builder, MUNGE_ME_FUNCTION_KEY, 0);
+				     did_munge);
-regenerate_echo_keys_from_this_command_keys (builder);
-}
 /* Check to see if we have a potential key-translation-map match. */
 {
 Lisp_Object key_translate_result =
 munge_keymap_translate (builder, MUNGE_ME_KEY_TRANSLATION,
-			      !NILP (result));
+			      !NILP (result), did_munge);
 if (!NILP (key_translate_result))
-{
+result = key_translate_result;
-	result = key_translate_result;
-	regenerate_echo_keys_from_this_command_keys (builder);
-}
 }
 if (!NILP (result))
 return result;
 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;
+struct key_data *key = &XEVENT (terminal)->event.key;
 Emchar c = 0;
 if ((key->modifiers & XEMACS_MOD_SHIFT)
 || (CHAR_OR_CHAR_INTP (key->keysym)
-&& ((c = XCHAR_OR_CHAR_INT (key->keysym)), c >= 'A' && c <= 'Z')))
+&& ((c = XCHAR_OR_CHAR_INT (key->keysym)),
+		  c >= 'A' && c <= 'Z')))
 {
-Lisp_Event terminal_copy = *XEVENT (terminal);
+	  Lisp_Object neubauten = copy_command_builder (builder, 0);
+	  struct command_builder *neub = XCOMMAND_BUILDER (neubauten);
+	  struct gcpro gcpro1;
+	  GCPRO1 (neubauten);
+terminal = event_chain_tail (neub->current_events);
+	  key = &XEVENT (terminal)->event.key;
 if (key->modifiers & XEMACS_MOD_SHIFT)
 key->modifiers &= (~ XEMACS_MOD_SHIFT);
 else
 key->keysym = make_char (c + 'a' - 'A');
-result = command_builder_find_leaf (builder, allow_misc_user_events_p);
+result =
+	    command_builder_find_leaf_no_mule_processing
+	      (neub, allow_misc_user_events_p, did_munge);
 if (!NILP (result))
+	    {
+	      copy_command_builder (neub, builder);
+	      *did_munge = 1;
+	    }
+	  free_command_builder (neub);
+	  UNGCPRO;
+	  if (!NILP (result))
 return result;
-/* If there was no match with the lower-case version either,
-then put back the upper-case event for the error
-message.  But make sure that function-key-map didn't
-change things out from under us. */
-if (EQ (terminal, builder->most_current_event))
-*XEVENT (terminal) = terminal_copy;
 }
 }
 /* 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;
-#ifdef HAVE_XIM
+return Qnil;
+}
+/* Compare the current state of the command builder against the local and
+global keymaps, and return the binding.  If there is no match, try again,
+case-insensitively.  The return value will be one of:
+-- nil (there is no binding)
+-- a keymap (part of a command has been specified)
+-- a command (anything that satisfies `commandp'; this includes
+some symbols, lists, subrs, strings, vectors, and
+		    compiled-function objects)
+This may "munge" the current event chain in the command builder;
+i.e.  the sequence might be mutated into a different sequence,
+which we then pretend is what the user actually typed instead of
+the passed-in sequence.  This happens as a result of:
+-- key-translation-map changes
+-- function-key-map changes
+-- retry-undefined-key-binding-unshifted (q.v.)
+-- "Russian C-x problem" changes (see definition of struct key_data,
+events.h)
+DID_MUNGE must be initialized before calling this function.  If munging
+happened, DID_MUNGE will be non-zero; otherwise, it will be left alone.
+*/
+static Lisp_Object
+command_builder_find_leaf (struct command_builder *builder,
+			   int allow_misc_user_events_p,
+			   int *did_munge)
+{
+Lisp_Object result =
+command_builder_find_leaf_no_mule_processing
+(builder, allow_misc_user_events_p, did_munge);
+if (!NILP (result))
+return result;
+#ifdef MULE
+/* #### Do Russian C-x processing here */
 /* 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;
+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 */
+#endif
-/* 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;
-}
 return Qnil;
 }
+/* Like command_builder_find_leaf but update this-command-keys and the
+echo area as necessary when the current event chain was munged. */
+static Lisp_Object
+command_builder_find_leaf_and_update_global_state (struct command_builder *
+						   builder,
+						   int
+						   allow_misc_user_events_p)
+{
+int did_munge = 0;
+int orig_length = event_chain_count (builder->current_events);
+Lisp_Object result = command_builder_find_leaf (builder,
+						  allow_misc_user_events_p,
+						  &did_munge);
+if (did_munge)
+{
+int tck_length = event_chain_count (Vthis_command_keys);
+/* We just assume that the events we just replaced are
+	 sitting in copied form at the end of this-command-keys.
+	 If the user did weird things with `dispatch-event' this
+	 may not be the case, but at least we make sure we won't
+	 crash. */
+if (tck_length >= orig_length)
+	{
+	  Lisp_Object new_chain =
+	    copy_event_chain (builder->current_events);
+	  this_command_keys_replace_suffix
+	    (event_chain_nth (Vthis_command_keys, tck_length - orig_length),
+	     new_chain);
+	  regenerate_echo_keys_from_this_command_keys (builder);
+	}
+}
+if (NILP (result))
+{
+/* 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;
+	}
+}
+return result;
+}
 /* Every time a command-event (a key, button, or menu selection) is read by
 Fnext_event(), it is stored in the recent_keys_ring, in Vlast_input_event,
 and in Vthis_command_keys.  (Eval-events are not stored there.)
 	}
 	regenerate_echo_keys_from_this_command_keys (command_builder);
 }
 else
-{
+command_builder_append_event (command_builder, event);
-	event = Fcopy_event (event, Fmake_event (Qnil, Qnil));
-	command_builder_append_event (command_builder, event);
-}
 }
 {
-Lisp_Object leaf = command_builder_find_leaf (command_builder,
+Lisp_Object leaf =
-allow_misc_user_events_p);
+command_builder_find_leaf_and_update_global_state
+	(command_builder,
+	 allow_misc_user_events_p);
 struct gcpro gcpro1;
 GCPRO1 (leaf);
 if (KEYMAPP (leaf))
 {
 	    /* if quit happened during menu acceleration, pretend we read it */
 	    struct console *con = XCONSOLE (Fselected_console ());
 	    int ch = CONSOLE_QUIT_CHAR (con);
 	    character_to_event (ch, e, con, 1, 1);
-	    e->channel = make_console (con);
+	    e->channel = wrap_console (con);
 	    enqueue_command_event (quit_event);
 	    Vquit_flag = Qnil;
 	  }
 }
 	   reset the echoing state, and don't go into keyboard macros unless
 	   followed by another command.  Also don't quit here.  */
 	int speccount = specpdl_depth ();
 	specbind (Qinhibit_quit, Qt);
 	maybe_echo_keys (command_builder, 0);
-	unbind_to (speccount, Qnil);
+	unbind_to (speccount);
 	/* If we're recording a keyboard macro, and the last command
 	   executed set a prefix argument, then decrement the pointer to
 	   the "last character really in the macro" to be just before this
 	   command.  This is so that the ^U in "^U ^X )" doesn't go onto
 	/* Emacs 18 doesn't unconditionally clear the echoed keystrokes,
 	   so we don't either */
 	if (!is_scrollbar_event (event))
-	  reset_this_command_keys (CONSOLE_LIVE_P (con) ? make_console (con)
+	  reset_this_command_keys (CONSOLE_LIVE_P (con) ? wrap_console (con)
 				   : Qnil, 0);
 }
 }
 UNGCPRO;
 		/* Temporarily pretend the last event was an "up" instead of a
 		   "down", and look up its binding. */
 		XEVENT_TYPE (terminal) = button_release_event;
 		/* If the "up" version is bound, don't complain. */
 		no_bitching
-		  = !NILP (command_builder_find_leaf (command_builder, 0));
+		  = !NILP (command_builder_find_leaf_and_update_global_state
+			   (command_builder, 0));
 		/* Undo the temporary changes we just made. */
 		XEVENT_TYPE (terminal) = button_press_event;
 		if (no_bitching)
 		  {
 		    /* Pretend this press was not seen (treat as a prefix) */
 CHECK_STRING (prompt);
 /* else prompt = Fkeymap_prompt (current_buffer->keymap); may GC */
 QUIT;
 if (NILP (continue_echo))
-reset_this_command_keys (make_console (con), 1);
+reset_this_command_keys (wrap_console (con), 1);
 specbind (Qinhibit_quit, Qt);
 if (!NILP (dont_downcase_last))
 specbind (Qretry_undefined_key_binding_unshifted, Qnil);
 	}
 }
 Vquit_flag = Qnil;  /* In case we read a ^G; do not call check_quit() here */
 Fdeallocate_event (event);
-RETURN_UNGCPRO (unbind_to (speccount, result));
+RETURN_UNGCPRO (unbind_to_1 (speccount, result));
 }
 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
 if (!NILP (filename))
 {
 int fd;
 filename = Fexpand_file_name (filename, Qnil);
-fd = open ((char*) XSTRING_DATA (filename),
+fd = qxe_open (XSTRING_DATA (filename),
-		 O_WRONLY | O_TRUNC | O_CREAT | OPEN_BINARY,
+		     O_WRONLY | O_TRUNC | O_CREAT | OPEN_BINARY,
-		 CREAT_MODE);
+		     CREAT_MODE);
 if (fd < 0)
 	report_file_error ("Unable to create dribble file", filename);
 Vdribble_file = make_filedesc_output_stream (fd, 0, 0, LSTR_CLOSING);
 #ifdef MULE
 Vdribble_file =
-	make_encoding_output_stream (XLSTREAM (Vdribble_file),
+	make_coding_output_stream
-				     Fget_coding_system (Qescape_quoted));
+	  (XLSTREAM (Vdribble_file),
+	   Qescape_quoted, CODING_ENCODE);
 #endif
 }
 return Qnil;
 }
 recent_keys_ring_size = 100;
 num_input_chars = 0;
 Vtimeout_free_list = make_lcrecord_list (sizeof (Lisp_Timeout),
 					   &lrecord_timeout);
 staticpro_nodump (&Vtimeout_free_list);
+Vcommand_builder_free_list =
+make_lcrecord_list (sizeof (struct command_builder),
+			&lrecord_command_builder);
+staticpro_nodump (&Vcommand_builder_free_list);
 the_low_level_timeout_blocktype =
 Blocktype_new (struct low_level_timeout_blocktype);
 something_happened = 0;
 recursive_sit_for = Qnil;
 }
 This variable has no effect when `modifier-keys-are-sticky' is nil.
 Currently only implemented under X Window System.
 */ );
 Vmodifier_keys_sticky_time = make_int (500);
-#ifdef HAVE_XIM
+#ifdef MULE
 DEFVAR_LISP ("composed-character-default-binding",
 &Vcomposed_character_default_binding /*
 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.
 */ );
 Vcomposed_character_default_binding = Qself_insert_command;
-#endif /* HAVE_XIM */
+#endif
 Vcontrolling_terminal = Qnil;
 staticpro (&Vcontrolling_terminal);
 Vdribble_file = Qnil;
 DEFVAR_BOOL ("inhibit-input-event-recording", &inhibit_input_event_recording /*
 Non-nil inhibits recording of input-events to recent-keys ring.
 */ );
 inhibit_input_event_recording = 0;
-}
-void
-complex_vars_of_event_stream (void)
-{
 Vkeyboard_translate_table =
 make_lisp_hash_table (100, HASH_TABLE_NON_WEAK, HASH_TABLE_EQ);
 }
 void

Mercurial > hg > xemacs-beta

comparison src/event-stream.c @ 771:943eaba38521