Merge from emacs--devo--0

Patches applied:

 * emacs--devo--0  (patch 300-313)

   - Update from CVS
   - Update from CVS: lispref/display.texi (Forcing Redisplay): Fix typo.
   - Merge from gnus--rel--5.10

 * gnus--rel--5.10  (patch 105-106)

   - Update from CVS

Revision: emacs@sv.gnu.org/emacs--unicode--0--patch-74

13 files changed, 839 insertions, 174 deletions

diff --git a/src/.gdbinit b/src/.gdbinit
index 7de361fddfb..dd848fed3d5 100644
--- a/src/.gdbinit
+++ b/src/.gdbinit
@@ -190,12 +190,8 @@ define pitx
       printf " ch=[%d,%d]", $it->c, $it->len
     end
   else
-    if ($it->what == IT_IMAGE)
-      printf " IMAGE=%d", $it->image_id
-    else
-      printf " "
-      output $it->what
-    end
+    printf " "
+    output $it->what
   end
   if ($it->method != GET_FROM_BUFFER)
     printf " next="
@@ -203,6 +199,12 @@ define pitx
     if ($it->method == GET_FROM_STRING)
       printf "[%d]", $it->current.string_pos.charpos
     end
+    if ($it->method == GET_FROM_IMAGE)
+      printf "[%d]", $it->image_id
+    end
+    if ($it->method == GET_FROM_COMPOSITION)
+      printf "[%d,%d,%d]", $it->cmp_id, $it->len, $it->cmp_len
+    end
   end
   printf "\n"
   if ($it->region_beg_charpos >= 0)
@@ -372,6 +374,121 @@ document pwin
 Pretty print window structure w.
 end
 
+define pgx
+  set $g = $arg0
+  if ($g->type == CHAR_GLYPH)
+    if ($g->u.ch >= ' ' && $g->u.ch < 127)
+      printf "CHAR[%c]", $g->u.ch
+    else
+      printf "CHAR[0x%x]", $g->u.ch
+    end
+  end
+  if ($g->type == COMPOSITE_GLYPH)
+    printf "COMP[%d]", $g->u.cmp_id
+  end
+  if ($g->type == IMAGE_GLYPH)
+    printf "IMAGE[%d]", $g->u.img_id
+  end
+  if ($g->type == STRETCH_GLYPH)
+    printf "STRETCH[%d+%d]", $g->u.stretch.height, $g->u.stretch.ascent
+  end
+  xgettype ($g->object)
+  if ($type == Lisp_String)
+    printf " str=%x[%d]", $g->object, $g->charpos
+  else
+    printf " pos=%d", $g->charpos
+  end
+  printf " w=%d a+d=%d+%d", $g->pixel_width, $g->ascent, $g->descent
+  if ($g->face_id != DEFAULT_FACE_ID)
+    printf " face=%d", $g->face_id
+  end
+  if ($g->voffset)
+    printf " vof=%d", $g->voffset
+  end
+  if ($g->multibyte_p)
+    printf " MB"
+  end
+  if ($g->padding_p)
+    printf " PAD"
+  end
+  if ($g->glyph_not_available_p)
+    printf " N/A"
+  end
+  if ($g->overlaps_vertically_p)
+    printf " OVL"
+  end
+  if ($g->left_box_line_p)
+    printf " ["
+  end
+  if ($g->right_box_line_p)
+    printf " ]"
+  end
+  if ($g->slice.x || $g->slice.y || $g->slice.width || $g->slice.height)
+    printf " slice=%d,%d,%d,%d" ,$g->slice.x, $g->slice.y, $g->slice.width, $g->slice.height
+  end
+  printf "\n"
+end
+document pgx
+Pretty print a glyph structure.
+Takes one argument, a pointer to a glyph structure
+end
+
+define pg
+  set $pgidx = 0
+  pgx glyph
+end
+document pg
+Pretty print glyph structure glyph.
+end
+
+define pgi
+  set $pgidx = $arg0
+  pgx (&glyph[$pgidx])
+end
+document pgi
+Pretty print glyph structure glyph[I].
+Takes one argument, a integer I.
+end
+
+define pgn
+  set $pgidx = $pgidx + 1
+  pgx (&glyph[$pgidx])
+end
+document pgn
+Pretty print next glyph structure.
+end
+
+define pgrowx
+  set $row = $arg0
+  set $area = 0
+  set $xofs = $row->x
+  while ($area < 3)
+    set $used = $row->used[$area]
+    if ($used > 0)
+      set $gl0 = $row->glyphs[$area]
+      set $pgidx = 0
+      printf "%s: %d glyphs\n", ($area == 0 ? "LEFT" : $area == 2 ? "RIGHT" : "TEXT"), $used
+      while ($pgidx < $used)
+        printf "%3d %4d: ", $pgidx, $xofs
+        pgx $gl0[$pgidx]
+        set $xofs = $xofs + $gl0[$pgidx]->pixel_width
+        set $pgidx = $pgidx + 1
+      end
+    end
+    set $area = $area + 1
+  end
+end
+document pgrowx
+Pretty print all glyphs in a row structure.
+Takes one argument, a pointer to a row structure.
+end
+
+define pgrow
+  pgrowx row
+end
+document pgrow
+Pretty print all glyphs in row structure row.
+end
 
 define xtype
   xgettype $
diff --git a/src/ChangeLog b/src/ChangeLog
index d0ad63de10d..c4c798e6f77 100644
--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -1,3 +1,126 @@
+2006-06-17  Kim F. Storm  <storm@cua.dk>
+
+        * dispnew.c (update_frame): Check for input pending on entry.
+        (update_window, update_frame_1): Break loop if input is detected.
+
+2006-06-16  Francis Litterio  <flitterio@gmail.com>
+
+        * xterm.c (x_check_expected_move, handle_one_xevent)
+        (x_set_offset, x_check_fullscreen): Extensive changes to make
+        frame positioning deterministic under X.
+
+        * xterm.h (x_output): Added members left_before_move and
+        top_before_move.  Removed members expected_left and expected_top.
+
+2006-06-16  Kim F. Storm  <storm@cua.dk>
+
+        * dispextern.h (struct it): Add union to iterator stack to save
+        image, composition, and stretch specific paramters.
+
+        * xdisp.c (next_overlay_string): Fix assert.
+        (push_it, pop_it): Handle composition and stretch specific values.
+        Only handle it->slice in image (for now).
+        (back_to_previous_visible_line_start): Continue search if newline is
+        part of a compisition.  Simplify.
+        (reseat_1): Set it->object to buffer.
+        (set_iterator_to_next): Set it->object to string or buffer, when
+        setting it->method to GET_FROM_STRING or GET_FROM_BUFFER.
+        (next_element_from_composition): Set it->object to buffer if not
+        from string.
+        (set_cursor_from_row): Only save start of string if not already
+        done to handle multiple strings in a row.
+
+        * .gdbinit (pitx): Show composition parameters.
+        (pgx, pg): New commands to print a glyph structure.
+        (pgi, pgn): New commands to print specific/next glyph.
+        (pgrowx, pgrow): New commands to print all glyphs in a row.
+
+2006-06-16  YAMAMOTO Mitsuharu  <mituharu@math.s.chiba-u.ac.jp>
+
+        * macfns.c (Fx_display_mm_height, Fx_display_mm_width)
+        [MAC_OS_X_VERSION_MAX_ALLOWED >= 1030]: Use CGDisplayScreenSize.
+
+        * macterm.c (do_app_resume, do_app_suspend): Remove functions.
+        (mac_tsm_resume, mac_tsm_suspend) [USE_MAC_TSM]: New functions.
+        (mac_handle_window_event, XTread_socket) [USE_MAC_TSM]: Use them.
+        (Vmac_ts_script_language_on_focus) [USE_MAC_TSM]: New variable.
+        (syms_of_macterm) [USE_MAC_TSM]: Defvar it.
+        (saved_ts_language, saved_ts_component) [USE_MAC_TSM]: New variables.
+        (mac_initialize_display_info) [MAC_OSX]: Use Quartz Display
+        Services functions to get size of main display in pixels.
+
+2006-06-14  Chong Yidong  <cyd@stupidchicken.com>
+
+        * xdisp.c (back_to_previous_visible_line_start): Reset
+        it->continuation_lines_width.
+
+2006-06-14  Richard Stallman  <rms@gnu.org>
+
+        * eval.c (Fdefconst): Mark variable as risky.
+
+        * callproc.c (Fcall_process): Doc fix.
+
+        * window.c (adjust_window_trailing_edge): Don't break out of the loop
+        because there's no next window, if there are parallel windows.
+        Do break out when WINDOW is nil.
+
+2006-06-14  Kim F. Storm  <storm@cua.dk>
+
+        * dispextern.h (IT_STACK_SIZE): New macro specifying size of
+        iterator stack (instead of hardcoded number).  Increase from 2 to
+        4 to make room for propertized overlay strings before and after a
+        display string, image or composition.
+        (struct it): Add image_id and method members to iterator stack.
+
+        * xdisp.c (init_from_display_pos): Don't set it->method and
+        overlay_string_index after pop_it.  Add asserts.
+        (handle_stop): Look for overlay strings around a display string,
+        image, or composition.  Handle properties on those strings.
+        (next_overlay_string): Don't set string, pos or method after pop_it.
+        (get_overlay_strings_1): Split from get_overlay_strings; don't
+        modify it if no overlay strings are found.
+        (get_overlay_strings): Use get_overlay_strings_1.  Always set
+        it->string and it->method.
+        (push_it): Push it->image_id and it->method.  Push it->object
+        instead of it->string if method is GET_FROM_IMAGE.
+        (pop_it): Pop it->image_id and it->method.  Ppo it->object
+        instead of it->string if method is GET_FROM_IMAGE.
+        Reset it->current.string_pos if popped it->string is nil.
+        (reseat_1): Remove comment dated 19 May 2003.  It expressed doubt
+        whether a given change was correct; but the change is correct.
+        Clear it->string_from_display_prop_p.
+        (set_iterator_to_next): Rely on it->method and it->image_id from
+        iterator stack, instead of setting them explicitly after pop_it.
+
+        * dispnew.c (sit_for): Undo 2006-06-01 change.  Instead, a
+        negative time forces redisplay even when input is available.
+        (Fsit_for): Doc fix.
+
+2006-06-13  Kim F. Storm  <storm@cua.dk>
+
+        * dispnew.c: Modify preemptive redisplay to be based on periodic
+        checks for input.
+        (PERIODIC_PREEMPTION_CHECKING): Define to 1 iff EMACS_HAS_USECS.
+        (Vredisplay_preemption_period): New variable.
+        (syms_of_display): DEFVAR_LISP and initialize it.
+        (preemption_period, preemption_next_check): New variables.
+        (update_frame, update_single_window): Initialize them based on
+        Vredisplay_preemption_period if !force_p.
+        (update_window, update_frame_1): Use them to determine when to
+        check for input.
+
+2006-06-03  Aidan Kehoe  <kehoea@parhasard.net>
+
+        * lread.c (read_escape): Provide a Unicode character escape
+        syntax; \u followed by exactly four or \U followed by exactly
+        eight hex digits in a comment or string is read as a Unicode
+        character with that code point.
+
+2006-06-09  Eli Zaretskii  <eliz@gnu.org>
+
+        * window.c (window_scroll_pixel_based): Signal "Beginning of
+        buffer" when scroll-down at the beginning of an empty buffer.
+
 2006-06-06  YAMAMOTO Mitsuharu  <mituharu@math.s.chiba-u.ac.jp>
 
         * macterm.c [USE_MAC_TSM] (mac_handle_text_input_event): Exclude
diff --git a/src/callproc.c b/src/callproc.c
index 4fcf2ec0eda..d8eebac08a6 100644
--- a/src/callproc.c
+++ b/src/callproc.c
@@ -203,6 +203,10 @@ t (mix it with ordinary output), or a file name string.
 Fourth arg DISPLAY non-nil means redisplay buffer as output is inserted.
 Remaining arguments are strings passed as command arguments to PROGRAM.
 
+If executable PROGRAM can't be found as an executable, `call-process'
+signals a Lisp error.  `call-process' reports errors in execution of
+the program only through its return and output.
+
 If BUFFER is 0, `call-process' returns immediately with value nil.
 Otherwise it waits for PROGRAM to terminate
 and returns a numeric exit status or a signal description string.
diff --git a/src/dispextern.h b/src/dispextern.h
index 92005e6b149..8c9c427f68d 100644
--- a/src/dispextern.h
+++ b/src/dispextern.h
@@ -1827,6 +1827,8 @@ enum it_method {
   NUM_IT_METHODS
 };
 
+#define IT_STACK_SIZE 4
+
 struct it
 {
   /* The window in which we iterate over current_buffer (or a string).  */
@@ -1938,19 +1940,34 @@ struct it
     int stop_charpos;
     int face_id;
     Lisp_Object string;
+    union {
+      struct {
+        Lisp_Object object;
+        struct it_slice slice;
+        int image_id;
+      } image;
+      struct {
+        Lisp_Object object;
+        int c, len;
+        int cmp_id, cmp_len;
+      } comp;
+      struct {
+        Lisp_Object object;
+      } stretch;
+    } u;
     struct display_pos pos;
     int end_charpos;
     int string_nchars;
     enum glyph_row_area area;
+    enum it_method method;
     unsigned multibyte_p : 1;
     unsigned string_from_display_prop_p : 1;
     unsigned display_ellipsis_p : 1;
-    struct it_slice slice;
     Lisp_Object space_width;
     short voffset;
     Lisp_Object font_height;
   }
-  stack[2];
+  stack[IT_STACK_SIZE];
 
   /* Stack pointer.  */
   int sp;
diff --git a/src/dispnew.c b/src/dispnew.c
index f239d6969f4..b899cd2bd93 100644
--- a/src/dispnew.c
+++ b/src/dispnew.c
@@ -192,6 +192,28 @@ struct window *frame_row_to_window P_ ((struct window *, int));
 
 int redisplay_dont_pause;
 
+/* Define PERIODIC_PREEMPTION_CHECKING to 1, if micro-second timers
+   are supported, so we can check for input during redisplay at
+   regular intervals.  */
+#ifdef EMACS_HAS_USECS
+#define PERIODIC_PREEMPTION_CHECKING 1
+#else
+#define PERIODIC_PREEMPTION_CHECKING 0
+#endif
+
+#if PERIODIC_PREEMPTION_CHECKING
+
+/* If a number (float), check for user input every N seconds.  */
+
+Lisp_Object Vredisplay_preemption_period;
+
+/* Redisplay preemption timers.  */
+
+static EMACS_TIME preemption_period;
+static EMACS_TIME preemption_next_check;
+
+#endif
+
 /* Nonzero upon entry to redisplay means do not assume anything about
    current contents of actual terminal frame; clear and redraw it.  */
 
@@ -3806,6 +3828,28 @@ update_frame (f, force_p, inhibit_hairy_id_p)
   int paused_p;
   struct window *root_window = XWINDOW (f->root_window);
 
+#if PERIODIC_PREEMPTION_CHECKING
+  if (!force_p && NUMBERP (Vredisplay_preemption_period))
+    {
+      EMACS_TIME tm;
+      double p = XFLOATINT (Vredisplay_preemption_period);
+      int sec, usec;
+
+      if (detect_input_pending_ignore_squeezables ())
+        {
+          paused_p = 1;
+          goto do_pause;
+        }
+
+      sec = (int) p;
+      usec = (p - sec) * 1000000;
+
+      EMACS_GET_TIME (tm);
+      EMACS_SET_SECS_USECS (preemption_period, sec, usec);
+      EMACS_ADD_TIME (preemption_next_check, tm, preemption_period);
+    }
+#endif
+
   if (FRAME_WINDOW_P (f))
     {
       /* We are working on window matrix basis.  All windows whose
@@ -3884,6 +3928,7 @@ update_frame (f, force_p, inhibit_hairy_id_p)
 #endif
     }
 
+ do_pause:
   /* Reset flags indicating that a window should be updated.  */
   set_window_update_flags (root_window, 0);
 
@@ -3938,6 +3983,22 @@ update_single_window (w, force_p)
       /* Record that this is not a frame-based redisplay.  */
       set_frame_matrix_frame (NULL);
 
+#if PERIODIC_PREEMPTION_CHECKING
+      if (!force_p && NUMBERP (Vredisplay_preemption_period))
+        {
+          EMACS_TIME tm;
+          double p = XFLOATINT (Vredisplay_preemption_period);
+          int sec, usec;
+
+          sec = (int) p;
+          usec = (p - sec) * 1000000;
+
+          EMACS_GET_TIME (tm);
+          EMACS_SET_SECS_USECS (preemption_period, sec, usec);
+          EMACS_ADD_TIME (preemption_next_check, tm, preemption_period);
+        }
+#endif
+
       /* Update W.  */
       update_begin (f);
       update_window (w, force_p);
@@ -4093,7 +4154,9 @@ update_window (w, force_p)
 {
   struct glyph_matrix *desired_matrix = w->desired_matrix;
   int paused_p;
+#if !PERIODIC_PREEMPTION_CHECKING
   int preempt_count = baud_rate / 2400 + 1;
+#endif
   extern int input_pending;
   extern Lisp_Object do_mouse_tracking;
 #if GLYPH_DEBUG
@@ -4105,8 +4168,13 @@ update_window (w, force_p)
   /* Check pending input the first time so that we can quickly return.  */
   if (redisplay_dont_pause)
     force_p = 1;
-  else
+#if PERIODIC_PREEMPTION_CHECKING
+  else if (NILP (Vredisplay_preemption_period))
+    force_p = 1;
+#else
+  else if (!force_p)
     detect_input_pending_ignore_squeezables ();
+#endif
 
   /* If forced to complete the update, or if no input is pending, do
      the update.  */
@@ -4178,9 +4246,23 @@ update_window (w, force_p)
                detect_input_pending.  If it's done too often,
                scrolling large windows with repeated scroll-up
                commands will too quickly pause redisplay.  */
+#if PERIODIC_PREEMPTION_CHECKING
+            if (!force_p)
+              {
+                EMACS_TIME tm, dif;
+                EMACS_GET_TIME (tm);
+                EMACS_SUB_TIME (dif, preemption_next_check, tm);
+                if (EMACS_TIME_NEG_P (dif))
+                  {
+                    EMACS_ADD_TIME (preemption_next_check, tm, preemption_period);
+                    if (detect_input_pending_ignore_squeezables ())
+                      break;
+                  }
+              }
+#else
             if (!force_p && ++n_updated % preempt_count == 0)
               detect_input_pending_ignore_squeezables ();
-
+#endif
             changed_p |= update_window_line (w, vpos,
                                              &mouse_face_overwritten_p);
 
@@ -5131,11 +5213,16 @@ update_frame_1 (f, force_p, inhibit_id_p)
 
   if (redisplay_dont_pause)
     force_p = 1;
+#if PERIODIC_PREEMPTION_CHECKING
+  else if (NILP (Vredisplay_preemption_period))
+    force_p = 1;
+#else
   else if (!force_p && detect_input_pending_ignore_squeezables ())
     {
       pause = 1;
       goto do_pause;
     }
+#endif
 
   /* If we cannot insert/delete lines, it's no use trying it.  */
   if (!line_ins_del_ok)
@@ -5186,8 +5273,23 @@ update_frame_1 (f, force_p, inhibit_id_p)
                 }
             }
 
-          if ((i - 1) % preempt_count == 0)
+#if PERIODIC_PREEMPTION_CHECKING
+          if (!force_p)
+            {
+              EMACS_TIME tm, dif;
+              EMACS_GET_TIME (tm);
+              EMACS_SUB_TIME (dif, preemption_next_check, tm);
+              if (EMACS_TIME_NEG_P (dif))
+                {
+                  EMACS_ADD_TIME (preemption_next_check, tm, preemption_period);
+                  if (detect_input_pending_ignore_squeezables ())
+                    break;
+                }
+            }
+#else
+          if (!force_p && (i - 1) % preempt_count == 0)
             detect_input_pending_ignore_squeezables ();
+#endif
 
           update_frame_line (f, i);
         }
@@ -6388,15 +6490,22 @@ Lisp_Object
 sit_for (sec, usec, reading, display, initial_display)
      int sec, usec, reading, display, initial_display;
 {
+  int preempt = (sec >= 0) || (sec == 0 && usec >= 0);
+
   swallow_events (display);
 
-  if ((detect_input_pending_run_timers (display)
-       && !redisplay_dont_pause)
+  if ((detect_input_pending_run_timers (display) && preempt)
       || !NILP (Vexecuting_kbd_macro))
     return Qnil;
 
   if (initial_display)
-    redisplay_preserve_echo_area (2);
+    {
+      int count = SPECPDL_INDEX ();
+      if (!preempt)
+        specbind (Qredisplay_dont_pause, Qt);
+      redisplay_preserve_echo_area (2);
+      unbind_to (count, Qnil);
+    }
 
   if (sec == 0 && usec == 0)
     return Qt;
@@ -6422,8 +6531,7 @@ Redisplay is preempted as always if input arrives, and does not happen
 if input is available before it starts.
 Value is t if waited the full time with no input arriving.
 
-Redisplay will occur even when input is available if you bind
-`redisplay-dont-pause' to a non-nil value.
+Redisplay will occur even when input is available if SECONDS is negative.
 
 An obsolete but still supported form is
 \(sit-for SECONDS &optional MILLISECONDS NODISP)
@@ -6922,7 +7030,14 @@ See `buffer-display-table' for more information.  */);
                doc: /* *Non-nil means update isn't paused when input is detected.  */);
   redisplay_dont_pause = 0;
 
-  /* Initialize `window-system', unless init_display already decided it.  */
+#if PERIODIC_PREEMPTION_CHECKING
+  DEFVAR_LISP ("redisplay-preemption-period", &Vredisplay_preemption_period,
+               doc: /* *The period in seconds between checking for input during redisplay.
+If input is detected, redisplay is pre-empted, and the input is processed.
+If nil, never pre-empt redisplay.  */);
+  Vredisplay_preemption_period = make_float (0.10);
+#endif
+
 #ifdef CANNOT_DUMP
   if (noninteractive)
 #endif
diff --git a/src/eval.c b/src/eval.c
index 20f29b5f06b..5f8d266ec7b 100644
--- a/src/eval.c
+++ b/src/eval.c
@@ -195,9 +195,10 @@ int handling_signal;
 
 Lisp_Object Vmacro_declaration_function;
 
+extern Lisp_Object Qrisky_local_variable;
 
 static Lisp_Object funcall_lambda P_ ((Lisp_Object, int, Lisp_Object*));
-
+
 void
 init_eval_once ()
 {
@@ -895,6 +896,7 @@ usage: (defconst SYMBOL INITVALUE [DOCSTRING])  */)
         tem = Fpurecopy (tem);
       Fput (sym, Qvariable_documentation, tem);
     }
+  Fput (sym, Qrisky_local_variable, Qt);
   LOADHIST_ATTACH (sym);
   return sym;
 }
diff --git a/src/lread.c b/src/lread.c
index d8abde1c458..6ea92d1aebf 100644
--- a/src/lread.c
+++ b/src/lread.c
@@ -1924,6 +1924,9 @@ read_escape (readcharfun, stringp)
      int stringp;
 {
   register int c = READCHAR;
+  /* \u allows up to four hex digits, \U up to eight. Default to the
+     behaviour for \u, and change this value in the case that \U is seen. */
+  int unicode_hex_count = 4;
 
   switch (c)
     {
@@ -2090,6 +2093,52 @@ read_escape (readcharfun, stringp)
         return i;
       }
 
+    case 'U':
+      /* Post-Unicode-2.0: Up to eight hex chars.  */
+      unicode_hex_count = 8;
+    case 'u':
+
+      /* A Unicode escape. We only permit them in strings and characters,
+         not arbitrarily in the source code, as in some other languages.  */
+      {
+        int i = 0;
+        int count = 0;
+        Lisp_Object lisp_char;
+        struct gcpro gcpro1;
+
+        while (++count <= unicode_hex_count)
+          {
+            c = READCHAR;
+            /* isdigit(), isalpha() may be locale-specific, which we don't
+               want. */
+            if      (c >= '0' && c <= '9')  i = (i << 4) + (c - '0');
+            else if (c >= 'a' && c <= 'f')  i = (i << 4) + (c - 'a') + 10;
+            else if (c >= 'A' && c <= 'F')  i = (i << 4) + (c - 'A') + 10;
+            else
+              {
+                error ("Non-hex digit used for Unicode escape");
+                break;
+              }
+          }
+
+        GCPRO1 (readcharfun);
+        lisp_char = call2(intern("decode-char"), intern("ucs"),
+                          make_number(i));
+        UNGCPRO;
+
+        if (EQ(Qnil, lisp_char))
+          {
+            /* This is ugly and horrible and trashes the user's data.  */
+            XSETFASTINT (i, MAKE_CHAR (charset_katakana_jisx0201,
+                                       34 + 128, 46 + 128));
+            return i;
+          }
+        else
+          {
+            return XFASTINT (lisp_char);
+          }
+      }
+
     default:
       return c;
     }
diff --git a/src/macfns.c b/src/macfns.c
index 1c774f8ade2..6d77aea0409 100644
--- a/src/macfns.c
+++ b/src/macfns.c
@@ -3070,11 +3070,20 @@ If omitted or nil, that stands for the selected frame's display.  */)
      (display)
      Lisp_Object display;
 {
-  /* MAC_TODO: this is an approximation, and only of the main display */
-
   struct mac_display_info *dpyinfo = check_x_display_info (display);
+  /* Only of the main display.  */
+#if MAC_OS_X_VERSION_MAX_ALLOWED >= 1030
+  CGSize size;
+
+  BLOCK_INPUT;
+  size = CGDisplayScreenSize (kCGDirectMainDisplay);
+  UNBLOCK_INPUT;
 
+  return make_number ((int) (size.height + .5f));
+#else
+  /* This is an approximation.  */
   return make_number ((int) (dpyinfo->height * 25.4 / dpyinfo->resy));
+#endif
 }
 
 DEFUN ("x-display-mm-width", Fx_display_mm_width, Sx_display_mm_width, 0, 1, 0,
@@ -3085,11 +3094,20 @@ If omitted or nil, that stands for the selected frame's display.  */)
      (display)
      Lisp_Object display;
 {
-  /* MAC_TODO: this is an approximation, and only of the main display */
-
   struct mac_display_info *dpyinfo = check_x_display_info (display);
+  /* Only of the main display.  */
+#if MAC_OS_X_VERSION_MAX_ALLOWED >= 1030
+  CGSize size;
+
+  BLOCK_INPUT;
+  size = CGDisplayScreenSize (kCGDirectMainDisplay);
+  UNBLOCK_INPUT;
 
+  return make_number ((int) (size.width + .5f));
+#else
+  /* This is an approximation.  */
   return make_number ((int) (dpyinfo->width * 25.4 / dpyinfo->resx));
+#endif
 }
 
 DEFUN ("x-display-backing-store", Fx_display_backing_store,
diff --git a/src/macterm.c b/src/macterm.c
index dc449498a4a..7e354642759 100644
--- a/src/macterm.c
+++ b/src/macterm.c
@@ -8533,6 +8533,9 @@ static Lisp_Object Qtext_input;
 static Lisp_Object Qupdate_active_input_area, Qunicode_for_key_event;
 static Lisp_Object Vmac_ts_active_input_overlay;
 extern Lisp_Object Qbefore_string;
+static Lisp_Object Vmac_ts_script_language_on_focus;
+static ScriptLanguageRecord saved_ts_language;
+static Component saved_ts_component;
 #endif
 #endif
 extern int mac_ready_for_apple_events;
@@ -8882,22 +8885,84 @@ is_emacs_window (WindowPtr win)
   return 0;
 }
 
-static void
-do_app_resume ()
-{
 #if USE_MAC_TSM
-  ActivateTSMDocument (tsm_document_id);
+static OSStatus
+mac_tsm_resume ()
+{
+  OSStatus err;
+  ScriptLanguageRecord slrec, *slptr = NULL;
+
+  err = ActivateTSMDocument (tsm_document_id);
+
+  if (err == noErr)
+    {
+      if (EQ (Vmac_ts_script_language_on_focus, Qt))
+        slptr = &saved_ts_language;
+      else if (CONSP (Vmac_ts_script_language_on_focus)
+               && INTEGERP (XCAR (Vmac_ts_script_language_on_focus))
+               && INTEGERP (XCDR (Vmac_ts_script_language_on_focus)))
+        {
+          slrec.fScript = XINT (XCAR (Vmac_ts_script_language_on_focus));
+          slrec.fLanguage = XINT (XCDR (Vmac_ts_script_language_on_focus));
+          slptr = &slrec;
+        }
+    }
+
+  if (slptr)
+    {
+#if MAC_OS_X_VERSION_MAX_ALLOWED >= 1020
+      err = SetDefaultInputMethodOfClass (saved_ts_component, slptr,
+                                          kKeyboardInputMethodClass);
+#else
+      err = SetDefaultInputMethod (saved_ts_component, slptr);
 #endif
+      if (err == noErr)
+        err = SetTextServiceLanguage (slptr);
+
+      /* Seems to be needed on Mac OS X 10.2.  */
+      if (err == noErr)
+        KeyScript (slptr->fScript | smKeyForceKeyScriptMask);
+    }
+
+  return err;
 }
 
-static void
-do_app_suspend ()
+static OSStatus
+mac_tsm_suspend ()
 {
-#if USE_MAC_TSM
-  DeactivateTSMDocument (tsm_document_id);
+  OSStatus err;
+  ScriptLanguageRecord slrec, *slptr = NULL;
+
+  if (EQ (Vmac_ts_script_language_on_focus, Qt))
+    {
+      err = GetTextServiceLanguage (&saved_ts_language);
+      if (err == noErr)
+        slptr = &saved_ts_language;
+    }
+  else if (CONSP (Vmac_ts_script_language_on_focus)
+           && INTEGERP (XCAR (Vmac_ts_script_language_on_focus))
+           && INTEGERP (XCDR (Vmac_ts_script_language_on_focus)))
+    {
+      slrec.fScript = XINT (XCAR (Vmac_ts_script_language_on_focus));
+      slrec.fLanguage = XINT (XCDR (Vmac_ts_script_language_on_focus));
+      slptr = &slrec;
+    }
+
+  if (slptr)
+    {
+#if MAC_OS_X_VERSION_MAX_ALLOWED >= 1020
+      GetDefaultInputMethodOfClass (&saved_ts_component, slptr,
+                                    kKeyboardInputMethodClass);
+#else
+      GetDefaultInputMethod (&saved_ts_component, slptr);
 #endif
-}
+    }
 
+  err = DeactivateTSMDocument (tsm_document_id);
+
+  return err;
+}
+#endif
 
 static void
 do_apple_menu (SInt16 menu_item)
@@ -9351,12 +9416,12 @@ mac_handle_window_event (next_handler, event, data)
 #if USE_MAC_TSM
     case kEventWindowFocusAcquired:
       result = CallNextEventHandler (next_handler, event);
-      err = ActivateTSMDocument (tsm_document_id);
+      err = mac_tsm_resume ();
       return err == noErr ? noErr : result;
 
     case kEventWindowFocusRelinquish:
       result = CallNextEventHandler (next_handler, event);
-      err = DeactivateTSMDocument (tsm_document_id);
+      err = mac_tsm_suspend ();
       return err == noErr ? noErr : result;
 #endif
     }
@@ -10391,10 +10456,12 @@ XTread_socket (sd, expected, hold_quit)
           switch ((er.message >> 24) & 0x000000FF)
             {
             case suspendResumeMessage:
-              if ((er.message & resumeFlag) == 1)
-                do_app_resume ();
+#if USE_MAC_TSM
+              if (er.message & resumeFlag)
+                mac_tsm_resume ();
               else
-                do_app_suspend ();
+                mac_tsm_suspend ();
+#endif
               break;
 
             case mouseMovedMessage:
@@ -10957,7 +11024,6 @@ void
 mac_initialize_display_info ()
 {
   struct mac_display_info *dpyinfo = &one_mac_display_info;
-  GDHandle main_device_handle;
 
   bzero (dpyinfo, sizeof (*dpyinfo));
 
@@ -10973,37 +11039,29 @@ mac_initialize_display_info ()
   strcpy (dpyinfo->mac_id_name, "Mac Display");
 #endif
 
-  main_device_handle = LMGetMainDevice();
-
   dpyinfo->reference_count = 0;
   dpyinfo->resx = 72.0;
   dpyinfo->resy = 72.0;
-  dpyinfo->color_p = TestDeviceAttribute (main_device_handle, gdDevType);
 #ifdef MAC_OSX
   /* HasDepth returns true if it is possible to have a 32 bit display,
-     but this may not be what is actually used.  Mac OSX can do better.
-     CGMainDisplayID is only available on OSX 10.2 and higher, but the
-     header for CGGetActiveDisplayList says that the first display returned
-     is the active one, so we use that.  */
+     but this may not be what is actually used.  Mac OSX can do better.  */
+  dpyinfo->color_p = 1;
+  dpyinfo->n_planes = CGDisplayBitsPerPixel (kCGDirectMainDisplay);
+  dpyinfo->height = CGDisplayPixelsHigh (kCGDirectMainDisplay);
+  dpyinfo->width = CGDisplayPixelsWide (kCGDirectMainDisplay);
+#else
   {
-    CGDirectDisplayID disp_id[1];
-    CGDisplayCount disp_count;
-    CGDisplayErr error_code;
-
-    error_code = CGGetActiveDisplayList (1, disp_id, &disp_count);
-    if (error_code != 0)
-      error ("No display found, CGGetActiveDisplayList error %d", error_code);
+    GDHandle main_device_handle = LMGetMainDevice();
 
-    dpyinfo->n_planes = CGDisplayBitsPerPixel (disp_id[0]);
+    dpyinfo->color_p = TestDeviceAttribute (main_device_handle, gdDevType);
+    for (dpyinfo->n_planes = 32; dpyinfo->n_planes > 0; dpyinfo->n_planes >>= 1)
+      if (HasDepth (main_device_handle, dpyinfo->n_planes,
+                    gdDevType, dpyinfo->color_p))
+        break;
+    dpyinfo->height = (**main_device_handle).gdRect.bottom;
+    dpyinfo->width = (**main_device_handle).gdRect.right;
   }
-#else
-  for (dpyinfo->n_planes = 32; dpyinfo->n_planes > 0; dpyinfo->n_planes >>= 1)
-    if (HasDepth (main_device_handle, dpyinfo->n_planes,
-                  gdDevType, dpyinfo->color_p))
-      break;
 #endif
-  dpyinfo->height = (**main_device_handle).gdRect.bottom;
-  dpyinfo->width = (**main_device_handle).gdRect.right;
   dpyinfo->grabbed = 0;
   dpyinfo->root_window = NULL;
   dpyinfo->image_cache = make_image_cache ();
@@ -11554,6 +11612,15 @@ order.  */);
   DEFVAR_LISP ("mac-ts-active-input-overlay", &Vmac_ts_active_input_overlay,
     doc: /* Overlay used to display Mac TSM active input area.  */);
   Vmac_ts_active_input_overlay = Qnil;
+
+  DEFVAR_LISP ("mac-ts-script-language-on-focus", &Vmac_ts_script_language_on_focus,
+    doc: /* *How to change Mac TSM script/language when a frame gets focus.
+If the value is t, the input script and language are restored to those
+used in the last focus frame.  If the value is a pair of integers, the
+input script and language codes, which are defined in the Script
+Manager, are set to its car and cdr parts, respectively.  Otherwise,
+Emacs doesn't set them and thus follows the system default behavior.  */);
+  Vmac_ts_script_language_on_focus = Qnil;
 #endif
 }
 
diff --git a/src/window.c b/src/window.c
index 59c223b4a8f..6a1edb24efb 100644
--- a/src/window.c
+++ b/src/window.c
@@ -4279,15 +4279,17 @@ adjust_window_trailing_edge (window, delta, horiz_flag)
     {
       Lisp_Object first_parallel = Qnil;
 
-      p = XWINDOW (window);
-      parent = p->parent;
-
-      if (NILP (XWINDOW (window)->next))
+      if (NILP (window))
         {
+          /* This can happen if WINDOW on the previous iteration was
+             at top level of the tree and we did not exit.  */
           Fset_window_configuration (old_config);
-          error ("No other window following this one");
+          error ("Specified window edge is fixed");
         }
 
+      p = XWINDOW (window);
+      parent = p->parent;
+
       /* See if this level has windows in parallel in the specified
          direction.  If so, set FIRST_PARALLEL to the first one.  */
       if (horiz_flag)
@@ -4301,6 +4303,14 @@ adjust_window_trailing_edge (window, delta, horiz_flag)
             first_parallel = XWINDOW (parent)->hchild;
         }
 
+      /* If this level's succession is in the desired dimension,
+         and this window is the last one, its trailing edge is fixed.  */
+      if (NILP (XWINDOW (window)->next) && NILP (first_parallel))
+        {
+          Fset_window_configuration (old_config);
+          error ("Specified window edge is fixed");
+        }
+
       /* Don't make this window too small.  */
       if (XINT (CURSIZE (window)) + delta
           < (horiz_flag ? window_min_width : window_min_height))
@@ -4324,7 +4334,7 @@ adjust_window_trailing_edge (window, delta, horiz_flag)
          we will fail and report an error, above.)  */
       if (NILP (first_parallel))
         {
-          if (!NILP (XWINDOW (window)->next))
+          if (!NILP (p->next))
             {
               /* This may happen for the minibuffer.  In that case
                  the window_deletion_count check below does not work.  */
@@ -4895,6 +4905,8 @@ window_scroll_pixel_based (window, n, whole, noerror)
             }
           else if (noerror)
             return;
+          else if (n < 0)       /* could happen with empty buffers */
+            Fsignal (Qbeginning_of_buffer, Qnil);
           else
             Fsignal (Qend_of_buffer, Qnil);
         }
diff --git a/src/xdisp.c b/src/xdisp.c
index 0cb34a2fef8..bf51137c716 100644
--- a/src/xdisp.c
+++ b/src/xdisp.c
@@ -925,6 +925,7 @@ static int display_string P_ ((unsigned char *, Lisp_Object, Lisp_Object,
 static void compute_line_metrics P_ ((struct it *));
 static void run_redisplay_end_trigger_hook P_ ((struct it *));
 static int get_overlay_strings P_ ((struct it *, int));
+static int get_overlay_strings_1 P_ ((struct it *, int, int));
 static void next_overlay_string P_ ((struct it *));
 static void reseat P_ ((struct it *, struct text_pos, int));
 static void reseat_1 P_ ((struct it *, struct text_pos, int));
@@ -2918,8 +2919,8 @@ init_from_display_pos (it, w, pos)
          also ``processed'' overlay strings at ZV.  */
       while (it->sp)
         pop_it (it);
-      it->current.overlay_string_index = -1;
-      it->method = GET_FROM_BUFFER;
+      xassert (it->current.overlay_string_index == -1);
+      xassert (it->method == GET_FROM_BUFFER);
       if (CHARPOS (pos->pos) == ZV)
         it->overlay_strings_at_end_processed_p = 1;
     }
@@ -3030,7 +3031,18 @@ handle_stop (it)
           if (handled == HANDLED_RECOMPUTE_PROPS)
             break;
           else if (handled == HANDLED_RETURN)
-            return;
+            {
+              /* We still want to show before and after strings from
+                 overlays even if the actual buffer text is replaced.  */
+              if (!handle_overlay_change_p || it->sp > 1)
+                return;
+              if (!get_overlay_strings_1 (it, 0, 0))
+                return;
+              it->string_from_display_prop_p = 0;
+              handle_overlay_change_p = 0;
+              handled = HANDLED_RECOMPUTE_PROPS;
+              break;
+            }
           else if (handled == HANDLED_OVERLAY_STRING_CONSUMED)
             handle_overlay_change_p = 0;
         }
@@ -4650,13 +4662,14 @@ next_overlay_string (it)
       int display_ellipsis_p = it->stack[it->sp - 1].display_ellipsis_p;
 
       pop_it (it);
-      xassert (it->stop_charpos >= BEGV
-               && it->stop_charpos <= it->end_charpos);
-      it->string = Qnil;
+      xassert (it->sp > 0
+               || it->method == GET_FROM_COMPOSITION
+               || (NILP (it->string)
+                   && it->method == GET_FROM_BUFFER
+                   && it->stop_charpos >= BEGV
+                   && it->stop_charpos <= it->end_charpos));
       it->current.overlay_string_index = -1;
-      SET_TEXT_POS (it->current.string_pos, -1, -1);
       it->n_overlay_strings = 0;
-      it->method = GET_FROM_BUFFER;
 
       /* If we're at the end of the buffer, record that we have
          processed the overlay strings there already, so that
@@ -4912,7 +4925,7 @@ load_overlay_strings (it, charpos)
    least one overlay string was found.  */
 
 static int
-get_overlay_strings (it, charpos)
+get_overlay_strings_1 (it, charpos, compute_stop_p)
      struct it *it;
      int charpos;
 {
@@ -4934,12 +4947,13 @@ get_overlay_strings (it, charpos)
       /* Make sure we know settings in current_buffer, so that we can
          restore meaningful values when we're done with the overlay
          strings.  */
-      compute_stop_pos (it);
+      if (compute_stop_p)
+        compute_stop_pos (it);
       xassert (it->face_id >= 0);
 
       /* Save IT's settings.  They are restored after all overlay
          strings have been processed.  */
-      xassert (it->sp == 0);
+      xassert (!compute_stop_p || it->sp == 0);
       push_it (it);
 
       /* Set up IT to deliver display elements from the first overlay
@@ -4951,13 +4965,22 @@ get_overlay_strings (it, charpos)
       it->end_charpos = SCHARS (it->string);
       it->multibyte_p = STRING_MULTIBYTE (it->string);
       it->method = GET_FROM_STRING;
+      return 1;
     }
-  else
-    {
-      it->string = Qnil;
-      it->current.overlay_string_index = -1;
-      it->method = GET_FROM_BUFFER;
-    }
+
+  it->current.overlay_string_index = -1;
+  return 0;
+}
+
+static int
+get_overlay_strings (it, charpos)
+     struct it *it;
+     int charpos;
+{
+  it->string = Qnil;
+  it->method = GET_FROM_BUFFER;
+
+  (void) get_overlay_strings_1 (it, charpos, 1);
 
   CHECK_IT (it);
 
@@ -4982,19 +5005,37 @@ push_it (it)
 {
   struct iterator_stack_entry *p;
 
-  xassert (it->sp < 2);
+  xassert (it->sp < IT_STACK_SIZE);
   p = it->stack + it->sp;
 
   p->stop_charpos = it->stop_charpos;
   xassert (it->face_id >= 0);
   p->face_id = it->face_id;
   p->string = it->string;
+  p->method = it->method;
+  switch (p->method)
+    {
+    case GET_FROM_IMAGE:
+      p->u.image.object = it->object;
+      p->u.image.image_id = it->image_id;
+      p->u.image.slice = it->slice;
+      break;
+    case GET_FROM_COMPOSITION:
+      p->u.comp.object = it->object;
+      p->u.comp.c = it->c;
+      p->u.comp.len = it->len;
+      p->u.comp.cmp_id = it->cmp_id;
+      p->u.comp.cmp_len = it->cmp_len;
+      break;
+    case GET_FROM_STRETCH:
+      p->u.stretch.object = it->object;
+      break;
+    }
   p->pos = it->current;
   p->end_charpos = it->end_charpos;
   p->string_nchars = it->string_nchars;
   p->area = it->area;
   p->multibyte_p = it->multibyte_p;
-  p->slice = it->slice;
   p->space_width = it->space_width;
   p->font_height = it->font_height;
   p->voffset = it->voffset;
@@ -5021,13 +5062,33 @@ pop_it (it)
   p = it->stack + it->sp;
   it->stop_charpos = p->stop_charpos;
   it->face_id = p->face_id;
-  it->string = p->string;
   it->current = p->pos;
+  it->string = p->string;
+  if (NILP (it->string))
+    SET_TEXT_POS (it->current.string_pos, -1, -1);
+  it->method = p->method;
+  switch (it->method)
+    {
+    case GET_FROM_IMAGE:
+      it->image_id = p->u.image.image_id;
+      it->object = p->u.image.object;
+      it->slice = p->u.image.slice;
+      break;
+    case GET_FROM_COMPOSITION:
+      it->object = p->u.comp.object;
+      it->c = p->u.comp.c;
+      it->len = p->u.comp.len;
+      it->cmp_id = p->u.comp.cmp_id;
+      it->cmp_len = p->u.comp.cmp_len;
+      break;
+    case GET_FROM_STRETCH:
+      it->object = p->u.comp.object;
+      break;
+    }
   it->end_charpos = p->end_charpos;
   it->string_nchars = p->string_nchars;
   it->area = p->area;
   it->multibyte_p = p->multibyte_p;
-  it->slice = p->slice;
   it->space_width = p->space_width;
   it->font_height = p->font_height;
   it->voffset = p->voffset;
@@ -5178,37 +5239,47 @@ back_to_previous_visible_line_start (it)
           continue;
       }
 
-      /* If newline has a display property that replaces the newline with something
-         else (image or text), find start of overlay or interval and continue search
-         from that point.  */
-      if (IT_CHARPOS (*it) > BEGV)
-        {
-          struct it it2 = *it;
-          int pos;
-          int beg, end;
-          Lisp_Object val, overlay;
-
-          pos = --IT_CHARPOS (it2);
-          --IT_BYTEPOS (it2);
-          it2.sp = 0;
-          if (handle_display_prop (&it2) == HANDLED_RETURN
-              && !NILP (val = get_char_property_and_overlay
-                        (make_number (pos), Qdisplay, Qnil, &overlay))
-              && (OVERLAYP (overlay)
-                  ? (beg = OVERLAY_POSITION (OVERLAY_START (overlay)))
-                  : get_property_and_range (pos, Qdisplay, &val, &beg, &end, Qnil)))
-            {
-              if (beg < BEGV)
-                beg = BEGV;
-              IT_CHARPOS (*it) = beg;
-              IT_BYTEPOS (*it) = buf_charpos_to_bytepos (current_buffer, beg);
-              continue;
-            }
-        }
+      if (IT_CHARPOS (*it) <= BEGV)
+        break;
 
-      break;
+      {
+        struct it it2;
+        int pos;
+        int beg, end;
+        Lisp_Object val, overlay;
+
+        /* If newline is part of a composition, continue from start of composition */
+        if (find_composition (IT_CHARPOS (*it), -1, &beg, &end, &val, Qnil)
+            && beg < IT_CHARPOS (*it))
+          goto replaced;
+
+        /* If newline is replaced by a display property, find start of overlay
+           or interval and continue search from that point.  */
+        it2 = *it;
+        pos = --IT_CHARPOS (it2);
+        --IT_BYTEPOS (it2);
+        it2.sp = 0;
+        if (handle_display_prop (&it2) == HANDLED_RETURN
+            && !NILP (val = get_char_property_and_overlay
+                      (make_number (pos), Qdisplay, Qnil, &overlay))
+            && (OVERLAYP (overlay)
+                ? (beg = OVERLAY_POSITION (OVERLAY_START (overlay)))
+                : get_property_and_range (pos, Qdisplay, &val, &beg, &end, Qnil)))
+          goto replaced;
+
+        /* Newline is not replaced by anything -- so we are done.  */
+        break;
+
+      replaced:
+        if (beg < BEGV)
+          beg = BEGV;
+        IT_CHARPOS (*it) = beg;
+        IT_BYTEPOS (*it) = buf_charpos_to_bytepos (current_buffer, beg);
+      }
     }
 
+  it->continuation_lines_width = 0;
+
   xassert (IT_CHARPOS (*it) >= BEGV);
   xassert (IT_CHARPOS (*it) == BEGV
            || FETCH_BYTE (IT_BYTEPOS (*it) - 1) == '\n');
@@ -5340,15 +5411,11 @@ reseat_1 (it, pos, set_stop_p)
   IT_STRING_BYTEPOS (*it) = -1;
   it->string = Qnil;
   it->method = GET_FROM_BUFFER;
-  /* RMS: I added this to fix a bug in move_it_vertically_backward
-     where it->area continued to relate to the starting point
-     for the backward motion.  Bug report from
-     Nick Roberts <nick@nick.uklinux.net> on 19 May 2003.
-     However, I am not sure whether reseat still does the right thing
-     in general after this change.  */
+  it->object = it->w->buffer;
   it->area = TEXT_AREA;
   it->multibyte_p = !NILP (current_buffer->enable_multibyte_characters);
   it->sp = 0;
+  it->string_from_display_prop_p = 0;
   it->face_before_selective_p = 0;
 
   if (set_stop_p)
@@ -5830,6 +5897,7 @@ set_iterator_to_next (it, reseat_p)
           IT_STRING_BYTEPOS (*it) += it->len;
           IT_STRING_CHARPOS (*it) += it->cmp_len;
           it->method = GET_FROM_STRING;
+          it->object = it->string;
           goto consider_string_end;
         }
       else
@@ -5837,6 +5905,7 @@ set_iterator_to_next (it, reseat_p)
           IT_BYTEPOS (*it) += it->len;
           IT_CHARPOS (*it) += it->cmp_len;
           it->method = GET_FROM_BUFFER;
+          it->object = it->w->buffer;
         }
       break;
 
@@ -5866,7 +5935,10 @@ set_iterator_to_next (it, reseat_p)
           else if (STRINGP (it->string))
             it->method = GET_FROM_STRING;
           else
-            it->method = GET_FROM_BUFFER;
+            {
+              it->method = GET_FROM_BUFFER;
+              it->object = it->w->buffer;
+            }
 
           it->dpvec = NULL;
           it->current.dpvec_index = -1;
@@ -5914,9 +5986,8 @@ set_iterator_to_next (it, reseat_p)
               && it->sp > 0)
             {
               pop_it (it);
-              if (STRINGP (it->string))
+              if (it->method == GET_FROM_STRING)
                 goto consider_string_end;
-              it->method = GET_FROM_BUFFER;
             }
         }
       break;
@@ -5928,13 +5999,8 @@ set_iterator_to_next (it, reseat_p)
          if the `display' property takes up the whole string.  */
       xassert (it->sp > 0);
       pop_it (it);
-      it->image_id = 0;
-      if (STRINGP (it->string))
-        {
-          it->method = GET_FROM_STRING;
-          goto consider_string_end;
-        }
-      it->method = GET_FROM_BUFFER;
+      if (it->method == GET_FROM_STRING)
+        goto consider_string_end;
       break;
 
     default:
@@ -6157,6 +6223,7 @@ next_element_from_ellipsis (it)
          setting face_before_selective_p.  */
       it->saved_face_id = it->face_id;
       it->method = GET_FROM_BUFFER;
+      it->object = it->w->buffer;
       reseat_at_next_visible_line_start (it, 1);
       it->face_before_selective_p = 1;
     }
@@ -6345,6 +6412,8 @@ next_element_from_composition (it)
                   : it->current.pos);
   if (STRINGP (it->string))
     it->object = it->string;
+  else
+    it->object = it->w->buffer;
   return 1;
 }
 
@@ -11787,9 +11856,12 @@ set_cursor_from_row (w, row, matrix, delta, delta_bytes, dy, dvpos)
         }
       else
         {
-          string_before_pos = last_pos;
-          string_start = glyph;
-          string_start_x = x;
+          if (string_start == NULL)
+            {
+              string_before_pos = last_pos;
+              string_start = glyph;
+              string_start_x = x;
+            }
           /* Skip all glyphs from string.  */
           do
             {
diff --git a/src/xterm.c b/src/xterm.c
index 4f2bc73c9f9..df99f9cad0d 100644
--- a/src/xterm.c
+++ b/src/xterm.c
@@ -359,7 +359,8 @@ static void x_scroll_bar_report_motion P_ ((struct frame **, Lisp_Object *,
                                             Lisp_Object *, Lisp_Object *,
                                             unsigned long *));
 static void x_check_fullscreen P_ ((struct frame *));
-static void x_check_expected_move P_ ((struct frame *));
+static void x_check_expected_move P_ ((struct frame *, int, int));
+static void x_sync_with_move P_ ((struct frame *, int, int, int));
 static int handle_one_xevent P_ ((struct x_display_info *, XEvent *,
                                   int *, struct input_event *));
 static SIGTYPE x_connection_closed P_ ((Display *, char *));
@@ -6883,11 +6884,8 @@ handle_one_xevent (dpyinfo, eventp, finish, hold_quit)
               && GTK_WIDGET_MAPPED (FRAME_GTK_OUTER_WIDGET (f)))
 #endif
             {
-              /* What we have now is the position of Emacs's own window.
-                 Convert that to the position of the window manager window.  */
               x_real_positions (f, &f->left_pos, &f->top_pos);
 
-              x_check_expected_move (f);
               if (f->want_fullscreen & FULLSCREEN_WAIT)
                 f->want_fullscreen &= ~(FULLSCREEN_WAIT|FULLSCREEN_BOTH);
             }
@@ -8512,8 +8510,11 @@ x_set_offset (f, xoff, yoff, change_gravity)
 {
   int modified_top, modified_left;
 
-  if (change_gravity > 0)
+  if (change_gravity != 0)
     {
+      FRAME_X_OUTPUT (f)->left_before_move = f->left_pos;
+      FRAME_X_OUTPUT (f)->top_before_move = f->top_pos;
+
       f->top_pos = yoff;
       f->left_pos = xoff;
       f->size_hint_flags &= ~ (XNegative | YNegative);
@@ -8531,7 +8532,7 @@ x_set_offset (f, xoff, yoff, change_gravity)
   modified_left = f->left_pos;
   modified_top = f->top_pos;
 
-  if (FRAME_X_DISPLAY_INFO (f)->wm_type == X_WMTYPE_A)
+  if (change_gravity != 0 && FRAME_X_DISPLAY_INFO (f)->wm_type == X_WMTYPE_A)
     {
       /* Some WMs (twm, wmaker at least) has an offset that is smaller
          than the WM decorations.  So we use the calculated offset instead
@@ -8543,13 +8544,26 @@ x_set_offset (f, xoff, yoff, change_gravity)
   XMoveWindow (FRAME_X_DISPLAY (f), FRAME_OUTER_WINDOW (f),
                modified_left, modified_top);
 
-  if (FRAME_VISIBLE_P (f)
-      && FRAME_X_DISPLAY_INFO (f)->wm_type == X_WMTYPE_UNKNOWN)
-    {
-      FRAME_X_OUTPUT (f)->check_expected_move = 1;
-      FRAME_X_OUTPUT (f)->expected_top = f->top_pos;
-      FRAME_X_OUTPUT (f)->expected_left = f->left_pos;
-    }
+  x_sync_with_move (f, f->left_pos, f->top_pos,
+                    FRAME_X_DISPLAY_INFO (f)->wm_type == X_WMTYPE_UNKNOWN
+                    ? 1 : 0);
+
+  /* change_gravity is non-zero when this function is called from Lisp to
+     programmatically move a frame.  In that case, we call
+     x_check_expected_move to discover if we have a "Type A" or "Type B"
+     window manager, and, for a "Type A" window manager, adjust the position
+     of the frame.
+
+     We call x_check_expected_move if a programmatic move occurred, and
+     either the window manager type (A/B) is unknown or it is Type A but we
+     need to compute the top/left offset adjustment for this frame.  */
+
+  if (change_gravity != 0 &&
+      (FRAME_X_DISPLAY_INFO (f)->wm_type == X_WMTYPE_UNKNOWN
+       || (FRAME_X_DISPLAY_INFO (f)->wm_type == X_WMTYPE_A
+           && (FRAME_X_OUTPUT (f)->move_offset_left == 0
+               && FRAME_X_OUTPUT (f)->move_offset_top == 0))))
+    x_check_expected_move (f, modified_left, modified_top);
 
   UNBLOCK_INPUT;
 }
@@ -8584,37 +8598,96 @@ x_check_fullscreen (f)
     }
 }
 
-/* If frame parameters are set after the frame is mapped, we need to move
-   the window.
-   Some window managers moves the window to the right position, some
-   moves the outer window manager window to the specified position.
-   Here we check that we are in the right spot.  If not, make a second
-   move, assuming we are dealing with the second kind of window manager. */
+/* This function is called by x_set_offset to determine whether the window
+   manager interfered with the positioning of the frame.  Type A window
+   managers position the surrounding window manager decorations a small
+   amount above and left of the user-supplied position.  Type B window
+   managers position the surrounding window manager decorations at the
+   user-specified position.  If we detect a Type A window manager, we
+   compensate by moving the window right and down by the proper amount.  */
+
 static void
-x_check_expected_move (f)
+x_check_expected_move (f, expected_left, expected_top)
      struct frame *f;
+     int expected_left;
+     int expected_top;
 {
-  if (FRAME_X_OUTPUT (f)->check_expected_move)
-  {
-    int expect_top = FRAME_X_OUTPUT (f)->expected_top;
-    int expect_left = FRAME_X_OUTPUT (f)->expected_left;
+  int count = 0, current_left = 0, current_top = 0;
+
+  /* x_real_positions returns the left and top offsets of the outermost
+     window manager window around the frame.  */
 
-    if (expect_top != f->top_pos || expect_left != f->left_pos)
+  x_real_positions (f, &current_left, &current_top);
+
+  if (current_left != expected_left || current_top != expected_top)
       {
+      /* It's a "Type A" window manager. */
+
+      int adjusted_left;
+      int adjusted_top;
+
         FRAME_X_DISPLAY_INFO (f)->wm_type = X_WMTYPE_A;
-        FRAME_X_OUTPUT (f)->move_offset_left = expect_left - f->left_pos;
-        FRAME_X_OUTPUT (f)->move_offset_top = expect_top - f->top_pos;
+      FRAME_X_OUTPUT (f)->move_offset_left = expected_left - current_left;
+      FRAME_X_OUTPUT (f)->move_offset_top = expected_top - current_top;
+
+      /* Now fix the mispositioned frame's location. */
 
-        f->left_pos = expect_left;
-        f->top_pos = expect_top;
-        x_set_offset (f, expect_left, expect_top, 0);
+      adjusted_left = expected_left + FRAME_X_OUTPUT (f)->move_offset_left;
+      adjusted_top = expected_top + FRAME_X_OUTPUT (f)->move_offset_top;
+
+      XMoveWindow (FRAME_X_DISPLAY (f), FRAME_OUTER_WINDOW (f),
+                   adjusted_left, adjusted_top);
+
+      x_sync_with_move (f, expected_left, expected_top, 0);
       }
-    else if (FRAME_X_DISPLAY_INFO (f)->wm_type == X_WMTYPE_UNKNOWN)
+  else
+    /* It's a "Type B" window manager.  We don't have to adjust the
+       frame's position. */
+
       FRAME_X_DISPLAY_INFO (f)->wm_type = X_WMTYPE_B;
+}
+
+
+/* Wait for XGetGeometry to return up-to-date position information for a
+   recently-moved frame.  Call this immediately after calling XMoveWindow.
+   If FUZZY is non-zero, then LEFT and TOP are just estimates of where the
+   frame has been moved to, so we use a fuzzy position comparison instead
+   of an exact comparison.  */
+
+static void
+x_sync_with_move (f, left, top, fuzzy)
+    struct frame *f;
+    int left, top, fuzzy;
+{
+  int count = 0;
+
+  while (count++ < 50)
+    {
+      int current_left = 0, current_top = 0;
+
+      /* In theory, this call to XSync only needs to happen once, but in
+         practice, it doesn't seem to work, hence the need for the surrounding
+         loop.  */
+
+      XSync (FRAME_X_DISPLAY (f), False);
+      x_real_positions (f, &current_left, &current_top);
+
+      if (fuzzy)
+        {
+          /* The left fuzz-factor is 10 pixels.  The top fuzz-factor is 40
+             pixels.  */
 
-    /* Just do this once */
-    FRAME_X_OUTPUT (f)->check_expected_move = 0;
+          if (abs (current_left - left) <= 10 && abs (current_top - top) <= 40)
+            return;
   }
+      else if (current_left == left && current_top == top)
+        return;
+    }
+
+  /* As a last resort, just wait 0.5 seconds and hope that XGetGeometry
+     will then return up-to-date position info. */
+
+  wait_reading_process_output (0, 500000, 0, 0, Qnil, NULL, 0);
 }
 
 
diff --git a/src/xterm.h b/src/xterm.h
index 411a7deea87..8bc9782b02b 100644
--- a/src/xterm.h
+++ b/src/xterm.h
@@ -644,18 +644,14 @@ struct x_output
      FocusOut and LeaveNotify clears EXPLICIT/IMPLICIT. */
   int focus_state;
 
-  /* The latest move we made to FRAME_OUTER_WINDOW.  Saved so we can
-     compensate for type A WMs (see wm_type in dpyinfo above).  */
-  int expected_top;
-  int expected_left;
-
   /* The offset we need to add to compensate for type A WMs.  */
   int move_offset_top;
   int move_offset_left;
 
-  /* Nonzero if we have made a move and needs to check if the WM placed us
-     at the right position.  */
-  int check_expected_move;
+  /* The frame's left/top offsets before we call XMoveWindow.  See
+     x_check_expected_move.  */
+  int left_before_move;
+  int top_before_move;
 };
 
 #define No_Cursor (None)