X-Git-Url: http://git.chise.org/gitweb/?a=blobdiff_plain;f=src%2Fevents.c;h=325be1e0425ccfd06bd01997775603e23d51cddc;hb=4f29597e4f3696a59bb08ffece07183c1568c4a5;hp=57270376d7b6437150e955c67847f72d72533fd3;hpb=6883ee56ec887c2c48abe5b06b5e66aa74031910;p=chise%2Fxemacs-chise.git-

diff --git a/src/events.c b/src/events.c
index 5727037..325be1e 100644
--- a/src/events.c
+++ b/src/events.c
@@ -37,17 +37,6 @@ Boston, MA 02111-1307, USA.  */
 #include "keymap.h" /* for key_desc_list_to_event() */
 #include "redisplay.h"
 #include "window.h"
-
-#ifdef WINDOWSNT
-/* Hmm, under unix we want X modifiers, under NT we want X modifiers if
-   we are running X and Windows modifiers otherwise.
-   gak. This is a kludge until we support multiple native GUIs!
-*/
-#undef MOD_ALT
-#undef MOD_CONTROL
-#undef MOD_SHIFT
-#endif
-
 #include "events-mod.h"
 
 /* Where old events go when they are explicitly deallocated.
@@ -81,51 +70,51 @@ static void
 deinitialize_event (Lisp_Object ev)
 {
   int i;
-  struct Lisp_Event *event = XEVENT (ev);
+  Lisp_Event *event = XEVENT (ev);
 
-  for (i = 0; i < (int) (sizeof (struct Lisp_Event) / sizeof (int)); i++)
+  for (i = 0; i < (int) (sizeof (Lisp_Event) / sizeof (int)); i++)
     ((int *) event) [i] = 0xdeadbeef;
   event->event_type = dead_event;
   event->channel = Qnil;
-  set_lheader_implementation (&(event->lheader), lrecord_event);
+  set_lheader_implementation (&event->lheader, &lrecord_event);
   XSET_EVENT_NEXT (ev, Qnil);
 }
 
 /* Set everything to zero or nil so that it's predictable. */
 void
-zero_event (struct Lisp_Event *e)
+zero_event (Lisp_Event *e)
 {
   xzero (*e);
-  set_lheader_implementation (&(e->lheader), lrecord_event);
+  set_lheader_implementation (&e->lheader, &lrecord_event);
   e->event_type = empty_event;
   e->next = Qnil;
   e->channel = Qnil;
 }
 
 static Lisp_Object
-mark_event (Lisp_Object obj, void (*markobj) (Lisp_Object))
+mark_event (Lisp_Object obj)
 {
-  struct Lisp_Event *event = XEVENT (obj);
+  Lisp_Event *event = XEVENT (obj);
 
   switch (event->event_type)
     {
     case key_press_event:
-      ((markobj) (event->event.key.keysym));
+      mark_object (event->event.key.keysym);
       break;
     case process_event:
-      ((markobj) (event->event.process.process));
+      mark_object (event->event.process.process);
       break;
     case timeout_event:
-      ((markobj) (event->event.timeout.function));
-      ((markobj) (event->event.timeout.object));
+      mark_object (event->event.timeout.function);
+      mark_object (event->event.timeout.object);
       break;
     case eval_event:
     case misc_user_event:
-      ((markobj) (event->event.eval.function));
-      ((markobj) (event->event.eval.object));
+      mark_object (event->event.eval.function);
+      mark_object (event->event.eval.object);
       break;
     case magic_eval_event:
-      ((markobj) (event->event.magic_eval.object));
+      mark_object (event->event.magic_eval.object);
       break;
     case button_press_event:
     case button_release_event:
@@ -137,12 +126,12 @@ mark_event (Lisp_Object obj, void (*markobj) (Lisp_Object))
     default:
       abort ();
     }
-  ((markobj) (event->channel));
+  mark_object (event->channel);
   return event->next;
 }
 
 static void
-print_event_1 (CONST char *str, Lisp_Object obj, Lisp_Object printcharfun)
+print_event_1 (const char *str, Lisp_Object obj, Lisp_Object printcharfun)
 {
   char buf[255];
   write_c_string (str, printcharfun);
@@ -154,7 +143,7 @@ static void
 print_event (Lisp_Object obj, Lisp_Object printcharfun, int escapeflag)
 {
   if (print_readably)
-    error ("printing unreadable object #<event>");
+    error ("Printing unreadable object #<event>");
 
   switch (XEVENT (obj)->event_type)
     {
@@ -179,7 +168,7 @@ print_event (Lisp_Object obj, Lisp_Object printcharfun, int escapeflag)
 	assert (INTP (Vx));
 	Vy = Fevent_y_pixel (obj);
 	assert (INTP (Vy));
-	sprintf (buf, "#<motion-event %ld, %ld", (long)(XINT (Vx)), (long)(XINT (Vy)));
+	sprintf (buf, "#<motion-event %ld, %ld", (long) XINT (Vx), (long) XINT (Vy));
 	write_c_string (buf, printcharfun);
 	break;
       }
@@ -219,16 +208,18 @@ print_event (Lisp_Object obj, Lisp_Object printcharfun, int escapeflag)
 }
 
 static int
-event_equal (Lisp_Object o1, Lisp_Object o2, int depth)
+event_equal (Lisp_Object obj1, Lisp_Object obj2, int depth)
 {
-  struct Lisp_Event *e1 = XEVENT (o1);
-  struct Lisp_Event *e2 = XEVENT (o2);
+  Lisp_Event *e1 = XEVENT (obj1);
+  Lisp_Event *e2 = XEVENT (obj2);
 
   if (e1->event_type != e2->event_type) return 0;
   if (!EQ (e1->channel, e2->channel)) return 0;
 /*  if (e1->timestamp != e2->timestamp) return 0; */
   switch (e1->event_type)
     {
+    default: abort ();
+
     case process_event:
       return EQ (e1->event.process.process, e2->event.process.process);
 
@@ -284,32 +275,29 @@ event_equal (Lisp_Object o1, Lisp_Object o2, int depth)
 #endif
 #ifdef HAVE_TTY
 	if (CONSOLE_TTY_P (con))
-	return (e1->event.magic.underlying_tty_event ==
-		e2->event.magic.underlying_tty_event);
+	  return (e1->event.magic.underlying_tty_event ==
+		  e2->event.magic.underlying_tty_event);
 #endif
 #ifdef HAVE_MS_WINDOWS
 	if (CONSOLE_MSWINDOWS_P (con))
-	return (!memcmp(&e1->event.magic.underlying_mswindows_event,
-		&e2->event.magic.underlying_mswindows_event,
-		sizeof(union magic_data)));
+	  return (!memcmp(&e1->event.magic.underlying_mswindows_event,
+			  &e2->event.magic.underlying_mswindows_event,
+			  sizeof (union magic_data)));
 #endif
+	abort ();
 	return 1; /* not reached */
       }
 
     case empty_event:      /* Empty and deallocated events are equal. */
     case dead_event:
       return 1;
-
-    default:
-      abort ();
-      return 0;                 /* not reached; warning suppression */
     }
 }
 
 static unsigned long
 event_hash (Lisp_Object obj, int depth)
 {
-  struct Lisp_Event *e = XEVENT (obj);
+  Lisp_Event *e = XEVENT (obj);
   unsigned long hash;
 
   hash = HASH2 (e->event_type, LISP_HASH (e->channel));
@@ -362,6 +350,8 @@ event_hash (Lisp_Object obj, int depth)
 	if (CONSOLE_MSWINDOWS_P (con))
 	  return HASH2 (hash, e->event.magic.underlying_mswindows_event);
 #endif
+	abort ();
+	return 0;
       }
 
     case empty_event:
@@ -377,7 +367,7 @@ event_hash (Lisp_Object obj, int depth)
 
 DEFINE_BASIC_LRECORD_IMPLEMENTATION ("event", event,
 				     mark_event, print_event, 0, event_equal,
-				     event_hash, struct Lisp_Event);
+				     event_hash, 0, Lisp_Event);
 
 
 DEFUN ("make-event", Fmake_event, 0, 2, 0, /*
@@ -430,7 +420,7 @@ WARNING: the event object returned may be a reused one; see the function
 {
   Lisp_Object tail, keyword, value;
   Lisp_Object event = Qnil;
-  struct Lisp_Event *e;
+  Lisp_Event *e;
   EMACS_INT coord_x = 0, coord_y = 0;
   struct gcpro gcpro1;
 
@@ -512,90 +502,109 @@ WARNING: the event object returned may be a reused one; see the function
 	}
       else if (EQ (keyword, Qkey))
 	{
-	  if (e->event_type != key_press_event)
-	    WRONG_EVENT_TYPE_FOR_PROPERTY (type, keyword);
-	  if (!SYMBOLP (value) && !CHARP (value))
-	    signal_simple_error ("Invalid event key", value);
-	  e->event.key.keysym = value;
+	  switch (e->event_type)
+	    {
+	    case key_press_event:
+	      if (!SYMBOLP (value) && !CHARP (value))
+		signal_simple_error ("Invalid event key", value);
+	      e->event.key.keysym = value;
+	      break;
+	    default:
+	      WRONG_EVENT_TYPE_FOR_PROPERTY (type, keyword);
+	      break;
+	    }
 	}
       else if (EQ (keyword, Qbutton))
 	{
-	  if (e->event_type != button_press_event
-	      && e->event_type != button_release_event
-	      && e->event_type != misc_user_event)
+	  CHECK_NATNUM (value);
+	  check_int_range (XINT (value), 0, 7);
+
+	  switch (e->event_type)
 	    {
+	    case button_press_event:
+	    case button_release_event:
+	      e->event.button.button = XINT (value);
+	      break;
+	    case misc_user_event:
+	      e->event.misc.button = XINT (value);
+	      break;
+	    default:
 	      WRONG_EVENT_TYPE_FOR_PROPERTY (type, keyword);
+	      break;
 	    }
-	  CHECK_NATNUM (value);
-	  check_int_range (XINT (value), 0, 7);
-	  if (e->event_type == misc_user_event)
-	    e->event.misc.button = XINT (value);
-	  else
-	    e->event.button.button = XINT (value);
 	}
       else if (EQ (keyword, Qmodifiers))
 	{
-	  Lisp_Object modtail;
 	  int modifiers = 0;
+	  Lisp_Object sym;
 
-	  if (e->event_type != key_press_event
-	      && e->event_type != button_press_event
-	      && e->event_type != button_release_event
-	      && e->event_type != pointer_motion_event
-	      && e->event_type != misc_user_event)
+	  EXTERNAL_LIST_LOOP_2 (sym, value)
 	    {
-	      WRONG_EVENT_TYPE_FOR_PROPERTY (type, keyword);
+	      if      (EQ (sym, Qcontrol)) modifiers |= XEMACS_MOD_CONTROL;
+	      else if (EQ (sym, Qmeta))    modifiers |= XEMACS_MOD_META;
+	      else if (EQ (sym, Qsuper))   modifiers |= XEMACS_MOD_SUPER;
+	      else if (EQ (sym, Qhyper))   modifiers |= XEMACS_MOD_HYPER;
+	      else if (EQ (sym, Qalt))     modifiers |= XEMACS_MOD_ALT;
+	      else if (EQ (sym, Qsymbol))  modifiers |= XEMACS_MOD_ALT;
+	      else if (EQ (sym, Qshift))   modifiers |= XEMACS_MOD_SHIFT;
+	      else
+		signal_simple_error ("Invalid key modifier", sym);
 	    }
 
-	  EXTERNAL_LIST_LOOP (modtail, value)
+	  switch (e->event_type)
 	    {
-	      Lisp_Object sym = XCAR (modtail);
-	      if (EQ (sym, Qcontrol))      modifiers |= MOD_CONTROL;
-	      else if (EQ (sym, Qmeta))    modifiers |= MOD_META;
-	      else if (EQ (sym, Qsuper))   modifiers |= MOD_SUPER;
-	      else if (EQ (sym, Qhyper))   modifiers |= MOD_HYPER;
-	      else if (EQ (sym, Qalt))     modifiers |= MOD_ALT;
-	      else if (EQ (sym, Qsymbol))  modifiers |= MOD_ALT;
-	      else if (EQ (sym, Qshift))   modifiers |= MOD_SHIFT;
-	      else
-		signal_simple_error ("Invalid key modifier", sym);
+	    case key_press_event:
+	      e->event.key.modifiers = modifiers;
+	      break;
+	    case button_press_event:
+	    case button_release_event:
+	      e->event.button.modifiers = modifiers;
+	      break;
+	    case pointer_motion_event:
+	      e->event.motion.modifiers = modifiers;
+	      break;
+	    case misc_user_event:
+	      e->event.misc.modifiers = modifiers;
+	      break;
+	    default:
+	      WRONG_EVENT_TYPE_FOR_PROPERTY (type, keyword);
+	      break;
 	    }
-	  if (e->event_type == key_press_event)
-	    e->event.key.modifiers = modifiers;
-	  else if (e->event_type == button_press_event
-		   || e->event_type == button_release_event)
-	    e->event.button.modifiers = modifiers;
-	  else if (e->event_type == pointer_motion_event)
-	    e->event.motion.modifiers = modifiers;
-	  else /* misc_user_event */
-	    e->event.misc.modifiers = modifiers;
 	}
       else if (EQ (keyword, Qx))
 	{
-	  if (e->event_type != pointer_motion_event
-	      && e->event_type != button_press_event
-	      && e->event_type != button_release_event
-	      && e->event_type != misc_user_event)
+	  switch (e->event_type)
 	    {
+	    case pointer_motion_event:
+	    case button_press_event:
+	    case button_release_event:
+	    case misc_user_event:
+	      /* Allow negative values, so we can specify toolbar
+		 positions.  */
+	      CHECK_INT (value);
+	      coord_x = XINT (value);
+	      break;
+	    default:
 	      WRONG_EVENT_TYPE_FOR_PROPERTY (type, keyword);
+	      break;
 	    }
-	  /* Allow negative values, so we can specify toolbar
-             positions.  */
-	  CHECK_INT (value);
-	  coord_x = XINT (value);
 	}
       else if (EQ (keyword, Qy))
 	{
-	  if (e->event_type != pointer_motion_event
-	      && e->event_type != button_press_event
-	      && e->event_type != button_release_event
-	      && e->event_type != misc_user_event)
+	  switch (e->event_type)
 	    {
+	    case pointer_motion_event:
+	    case button_press_event:
+	    case button_release_event:
+	    case misc_user_event:
+	      /* Allow negative values; see above. */
+	      CHECK_INT (value);
+	      coord_y = XINT (value);
+	      break;
+	    default:
 	      WRONG_EVENT_TYPE_FOR_PROPERTY (type, keyword);
+	      break;
 	    }
-	  /* Allow negative values; see above. */
-	  CHECK_INT (value);
-	  coord_y = XINT (value);
 	}
       else if (EQ (keyword, Qtimestamp))
 	{
@@ -604,15 +613,27 @@ WARNING: the event object returned may be a reused one; see the function
 	}
       else if (EQ (keyword, Qfunction))
 	{
-	  if (e->event_type != misc_user_event)
-	    WRONG_EVENT_TYPE_FOR_PROPERTY (type, keyword);
-	  e->event.eval.function = value;
+	  switch (e->event_type)
+	    {
+	    case misc_user_event:
+	      e->event.eval.function = value;
+	      break;
+	    default:
+	      WRONG_EVENT_TYPE_FOR_PROPERTY (type, keyword);
+	      break;
+	    }
 	}
       else if (EQ (keyword, Qobject))
 	{
-	  if (e->event_type != misc_user_event)
-	    WRONG_EVENT_TYPE_FOR_PROPERTY (type, keyword);
-	  e->event.eval.object = value;
+	  switch (e->event_type)
+	    {
+	    case misc_user_event:
+	      e->event.eval.object = value;
+	      break;
+	    default:
+	      WRONG_EVENT_TYPE_FOR_PROPERTY (type, keyword);
+	      break;
+	    }
 	}
       else
 	signal_simple_error_2 ("Invalid property", keyword, value);
@@ -629,31 +650,28 @@ WARNING: the event object returned may be a reused one; see the function
 
   /* Fevent_properties, Fevent_x_pixel, etc. work with pixels relative
      to the frame, so we must adjust accordingly.  */
-  if (e->event_type == pointer_motion_event
-      || e->event_type == button_press_event
-      || e->event_type == button_release_event
-      || e->event_type == misc_user_event)
+  if (FRAMEP (EVENT_CHANNEL (e)))
     {
-      struct frame *f = XFRAME (EVENT_CHANNEL (e));
+      coord_x += FRAME_REAL_LEFT_TOOLBAR_WIDTH (XFRAME (EVENT_CHANNEL (e)));
+      coord_y += FRAME_REAL_TOP_TOOLBAR_HEIGHT (XFRAME (EVENT_CHANNEL (e)));
 
-      coord_x += FRAME_REAL_LEFT_TOOLBAR_WIDTH (f);
-      coord_y += FRAME_REAL_TOP_TOOLBAR_HEIGHT (f);
-
-      if (e->event_type == pointer_motion_event)
+      switch (e->event_type)
 	{
+	case pointer_motion_event:
 	  e->event.motion.x = coord_x;
 	  e->event.motion.y = coord_y;
-	}
-      else if (e->event_type == button_press_event
-	       || e->event_type == button_release_event)
-	{
+	  break;
+	case button_press_event:
+	case button_release_event:
 	  e->event.button.x = coord_x;
 	  e->event.button.y = coord_y;
-	}
-      else if (e->event_type == misc_user_event)
-	{
+	  break;
+	case misc_user_event:
 	  e->event.misc.x = coord_x;
 	  e->event.misc.y = coord_y;
+	  break;
+	default:
+	  abort();
 	}
     }
 
@@ -661,20 +679,20 @@ WARNING: the event object returned may be a reused one; see the function
   switch (e->event_type)
     {
     case key_press_event:
-      if (UNBOUNDP (e->event.key.keysym)
-	  || !(SYMBOLP (e->event.key.keysym) || CHARP (e->event.key.keysym)))
-	error ("Undefined key for keypress event");
+      if (UNBOUNDP (e->event.key.keysym))
+	error ("A key must be specified to make a keypress event");
       break;
     case button_press_event:
+      if (!e->event.button.button)
+	error ("A button must be specified to make a button-press event");
+      break;
     case button_release_event:
       if (!e->event.button.button)
-	error ("Undefined button for %s event",
-	       e->event_type == button_press_event
-	       ? "buton-press" : "button-release");
+	error ("A button must be specified to make a button-release event");
       break;
     case misc_user_event:
       if (NILP (e->event.misc.function))
-	error ("Undefined function for misc-user event");
+	error ("A function must be specified to make a misc-user event");
       break;
     default:
       break;
@@ -737,7 +755,7 @@ DEFUN ("copy-event", Fcopy_event, 1, 2, 0, /*
 Make a copy of the given event object.
 If a second argument is given, the first event is copied into the second
 and the second is returned.  If the second argument is not supplied (or
-is nil) then a new event will be made as with `allocate-event.'  See also
+is nil) then a new event will be made as with `make-event'.  See also
 the function `deallocate-event'.
 */
        (event1, event2))
@@ -745,19 +763,26 @@ the function `deallocate-event'.
   CHECK_LIVE_EVENT (event1);
   if (NILP (event2))
     event2 = Fmake_event (Qnil, Qnil);
-  else CHECK_LIVE_EVENT (event2);
-  if (EQ (event1, event2))
-    return signal_simple_continuable_error_2
-      ("copy-event called with `eq' events", event1, event2);
+  else
+    {
+      CHECK_LIVE_EVENT (event2);
+      if (EQ (event1, event2))
+	return signal_simple_continuable_error_2
+	  ("copy-event called with `eq' events", event1, event2);
+    }
 
   assert (XEVENT_TYPE (event1) <= last_event_type);
   assert (XEVENT_TYPE (event2) <= last_event_type);
 
   {
-    Lisp_Object save_next = XEVENT_NEXT (event2);
+    Lisp_Event *ev2 = XEVENT (event2);
+    Lisp_Event *ev1 = XEVENT (event1);
+
+    ev2->event_type = ev1->event_type;
+    ev2->channel    = ev1->channel;
+    ev2->timestamp  = ev1->timestamp;
+    ev2->event      = ev1->event;
 
-    *XEVENT (event2) = *XEVENT (event1);
-    XSET_EVENT_NEXT (event2, save_next);
     return event2;
   }
 }
@@ -937,11 +962,11 @@ command_event_p (Lisp_Object event)
 
 
 void
-character_to_event (Emchar c, struct Lisp_Event *event, struct console *con,
+character_to_event (Emchar c, Lisp_Event *event, struct console *con,
 		    int use_console_meta_flag, int do_backspace_mapping)
 {
   Lisp_Object k = Qnil;
-  unsigned int m = 0;
+  int m = 0;
   if (event->event_type == dead_event)
     error ("character-to-event called with a deallocated event!");
 
@@ -960,21 +985,21 @@ character_to_event (Emchar c, struct Lisp_Event *event, struct console *con,
 	  break;
 	case 1: /* top bit is meta */
 	  c -= 128;
-	  m = MOD_META;
+	  m = XEMACS_MOD_META;
 	  break;
 	default: /* this is a real character */
 	  break;
 	}
     }
-  if (c < ' ') c += '@', m |= MOD_CONTROL;
-  if (m & MOD_CONTROL)
+  if (c < ' ') c += '@', m |= XEMACS_MOD_CONTROL;
+  if (m & XEMACS_MOD_CONTROL)
     {
       switch (c)
 	{
-	case 'I': k = QKtab;	  m &= ~MOD_CONTROL; break;
-	case 'J': k = QKlinefeed; m &= ~MOD_CONTROL; break;
-	case 'M': k = QKreturn;	  m &= ~MOD_CONTROL; break;
-	case '[': k = QKescape;	  m &= ~MOD_CONTROL; break;
+	case 'I': k = QKtab;	  m &= ~XEMACS_MOD_CONTROL; break;
+	case 'J': k = QKlinefeed; m &= ~XEMACS_MOD_CONTROL; break;
+	case 'M': k = QKreturn;	  m &= ~XEMACS_MOD_CONTROL; break;
+	case '[': k = QKescape;	  m &= ~XEMACS_MOD_CONTROL; break;
 	default:
 #if defined(HAVE_TTY)
 	  if (do_backspace_mapping &&
@@ -982,14 +1007,14 @@ character_to_event (Emchar c, struct Lisp_Event *event, struct console *con,
 	      c - '@' == XCHAR (con->tty_erase_char))
 	    {
 	      k = QKbackspace;
-	      m &= ~MOD_CONTROL;
+	      m &= ~XEMACS_MOD_CONTROL;
 	    }
 #endif /* defined(HAVE_TTY) && !defined(__CYGWIN32__) */
 	  break;
 	}
       if (c >= 'A' && c <= 'Z') c -= 'A'-'a';
     }
-#if defined(HAVE_TTY) 
+#if defined(HAVE_TTY)
   else if (do_backspace_mapping &&
 	   CHARP (con->tty_erase_char) && c == XCHAR (con->tty_erase_char))
     k = QKbackspace;
@@ -1006,17 +1031,18 @@ character_to_event (Emchar c, struct Lisp_Event *event, struct console *con,
   event->event.key.modifiers = m;
 }
 
-
 /* This variable controls what character name -> character code mapping
    we are using.  Window-system-specific code sets this to some symbol,
    and we use that symbol as the plist key to convert keysyms into 8-bit
    codes.  In this way one can have several character sets predefined and
    switch them by changing this.
+
+   #### This is utterly bogus and should be removed.
  */
 Lisp_Object Vcharacter_set_property;
 
 Emchar
-event_to_character (struct Lisp_Event *event,
+event_to_character (Lisp_Event *event,
 		    int allow_extra_modifiers,
 		    int allow_meta,
 		    int allow_non_ascii)
@@ -1026,11 +1052,11 @@ event_to_character (struct Lisp_Event *event,
 
   if (event->event_type != key_press_event)
     {
-      if (event->event_type == dead_event) abort ();
+      assert (event->event_type != dead_event);
       return -1;
     }
   if (!allow_extra_modifiers &&
-      event->event.key.modifiers & (MOD_SUPER|MOD_HYPER|MOD_ALT))
+      event->event.key.modifiers & (XEMACS_MOD_SUPER|XEMACS_MOD_HYPER|XEMACS_MOD_ALT))
     return -1;
   if (CHAR_OR_CHAR_INTP (event->event.key.keysym))
     c = XCHAR_OR_CHAR_INT (event->event.key.keysym);
@@ -1049,7 +1075,7 @@ event_to_character (struct Lisp_Event *event,
   else
     return -1;
 
-  if (event->event.key.modifiers & MOD_CONTROL)
+  if (event->event.key.modifiers & XEMACS_MOD_CONTROL)
     {
       if (c >= 'a' && c <= 'z')
 	c -= ('a' - 'A');
@@ -1067,7 +1093,7 @@ event_to_character (struct Lisp_Event *event,
 	if (! allow_extra_modifiers) return -1;
     }
 
-  if (event->event.key.modifiers & MOD_META)
+  if (event->event.key.modifiers & XEMACS_MOD_META)
     {
       if (! allow_meta) return -1;
       if (c & 0200) return -1;		/* don't allow M-oslash (overlap) */
@@ -1193,7 +1219,7 @@ key_sequence_to_event_chain (Lisp_Object seq)
 }
 
 void
-format_event_object (char *buf, struct Lisp_Event *event, int brief)
+format_event_object (char *buf, Lisp_Event *event, int brief)
 {
   int mouse_p = 0;
   int mod = 0;
@@ -1207,13 +1233,13 @@ format_event_object (char *buf, struct Lisp_Event *event, int brief)
         key = event->event.key.keysym;
         /* Hack. */
         if (! brief && CHARP (key) &&
-            mod & (MOD_CONTROL | MOD_META | MOD_SUPER | MOD_HYPER))
+            mod & (XEMACS_MOD_CONTROL | XEMACS_MOD_META | XEMACS_MOD_SUPER | XEMACS_MOD_HYPER))
 	{
 	  int k = XCHAR (key);
 	  if (k >= 'a' && k <= 'z')
 	    key = make_char (k - ('a' - 'A'));
 	  else if (k >= 'A' && k <= 'Z')
-	    mod |= MOD_SHIFT;
+	    mod |= XEMACS_MOD_SHIFT;
 	}
         break;
       }
@@ -1229,7 +1255,7 @@ format_event_object (char *buf, struct Lisp_Event *event, int brief)
       }
     case magic_event:
       {
-        CONST char *name = NULL;
+        const char *name = NULL;
 
 #ifdef HAVE_X_WINDOWS
 	{
@@ -1253,14 +1279,14 @@ format_event_object (char *buf, struct Lisp_Event *event, int brief)
     default:
       abort ();
     }
-#define modprint1(x)  { strcpy (buf, (x)); buf += sizeof (x)-1; }
-#define modprint(x,y) { if (brief) modprint1 (y) else modprint1 (x) }
-  if (mod & MOD_CONTROL) modprint ("control-", "C-");
-  if (mod & MOD_META)    modprint ("meta-",    "M-");
-  if (mod & MOD_SUPER)   modprint ("super-",   "S-");
-  if (mod & MOD_HYPER)   modprint ("hyper-",   "H-");
-  if (mod & MOD_ALT)	 modprint ("alt-",     "A-");
-  if (mod & MOD_SHIFT)   modprint ("shift-",   "Sh-");
+#define modprint1(x)  do { strcpy (buf, (x)); buf += sizeof (x)-1; } while (0)
+#define modprint(x,y) do { if (brief) modprint1 (y); else modprint1 (x); } while (0)
+  if (mod & XEMACS_MOD_CONTROL) modprint ("control-", "C-");
+  if (mod & XEMACS_MOD_META)    modprint ("meta-",    "M-");
+  if (mod & XEMACS_MOD_SUPER)   modprint ("super-",   "S-");
+  if (mod & XEMACS_MOD_HYPER)   modprint ("hyper-",   "H-");
+  if (mod & XEMACS_MOD_ALT)	modprint ("alt-",     "A-");
+  if (mod & XEMACS_MOD_SHIFT)   modprint ("shift-",   "Sh-");
   if (mouse_p)
     {
       modprint1 ("button");
@@ -1277,7 +1303,7 @@ format_event_object (char *buf, struct Lisp_Event *event, int brief)
     }
   else if (SYMBOLP (key))
     {
-      CONST char *str = 0;
+      const char *str = 0;
       if (brief)
 	{
 	  if      (EQ (key, QKlinefeed))  str = "LFD";
@@ -1296,7 +1322,7 @@ format_event_object (char *buf, struct Lisp_Event *event, int brief)
 	}
       else
 	{
-	  struct Lisp_String *name = XSYMBOL (key)->name;
+	  Lisp_String *name = XSYMBOL (key)->name;
 	  memcpy (buf, string_data (name), string_length (name) + 1);
 	  str += string_length (name);
 	}
@@ -1332,7 +1358,7 @@ The `next-event' field is changed by calling `set-next-event'.
 */
 	 (event))
 {
-  struct Lisp_Event *e;
+  Lisp_Event *e;
   CHECK_LIVE_EVENT (event);
 
   return XEVENT_NEXT (event);
@@ -1429,22 +1455,28 @@ Return the timestamp of the event object EVENT.
 #define CHECK_EVENT_TYPE(e,t1,sym) do {		\
   CHECK_LIVE_EVENT (e);				\
   if (XEVENT(e)->event_type != (t1))		\
-    e = wrong_type_argument ((sym),(e));	\
+    e = wrong_type_argument (sym,e);		\
 } while (0)
 
-#define CHECK_EVENT_TYPE2(e,t1,t2,sym) do {	\
-  CHECK_LIVE_EVENT (e);				\
-  if (XEVENT(e)->event_type != (t1) &&		\
-      XEVENT(e)->event_type != (t2))		\
-    e = wrong_type_argument ((sym),(e));	\
+#define CHECK_EVENT_TYPE2(e,t1,t2,sym) do {		\
+  CHECK_LIVE_EVENT (e);					\
+  {							\
+    emacs_event_type CET_type = XEVENT (e)->event_type;	\
+    if (CET_type != (t1) &&				\
+	CET_type != (t2))				\
+      e = wrong_type_argument (sym,e);			\
+  }							\
 } while (0)
 
-#define CHECK_EVENT_TYPE3(e,t1,t2,t3,sym) do {	\
-  CHECK_LIVE_EVENT (e);				\
-  if (XEVENT(e)->event_type != (t1) &&		\
-      XEVENT(e)->event_type != (t2) &&		\
-      XEVENT(e)->event_type != (t3))		\
-    e = wrong_type_argument ((sym),(e));	\
+#define CHECK_EVENT_TYPE3(e,t1,t2,t3,sym) do {		\
+  CHECK_LIVE_EVENT (e);					\
+  {							\
+    emacs_event_type CET_type = XEVENT (e)->event_type;	\
+    if (CET_type != (t1) &&				\
+	CET_type != (t2) &&				\
+	CET_type != (t3))				\
+      e = wrong_type_argument (sym,e);			\
+  }							\
 } while (0)
 
 DEFUN ("event-key", Fevent_key, 1, 1, 0, /*
@@ -1511,12 +1543,12 @@ See also the function event-modifier-bits.
 {
   int mod = XINT (Fevent_modifier_bits (event));
   Lisp_Object result = Qnil;
-  if (mod & MOD_SHIFT)   result = Fcons (Qshift, result);
-  if (mod & MOD_ALT)	 result = Fcons (Qalt, result);
-  if (mod & MOD_HYPER)   result = Fcons (Qhyper, result);
-  if (mod & MOD_SUPER)   result = Fcons (Qsuper, result);
-  if (mod & MOD_META)    result = Fcons (Qmeta, result);
-  if (mod & MOD_CONTROL) result = Fcons (Qcontrol, result);
+  if (mod & XEMACS_MOD_SHIFT)   result = Fcons (Qshift, result);
+  if (mod & XEMACS_MOD_ALT)	result = Fcons (Qalt, result);
+  if (mod & XEMACS_MOD_HYPER)   result = Fcons (Qhyper, result);
+  if (mod & XEMACS_MOD_SUPER)   result = Fcons (Qsuper, result);
+  if (mod & XEMACS_MOD_META)    result = Fcons (Qmeta, result);
+  if (mod & XEMACS_MOD_CONTROL) result = Fcons (Qcontrol, result);
   return result;
 }
 
@@ -2066,7 +2098,7 @@ This is in the form of a property list (alternating keyword/value pairs).
        (event))
 {
   Lisp_Object props = Qnil;
-  struct Lisp_Event *e;
+  Lisp_Event *e;
   struct gcpro gcpro1;
 
   CHECK_LIVE_EVENT (event);
@@ -2077,6 +2109,8 @@ This is in the form of a property list (alternating keyword/value pairs).
 
   switch (e->event_type)
     {
+    default: abort ();
+
     case process_event:
       props = cons3 (Qprocess, e->event.process.process, props);
       break;
@@ -2127,10 +2161,6 @@ This is in the form of a property list (alternating keyword/value pairs).
     case empty_event:
       RETURN_UNGCPRO (Qnil);
       break;
-
-    default:
-      abort ();
-      break;                 /* not reached; warning suppression */
     }
 
   props = cons3 (Qchannel, Fevent_channel (event), props);
@@ -2147,6 +2177,8 @@ This is in the form of a property list (alternating keyword/value pairs).
 void
 syms_of_events (void)
 {
+  INIT_LRECORD_IMPLEMENTATION (event);
+
   DEFSUBR (Fcharacter_to_event);
   DEFSUBR (Fevent_to_character);
 
@@ -2199,11 +2231,28 @@ syms_of_events (void)
   defsymbol (&Qbutton_release, "button-release");
   defsymbol (&Qmisc_user, "misc-user");
   defsymbol (&Qascii_character, "ascii-character");
+
+  defsymbol (&QKbackspace, "backspace");
+  defsymbol (&QKtab, "tab");
+  defsymbol (&QKlinefeed, "linefeed");
+  defsymbol (&QKreturn, "return");
+  defsymbol (&QKescape, "escape");
+  defsymbol (&QKspace, "space");
+  defsymbol (&QKdelete, "delete");
+}
+
+
+void
+reinit_vars_of_events (void)
+{
+  Vevent_resource = Qnil;
 }
 
 void
 vars_of_events (void)
 {
+  reinit_vars_of_events ();
+
   DEFVAR_LISP ("character-set-property", &Vcharacter_set_property /*
 A symbol used to look up the 8-bit character of a keysym.
 To convert a keysym symbol to an 8-bit code, as when that key is
@@ -2213,22 +2262,4 @@ system-specific code will set up appropriate properties and set this
 variable.
 */ );
   Vcharacter_set_property = Qnil;
-
-  Vevent_resource = Qnil;
-
-  QKbackspace = KEYSYM ("backspace");
-  QKtab       = KEYSYM ("tab");
-  QKlinefeed  = KEYSYM ("linefeed");
-  QKreturn    = KEYSYM ("return");
-  QKescape    = KEYSYM ("escape");
-  QKspace     = KEYSYM ("space");
-  QKdelete    = KEYSYM ("delete");
-
-  staticpro (&QKbackspace);
-  staticpro (&QKtab);
-  staticpro (&QKlinefeed);
-  staticpro (&QKreturn);
-  staticpro (&QKescape);
-  staticpro (&QKspace);
-  staticpro (&QKdelete);
 }