upstream

7 files changed, 128 insertions, 51 deletions

diff --git a/src/ChangeLog b/src/ChangeLog
index bc9ffc8f3fe..9cef045c029 100644
--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -1,3 +1,41 @@
+2011-10-08  Glenn Morris  <rgm@gnu.org>
+
+        * callint.c (Fcall_interactively): Give a more explicit error for the
+        'c' case with a non-character input.  (Bug#8479)
+
+2011-10-08  Eli Zaretskii  <eliz@gnu.org>
+
+        * xdisp.c (hscroll_window_tree): Support hscroll in right-to-left
+        lines.
+        (set_cursor_from_row): Fix cursor positioning in mixed L2R+R2L
+        lines that are hscrolled on the left.
+
+        * dispnew.c (buffer_posn_from_coords): Account for a possible
+        presence of header-line.  (Bug#4426)
+
+2011-10-07  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * buffer.c (syms_of_buffer) <enable-multibyte-characters>: Don't
+        advertise functionality which we discourage or doesn't work.
+
+2011-10-07  Paul Eggert  <eggert@cs.ucla.edu>
+
+        * alloc.c (GC_LISP_OBJECT_ALIGNMENT): Use offsetof, not __alignof__
+        or sizeof.  __alignof__ gives the wrong answer on Fedora x86-64
+        with GCC 4.6.1 when configured with CC='gcc -m32' --with-wide-int;
+        this makes Emacs dump core during garbage collection on rare
+        occasions.  sizeof is obviously inferior to offsetof here, so
+        stick with offsetof.
+        (GC_POINTER_ALIGNMENT): New macro.
+        (mark_memory): Omit 3rd (offset) arg; caller changed.
+        Don't assume EMACS_INT alignment is the same as pointer alignment.
+
+2011-10-03  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * keyboard.c (read_key_sequence_remapped): New var.
+        (read_key_sequence): Compute remapping in the right buffer.
+        (command_loop_1): Use read_key_sequence's remapping directly.
+
 2011-10-02  Stefan Monnier  <monnier@iro.umontreal.ca>
 
         * dired.c (file_name_completion): Don't expand file name.
@@ -124,8 +162,8 @@
 
 2011-09-24  Eli Zaretskii  <eliz@gnu.org>
 
-        * dispnew.c (syms_of_display) <redisplay-dont-pause>: Default
-        value is now t.  Doc fix.
+        * dispnew.c (syms_of_display) <redisplay-dont-pause>:
+        Default value is now t.  Doc fix.
 
         * indent.c (Fvertical_motion): Compute and apply the overshoot
         logic when moving up, not only when moving down.  Fix the
@@ -141,8 +179,8 @@
 
         * dbusbind.c (Fdbus_register_signal): Add match rule to
         Vdbus_registered_objects_table.  (Bug#9581)
-        (Fdbus_register_method, Vdbus_registered_objects_table): Fix
-        docstring.
+        (Fdbus_register_method, Vdbus_registered_objects_table):
+        Fix docstring.
 
 2011-09-24  Jim Meyering  <meyering@redhat.com>
 
@@ -622,15 +660,15 @@
         * term.c (tty_append_glyph): New function.
         (produce_stretch_glyph): Static function and its prototype deleted.
 
-        * dispextern.h (produce_stretch_glyph, tty_append_glyph): Add
-        prototypes.
+        * dispextern.h (produce_stretch_glyph, tty_append_glyph):
+        Add prototypes.
 
 2011-08-29  Paul Eggert  <eggert@cs.ucla.edu>
 
         * image.c (parse_image_spec): Check for nonnegative, not for positive,
         when checking :margin (Bug#9390).
         (IMAGE_NON_NEGATIVE_INTEGER_VALUE_OR_PAIR):
-        Renamed from IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR,
+        Rename from IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR,
         so that the name doesn't mislead.  All uses changed.
 
 2011-08-28  Johan Bockgård  <bojohan@gnu.org>
@@ -832,8 +870,8 @@
         (read_char_minibuf_menu_prompt, follow_key, read_key_sequence):
         Use ptrdiff_t, not int, to count maps.
         (read_char_minibuf_menu_prompt): Check for overflow in size
-        calculations.  Don't update size until allocation succeeds.  Redo
-        calculations to avoid overflow.
+        calculations.  Don't update size until allocation succeeds.
+        Redo calculations to avoid overflow.
         * keyboard.h: Change prototypes to match the above.
 
         * keymap.c (cmm_size, current_minor_maps): Use ptrdiff_t, not int,
@@ -1002,7 +1040,7 @@
         * indent.c (MULTIBYTE_BYTES_WIDTH):
         Use sanitize_char_width to avoid undefined and/or bad behavior
         with outlandish widths.
-        * character.h (sanitize_tab_width): Renamed from sanitize_width,
+        * character.h (sanitize_tab_width): Rename from sanitize_width,
         now that we have two such functions.  All uses changed.
         (sanitize_char_width): New inline function.
 
@@ -1068,8 +1106,8 @@
         (png_load, gif_load, svg_load_image):
         Prefer int to unsigned where either will do.
         (tiff_handler): New function, combining the cores of the
-        old tiff_error_handler and tiff_warning_handler.  This
-        function is rewritten to use vsnprintf and thereby avoid
+        old tiff_error_handler and tiff_warning_handler.
+        This function is rewritten to use vsnprintf and thereby avoid
         stack buffer overflows.  It uses only the features of vsnprintf
         that are common to both POSIX and native Microsoft.
         (tiff_error_handler, tiff_warning_handler): Use it.
@@ -1098,8 +1136,8 @@
         `(space ...)', and specifies display in the text area, return 2
         rather than 1.
         (try_cursor_movement): Check for the need to scroll more
-        accurately, and prefer exact match for point under bidi.  Don't
-        advance `row' beyond the last row of the window.
+        accurately, and prefer exact match for point under bidi.
+        Don't advance `row' beyond the last row of the window.
 
         * dispextern.h (struct bidi_it): Rename the disp_prop_p member
         into disp_prop; all users changed.
diff --git a/src/alloc.c b/src/alloc.c
index ead5c8a8ca4..09ef4b085df 100644
--- a/src/alloc.c
+++ b/src/alloc.c
@@ -393,7 +393,7 @@ static int live_symbol_p (struct mem_node *, void *);
 static int live_float_p (struct mem_node *, void *);
 static int live_misc_p (struct mem_node *, void *);
 static void mark_maybe_object (Lisp_Object);
-static void mark_memory (void *, void *, int);
+static void mark_memory (void *, void *);
 static void mem_init (void);
 static struct mem_node *mem_insert (void *, void *, enum mem_type);
 static void mem_insert_fixup (struct mem_node *);
@@ -4235,14 +4235,25 @@ mark_maybe_pointer (void *p)
 }
 
 
+/* Alignment of Lisp_Object and pointer values.  Use offsetof, as it
+   sometimes returns a smaller alignment than GCC's __alignof__ and
+   mark_memory might miss objects if __alignof__ were used.  For
+   example, on x86 with WIDE_EMACS_INT, __alignof__ (Lisp_Object) is 8
+   but GC_LISP_OBJECT_ALIGNMENT should be 4.  */
+#ifndef GC_LISP_OBJECT_ALIGNMENT
+# define GC_LISP_OBJECT_ALIGNMENT offsetof (struct {char a; Lisp_Object b;}, b)
+#endif
+#define GC_POINTER_ALIGNMENT offsetof (struct {char a; void *b;}, b)
+
 /* Mark Lisp objects referenced from the address range START+OFFSET..END
    or END+OFFSET..START. */
 
 static void
-mark_memory (void *start, void *end, int offset)
+mark_memory (void *start, void *end)
 {
   Lisp_Object *p;
   void **pp;
+  int i;
 
 #if GC_MARK_STACK == GC_USE_GCPROS_CHECK_ZOMBIES
   nzombies = 0;
@@ -4258,8 +4269,9 @@ mark_memory (void *start, void *end, int offset)
     }
 
   /* Mark Lisp_Objects.  */
-  for (p = (Lisp_Object *) ((char *) start + offset); (void *) p < end; ++p)
-    mark_maybe_object (*p);
+  for (p = start; (void *) p < end; p++)
+    for (i = 0; i < sizeof *p; i += GC_LISP_OBJECT_ALIGNMENT)
+      mark_maybe_object (*(Lisp_Object *) ((char *) p + i));
 
   /* Mark Lisp data pointed to.  This is necessary because, in some
      situations, the C compiler optimizes Lisp objects away, so that
@@ -4279,8 +4291,9 @@ mark_memory (void *start, void *end, int offset)
      away.  The only reference to the life string is through the
      pointer `s'.  */
 
-  for (pp = (void **) ((char *) start + offset); (void *) pp < end; ++pp)
-    mark_maybe_pointer (*pp);
+  for (pp = start; (void *) pp < end; pp++)
+    for (i = 0; i < sizeof *pp; i += GC_POINTER_ALIGNMENT)
+      mark_maybe_pointer (*(void **) ((char *) pp + i));
 }
 
 /* setjmp will work with GCC unless NON_SAVING_SETJMP is defined in
@@ -4454,15 +4467,11 @@ dump_zombies (void)
    pass starting at the start of the stack + 2.  Likewise, if the
    minimal alignment of Lisp_Objects on the stack is 1, four passes
    would be necessary, each one starting with one byte more offset
-   from the stack start.
-
-   The current code assumes by default that Lisp_Objects are aligned
-   equally on the stack.  */
+   from the stack start.  */
 
 static void
 mark_stack (void)
 {
-  int i;
   void *end;
 
 #ifdef HAVE___BUILTIN_UNWIND_INIT
@@ -4520,15 +4529,8 @@ mark_stack (void)
   /* This assumes that the stack is a contiguous region in memory.  If
      that's not the case, something has to be done here to iterate
      over the stack segments.  */
-#ifndef GC_LISP_OBJECT_ALIGNMENT
-#ifdef __GNUC__
-#define GC_LISP_OBJECT_ALIGNMENT __alignof__ (Lisp_Object)
-#else
-#define GC_LISP_OBJECT_ALIGNMENT sizeof (Lisp_Object)
-#endif
-#endif
-  for (i = 0; i < sizeof (Lisp_Object); i += GC_LISP_OBJECT_ALIGNMENT)
-    mark_memory (stack_base, end, i);
+  mark_memory (stack_base, end);
+
   /* Allow for marking a secondary stack, like the register stack on the
      ia64.  */
 #ifdef GC_MARK_SECONDARY_STACK
diff --git a/src/buffer.c b/src/buffer.c
index f38c9a739a6..fdf006a41eb 100644
--- a/src/buffer.c
+++ b/src/buffer.c
@@ -5448,9 +5448,7 @@ file I/O and the behavior of various editing commands.
 
 This variable is buffer-local but you cannot set it directly;
 use the function `set-buffer-multibyte' to change a buffer's representation.
-Changing its default value with `setq-default' is supported.
-See also variable `default-enable-multibyte-characters' and Info node
-`(elisp)Text Representations'.  */);
+See also Info node `(elisp)Text Representations'.  */);
   XSYMBOL (intern_c_string ("enable-multibyte-characters"))->constant = 1;
 
   DEFVAR_PER_BUFFER ("buffer-file-coding-system",
diff --git a/src/callint.c b/src/callint.c
index 5cf99495671..61ab4a3963e 100644
--- a/src/callint.c
+++ b/src/callint.c
@@ -535,6 +535,8 @@ invoke it.  If KEYS is omitted or nil, the return value of
           message1_nolog ((char *) 0);
           /* Passing args[i] directly stimulates compiler bug */
           teml = args[i];
+          /* See bug#8479.  */
+          if (! CHARACTERP (teml)) error ("Non-character input-event");
           visargs[i] = Fchar_to_string (teml);
           break;
 
diff --git a/src/dispnew.c b/src/dispnew.c
index ccb24c8ceea..879ff88ff14 100644
--- a/src/dispnew.c
+++ b/src/dispnew.c
@@ -5274,6 +5274,10 @@ buffer_posn_from_coords (struct window *w, int *x, int *y, struct display_pos *p
   CHARPOS (startp) = min (ZV, max (BEGV, CHARPOS (startp)));
   BYTEPOS (startp) = min (ZV_BYTE, max (BEGV_BYTE, BYTEPOS (startp)));
   start_display (&it, w, startp);
+  /* start_display takes into account the header-line row, but IT's
+     vpos still counts from the glyph row that includes the window's
+     start position.  Adjust for a possible header-line row.  */
+  it.vpos += WINDOW_WANTS_HEADER_LINE_P (w) ? 1 : 0;
 
   x0 = *x;
 
diff --git a/src/keyboard.c b/src/keyboard.c
index b266da07a42..a21008b9502 100644
--- a/src/keyboard.c
+++ b/src/keyboard.c
@@ -252,6 +252,7 @@ static Lisp_Object Qtimer_event_handler;
 /* read_key_sequence stores here the command definition of the
    key sequence that it reads.  */
 static Lisp_Object read_key_sequence_cmd;
+static Lisp_Object read_key_sequence_remapped;
 
 static Lisp_Object Qinput_method_function;
 
@@ -1517,14 +1518,10 @@ command_loop_1 (void)
          reset it before we execute the command. */
       Vdeactivate_mark = Qnil;
 
-      /* Remap command through active keymaps */
+      /* Remap command through active keymaps.  */
       Vthis_original_command = cmd;
-      if (SYMBOLP (cmd))
-        {
-          Lisp_Object cmd1;
-          if (cmd1 = Fcommand_remapping (cmd, Qnil, Qnil), !NILP (cmd1))
-            cmd = cmd1;
-        }
+      if (!NILP (read_key_sequence_remapped))
+        cmd = read_key_sequence_remapped;
 
       /* Execute the command.  */
 
@@ -10015,6 +10012,13 @@ read_key_sequence (Lisp_Object *keybuf, int bufsize, Lisp_Object prompt,
     read_key_sequence_cmd = (first_binding < nmaps
                              ? defs[first_binding]
                              : Qnil);
+  read_key_sequence_remapped
+    /* Remap command through active keymaps.
+       Do the remapping here, before the unbind_to so it uses the keymaps
+       of the appropriate buffer.  */
+    = SYMBOLP (read_key_sequence_cmd)
+    ? Fcommand_remapping (read_key_sequence_cmd, Qnil, Qnil)
+    : Qnil;
 
   unread_switch_frame = delayed_switch_frame;
   unbind_to (count, Qnil);
@@ -11683,6 +11687,8 @@ syms_of_keyboard (void)
 
   read_key_sequence_cmd = Qnil;
   staticpro (&read_key_sequence_cmd);
+  read_key_sequence_remapped = Qnil;
+  staticpro (&read_key_sequence_remapped);
 
   menu_bar_one_keymap_changed_items = Qnil;
   staticpro (&menu_bar_one_keymap_changed_items);
diff --git a/src/xdisp.c b/src/xdisp.c
index 9e26360394c..9ec7463c555 100644
--- a/src/xdisp.c
+++ b/src/xdisp.c
@@ -12119,6 +12119,7 @@ hscroll_window_tree (Lisp_Object window)
             = (desired_cursor_row->enabled_p
                ? desired_cursor_row
                : current_cursor_row);
+          int row_r2l_p = cursor_row->reversed_p;
 
           text_area_width = window_box_width (w, TEXT_AREA);
 
@@ -12126,11 +12127,31 @@ hscroll_window_tree (Lisp_Object window)
           h_margin = hscroll_margin * WINDOW_FRAME_COLUMN_WIDTH (w);
 
           if (!NILP (Fbuffer_local_value (Qauto_hscroll_mode, w->buffer))
-              && ((XFASTINT (w->hscroll)
-                   && w->cursor.x <= h_margin)
-                  || (cursor_row->enabled_p
-                      && cursor_row->truncated_on_right_p
-                      && (w->cursor.x >= text_area_width - h_margin))))
+              /* For left-to-right rows, hscroll when cursor is either
+                 (i) inside the right hscroll margin, or (ii) if it is
+                 inside the left margin and the window is already
+                 hscrolled. */
+              && ((!row_r2l_p
+                   && ((XFASTINT (w->hscroll)
+                        && w->cursor.x <= h_margin)
+                       || (cursor_row->enabled_p
+                           && cursor_row->truncated_on_right_p
+                           && (w->cursor.x >= text_area_width - h_margin))))
+                  /* For right-to-left rows, the logic is similar,
+                     except that rules for scrolling to left and right
+                     are reversed.  E.g., if cursor.x <= h_margin, we
+                     need to hscroll "to the right" unconditionally,
+                     and that will scroll the screen to the left so as
+                     to reveal the next portion of the row.  */
+                  || (row_r2l_p
+                      && ((cursor_row->enabled_p
+                           /* FIXME: It is confusing to set the
+                              truncated_on_right_p flag when R2L rows
+                              are actually truncated on the left. */
+                           && cursor_row->truncated_on_right_p
+                           && w->cursor.x <= h_margin)
+                          || (XFASTINT (w->hscroll)
+                              && (w->cursor.x >= text_area_width - h_margin))))))
             {
               struct it it;
               int hscroll;
@@ -12165,7 +12186,9 @@ hscroll_window_tree (Lisp_Object window)
                                       ? (text_area_width - 4 * FRAME_COLUMN_WIDTH (it.f))
                                       : (text_area_width / 2))))
                           / FRAME_COLUMN_WIDTH (it.f);
-              else if (w->cursor.x >= text_area_width - h_margin)
+              else if ((!row_r2l_p
+                        && w->cursor.x >= text_area_width - h_margin)
+                       || (row_r2l_p && w->cursor.x <= h_margin))
                 {
                   if (hscroll_relative_p)
                     wanted_x = text_area_width * (1 - hscroll_step_rel)
@@ -13928,7 +13951,11 @@ set_cursor_from_row (struct window *w, struct glyph_row *row,
                                ? glyph_after > glyphs_end
                                : glyph_after < glyphs_end)))))
         {
-          cursor = glyph_after;
+          if (!match_with_avoid_cursor
+              && row->truncated_on_left_p && pt_old < bpos_min)
+            cursor = glyph_before;
+          else
+            cursor = glyph_after;
           x = -1;
         }
       else if (string_seen)