Merged in changes from CVS trunk.

Patches applied:

 * miles@gnu.org--gnu-2004/emacs--cvs-trunk--0--patch-501
   Update from CVS

 * miles@gnu.org--gnu-2004/emacs--cvs-trunk--0--patch-502
   Update from CVS

 * miles@gnu.org--gnu-2004/emacs--cvs-trunk--0--patch-503
   Update from CVS

 * miles@gnu.org--gnu-2004/emacs--cvs-trunk--0--patch-504
   Update from CVS

 * miles@gnu.org--gnu-2004/emacs--cvs-trunk--0--patch-505
   Update from CVS


git-archimport-id: lorentey@elte.hu--2004/emacs--multi-tty--0--patch-236

15 files changed, 164 insertions, 193 deletions

diff --git a/src/ChangeLog b/src/ChangeLog
index 9d9c4ee498c..cbf06bc480f 100644
--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -1,3 +1,45 @@
+2004-08-22  Richard M. Stallman  <rms@gnu.org>
+
+        * process.c (process_send_signal) [SIGNALS_VIA_CHARACTERS,
+        HAVE_TERMIOS]: If there's no char for this signal, drop through
+        and use system calls.
+
+        * bytecode.c (Fbyte_code) <unwind-protect>: Cannot GC.
+
+2004-08-20  Kim F. Storm  <storm@cua.dk>
+
+        * process.c (wait_reading_process_output): Rename from
+        wait_reading_process_input.  All uses changed.
+        (wait_reading_process_output_1): Rename from
+        wait_reading_process_input_1.  All uses changed.
+
+        * dispnew.c (Fsleep_for): Remove obsolete code.
+
+2004-08-20  Kenichi Handa  <handa@m17n.org>
+
+        * syntax.c (skip_chars): Fix for unibyte case.
+
+2004-08-19  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * syntax.c (char_quoted): Mixup byte/char pos.
+        (back_comment): Fixup globals in all cases.
+
+2004-08-19  Jan Dj,Ad(Brv  <jan.h.d@swipnet.se>
+
+        * xfns.c (x_set_name, x_set_title): Encode title to UTF8 before
+        passing it to gtk_window_set_title.
+
+2004-08-19  Kim F. Storm  <storm@cua.dk>
+
+        * process.c (wait_reading_process_input): Clean up.
+        Add wait_for_cell, wait_proc, and just_wait_proc args
+        to avoid overloading `read_kbd' and `do_display' args.
+        Change read_kbd arg to int.  All callers changed.
+
+        * process.c (process_send_signal): Use CDISABLE.
+
+        * sysdep.c (child_setup_tty, init_sys_modes): Use CDISABLE.
+
 2004-08-18  Kim F. Storm  <storm@cua.dk>
 
         * process.c (Faccept_process_output): Add arg JUST-THIS-ONE;
diff --git a/src/bytecode.c b/src/bytecode.c
index a13ecc19770..0d3be49877c 100644
--- a/src/bytecode.c
+++ b/src/bytecode.c
@@ -855,10 +855,7 @@ If the third argument is incorrect, Emacs may crash.  */)
           }
 
         case Bunwind_protect:
-          /* The function record_unwind_protect can GC.  */
-          BEFORE_POTENTIAL_GC ();
           record_unwind_protect (Fprogn, POP);
-          AFTER_POTENTIAL_GC ();
           break;
 
         case Bcondition_case:
diff --git a/src/dispnew.c b/src/dispnew.c
index a89bb0a9bcc..070c9648d1d 100644
--- a/src/dispnew.c
+++ b/src/dispnew.c
@@ -6358,52 +6358,13 @@ Emacs was built without floating point support.
   if (sec < 0 || (sec == 0 && usec == 0))
     return Qnil;
 
-  {
-    Lisp_Object zero;
-
-    XSETFASTINT (zero, 0);
-    wait_reading_process_input (sec, usec, zero, 0);
-  }
-
-  /* We should always have wait_reading_process_input; we have a dummy
-     implementation for systems which don't support subprocesses.  */
-#if 0
-  /* No wait_reading_process_input */
-  immediate_quit = 1;
-  QUIT;
-
-#ifdef VMS
-  sys_sleep (sec);
-#else /* not VMS */
-/* The reason this is done this way
-    (rather than defined (H_S) && defined (H_T))
-   is because the VMS preprocessor doesn't grok `defined'.  */
-#ifdef HAVE_SELECT
-  EMACS_GET_TIME (end_time);
-  EMACS_SET_SECS_USECS (timeout, sec, usec);
-  EMACS_ADD_TIME (end_time, end_time, timeout);
-
-  while (1)
-    {
-      EMACS_GET_TIME (timeout);
-      EMACS_SUB_TIME (timeout, end_time, timeout);
-      if (EMACS_TIME_NEG_P (timeout)
-          || !select (1, 0, 0, 0, &timeout))
-        break;
-    }
-#else /* not HAVE_SELECT */
-  sleep (sec);
-#endif /* HAVE_SELECT */
-#endif /* not VMS */
-
-  immediate_quit = 0;
-#endif /* no subprocesses */
+  wait_reading_process_output (sec, usec, 0, 0, Qnil, NULL, 0);
 
   return Qnil;
 }
 
 
-/* This is just like wait_reading_process_input, except that
+/* This is just like wait_reading_process_output, except that
    it does the redisplay.
 
    It's also much like Fsit_for, except that it can be used for
@@ -6413,8 +6374,6 @@ Lisp_Object
 sit_for (sec, usec, reading, display, initial_display)
      int sec, usec, reading, display, initial_display;
 {
-  Lisp_Object read_kbd;
-
   swallow_events (display);
 
   if (detect_input_pending_run_timers (display) || !NILP (Vexecuting_macro))
@@ -6430,8 +6389,8 @@ sit_for (sec, usec, reading, display, initial_display)
   gobble_input (0);
 #endif
 
-  XSETINT (read_kbd, reading ? -1 : 1);
-  wait_reading_process_input (sec, usec, read_kbd, display);
+  wait_reading_process_output (sec, usec, reading ? -1 : 1, display,
+                               Qnil, NULL, 0);
 
   return detect_input_pending () ? Qnil : Qt;
 }
diff --git a/src/keyboard.c b/src/keyboard.c
index d0b081e5cdd..940802764d2 100644
--- a/src/keyboard.c
+++ b/src/keyboard.c
@@ -3895,10 +3895,7 @@ kbd_buffer_get_event (kbp, used_mouse_menu)
         break;
 #endif
       {
-        Lisp_Object minus_one;
-
-        XSETINT (minus_one, -1);
-        wait_reading_process_input (0, 0, minus_one, 1);
+        wait_reading_process_output (0, 0, -1, 1, Qnil, NULL, 0);
 
         if (!interrupt_input && kbd_fetch_ptr == kbd_store_ptr)
           /* Pass 1 for EXPECT since we just waited to have input.  */
@@ -9995,7 +9992,7 @@ clear_input_pending ()
 }
 
 /* Return nonzero if there are pending requeued events.
-   This isn't used yet.  The hope is to make wait_reading_process_input
+   This isn't used yet.  The hope is to make wait_reading_process_output
    call it, and return if it runs Lisp code that unreads something.
    The problem is, kbd_buffer_get_event needs to be fixed to know what
    to do in that case.  It isn't trivial.  */
diff --git a/src/lisp.h b/src/lisp.h
index deb8d6414a2..133c5c07c56 100644
--- a/src/lisp.h
+++ b/src/lisp.h
@@ -2964,7 +2964,10 @@ EXFUN (Fprocess_send_eof, 1);
 EXFUN (Fwaiting_for_user_input_p, 0);
 extern Lisp_Object Qprocessp;
 extern void kill_buffer_processes P_ ((Lisp_Object));
-extern int wait_reading_process_input P_ ((int, int, Lisp_Object, int));
+extern int wait_reading_process_output P_ ((int, int, int, int,
+                                            Lisp_Object,
+                                            struct Lisp_Process *,
+                                            int));
 extern void deactivate_process P_ ((Lisp_Object));
 extern void add_keyboard_wait_descriptor P_ ((int));
 extern void delete_keyboard_wait_descriptor P_ ((int));
diff --git a/src/msdos.c b/src/msdos.c
index c9fbecf5cb2..8b511abebd7 100644
--- a/src/msdos.c
+++ b/src/msdos.c
@@ -5102,7 +5102,7 @@ dos_yield_time_slice (void)
 
 /* Only event queue is checked.  */
 /* We don't have to call timer_check here
-   because wait_reading_process_input takes care of that.  */
+   because wait_reading_process_output takes care of that.  */
 int
 sys_select (nfds, rfds, wfds, efds, timeout)
      int nfds;
diff --git a/src/process.c b/src/process.c
index 1cebdf07875..dab7bdc3198 100644
--- a/src/process.c
+++ b/src/process.c
@@ -3777,13 +3777,12 @@ Return non-nil iff we received any output before the timeout expired.  */)
   else
     seconds = NILP (process) ? -1 : 0;
 
-  if (NILP (process))
-    XSETFASTINT (process, 0);
-
   return
-    (wait_reading_process_input (seconds, useconds, process,
-                                 NILP (just_this_one) ? 0 :
-                                 !INTEGERP (just_this_one) ? -1 : -2)
+    (wait_reading_process_output (seconds, useconds, 0, 0,
+                                  Qnil,
+                                  !NILP (process) ? XPROCESS (process) : NULL,
+                                  NILP (just_this_one) ? 0 :
+                                  !INTEGERP (just_this_one) ? 1 : -1)
      ? Qt : Qnil);
 }
 
@@ -3983,12 +3982,12 @@ server_accept_connection (server, channel)
    lisp code is being evalled.
    This is also used in record_asynch_buffer_change.
    For that purpose, this must be 0
-   when not inside wait_reading_process_input.  */
+   when not inside wait_reading_process_output.  */
 static int waiting_for_user_input_p;
 
 /* This is here so breakpoints can be put on it.  */
 static void
-wait_reading_process_input_1 ()
+wait_reading_process_output_1 ()
 {
 }
 
@@ -4010,28 +4009,32 @@ wait_reading_process_input_1 ()
      1 to return when input is available, or
      -1 meaning caller will actually read the input, so don't throw to
        the quit handler, or
-     a cons cell, meaning wait until its car is non-nil
-       (and gobble terminal input into the buffer if any arrives), or
-     a process object, meaning wait until something arrives from that
-       process.  The return value is true iff we read some input from
-       that process.
-
-   If READ_KBD is a process object, DO_DISPLAY < 0 means handle only
-     output from that process (suspending output from other processes)
-     and DO_DISPLAY == -2 specifically means don't run any timers either.
-   Otherwise, != 0 means redisplay should be done to show subprocess
+
+   DO_DISPLAY != 0 means redisplay should be done to show subprocess
      output that arrives.
 
-   If READ_KBD is a pointer to a struct Lisp_Process, then the
-     function returns true iff we received input from that process
-     before the timeout elapsed.
+   If WAIT_FOR_CELL is a cons cell, wait until its car is non-nil
+     (and gobble terminal input into the buffer if any arrives).
+
+   If WAIT_PROC is specified, wait until something arrives from that
+     process.  The return value is true iff we read some input from
+     that process.
+
+   If JUST_WAIT_PROC is non-nil, handle only output from WAIT_PROC
+     (suspending output from other processes).  A negative value
+     means don't run any timers either.
+
+   If WAIT_PROC is specified, then the function returns true iff we
+     received input from that process before the timeout elapsed.
    Otherwise, return true iff we received input from any process.  */
 
 int
-wait_reading_process_input (time_limit, microsecs, read_kbd, do_display)
-     int time_limit, microsecs;
-     Lisp_Object read_kbd;
-     int do_display;
+wait_reading_process_output (time_limit, microsecs, read_kbd, do_display,
+                             wait_for_cell, wait_proc, just_wait_proc)
+     int time_limit, microsecs, read_kbd, do_display;
+     Lisp_Object wait_for_cell;
+     struct Lisp_Process *wait_proc;
+     int just_wait_proc;
 {
   register int channel, nfds;
   SELECT_TYPE Available;
@@ -4041,39 +4044,19 @@ wait_reading_process_input (time_limit, microsecs, read_kbd, do_display)
   Lisp_Object proc;
   EMACS_TIME timeout, end_time;
   int wait_channel = -1;
-  struct Lisp_Process *wait_proc = 0;
-  int just_wait_proc = 0;
   int got_some_input = 0;
   /* Either nil or a cons cell, the car of which is of interest and
      may be changed outside of this routine.  */
-  Lisp_Object wait_for_cell = Qnil;
   int saved_waiting_for_user_input_p = waiting_for_user_input_p;
 
   FD_ZERO (&Available);
   FD_ZERO (&Connecting);
 
-  /* If read_kbd is a process to watch, set wait_proc and wait_channel
-     accordingly.  */
-  if (PROCESSP (read_kbd))
-    {
-      wait_proc = XPROCESS (read_kbd);
-      wait_channel = XINT (wait_proc->infd);
-      XSETFASTINT (read_kbd, 0);
-      if (do_display < 0)
-        {
-          just_wait_proc = do_display;
-          do_display = 0;
-        }
-    }
-
-  /* If waiting for non-nil in a cell, record where.  */
-  if (CONSP (read_kbd))
-    {
-      wait_for_cell = read_kbd;
-      XSETFASTINT (read_kbd, 0);
-    }
+  /* If wait_proc is a process to watch, set wait_channel accordingly.  */
+  if (wait_proc != NULL)
+    wait_channel = XINT (wait_proc->infd);
 
-  waiting_for_user_input_p = XINT (read_kbd);
+  waiting_for_user_input_p = read_kbd;
 
   /* Since we may need to wait several times,
      compute the absolute time to return at.  */
@@ -4101,7 +4084,7 @@ wait_reading_process_input (time_limit, microsecs, read_kbd, do_display)
       /* If calling from keyboard input, do not quit
          since we want to return C-g as an input character.
          Otherwise, do pending quit if requested.  */
-      if (XINT (read_kbd) >= 0)
+      if (read_kbd >= 0)
         QUIT;
 #ifdef SYNC_INPUT
       else if (interrupt_input_pending)
@@ -4139,7 +4122,7 @@ wait_reading_process_input (time_limit, microsecs, read_kbd, do_display)
          the wait is supposed to be short,
          and those callers cannot handle running arbitrary Lisp code here.  */
       if (NILP (wait_for_cell)
-          && just_wait_proc != -2)
+          && just_wait_proc >= 0)
         {
           EMACS_TIME timer_delay;
 
@@ -4167,7 +4150,7 @@ wait_reading_process_input (time_limit, microsecs, read_kbd, do_display)
           while (!detect_input_pending ());
 
           /* If there is unread keyboard input, also return.  */
-          if (XINT (read_kbd) != 0
+          if (read_kbd != 0
               && requeued_events_pending_p ())
             break;
 
@@ -4185,7 +4168,7 @@ wait_reading_process_input (time_limit, microsecs, read_kbd, do_display)
           else if (time_limit != -1)
             {
               /* This is so a breakpoint can be put here.  */
-              wait_reading_process_input_1 ();
+              wait_reading_process_output_1 ();
             }
         }
 
@@ -4195,7 +4178,7 @@ wait_reading_process_input (time_limit, microsecs, read_kbd, do_display)
          It is important that we do this before checking for process
          activity.  If we get a SIGCHLD after the explicit checks for
          process activity, timeout is the only way we will know.  */
-      if (XINT (read_kbd) < 0)
+      if (read_kbd < 0)
         set_waiting_for_input (&timeout);
 
       /* If status of something has changed, and no input is
@@ -4275,8 +4258,10 @@ wait_reading_process_input (time_limit, microsecs, read_kbd, do_display)
 
       /* Wait till there is something to do */
 
-      if (just_wait_proc)
+      if (wait_proc && just_wait_proc)
         {
+          if (XINT (wait_proc->infd) < 0)  /* Terminated */
+            break;
           FD_SET (XINT (wait_proc->infd), &Available);
           check_connect = check_delay = 0;
         }
@@ -4287,7 +4272,7 @@ wait_reading_process_input (time_limit, microsecs, read_kbd, do_display)
         }
       else
         {
-          if (! XINT (read_kbd))
+          if (! read_kbd)
             Available = non_keyboard_wait_mask;
           else
             Available = input_wait_mask;
@@ -4304,12 +4289,12 @@ wait_reading_process_input (time_limit, microsecs, read_kbd, do_display)
         {
           clear_waiting_for_input ();
           redisplay_preserve_echo_area (11);
-          if (XINT (read_kbd) < 0)
+          if (read_kbd < 0)
             set_waiting_for_input (&timeout);
         }
 
       no_avail = 0;
-      if (XINT (read_kbd) && detect_input_pending ())
+      if (read_kbd && detect_input_pending ())
         {
           nfds = 0;
           no_avail = 1;
@@ -4426,10 +4411,10 @@ wait_reading_process_input (time_limit, microsecs, read_kbd, do_display)
       /* If we are using polling for input,
          and we see input available, make it get read now.
          Otherwise it might not actually get read for a second.
-         And on hpux, since we turn off polling in wait_reading_process_input,
+         And on hpux, since we turn off polling in wait_reading_process_output,
          it might never get read at all if we don't spend much time
-         outside of wait_reading_process_input.  */
-      if (XINT (read_kbd) && interrupt_input
+         outside of wait_reading_process_output.  */
+      if (read_kbd && interrupt_input
           && keyboard_bit_set (&Available)
           && input_polling_used ())
         kill (getpid (), SIGALRM);
@@ -4439,7 +4424,7 @@ wait_reading_process_input (time_limit, microsecs, read_kbd, do_display)
       /* If there is any, return immediately
          to give it higher priority than subprocesses */
 
-      if (XINT (read_kbd) != 0)
+      if (read_kbd != 0)
         {
           int old_timers_run = timers_run;
           struct buffer *old_buffer = current_buffer;
@@ -4464,7 +4449,7 @@ wait_reading_process_input (time_limit, microsecs, read_kbd, do_display)
         }
 
       /* If there is unread keyboard input, also return.  */
-      if (XINT (read_kbd) != 0
+      if (read_kbd != 0
           && requeued_events_pending_p ())
         break;
 
@@ -4475,7 +4460,7 @@ wait_reading_process_input (time_limit, microsecs, read_kbd, do_display)
          That would causes delays in pasting selections, for example.
 
          (We used to do this only if wait_for_cell.)  */
-      if (XINT (read_kbd) == 0 && detect_input_pending ())
+      if (read_kbd == 0 && detect_input_pending ())
         {
           swallow_events (do_display);
 #if 0  /* Exiting when read_kbd doesn't request that seems wrong, though.  */
@@ -4494,7 +4479,7 @@ wait_reading_process_input (time_limit, microsecs, read_kbd, do_display)
          In that case, there really is no input and no SIGIO,
          but select says there is input.  */
 
-      if (XINT (read_kbd) && interrupt_input
+      if (read_kbd && interrupt_input
           && keyboard_bit_set (&Available) && ! noninteractive)
         kill (getpid (), SIGIO);
 #endif
@@ -4504,7 +4489,7 @@ wait_reading_process_input (time_limit, microsecs, read_kbd, do_display)
 
       /* If checking input just got us a size-change event from X,
          obey it now if we should.  */
-      if (XINT (read_kbd) || ! NILP (wait_for_cell))
+      if (read_kbd || ! NILP (wait_for_cell))
         do_pending_window_change (0);
 
       /* Check for data from a process.  */
@@ -4679,7 +4664,7 @@ wait_reading_process_input (time_limit, microsecs, read_kbd, do_display)
   /* If calling from keyboard input, do not quit
      since we want to return C-g as an input character.
      Otherwise, do pending quit if requested.  */
-  if (XINT (read_kbd) >= 0)
+  if (read_kbd >= 0)
     {
       /* Prevent input_pending from remaining set if we quit.  */
       clear_input_pending ();
@@ -5326,7 +5311,6 @@ send_process (proc, buf, len, object)
                        that may allow the program
                        to finish doing output and read more.  */
                     {
-                      Lisp_Object zero;
                       int offset = 0;
 
 #ifdef BROKEN_PTY_READ_AFTER_EAGAIN
@@ -5361,11 +5345,10 @@ send_process (proc, buf, len, object)
                       else if (STRINGP (object))
                         offset = buf - SDATA (object);
 
-                      XSETFASTINT (zero, 0);
 #ifdef EMACS_HAS_USECS
-                      wait_reading_process_input (0, 20000, zero, 0);
+                      wait_reading_process_output (0, 20000, 0, 0, Qnil, NULL, 0);
 #else
-                      wait_reading_process_input (1, 0, zero, 0);
+                      wait_reading_process_output (1, 0, 0, 0, Qnil, NULL, 0);
 #endif
 
                       if (BUFFERP (object))
@@ -5594,17 +5577,13 @@ process_send_signal (process, signo, current_group, nomsg)
           break;
         }
 
-#ifndef _POSIX_VDISABLE
-#ifdef CVDISABLE
-#define _POSIX_VDISABLE CVDISABLE
-#else
-#define _POSIX_VDISABLE '\0'
-#endif
-#endif
-
-      if (sig_char && *sig_char != _POSIX_VDISABLE)
-        send_process (proc, sig_char, 1, Qnil);
-      return;
+      if (sig_char && *sig_char != CDISABLE)
+        {
+          send_process (proc, sig_char, 1, Qnil);
+          return;
+        }
+      /* If we can't send the signal with a character,
+         fall through and send it another way.  */
 #else /* ! HAVE_TERMIOS */
 
       /* On Berkeley descendants, the following IOCTL's retrieve the
@@ -5661,9 +5640,12 @@ process_send_signal (process, signo, current_group, nomsg)
          you'd better be using one of the alternatives above!  */
 #endif /* ! defined (TCGETA) */
 #endif /* ! defined (TIOCGLTC) && defined (TIOCGETC) */
-#endif /* ! defined HAVE_TERMIOS */
+        /* In this case, the code above should alway returns.  */
         abort ();
-      /* The code above always returns from the function.  */
+#endif /* ! defined HAVE_TERMIOS */
+
+      /* The code above may fall through if it can't
+         handle the signal.  */
 #endif /* defined (SIGNALS_VIA_CHARACTERS) */
 
 #ifdef TIOCGPGRP
@@ -6235,7 +6217,7 @@ sigchld_handler (signo)
               FD_CLR (XINT (p->infd), &non_keyboard_wait_mask);
             }
 
-          /* Tell wait_reading_process_input that it needs to wake up and
+          /* Tell wait_reading_process_output that it needs to wake up and
              look around.  */
           if (input_available_clear_time)
             EMACS_SET_SECS_USECS (*input_available_clear_time, 0, 0);
@@ -6253,7 +6235,7 @@ sigchld_handler (signo)
           else if (WIFSIGNALED (w))
             synch_process_termsig = WTERMSIG (w);
 
-          /* Tell wait_reading_process_input that it needs to wake up and
+          /* Tell wait_reading_process_output that it needs to wake up and
              look around.  */
           if (input_available_clear_time)
             EMACS_SET_SECS_USECS (*input_available_clear_time, 0, 0);
@@ -6892,10 +6874,9 @@ Lisp_Object QCtype;
      1 to return when input is available, or
      -1 means caller will actually read the input, so don't throw to
        the quit handler.
-     a cons cell, meaning wait until its car is non-nil
-       (and gobble terminal input into the buffer if any arrives), or
-     We know that read_kbd will never be a Lisp_Process, since
-     `subprocesses' isn't defined.
+
+   see full version for other parameters. We know that wait_proc will
+     always be NULL, since `subprocesses' isn't defined.
 
    do_display != 0 means redisplay should be done to show subprocess
    output that arrives.
@@ -6903,27 +6884,17 @@ Lisp_Object QCtype;
    Return true iff we received input from any process.  */
 
 int
-wait_reading_process_input (time_limit, microsecs, read_kbd, do_display)
-     int time_limit, microsecs;
-     Lisp_Object read_kbd;
-     int do_display;
+wait_reading_process_output (time_limit, microsecs, read_kbd, do_display,
+                             wait_for_cell, wait_proc, just_wait_proc)
+     int time_limit, microsecs, read_kbd, do_display;
+     Lisp_Object wait_for_cell;
+     struct Lisp_Process *wait_proc;
+     int just_wait_proc;
 {
   register int nfds;
   EMACS_TIME end_time, timeout;
   SELECT_TYPE waitchannels;
   int xerrno;
-  /* Either nil or a cons cell, the car of which is of interest and
-     may be changed outside of this routine.  */
-  Lisp_Object wait_for_cell;
-
-  wait_for_cell = Qnil;
-
-  /* If waiting for non-nil in a cell, record where.  */
-  if (CONSP (read_kbd))
-    {
-      wait_for_cell = read_kbd;
-      XSETFASTINT (read_kbd, 0);
-    }
 
   /* What does time_limit really mean?  */
   if (time_limit || microsecs)
@@ -6946,7 +6917,7 @@ wait_reading_process_input (time_limit, microsecs, read_kbd, do_display)
       /* If calling from keyboard input, do not quit
          since we want to return C-g as an input character.
          Otherwise, do pending quit if requested.  */
-      if (XINT (read_kbd) >= 0)
+      if (read_kbd >= 0)
         QUIT;
 
       /* Exit now if the cell we're waiting for became non-nil.  */
@@ -6997,7 +6968,7 @@ wait_reading_process_input (time_limit, microsecs, read_kbd, do_display)
           while (!detect_input_pending ());
 
           /* If there is unread keyboard input, also return.  */
-          if (XINT (read_kbd) != 0
+          if (read_kbd != 0
               && requeued_events_pending_p ())
             break;
 
@@ -7015,12 +6986,12 @@ wait_reading_process_input (time_limit, microsecs, read_kbd, do_display)
 
       /* Cause C-g and alarm signals to take immediate action,
          and cause input available signals to zero out timeout.  */
-      if (XINT (read_kbd) < 0)
+      if (read_kbd < 0)
         set_waiting_for_input (&timeout);
 
       /* Wait till there is something to do.  */
 
-      if (! XINT (read_kbd) && NILP (wait_for_cell))
+      if (! read_kbd && NILP (wait_for_cell))
         FD_ZERO (&waitchannels);
       else
         FD_SET (0, &waitchannels);
@@ -7031,11 +7002,11 @@ wait_reading_process_input (time_limit, microsecs, read_kbd, do_display)
         {
           clear_waiting_for_input ();
           redisplay_preserve_echo_area (15);
-          if (XINT (read_kbd) < 0)
+          if (read_kbd < 0)
             set_waiting_for_input (&timeout);
         }
 
-      if (XINT (read_kbd) && detect_input_pending ())
+      if (read_kbd && detect_input_pending ())
         {
           nfds = 0;
           FD_ZERO (&waitchannels);
@@ -7071,13 +7042,13 @@ wait_reading_process_input (time_limit, microsecs, read_kbd, do_display)
         kill (getpid (), SIGIO);
 #endif
 #ifdef SIGIO
-      if (XINT (read_kbd) && interrupt_input && (waitchannels & 1))
+      if (read_kbd && interrupt_input && (waitchannels & 1))
         kill (getpid (), SIGIO);
 #endif
 
       /* Check for keyboard input */
 
-      if ((XINT (read_kbd) != 0)
+      if (read_kbd
           && detect_input_pending_run_timers (do_display))
         {
           swallow_events (do_display);
@@ -7086,7 +7057,7 @@ wait_reading_process_input (time_limit, microsecs, read_kbd, do_display)
         }
 
       /* If there is unread keyboard input, also return.  */
-      if (XINT (read_kbd) != 0
+      if (read_kbd
           && requeued_events_pending_p ())
         break;
 
diff --git a/src/syntax.c b/src/syntax.c
index 83763061d82..272e9cf1b12 100644
--- a/src/syntax.c
+++ b/src/syntax.c
@@ -292,7 +292,7 @@ char_quoted (charpos, bytepos)
 
   DEC_BOTH (charpos, bytepos);
 
-  while (bytepos >= beg)
+  while (charpos >= beg)
     {
       int c;
 
@@ -673,7 +673,7 @@ back_comment (from, from_byte, stop, comnested, comstyle, charpos_ptr, bytepos_p
     {
       from = comstart_pos;
       from_byte = comstart_byte;
-      /* Globals are correct now.  */
+      UPDATE_SYNTAX_TABLE_FORWARD (from - 1);
     }
   else
     {
@@ -1728,12 +1728,12 @@ skip_chars (forwardp, syntaxp, string, lim, handle_iso_classes)
                       if (negate)
                         break;
                       else
-                        goto fwd_ok;
+                        goto fwd_unibyte_ok;
                     }
 
                   if (!fastmap[*p])
                     break;
-
+                fwd_unibyte_ok:
                   p++, pos++;
                 }
           }
@@ -1801,12 +1801,12 @@ skip_chars (forwardp, syntaxp, string, lim, handle_iso_classes)
                       if (negate)
                         break;
                       else
-                        goto fwd_ok;
+                        goto back_unibyte_ok;
                     }
 
                   if (!fastmap[p[-1]])
                     break;
-
+                back_unibyte_ok:
                   p--, pos--;
                 }
           }
diff --git a/src/sysdep.c b/src/sysdep.c
index 26f433c9a1d..a887b8c2d96 100644
--- a/src/sysdep.c
+++ b/src/sysdep.c
@@ -610,9 +610,9 @@ child_setup_tty (out)
 #ifdef SIGNALS_VIA_CHARACTERS
   /* the QUIT and INTR character are used in process_send_signal
      so set them here to something useful.  */
-  if (s.main.c_cc[VQUIT] == 0377)
+  if (s.main.c_cc[VQUIT] == CDISABLE)
     s.main.c_cc[VQUIT] = '\\'&037;      /* Control-\ */
-  if (s.main.c_cc[VINTR] == 0377)
+  if (s.main.c_cc[VINTR] == CDISABLE)
     s.main.c_cc[VINTR] = 'C'&037;       /* Control-C */
 #endif /* not SIGNALS_VIA_CHARACTERS */
 
@@ -631,11 +631,11 @@ child_setup_tty (out)
      would force it to 0377.  That looks like duplicated code.  */
 #ifndef SIGNALS_VIA_CHARACTERS
   /* QUIT and INTR work better as signals, so disable character forms */
-  s.main.c_cc[VQUIT] = 0377;
-  s.main.c_cc[VINTR] = 0377;
+  s.main.c_cc[VQUIT] = CDISABLE;
+  s.main.c_cc[VINTR] = CDISABLE;
   s.main.c_lflag &= ~ISIG;
 #endif /* no TIOCGPGRP or no TIOCGLTC or no TIOCGETC */
-  s.main.c_cc[VEOL] = 0377;
+  s.main.c_cc[VEOL] = CDISABLE;
   s.main.c_cflag = (s.main.c_cflag & ~CBAUD) | B9600; /* baud rate sanity */
 #endif /* AIX */
 
@@ -1550,10 +1550,10 @@ nil means don't delete them until `list-processes' is run.  */);
   tty.main.c_line = 0;
   tty.main.c_iflag &= ~ASCEDIT;
 #else
-  tty.main.c_cc[VSTRT] = 255;
-  tty.main.c_cc[VSTOP] = 255;
-  tty.main.c_cc[VSUSP] = 255;
-  tty.main.c_cc[VDSUSP] = 255;
+  tty.main.c_cc[VSTRT] = CDISABLE;
+  tty.main.c_cc[VSTOP] = CDISABLE;
+  tty.main.c_cc[VSUSP] = CDISABLE;
+  tty.main.c_cc[VDSUSP] = CDISABLE;
 #endif /* IBMR2AIX */
   if (tty_out->flow_control)
     {
diff --git a/src/w32proc.c b/src/w32proc.c
index 8452337f7e2..9abee2bf0c2 100644
--- a/src/w32proc.c
+++ b/src/w32proc.c
@@ -1218,7 +1218,7 @@ count_children:
     {
       DebPrint (("select.WaitForMultipleObjects (%d, %lu) failed with %lu\n",
                  nh + nc, timeout_ms, GetLastError ()));
-      /* don't return EBADF - this causes wait_reading_process_input to
+      /* don't return EBADF - this causes wait_reading_process_output to
          abort; WAIT_FAILED is returned when single-stepping under
          Windows 95 after switching thread focus in debugger, and
          possibly at other times. */
diff --git a/src/w32term.c b/src/w32term.c
index 9629595561c..0614522a178 100644
--- a/src/w32term.c
+++ b/src/w32term.c
@@ -4570,7 +4570,7 @@ w32_read_socket (sd, expected, hold_quit)
                   f->async_visible = 1;
                   f->async_iconified = 0;
 
-                  /* wait_reading_process_input will notice this and update
+                  /* wait_reading_process_output will notice this and update
                      the frame's display structures.  */
                   SET_FRAME_GARBAGED (f);
 
diff --git a/src/xdisp.c b/src/xdisp.c
index 70854b7d269..7cbc022380d 100644
--- a/src/xdisp.c
+++ b/src/xdisp.c
@@ -10377,7 +10377,7 @@ redisplay_internal (preserve_echo_area)
    This is useful in situations where you need to redisplay but no
    user action has occurred, making it inappropriate for the message
    area to be cleared.  See tracking_off and
-   wait_reading_process_input for examples of these situations.
+   wait_reading_process_output for examples of these situations.
 
    FROM_WHERE is an integer saying from where this function was
    called.  This is useful for debugging.  */
diff --git a/src/xfns.c b/src/xfns.c
index 7963a910d14..762b45d0089 100644
--- a/src/xfns.c
+++ b/src/xfns.c
@@ -1661,7 +1661,7 @@ x_set_name (f, name, explicit)
           }
 #ifdef USE_GTK
         gtk_window_set_title (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f)),
-                              SDATA (name));
+                              SDATA (ENCODE_UTF_8 (name)));
 #else /* not USE_GTK */
         XSetWMName (FRAME_X_DISPLAY (f), FRAME_OUTER_WINDOW (f), &text);
 #endif /* not USE_GTK */
@@ -1769,7 +1769,7 @@ x_set_title (f, name, old_name)
 
 #ifdef USE_GTK
         gtk_window_set_title (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f)),
-                              SDATA (name));
+                              SDATA (ENCODE_UTF_8 (name)));
 #else /* not USE_GTK */
         XSetWMName (FRAME_X_DISPLAY (f), FRAME_OUTER_WINDOW (f), &text);
 #endif /* not USE_GTK */
diff --git a/src/xselect.c b/src/xselect.c
index 8c8f1f98668..a10befe2cdb 100644
--- a/src/xselect.c
+++ b/src/xselect.c
@@ -1117,7 +1117,8 @@ wait_for_property_change (location)
       secs = x_selection_timeout / 1000;
       usecs = (x_selection_timeout % 1000) * 1000;
       TRACE2 ("  Waiting %d secs, %d usecs", secs, usecs);
-      wait_reading_process_input (secs, usecs, property_change_reply, 0);
+      wait_reading_process_output (secs, usecs, 0, 0,
+                                   property_change_reply, NULL, 0);
 
       if (NILP (XCAR (property_change_reply)))
         {
@@ -1305,7 +1306,8 @@ x_get_foreign_selection (selection_symbol, target_type, time_stamp)
   secs = x_selection_timeout / 1000;
   usecs = (x_selection_timeout % 1000) * 1000;
   TRACE1 ("  Start waiting %d secs for SelectionNotify", secs);
-  wait_reading_process_input (secs, usecs, reading_selection_reply, 0);
+  wait_reading_process_output (secs, usecs, 0, 0,
+                               reading_selection_reply, NULL, 0);
   TRACE1 ("  Got event = %d", !NILP (XCAR (reading_selection_reply)));
 
   BLOCK_INPUT;
diff --git a/src/xterm.c b/src/xterm.c
index c8b5921a3b5..eb455522d1c 100644
--- a/src/xterm.c
+++ b/src/xterm.c
@@ -6178,7 +6178,7 @@ handle_one_xevent (dpyinfo, eventp, finish, hold_quit)
       f = x_top_window_to_frame (dpyinfo, event.xmap.window);
       if (f)
         {
-          /* wait_reading_process_input will notice this and update
+          /* wait_reading_process_output will notice this and update
              the frame's display structures.
              If we where iconified, we should not set garbaged,
              because that stops redrawing on Expose events.  This looks