merge from upstream

68 files changed, 4240 insertions, 1742 deletions

diff --git a/src/.gdbinit b/src/.gdbinit
index 2cf5663df91..0f51a00ea76 100644
--- a/src/.gdbinit
+++ b/src/.gdbinit
@@ -677,7 +677,7 @@ end
 
 define xvectype
   xgetptr $
-  set $size = ((struct Lisp_Vector *) $ptr)->size
+  set $size = ((struct Lisp_Vector *) $ptr)->header.size
   output ($size & PVEC_FLAG) ? (enum pvec_type) ($size & PVEC_TYPE_MASK) : $size & ~gdb_array_mark_flag
   echo \n
 end
@@ -818,7 +818,7 @@ end
 define xvector
   xgetptr $
   print (struct Lisp_Vector *) $ptr
-  output ($->size > 50) ? 0 : ($->contents[0])@($->size & ~gdb_array_mark_flag)
+  output ($->header.size > 50) ? 0 : ($->contents[0])@($->header.size & ~gdb_array_mark_flag)
 echo \n
 end
 document xvector
@@ -853,7 +853,7 @@ end
 define xcompiled
   xgetptr $
   print (struct Lisp_Vector *) $ptr
-  output ($->contents[0])@($->size & 0xff)
+  output ($->contents[0])@($->header.size & 0xff)
 end
 document xcompiled
 Print $ as a compiled function pointer.
@@ -903,7 +903,7 @@ define xchartable
   print (struct Lisp_Char_Table *) $ptr
   printf "Purpose: "
   xprintsym $->purpose
-  printf "  %d extra slots", ($->size & 0x1ff) - 68
+  printf "  %d extra slots", ($->header.size & 0x1ff) - 68
   echo \n
 end
 document xchartable
@@ -927,7 +927,7 @@ end
 define xboolvector
   xgetptr $
   print (struct Lisp_Bool_Vector *) $ptr
-  output ($->size > 256) ? 0 : ($->data[0])@((($->size & ~gdb_array_mark_flag) + 7)/ 8)
+  output ($->header.size > 256) ? 0 : ($->data[0])@((($->header.size & ~gdb_array_mark_flag) + 7)/ 8)
   echo \n
 end
 document xboolvector
@@ -1093,7 +1093,7 @@ define xpr
 #    end
   end
   if $type == Lisp_Vectorlike
-    set $size = ((struct Lisp_Vector *) $ptr)->size
+    set $size = ((struct Lisp_Vector *) $ptr)->header.size
     if ($size & PVEC_FLAG)
       set $vec = (enum pvec_type) ($size & PVEC_TYPE_MASK)
       if $vec == PVEC_NORMAL_VECTOR
@@ -1202,7 +1202,7 @@ end
 
 define xfont
   xgetptr $
-  set $size = (((struct Lisp_Vector *) $ptr)->size & 0x1FF)
+  set $size = (((struct Lisp_Vector *) $ptr)->header.size & 0x1FF)
   if $size == FONT_SPEC_MAX
     print (struct font_spec *) $ptr
   else
@@ -1229,7 +1229,7 @@ define xbacktrace
       printf "0x%x ", $ptr
       if $type == Lisp_Vectorlike
         xgetptr (*$bt->function)
-        set $size = ((struct Lisp_Vector *) $ptr)->size
+        set $size = ((struct Lisp_Vector *) $ptr)->header.size
         output ($size & PVEC_FLAG) ? (enum pvec_type) ($size & PVEC_TYPE_MASK) : $size & ~gdb_array_mark_flag
       else
         printf "Lisp type %d", $type
diff --git a/src/ChangeLog b/src/ChangeLog
index 1e537f3872e..21563806ece 100644
--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -1,3 +1,764 @@
+2011-07-14  Paul Eggert  <eggert@cs.ucla.edu>
+
+        Fix minor problems found by static checking.
+        * bidi.c (bidi_cache_size): Now EMACS_INT, not size_t.
+        (elsz): Now a signed constant, not a size_t var.  We prefer signed
+        types to unsigned, to avoid integer comparison confusion.  Without
+        this change, GCC 4.6.1 with -Wunsafe-loop-optimizations complains
+        "cannot optimize loop, the loop counter may overflow", a symptom
+        of the confusion.
+        * indent.c (Fvertical_motion): Mark locals as initialized.
+        * xdisp.c (reseat_to_string): Fix pointer signedness issue.
+
+2011-07-14  Lars Magne Ingebrigtsen  <larsi@gnus.org>
+
+        * search.c (Fre_search_backward): Mention `case-fold-search' in
+        all the re_search_* functions (bug#8138).
+
+        * keyboard.c (Fopen_dribble_file): Document when the file is
+        closed (bug#8056).
+
+2011-07-14  Eli Zaretskii  <eliz@gnu.org>
+
+        * bidi.c (bidi_dump_cached_states): Fix format of displaying
+        bidi_cache_idx.
+
+        Support bidi reordering of display and overlay strings.
+        * xdisp.c (compute_display_string_pos)
+        (compute_display_string_end): Accept additional argument STRING.
+        (init_iterator, reseat_1): Initialize bidi_it->string.s to NULL.
+        (reseat_to_string): Initialize bidi_it->string.s and
+        bidi_it->string.schars.
+        (Fcurrent_bidi_paragraph_direction): Initialize itb.string.s to
+        NULL (avoids a crash in bidi_paragraph_init).  Initialize
+        itb.string.lstring.
+        (init_iterator): Call bidi_init_it only of a valid
+        buffer position was specified.  Initialize paragraph_embedding to
+        L2R.
+        (reseat_to_string): Initialize the bidi iterator.
+        (display_string): If we need to ignore text properties of
+        LISP_STRING, set IT->stop_charpos to IT->end_charpos.  (The
+        original value of -1 will not work with bidi.)
+        (compute_display_string_pos): First arg is now struct
+        `text_pos *'; all callers changed.  Support display properties on
+        Lisp strings.
+        (compute_display_string_end): Support display properties on Lisp
+        strings.
+        (init_iterator, reseat_1, reseat_to_string): Initialize the
+        string.bufpos member to 0 (zero, for compatibility with IT_CHARPOS
+        when iterating on a string not from display properties).
+        (compute_display_string_pos, compute_display_string_end): Fix
+        calculation of the object to scan.  Fixes an error when using
+        arrow keys.
+        (next_element_from_buffer): Don't abort when IT_CHARPOS is before
+        base_level_stop; instead, set base_level_stop to BEGV.  Fixes
+        crashes in vertical-motion.
+        (next_element_from_buffer): Improve commentary for when
+        the iterator is before prev_stop.
+        (init_iterator): Initialize bidi_p from the default value of
+        bidi-display-reordering, not from buffer-local value.  Use the
+        buffer-local value only if initializing for buffer iteration.
+        (handle_invisible_prop): Support invisible properties on strings
+        that are being bidi-reordered.
+        (set_iterator_to_next): Support bidi reordering of C strings and
+        Lisp strings.
+        (next_element_from_string): Support bidi reordering of Lisp
+        strings.
+        (handle_stop_backwards): Support Lisp strings as well.
+        (display_string): Support display of R2L glyph rows.  Use
+        IT_STRING_CHARPOS when displaying from a Lisp string.
+        (init_iterator): Don't initialize it->bidi_p for strings
+        here.
+        (reseat_to_string): Initialize it->bidi_p for strings here.
+        (next_element_from_string, next_element_from_c_string)
+        (next_element_from_buffer): Add xassert's for correspondence
+        between IT's object being iterated and it->bidi_it.string
+        structure.
+        (face_before_or_after_it_pos): Support bidi iteration.
+        (next_element_from_c_string): Handle the case of the first string
+        character that is not the first one in the visual order.
+        (get_visually_first_element): New function, refactored from common
+        parts of next_element_from_buffer, next_element_from_string, and
+        next_element_from_c_string.
+        (tool_bar_lines_needed, redisplay_tool_bar)
+        (display_menu_bar): Force left-to-right direction.  Add a FIXME
+        comment for making that be controlled by a user option.
+        (push_it, pop_it): Save and restore the state of the
+        bidi iterator.  Save and restore the bidi_p flag.
+        (pop_it): Iterate out of display property for string iteration as
+        well.
+        (iterate_out_of_display_property): Support iteration over strings.
+        (handle_single_display_spec): Set up it->bidi_it for iteration
+        over a display string, and call bidi_init_it.
+        (handle_single_display_spec, next_overlay_string)
+        (get_overlay_strings_1, push_display_prop): Set up the bidi
+        iterator for displaying display or overlay strings.
+        (forward_to_next_line_start): Don't use the shortcut if
+        bidi-iterating.
+        (back_to_previous_visible_line_start): If handle_display_prop
+        pushed the iterator stack, restore the internal state of the bidi
+        iterator by calling bidi_pop_it same number of times.
+        (reseat_at_next_visible_line_start): If ON_NEWLINE_P is non-zero,
+        and we are bidi-iterating, don't decrement the iterator position;
+        instead, set the first_elt flag in the bidi iterator, to produce
+        the same effect.
+        (reseat_1): Remove redundant setting of string_from_display_prop_p.
+        (push_display_prop): xassert that we are iterating a buffer.
+        (push_it, pop_it): Save and restore paragraph_embedding member.
+        (handle_single_display_spec, next_overlay_string)
+        (get_overlay_strings_1, reseat_1, reseat_to_string)
+        (push_display_prop): Set up the `unibyte' member of bidi_it.string
+        correctly.  Don't assume unibyte strings are not bidi-reordered.
+        (compute_display_string_pos)
+        (compute_display_string_end): Fix handling the case of C string.
+        (push_it, pop_it): Save and restore from_disp_prop_p.
+        (handle_single_display_spec, push_display_prop): Set the
+        from_disp_prop_p flag.
+        (get_overlay_strings_1): Reset the from_disp_prop_p flag.
+        (pop_it): Call iterate_out_of_display_property only if we are
+        popping after iteration over a string that came from a display
+        property.  Fix a typo in popping stretch info.  Add an assertion
+        for verifying that the iterator position is in sync with the bidi
+        iterator.
+        (handle_single_display_spec, get_overlay_strings_1)
+        (push_display_prop): Fix initialization of paragraph direction for
+        string when that of the parent object is not yet determined.
+        (reseat_1): Call bidi_init_it to resync the bidi
+        iterator with IT's position.  (Bug#7616)
+        (find_row_edges): If ROW->start.pos gives position
+        smaller than min_pos, use it as ROW->minpos.  (Bug#7616)
+        (handle_stop, back_to_previous_visible_line_start, reseat_1):
+        Reset the from_disp_prop_p flag.
+        (SAVE_IT, RESTORE_IT): New macros.
+        (pos_visible_p, face_before_or_after_it_pos)
+        (back_to_previous_visible_line_start)
+        (move_it_in_display_line_to, move_it_in_display_line)
+        (move_it_to, move_it_vertically_backward, move_it_by_lines)
+        (try_scrolling, redisplay_window, display_line): Use them when
+        saving a temporary copy of the iterator and restoring it back.
+        (back_to_previous_visible_line_start, reseat_1)
+        (init_iterator): Empty the bidi cache "stack".
+        (move_it_in_display_line_to): If iterator ended up at
+        EOL, but we never saw any buffer positions smaller than
+        to_charpos, return MOVE_POS_MATCH_OR_ZV.  Fixes vertical cursor
+        motion in bidi-reordered lines.
+        (move_it_in_display_line_to): Record prev_method and prev_pos
+        immediately before the call to set_iterator_to_next.  Fixes cursor
+        motion in bidi-reordered lines with stretch glyphs and strings
+        displayed in margins.  (Bug#8133) (Bug#8867)
+        Return MOVE_POS_MATCH_OR_ZV only if iterator position is past
+        TO_CHARPOS.
+        (pos_visible_p): Support positions in bidi-reordered lines.  Save
+        and restore bidi cache.
+
+        * bidi.c (bidi_level_of_next_char): clen should be EMACS_NT, not int.
+        (bidi_paragraph_info): Delete unused struct.
+        (bidi_cache_idx, bidi_cache_last_idx): Declare EMACS_INT.
+        (bidi_cache_start): New variable.
+        (bidi_cache_reset): Reset bidi_cache_idx to bidi_cache_start, not
+        to zero.
+        (bidi_cache_fetch_state, bidi_cache_search)
+        (bidi_cache_find_level_change, bidi_cache_iterator_state)
+        (bidi_cache_find, bidi_peek_at_next_level)
+        (bidi_level_of_next_char, bidi_find_other_level_edge)
+        (bidi_move_to_visually_next): Compare cache index with
+        bidi_cache_start rather than with zero.
+        (bidi_fetch_char): Accept new argument STRING; all callers
+        changed.  Support iteration over a string.  Support strings with
+        display properties.  Support unibyte strings.  Fix the type of
+        `len' according to what STRING_CHAR_AND_LENGTH expects.
+        (bidi_paragraph_init, bidi_resolve_explicit_1)
+        (bidi_resolve_explicit, bidi_resolve_weak)
+        (bidi_level_of_next_char, bidi_move_to_visually_next): Support
+        iteration over a string.
+        (bidi_set_sor_type, bidi_resolve_explicit_1)
+        (bidi_resolve_explicit, bidi_type_of_next_char): ignore_bn_limit
+        can now be zero (for strings); special values 0 and -1 were
+        changed to -1 and -2, respectively.
+        (bidi_char_at_pos): New function.
+        (bidi_paragraph_init, bidi_resolve_explicit, bidi_resolve_weak):
+        Call it instead of FETCH_MULTIBYTE_CHAR.
+        (bidi_move_to_visually_next): Abort if charpos or bytepos were not
+        initialized to valid values.
+        (bidi_init_it): Don't initialize charpos and bytepos with invalid
+        values.
+        (bidi_level_of_next_char): Allow the sentinel "position" to pass
+        the test for valid cached positions.  Fix the logic for looking up
+        the sentinel state in the cache.  GCPRO the Lisp string we are
+        iterating.
+        (bidi_push_it, bidi_pop_it): New functions.
+        (bidi_initialize): Initialize the bidi cache start stack pointer.
+        (bidi_cache_ensure_space): New function, refactored from part of
+        bidi_cache_iterator_state.  Don't assume the required size is just
+        one BIDI_CACHE_CHUNK away.
+        (bidi_cache_start_stack, bidi_push_it): Use IT_STACK_SIZE.
+        (bidi_count_bytes, bidi_char_at_pos): New functions.
+        (bidi_cache_search): Don't assume bidi_cache_last_idx is
+        always valid if bidi_cache_idx is valid.
+        (bidi_cache_find_level_change): xassert that bidi_cache_last_idx
+        is valid if it's going to be used.
+        (bidi_shelve_cache, bidi_unshelve_cache): New functions.
+        (bidi_cache_fetch_state, bidi_cache_search)
+        (bidi_cache_find_level_change, bidi_cache_ensure_space)
+        (bidi_cache_iterator_state, bidi_cache_find)
+        (bidi_find_other_level_edge, bidi_cache_start_stack): All
+        variables related to cache indices are now EMACS_INT.
+
+        * dispextern.h (struct bidi_string_data): New structure.
+        (struct bidi_it): New member `string'.  Make flag members be 1-bit
+        fields, and put them last in the struct.
+        (compute_display_string_pos, compute_display_string_end): Update
+        prototypes.
+        (bidi_push_it, bidi_pop_it): Add prototypes.
+        (struct iterator_stack_entry): New members bidi_p,
+        paragraph_embedding, and from_disp_prop_p.
+        (struct it): Member bidi_p is now a bit field 1 bit wide.
+        (bidi_shelve_cache, bidi_unshelve_cache): Declare
+        prototypes.
+
+        * .gdbinit (xvectype, xvector, xcompiled, xchartable, xboolvector)
+        (xpr, xfont, xbacktrace): Use "header.size" when accessing vectors
+        and vector-like objects.
+
+        * dispnew.c (buffer_posn_from_coords): Save and restore the bidi
+        cache around display iteration.
+
+        * window.c (Fwindow_end, window_scroll_pixel_based)
+        (displayed_window_lines, Frecenter): Save and restore the bidi
+        cache around display iteration.
+
+2011-07-14  Lars Magne Ingebrigtsen  <larsi@gnus.org>
+
+        * editfns.c (Fdelete_region): Clarify the use of the named
+        parameters (bug#6788).
+
+2011-07-14  Martin Rudalics  <rudalics@gmx.at>
+
+        * indent.c (Fvertical_motion): Set and restore w->pointm when
+        saving and restoring the window's buffer (Bug#9006).
+
+2011-07-13  Lars Magne Ingebrigtsen  <larsi@gnus.org>
+
+        * editfns.c (Fstring_to_char): Clarify just what is returned
+        (bug#6576).  Text by Eli Zaretskii.
+
+2011-07-13  Juanma Barranquero  <lekktu@gmail.com>
+
+        * gnutls.c (init_gnutls_functions): Honor gnutls_log_level (bug#9059).
+
+2011-07-13  Eli Zaretskii  <eliz@gnu.org>
+
+        * buffer.c (mmap_find): Fix a typo.
+
+2011-07-13  Johan Bockgård  <bojohan@gnu.org>
+
+        Fix execution of x selection hooks.
+        * xselect.c (Qx_lost_selection_functions)
+        (Qx_sent_selection_functions): New vars.
+        (syms_of_xselect): DEFSYM them.
+        (x_handle_selection_request): Pass Qx_sent_selection_functions
+        rather than Vx_sent_selection_functions to Frun_hook_with_args.
+        (x_handle_selection_clear,x_clear_frame_selections):
+        Pass Qx_lost_selection_functions rather than
+        Vx_lost_selection_functions to Frun_hook_with_args.
+
+2011-07-13  Paul Eggert  <eggert@cs.ucla.edu>
+
+        * buffer.c (Fget_buffer_create): Initialize inhibit_shrinking.
+        The old code sometimes used this field without initializing it.
+
+        * alloc.c (gc_sweep): Don't read past end of array.
+        In theory, the old code could also have corrupted Emacs internals,
+        though it'd be very unlikely.
+
+2011-07-12  Andreas Schwab  <schwab@linux-m68k.org>
+
+        * character.c (Fcharacterp): Don't advertise optional ignored
+        argument.  (Bug#4026)
+
+2011-07-12  Lars Magne Ingebrigtsen  <larsi@gnus.org>
+
+        * keymap.c (syms_of_keymap): Clarify that "modifier" is "modifier
+        key" (bug#4257).
+
+        * window.c (Fset_window_start): Doc fix (bug#4199).
+        (Fset_window_hscroll): Ditto.
+
+2011-07-12  Paul Eggert  <eggert@cs.ucla.edu>
+
+        Fix minor new problems caught by GCC 4.6.1.
+        * term.c (init_tty): Remove unused local.
+        * xsettings.c (store_monospaced_changed): Define this function only
+        if (defined HAVE_GSETTINGS || defined HAVE_GCONF), as it's
+        not used otherwise.
+
+2011-07-12  Chong Yidong  <cyd@stupidchicken.com>
+
+        * xdisp.c (Vresize_mini_windows): Minor doc fix (Bug#3300).
+
+2011-07-11  Lars Magne Ingebrigtsen  <larsi@gnus.org>
+
+        * xdisp.c (syms_of_xdisp): Make it explicit that the mini-windows
+        are the mini-buffer and the echo area (bug#3320).
+
+        * term.c (init_tty): Remove support for supdup, c10 and perq
+        terminals, which are no longer supported (bug#1482).
+
+2011-07-10  Johan Bockgård  <bojohan@gnu.org>
+
+        * xdisp.c (Ftool_bar_lines_needed): Fix WINDOWP check.
+
+2011-07-10  Jan Djärv  <jan.h.d@swipnet.se>
+
+        * xmenu.c (menu_highlight_callback): Only pass frame to show_help_event
+        for non-popups (Bug#3642).
+
+2011-07-10  Andreas Schwab  <schwab@linux-m68k.org>
+
+        * alloc.c (reset_malloc_hooks): Protoize.
+        * buffer.c (mmap_init, mmap_find, mmap_free_1, mmap_enlarge)
+        (mmap_set_vars, mmap_alloc, mmap_free, mmap_realloc): Likewise.
+        * cm.c (losecursor): Likewise.
+        * data.c (fmod): Likewise.
+        * dispnew.c (swap_glyphs_in_rows): Likewise.
+        * emacs.c (memory_warning_signal): Likewise.
+        * floatfns.c (float_error): Likewise.
+        * font.c (check_gstring, check_otf_features, otf_tag_symbol)
+        (otf_open, font_otf_capability, generate_otf_features)
+        (font_otf_DeviceTable, font_otf_ValueRecord, font_otf_Anchor):
+        Likewise.
+        * image.c (pbm_read_file): Likewise.
+        * indent.c (string_display_width): Likewise.
+        * intervals.c (check_for_interval, search_for_interval)
+        (inc_interval_count, count_intervals, root_interval)
+        (adjust_intervals_for_insertion, make_new_interval): Likewise.
+        * lread.c (defalias): Likewise.
+        * ralloc.c (r_alloc_check): Likewise.
+        * regex.c (set_image_of_range_1, set_image_of_range)
+        (regex_grow_registers): Likewise.
+        * sysdep.c (strerror): Likewise.
+        * termcap.c (valid_filename_p, tprint, main): Likewise.
+        * tparam.c (main): Likewise.
+        * unexhp9k800.c (run_time_remap, save_data_space)
+        (update_file_ptrs, read_header, write_header, calculate_checksum)
+        (copy_file, copy_rest, display_header): Likewise.
+        * widget.c (mark_shell_size_user_specified, create_frame_gcs):
+        Likewise.
+        * xdisp.c (check_it): Likewise.
+        * xfaces.c (register_color, unregister_color, unregister_colors):
+        Likewise.
+        * xfns.c (print_fontset_result): Likewise.
+        * xrdb.c (member, fatal, main): Likewise.
+
+2011-07-10  Paul Eggert  <eggert@cs.ucla.edu>
+
+        Fix minor problems found by static checking (Bug#9031).
+        * chartab.c (char_table_set_range, map_sub_char_table):
+        Remove unused locals.
+        (uniprop_table): Now static.
+        * composite.c (_work_char): Remove unused static var.
+
+2011-07-09  Juanma Barranquero  <lekktu@gmail.com>
+
+        * chartab.c (uniprop_table_uncompress): Remove unused local variable.
+
+2011-07-09  Jan Djärv  <jan.h.d@swipnet.se>
+
+        * gtkutil.c (qttip_cb): Remove code without function.
+
+2011-07-09  Eli Zaretskii  <eliz@gnu.org>
+
+        * w32.c (pthread_sigmask): New stub.
+
+2011-07-08  Paul Eggert  <eggert@cs.ucla.edu>
+
+        Use pthread_sigmask, not sigprocmask (Bug#9010).
+        sigprocmask is portable only for single-threaded applications, and
+        Emacs can be multi-threaded when it uses GTK.
+        * Makefile.in (LIB_PTHREAD_SIGMASK): New macro.
+        (LIBES): Use it.
+        * callproc.c (Fcall_process):
+        * process.c (create_process):
+        * sysdep.c (sys_sigblock, sys_sigunblock, sys_sigsetmask):
+        Use pthread_sigmask, not sigprocmask.
+
+2011-07-08  Jan Djärv  <jan.h.d@swipnet.se>
+
+        * gtkutil.c (qttip_cb): Set line wrap to FALSE for tooltip widget.
+        (xg_prepare_tooltip): Revert text in x->ttip_lbl, margins was
+        wrong (Bug#8591).
+
+2011-07-08  Jan Djärv  <jan.h.d@swipnet.se>
+
+        * gtkutil.c (xg_prepare_tooltip): Fix indentation and comment.
+        Put text in x->ttip_lbl instead of gtk_tooltip_set_text (Bug#8591).
+        (xg_hide_tooltip): Fix comment.
+
+        * nsterm.m (initFrameFromEmacs): Don't use ns_return_types
+        in registerServicesMenuSendTypes.
+        (validRequestorForSendType): Don't check ns_return_types.
+
+        * nsfns.m (Fx_open_connection): Put NSStringPboardType into
+        ns_return_type.
+
+2011-07-08  Jason Rumney  <jasonr@gnu.org>
+
+        * w32fns.c (w32_wnd_proc) [WM_TIMER, WM_SET_CURSOR]: Avoid using
+        frame struct members of non-existent frames (Bug#6284).
+
+2011-07-08  Jan Djärv  <jan.h.d@swipnet.se>
+
+        * nsterm.m (keyDown): Call to wantsToDelayTextChangeNotifications and
+        variable firstTime not needed on OSX >= 10.6.
+        (setPosition): setFloatValue:knobProportion: is deprecated on OSX
+        >= 10.5.  Use setKnobProportion, setDoubleValue.
+
+        * nsterm.h (MAC_OS_X_VERSION_10_3, MAC_OS_X_VERSION_10_4)
+        (MAC_OS_X_VERSION_10_5): Define if not defined.
+        (EmacsView, EmacsTooltip): Implements NSWindowDelegate on OSX >= 10.6.
+        (EmacsMenu): Implements NSMenuDelegate on OSX >= 10.6.
+        (EmacsToolbar): Implements NSToolbarDelegate on OSX >= 10.6.
+
+        * nsselect.m (ns_string_from_pasteboard): Don't use deprecated methods
+        cString and lossyCString on OSX >= 10.4
+
+        * nsmenu.m (fillWithWidgetValue): Don't use depercated method
+        sizeToFit on OSX >= 10.2.
+
+        * nsimage.m (allocInitFromFile): Don't use deprecated method
+        bestRepresentationForDevice on OSX >= 10.6.
+
+        * nsfns.m (check_ns_display_info): Cast to long and use %ld in error
+        to avoid warning.
+
+        * emacs.c: Declare unexec_init_emacs_zone.
+
+        * nsgui.h: Fix compiler warning about gnulib redefining verify.
+
+        * nsselect.m (ns_get_local_selection): Change to extern (Bug#8842).
+
+        * nsmenu.m (ns_update_menubar): Remove useless setDelegate call
+        on svcsMenu (Bug#8842).
+
+        * nsfns.m (Fx_open_connection): Remove NSStringPboardType from
+        ns_return_types.
+        (Fns_list_services): Just return Qnil on 10.6, code not working there.
+
+        * nsterm.m (QUTF8_STRING): Declare.
+        (initFrameFromEmacs): Call registerServicesMenuSendTypes.
+        (validRequestorForSendType): Return type is (id).
+        Change indexOfObjectIdenticalTo to indexOfObject.
+        Check if we have local selection before returning self (Bug#8842).
+        (writeSelectionToPasteboard): Put local selection into paste board
+        if we have a local selection (Bug#8842).
+        (syms_of_nsterm): DEFSYM QUTF8_STRING.
+
+        * nsterm.h (MAC_OS_X_VERSION_10_6): Define here instead of nsterm.m.
+        (ns_get_local_selection): Declare.
+
+2011-07-07  Lars Magne Ingebrigtsen  <larsi@gnus.org>
+
+        * keymap.c (describe_map_tree): Don't insert a double newline at
+        the end of the buffer (bug#1169) and return whether we inserted
+        something.
+
+        * callint.c (Fcall_interactively): Change "reading args" to
+        "providing args" to try to clarify what it does (bug#1010).
+
+2011-07-07  Kenichi Handa  <handa@m17n.org>
+
+        * composite.c (composition_compute_stop_pos): Ignore a static
+        composition starting before CHARPOS (Bug#8915).
+
+        * xdisp.c (handle_composition_prop): Likewise.
+
+2011-07-07  Eli Zaretskii  <eliz@gnu.org>
+
+        * term.c (produce_glyphs) <xassert>: Allow IT_GLYPHLESS in it->what.
+        (Bug#9015)
+
+2011-07-07  Kenichi Handa  <handa@m17n.org>
+
+        * character.h (unicode_category_t): New enum type.
+
+        * chartab.c (uniprop_decoder_t, uniprop_encoder_t): New types.
+        (Qchar_code_property_table): New variable.
+        (UNIPROP_TABLE_P, UNIPROP_GET_DECODER)
+        (UNIPROP_COMPRESSED_FORM_P): New macros.
+        (char_table_ascii): Uncompress the compressed values.
+        (sub_char_table_ref): New arg is_uniprop.  Callers changed.
+        Uncompress the compressed values.
+        (sub_char_table_ref_and_range): Likewise.
+        (char_table_ref_and_range): Uncompress the compressed values.
+        (sub_char_table_set): New arg is_uniprop.  Callers changed.
+        Uncompress the compressed values.
+        (sub_char_table_set_range): Args changed.  Callers changed.
+        (char_table_set_range): Adjuted for the above change.
+        (map_sub_char_table): Delete args default_val and parent.  Add arg
+        top.  Give decoded values to a Lisp function.
+        (map_char_table): Adjusted for the above change.  Give decoded
+        values to a Lisp function.  Gcpro more variables.
+        (uniprop_table_uncompress)
+        (uniprop_decode_value_run_length): New functions.
+        (uniprop_decoder, uniprop_decoder_count): New variables.
+        (uniprop_get_decoder, uniprop_encode_value_character)
+        (uniprop_encode_value_run_length, uniprop_encode_value_numeric):
+        New functions.
+        (uniprop_encoder, uniprop_encoder_count): New variables.
+        (uniprop_get_encoder, uniprop_table)
+        (Funicode_property_table_internal, Fget_unicode_property_internal)
+        (Fput_unicode_property_internal): New functions.
+        (syms_of_chartab): DEFSYM Qchar_code_property_table, defsubr
+        Sunicode_property_table_internal, Sget_unicode_property_internal,
+        and Sput_unicode_property_internal. Defvar_lisp
+        char-code-property-alist.
+
+        * composite.c (CHAR_COMPOSABLE_P): Adjusted for the change of
+        Vunicode_category_table.
+
+        * font.c (font_range): Adjusted for the change of
+        Vunicode_category_table.
+
+2011-07-07  Dan Nicolaescu  <dann@ics.uci.edu>
+
+        * m/iris4d.h: Remove file, move contents ...
+        * s/irix6-5.h: ... here.
+
+2011-07-06  Paul Eggert  <eggert@cs.ucla.edu>
+
+        Remove unportable assumption about struct layout (Bug#8884).
+        * alloc.c (mark_buffer):
+        * buffer.c (reset_buffer_local_variables, Fbuffer_local_variables)
+        (clone_per_buffer_values): Don't assume that
+        sizeof (struct buffer) is a multiple of sizeof (Lisp_Object).
+        This isn't true in general, and it's particularly not true
+        if Emacs is configured with --with-wide-int.
+        * buffer.h (FIRST_FIELD_PER_BUFFER, LAST_FIELD_PER_BUFFER):
+        New macros, used in the buffer.c change.
+
+2011-07-05  Jan Djärv  <jan.h.d@swipnet.se>
+
+        * xsettings.c: Use both GConf and GSettings if both are available.
+        (store_config_changed_event): Add comment.
+        (dpyinfo_valid, store_font_name_changed, map_tool_bar_style)
+        (store_tool_bar_style_changed): New functions.
+        (store_monospaced_changed): Add comment. Call dpyinfo_valid.
+        (struct xsettings): Move font inside HAVE_XFT.
+        (GSETTINGS_TOOL_BAR_STYLE, GSETTINGS_FONT_NAME): New defines.
+        (GSETTINGS_MONO_FONT): Renamed from SYSTEM_MONO_FONT.
+        Move inside HAVE_XFT.
+        (something_changed_gsettingsCB): Renamed from something_changedCB.
+        Check for changes in GSETTINGS_TOOL_BAR_STYLE and GSETTINGS_FONT_NAME
+        also.
+        (GCONF_TOOL_BAR_STYLE, GCONF_FONT_NAME): New defines.
+        (GCONF_MONO_FONT): Renamed from SYSTEM_MONO_FONT. Move inside HAVE_XFT.
+        (something_changed_gconfCB): Renamed from something_changedCB.
+        Check for changes in GCONF_TOOL_BAR_STYLE and GCONF_FONT_NAME also.
+        (parse_settings): Move check for font inside HAVE_XFT.
+        (read_settings, apply_xft_settings): Add comment.
+        (read_and_apply_settings): Add comment.  Call map_tool_bar_style and
+        store_tool_bar_style_changed.  Move check for font inside HAVE_XFT and
+        call store_font_name_changed.
+        (xft_settings_event): Add comment.
+        (init_gsettings): Add comment.  Get values for GSETTINGS_TOOL_BAR_STYLE
+        and GSETTINGS_FONT_NAME.  Move check for fonts within HAVE_XFT.
+        (init_gconf): Add comment.  Get values for GCONF_TOOL_BAR_STYLE
+        and GCONF_FONT_NAME.  Move check for fonts within HAVE_XFT.
+        (xsettings_initialize): Call init_gsettings last.
+        (xsettings_get_system_font, xsettings_get_system_normal_font): Add
+        comment.
+
+2011-07-05  Paul Eggert  <eggert@cs.ucla.edu>
+
+        Random fixes.  E.g., (random) never returned negative values.
+        * fns.c (Frandom): Use GET_EMACS_TIME for random seed, and add the
+        subseconds part to the entropy, as that's a bit more random.
+        Prefer signed to unsigned, since the signedness doesn't matter and
+        in general we prefer signed.  When given a limit, use a
+        denominator equal to INTMASK + 1, not to VALMASK + 1, because the
+        latter isn't right if USE_2_TAGS_FOR_INTS.
+        * sysdep.c (get_random): Return a value in the range 0..INTMASK,
+        not 0..VALMASK.  Don't discard "excess" bits that random () returns.
+
+2011-07-04  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * textprop.c (text_property_stickiness):
+        Obey Vtext_property_default_nonsticky.
+        (syms_of_textprop): Add `display' to Vtext_property_default_nonsticky.
+        * w32fns.c (syms_of_w32fns):
+        * xfns.c (syms_of_xfns): Don't Add `display' since it's there by default.
+
+2011-07-04  Paul Eggert  <eggert@cs.ucla.edu>
+
+        * fileio.c (barf_or_query_if_file_exists): Use S_ISDIR.
+        This is more efficient than Ffile_directory_p and avoids a minor race.
+
+2011-07-04  Lars Magne Ingebrigtsen  <larsi@gnus.org>
+
+        * buffer.c (Foverlay_put): Say what the return value is
+        (bug#7835).
+
+        * fileio.c (barf_or_query_if_file_exists): Check first if the file
+        is a directory before asking whether to use the file name
+        (bug#7564).
+        (barf_or_query_if_file_exists): Make the "File is a directory"
+        error be more correct.
+
+        * fns.c (Frequire): Remove the mention of the .gz files, since
+        that's installation-specific, but keep the mention of
+        `get-load-suffixes'.
+
+2011-07-04  Paul Eggert  <eggert@cs.ucla.edu>
+
+        * editfns.c (Fformat_time_string): Don't assume strlen fits in int.
+        Report string overflow if the output is too long.
+
+2011-07-04  Juanma Barranquero  <lekktu@gmail.com>
+
+        * gnutls.c (Fgnutls_boot): Don't mention :verify-error.
+        (syms_of_gnutls): Remove duplicate DEFSYM for
+        Qgnutls_bootprop_verify_hostname_error, an error for
+        Qgnutls_bootprop_verify_error (which is no longer used).
+
+        * eval.c (find_handler_clause): Remove parameters `sig' and `data',
+        unused since 2011-01-26T20:02:07Z!monnier@iro.umontreal.ca.  All callers changed.
+        Also (re)move comments that are misplaced or no longer relevant.
+
+2011-07-03  Lars Magne Ingebrigtsen  <larsi@gnus.org>
+
+        * callint.c (Finteractive): Clarify the meaning of "@" (bug#8813).
+
+2011-07-03  Chong Yidong  <cyd@stupidchicken.com>
+
+        * xfaces.c (Finternal_merge_in_global_face): Modify the foreground
+        and background color parameters if they have been changed.
+
+2011-07-03  Lars Magne Ingebrigtsen  <larsi@gnus.org>
+
+        * editfns.c (Fformat): Clarify the - and 0 flags (bug#6659).
+
+2011-07-03  Paul Eggert  <eggert@cs.ucla.edu>
+
+        * xsettings.c (SYSTEM_FONT): Define only when used.
+        No need to define when HAVE_GSETTINGS || !HAVE_XFT.
+
+        * keymap.c (access_keymap_1): Now static.
+
+2011-07-02  Chong Yidong  <cyd@stupidchicken.com>
+
+        * keyboard.c (command_loop_1): If a down-mouse event is unbound,
+        leave any prefix arg for the up event (Bug#1586).
+
+2011-07-02  Lars Magne Ingebrigtsen  <larsi@gnus.org>
+
+        * lread.c (syms_of_lread): Mention single symbols defined by
+        `defvar' or `defconst' (bug#7154).
+
+        * fns.c (Frequire): Mention .el.gz files (bug#7314).
+        (Frequire): Mention get-load-suffixes.
+
+2011-07-02  Martin Rudalics  <rudalics@gmx.at>
+
+        * window.h (window): Remove clone_number slot.
+        * window.c (Fwindow_clone_number, Fset_window_clone_number):
+        Remove.
+        (make_parent_window, make_window, saved_window)
+        (Fset_window_configuration, save_window_save): Don't deal with
+        clone numbers.
+        * buffer.c (Qclone_number): Remove declaration.
+        (sort_overlays, overlay_strings): Don't deal with clone numbers.
+
+2011-07-02  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        Add multiple inheritance to keymaps.
+        * keymap.c (Fmake_composed_keymap): New function.
+        (Fset_keymap_parent): Simplify.
+        (fix_submap_inheritance): Remove.
+        (access_keymap_1): New function extracted from access_keymap to handle
+        embedded parents and handle lists of maps.
+        (access_keymap): Use it.
+        (Fkeymap_prompt, map_keymap_internal, map_keymap, store_in_keymap)
+        (Fcopy_keymap): Handle embedded parents.
+        (Fcommand_remapping, define_as_prefix): Simplify.
+        (Fkey_binding): Simplify.
+        (syms_of_keymap): Move minibuffer-local-completion-map,
+        minibuffer-local-filename-completion-map,
+        minibuffer-local-must-match-map, and
+        minibuffer-local-filename-must-match-map to Elisp.
+        (syms_of_keymap): Defsubr make-composed-keymap.
+        * keyboard.c (menu_bar_items): Use map_keymap_canonical.
+        (parse_menu_item): Trivial simplification.
+
+2011-07-01  Glenn Morris  <rgm@gnu.org>
+
+        * Makefile.in (SETTINGS_LIBS): Fix typo.
+
+2011-07-01  Kazuhiro Ito  <kzhr@d1.dion.ne.jp>  (tiny patch)
+
+        * coding.c (Fencode_coding_string): Record the last coding system
+        used, as the function doc string says (bug#8738).
+
+2011-07-01  Jan Djärv  <jan.h.d@swipnet.se>
+
+        * xsettings.c (store_monospaced_changed): Take new font as arg and
+        check for change against current_mono_font.
+        (EMACS_TYPE_SETTINGS): Remove this and related defines.
+        (emacs_settings_constructor, emacs_settings_get_property)
+        (emacs_settings_set_property, emacs_settings_class_init)
+        (emacs_settings_init, gsettings_obj): Remove.
+        (something_changedCB): New function for HAVE_GSETTINGS.
+        (something_changedCB): HAVE_GCONF: Call store_monospaced_changed
+        with value as argument.
+        (init_gsettings): Check that GSETTINGS_SCHEMA exists before calling
+        g_settings_new (Bug#8967).  Do not create gsettings_obj.
+        Remove calls to g_settings_bind.  Connect something_changedCB to
+        "changed".
+
+        * xgselect.c: Add defined (HAVE_GSETTINGS).
+        (xgselect_initialize): Ditto.
+
+        * process.c: Add defined (HAVE_GSETTINGS) for xgselect.h
+        (wait_reading_process_output): Add defined (HAVE_GSETTINGS) for
+        xg_select.
+
+2011-07-01  Paul Eggert  <eggert@cs.ucla.edu>
+
+        * eval.c (struct backtrace): Simplify and port the data structure.
+        Do not assume that "int nargs : BITS_PER_INT - 2;" produces a
+        signed bit field, as this assumption is not portable and it makes
+        Emacs crash when compiled with Sun C 5.8 on sparc.  Do not use
+        "char debug_on_exit : 1" as this is not portable either; instead,
+        use the portable "unsigned int debug_on_exit : 1".  Remove unused
+        member evalargs.  Remove obsolete comments about cc bombing out.
+
+2011-06-30  Jan Djärv  <jan.h.d@swipnet.se>
+
+        * xsettings.c: Include glib-object.h, gio/gio.h if HAVE_GSETTINGS.
+        Let HAVE_GSETTINGS override HAVE_GCONF.
+        (store_monospaced_changed): New function.
+        (EMACS_SETTINGS): A new type derived from GObject to handle
+        GSettings notifications.
+        (emacs_settings_constructor, emacs_settings_get_property)
+        (emacs_settings_set_property, emacs_settings_class_init):
+        New functions.
+        (gsettings_client, gsettings_obj): New variables.
+        (GSETTINGS_SCHEMA): New define.
+        (something_changedCB): Call store_monospaced_changed.
+        (init_gsettings): New function.
+        (xsettings_initialize): Call init_gsettings.
+        (syms_of_xsettings): Initialize gsettings_client, gsettings_obj
+        to NULL.
+
+        * Makefile.in (SETTINGS_CFLAGS, SETTINGS_LIBS): Renamed from
+        GCONF_CFLAGS/LIBS.
+
+2011-06-29  Martin Rudalics  <rudalics@gmx.at>
+
+        * window.c (resize_root_window, grow_mini_window)
+        (shrink_mini_window): Rename Qresize_root_window to
+        Qwindow_resize_root_window and Qresize_root_window_vertically to
+        Qwindow_resize_root_window_vertically.
+
 2011-06-28  Paul Eggert  <eggert@cs.ucla.edu>
 
         * gnutls.c (Qgnutls_bootprop_verify_error): Remove unused var.
@@ -47,8 +808,8 @@
         min_width/height (Bug#8919).
 
         * gtkutil.c (xg_create_frame_widgets): Pass f to emacs_fixed_new.
-        (x_wm_set_size_hint): Remove call to emacs_fixed_set_min_size. Fix
-        indentation.
+        (x_wm_set_size_hint): Remove call to emacs_fixed_set_min_size.
+        Fix indentation.
 
 2011-06-26  Eli Zaretskii  <eliz@gnu.org>
 
@@ -1405,7 +2166,7 @@
         (xpm_put_color_table_h):
         * lisp.h (struct Lisp_Hash_Table):
         * minibuf.c (Ftry_completion, Fall_completions, Ftest_completion):
-        * print.c (print):  Use 'EMACS_UINT' and 'EMACS_INT'
+        * print.c (print): Use 'EMACS_UINT' and 'EMACS_INT'
         for hashes and hash indexes, instead of 'unsigned' and 'int'.
         * alloc.c (allocate_vectorlike):
         Check for overflow in vector size calculations.
@@ -1609,7 +2370,7 @@
         and %.0c.  Fix bug with strchr succeeding on '\0' when looking for
         flags.  Fix bug with (format "%c" 256.0).  Avoid integer overflow when
         formatting out-of-range floating point numbers with int
-        formats. (Bug#8668)
+        formats.  (Bug#8668)
 
         * lisp.h (FIXNUM_OVERFLOW_P): Work even if arg is a NaN.
 
@@ -1702,7 +2463,7 @@
 
         * dispnew.c (shift_glyph_matrix, scrolling_window): Mark scrolled row
         for fringe update if it has periodic bitmap.
-        (row_equal_p): Also compare left_fringe_offset, right_fringe_offset,
+        (row_equal_p): Also compare left_fringe_offset, right_fringe_offset,
         and fringe_bitmap_periodic_p.
 
         * fringe.c (get_fringe_bitmap_data): New function.
@@ -2573,9 +3334,9 @@
         :verify-hostname-error, :verify-error, and :verify-flags
         parameters of `gnutls-boot' and documented those parameters in the
         docstring.  Start callback support.
-        (emacs_gnutls_handshake): Add Woe32 support. Retry handshake
-        unless a fatal error occured. Call gnutls_alert_send_appropriate
-        on error. Return error code.
+        (emacs_gnutls_handshake): Add Woe32 support.  Retry handshake
+        unless a fatal error occurred.  Call gnutls_alert_send_appropriate
+        on error.  Return error code.
         (emacs_gnutls_write): Call emacs_gnutls_handle_error.
         (emacs_gnutls_read): Likewise.
         (Fgnutls_boot): Return handshake error code.
diff --git a/src/ChangeLog.6 b/src/ChangeLog.6
index d7903568102..f9372aa666a 100644
--- a/src/ChangeLog.6
+++ b/src/ChangeLog.6
@@ -4599,7 +4599,7 @@
 
 1995-08-14  Erik Naggum  <erik@naggum.no>
 
-        * emacs.c (standard_args): Add option --eval to evalute an
+        * emacs.c (standard_args): Add option --eval to evaluate an
         expression on the command line and print the result.
 
 1995-08-14  Richard Stallman  <rms@mole.gnu.ai.mit.edu>
diff --git a/src/ChangeLog.9 b/src/ChangeLog.9
index 0c39de74a6a..f25434087c1 100644
--- a/src/ChangeLog.9
+++ b/src/ChangeLog.9
@@ -5985,7 +5985,7 @@
         GC_PROTECT_MALLOC_STATE]: New function.
         (PROTECT_MALLOC_STATE): New macro.
         (__malloc_initialize, morecore, _malloc_internal)
-        (_free_internal) _realloc_internal): Use it to make _heapinfo
+        (_free_internal, _realloc_internal): Use it to make _heapinfo
         read-only outside of gmalloc.
 
         * keymap.c: Update copyright.
diff --git a/src/Makefile.in b/src/Makefile.in
index d1e212e92b7..27ae6aff4da 100644
--- a/src/Makefile.in
+++ b/src/Makefile.in
@@ -152,8 +152,8 @@ DBUS_LIBS = @DBUS_LIBS@
 ## dbusbind.o if HAVE_DBUS, else empty.
 DBUS_OBJ = @DBUS_OBJ@
 
-GCONF_CFLAGS = @GCONF_CFLAGS@
-GCONF_LIBS = @GCONF_LIBS@
+SETTINGS_CFLAGS = @SETTINGS_CFLAGS@
+SETTINGS_LIBS = @SETTINGS_LIBS@
 
 ## gtkutil.o if USE_GTK, else empty.
 GTK_OBJ=@GTK_OBJ@
@@ -275,6 +275,8 @@ LIBSELINUX_LIBS = @LIBSELINUX_LIBS@
 LIBGNUTLS_LIBS = @LIBGNUTLS_LIBS@
 LIBGNUTLS_CFLAGS = @LIBGNUTLS_CFLAGS@
 
+LIB_PTHREAD_SIGMASK = @LIB_PTHREAD_SIGMASK@
+
 INTERVALS_H = dispextern.h intervals.h composite.h
 
 GETLOADAVG_LIBS = @GETLOADAVG_LIBS@
@@ -311,8 +313,10 @@ ALL_CFLAGS=-Demacs -DHAVE_CONFIG_H $(MYCPPFLAGS) -I. -I$(srcdir) \
   $(C_SWITCH_MACHINE) $(C_SWITCH_SYSTEM) $(C_SWITCH_X_SITE) \
   $(C_SWITCH_X_SYSTEM) $(CFLAGS_SOUND) $(RSVG_CFLAGS) $(IMAGEMAGICK_CFLAGS) \
   $(LIBXML2_CFLAGS) $(DBUS_CFLAGS) \
+
   $(WEBKIT_CFLAGS) $(CLUTTER_CFLAGS) \
-  $(GCONF_CFLAGS) $(FREETYPE_CFLAGS) $(FONTCONFIG_CFLAGS) \
+  $(SETTINGS_CFLAGS) $(FREETYPE_CFLAGS) $(FONTCONFIG_CFLAGS) \
+
   $(LIBOTF_CFLAGS) $(M17N_FLT_CFLAGS) $(DEPFLAGS) $(PROFILING_CFLAGS) \
   $(LIBGNUTLS_CFLAGS) \
   $(C_WARNINGS_SWITCH) $(CFLAGS)
@@ -391,9 +395,9 @@ LIBES = $(LIBS) $(LIBX_BASE) $(LIBX_OTHER) $(LIBSOUND) \
    $(RSVG_LIBS) $(IMAGEMAGICK_LIBS) $(DBUS_LIBS) \
    $(WEBKIT_LIBS) $(CLUTTER_LIBS) \
    $(LIBXML2_LIBS) $(LIBGPM) $(LIBRESOLV) $(LIBS_SYSTEM) \
-   $(LIBS_TERMCAP) $(GETLOADAVG_LIBS) $(GCONF_LIBS) $(LIBSELINUX_LIBS) \
+   $(LIBS_TERMCAP) $(GETLOADAVG_LIBS) $(SETTINGS_LIBS) $(LIBSELINUX_LIBS) \
    $(FREETYPE_LIBS) $(FONTCONFIG_LIBS) $(LIBOTF_LIBS) $(M17N_FLT_LIBS) \
-   $(LIBGNUTLS_LIBS) \
+   $(LIBGNUTLS_LIBS) $(LIB_PTHREAD_SIGMASK) \
    $(LIB_GCC) $(LIB_MATH) $(LIB_STANDARD) $(LIB_GCC)
 
 all: emacs$(EXEEXT) $(OTHER_FILES)
diff --git a/src/alloc.c b/src/alloc.c
index 43befd722bb..44f935c243d 100644
--- a/src/alloc.c
+++ b/src/alloc.c
@@ -1258,7 +1258,7 @@ emacs_blocked_realloc (void *ptr, size_t size, const void *ptr2)
    calls malloc because it is the first call, and we have an endless loop.  */
 
 void
-reset_malloc_hooks ()
+reset_malloc_hooks (void)
 {
   __free_hook = old_free_hook;
   __malloc_hook = old_malloc_hook;
@@ -5619,7 +5619,8 @@ mark_buffer (Lisp_Object buf)
   /* buffer-local Lisp variables start at `undo_list',
      tho only the ones from `name' on are GC'd normally.  */
   for (ptr = &buffer->BUFFER_INTERNAL_FIELD (name);
-       (char *)ptr < (char *)buffer + sizeof (struct buffer);
+       ptr <= &PER_BUFFER_VALUE (buffer,
+                                 PER_BUFFER_VAR_OFFSET (LAST_FIELD_PER_BUFFER));
        ptr++)
     mark_object (*ptr);
 
@@ -5732,7 +5733,7 @@ gc_sweep (void)
         int ilim = (lim + BITS_PER_INT - 1) / BITS_PER_INT;
 
         /* Scan the mark bits an int at a time.  */
-        for (i = 0; i <= ilim; i++)
+        for (i = 0; i < ilim; i++)
           {
             if (cblk->gcmarkbits[i] == -1)
               {
diff --git a/src/bidi.c b/src/bidi.c
index 469afdb3819..c83ee549923 100644
--- a/src/bidi.c
+++ b/src/bidi.c
@@ -1,4 +1,4 @@
-/* Low-level bidirectional buffer-scanning functions for GNU Emacs.
+/* Low-level bidirectional buffer/string-scanning functions for GNU Emacs.
    Copyright (C) 2000-2001, 2004-2005, 2009-2011
    Free Software Foundation, Inc.
 
@@ -20,7 +20,7 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 /* Written by Eli Zaretskii <eliz@gnu.org>.
 
    A sequential implementation of the Unicode Bidirectional algorithm,
-   as per UAX#9, a part of the Unicode Standard.
+   (UBA) as per UAX#9, a part of the Unicode Standard.
 
    Unlike the reference and most other implementations, this one is
    designed to be called once for every character in the buffer or
@@ -35,11 +35,16 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
    details about its algorithm that finds the next visual-order
    character by resolving their levels on the fly.
 
-   The two other entry points are bidi_paragraph_init and
+   Two other entry points are bidi_paragraph_init and
    bidi_mirror_char.  The first determines the base direction of a
    paragraph, while the second returns the mirrored version of its
    argument character.
 
+   A few auxiliary entry points are used to initialize the bidi
+   iterator for iterating an object (buffer or string), push and pop
+   the bidi iterator state, and save and restore the state of the bidi
+   cache.
+
    If you want to understand the code, you will have to read it
    together with the relevant portions of UAX#9.  The comments include
    references to UAX#9 rules, for that very reason.
@@ -66,16 +71,6 @@ static Lisp_Object bidi_type_table, bidi_mirror_table;
 #define RLM_CHAR   0x200F
 #define BIDI_EOB   -1
 
-/* Local data structures.  (Look in dispextern.h for the rest.)  */
-
-/* What we need to know about the current paragraph.  */
-struct bidi_paragraph_info {
-  EMACS_INT start_bytepos;      /* byte position where it begins */
-  EMACS_INT end_bytepos;        /* byte position where it ends */
-  int       embedding_level;    /* its basic embedding level */
-  bidi_dir_t base_dir;          /* its base direction */
-};
-
 /* Data type for describing the bidirectional character categories.  */
 typedef enum {
   UNKNOWN_BC,
@@ -90,43 +85,10 @@ int bidi_ignore_explicit_marks_for_paragraph_level = 1;
 static Lisp_Object paragraph_start_re, paragraph_separate_re;
 static Lisp_Object Qparagraph_start, Qparagraph_separate;
 
-static void
-bidi_initialize (void)
-{
-
-#include "biditype.h"
-#include "bidimirror.h"
-
-  int i;
-
-  bidi_type_table = Fmake_char_table (Qnil, make_number (STRONG_L));
-  staticpro (&bidi_type_table);
-
-  for (i = 0; i < sizeof bidi_type / sizeof bidi_type[0]; i++)
-    char_table_set_range (bidi_type_table, bidi_type[i].from, bidi_type[i].to,
-                          make_number (bidi_type[i].type));
-
-  bidi_mirror_table = Fmake_char_table (Qnil, Qnil);
-  staticpro (&bidi_mirror_table);
-
-  for (i = 0; i < sizeof bidi_mirror / sizeof bidi_mirror[0]; i++)
-    char_table_set (bidi_mirror_table, bidi_mirror[i].from,
-                    make_number (bidi_mirror[i].to));
-
-  Qparagraph_start = intern ("paragraph-start");
-  staticpro (&Qparagraph_start);
-  paragraph_start_re = Fsymbol_value (Qparagraph_start);
-  if (!STRINGP (paragraph_start_re))
-    paragraph_start_re = build_string ("\f\\|[ \t]*$");
-  staticpro (&paragraph_start_re);
-  Qparagraph_separate = intern ("paragraph-separate");
-  staticpro (&Qparagraph_separate);
-  paragraph_separate_re = Fsymbol_value (Qparagraph_separate);
-  if (!STRINGP (paragraph_separate_re))
-    paragraph_separate_re = build_string ("[ \t\f]*$");
-  staticpro (&paragraph_separate_re);
-  bidi_initialized = 1;
-}
+
+/***********************************************************************
+                        Utilities
+ ***********************************************************************/
 
 /* Return the bidi type of a character CH, subject to the current
    directional OVERRIDE.  */
@@ -243,6 +205,77 @@ bidi_mirror_char (int c)
   return c;
 }
 
+/* Determine the start-of-run (sor) directional type given the two
+   embedding levels on either side of the run boundary.  Also, update
+   the saved info about previously seen characters, since that info is
+   generally valid for a single level run.  */
+static inline void
+bidi_set_sor_type (struct bidi_it *bidi_it, int level_before, int level_after)
+{
+  int higher_level = level_before > level_after ? level_before : level_after;
+
+  /* The prev_was_pdf gork is required for when we have several PDFs
+     in a row.  In that case, we want to compute the sor type for the
+     next level run only once: when we see the first PDF.  That's
+     because the sor type depends only on the higher of the two levels
+     that we find on the two sides of the level boundary (see UAX#9,
+     clause X10), and so we don't need to know the final embedding
+     level to which we descend after processing all the PDFs.  */
+  if (!bidi_it->prev_was_pdf || level_before < level_after)
+    /* FIXME: should the default sor direction be user selectable?  */
+    bidi_it->sor = (higher_level & 1) != 0 ? R2L : L2R;
+  if (level_before > level_after)
+    bidi_it->prev_was_pdf = 1;
+
+  bidi_it->prev.type = UNKNOWN_BT;
+  bidi_it->last_strong.type = bidi_it->last_strong.type_after_w1 =
+    bidi_it->last_strong.orig_type = UNKNOWN_BT;
+  bidi_it->prev_for_neutral.type = bidi_it->sor == R2L ? STRONG_R : STRONG_L;
+  bidi_it->prev_for_neutral.charpos = bidi_it->charpos;
+  bidi_it->prev_for_neutral.bytepos = bidi_it->bytepos;
+  bidi_it->next_for_neutral.type = bidi_it->next_for_neutral.type_after_w1 =
+    bidi_it->next_for_neutral.orig_type = UNKNOWN_BT;
+  bidi_it->ignore_bn_limit = -1; /* meaning it's unknown */
+}
+
+/* Push the current embedding level and override status; reset the
+   current level to LEVEL and the current override status to OVERRIDE.  */
+static inline void
+bidi_push_embedding_level (struct bidi_it *bidi_it,
+                           int level, bidi_dir_t override)
+{
+  bidi_it->stack_idx++;
+  xassert (bidi_it->stack_idx < BIDI_MAXLEVEL);
+  bidi_it->level_stack[bidi_it->stack_idx].level = level;
+  bidi_it->level_stack[bidi_it->stack_idx].override = override;
+}
+
+/* Pop the embedding level and directional override status from the
+   stack, and return the new level.  */
+static inline int
+bidi_pop_embedding_level (struct bidi_it *bidi_it)
+{
+  /* UAX#9 says to ignore invalid PDFs.  */
+  if (bidi_it->stack_idx > 0)
+    bidi_it->stack_idx--;
+  return bidi_it->level_stack[bidi_it->stack_idx].level;
+}
+
+/* Record in SAVED_INFO the information about the current character.  */
+static inline void
+bidi_remember_char (struct bidi_saved_info *saved_info,
+                    struct bidi_it *bidi_it)
+{
+  saved_info->charpos = bidi_it->charpos;
+  saved_info->bytepos = bidi_it->bytepos;
+  saved_info->type = bidi_it->type;
+  bidi_check_type (bidi_it->type);
+  saved_info->type_after_w1 = bidi_it->type_after_w1;
+  bidi_check_type (bidi_it->type_after_w1);
+  saved_info->orig_type = bidi_it->orig_type;
+  bidi_check_type (bidi_it->orig_type);
+}
+
 /* Copy the bidi iterator from FROM to TO.  To save cycles, this only
    copies the part of the level stack that is actually in use.  */
 static inline void
@@ -259,22 +292,37 @@ bidi_copy_it (struct bidi_it *to, struct bidi_it *from)
     to->level_stack[i] = from->level_stack[i];
 }
 
-/* Caching the bidi iterator states.  */
+
+/***********************************************************************
+                        Caching the bidi iterator states
+ ***********************************************************************/
 
 #define BIDI_CACHE_CHUNK 200
 static struct bidi_it *bidi_cache;
-static size_t bidi_cache_size = 0;
-static size_t elsz = sizeof (struct bidi_it);
-static int bidi_cache_idx;      /* next unused cache slot */
-static int bidi_cache_last_idx; /* slot of last cache hit */
-
+static EMACS_INT bidi_cache_size = 0;
+enum { elsz = sizeof (struct bidi_it) };
+static EMACS_INT bidi_cache_idx;        /* next unused cache slot */
+static EMACS_INT bidi_cache_last_idx;   /* slot of last cache hit */
+static EMACS_INT bidi_cache_start = 0;  /* start of cache for this
+                                           "stack" level */
+
+/* Reset the cache state to the empty state.  We only reset the part
+   of the cache relevant to iteration of the current object.  Previous
+   objects, which are pushed on the display iterator's stack, are left
+   intact.  This is called when the cached information is no more
+   useful for the current iteration, e.g. when we were reseated to a
+   new position on the same object.  */
 static inline void
 bidi_cache_reset (void)
 {
-  bidi_cache_idx = 0;
+  bidi_cache_idx = bidi_cache_start;
   bidi_cache_last_idx = -1;
 }
 
+/* Shrink the cache to its minimal size.  Called when we init the bidi
+   iterator for reordering a buffer or a string that does not come
+   from display properties, because that means all the previously
+   cached info is of no further use.  */
 static inline void
 bidi_cache_shrink (void)
 {
@@ -288,11 +336,11 @@ bidi_cache_shrink (void)
 }
 
 static inline void
-bidi_cache_fetch_state (int idx, struct bidi_it *bidi_it)
+bidi_cache_fetch_state (EMACS_INT idx, struct bidi_it *bidi_it)
 {
   int current_scan_dir = bidi_it->scan_dir;
 
-  if (idx < 0 || idx >= bidi_cache_idx)
+  if (idx < bidi_cache_start || idx >= bidi_cache_idx)
     abort ();
 
   bidi_copy_it (bidi_it, &bidi_cache[idx]);
@@ -304,13 +352,15 @@ bidi_cache_fetch_state (int idx, struct bidi_it *bidi_it)
    level less or equal to LEVEL.  if LEVEL is -1, disregard the
    resolved levels in cached states.  DIR, if non-zero, means search
    in that direction from the last cache hit.  */
-static inline int
+static inline EMACS_INT
 bidi_cache_search (EMACS_INT charpos, int level, int dir)
 {
-  int i, i_start;
+  EMACS_INT i, i_start;
 
-  if (bidi_cache_idx)
+  if (bidi_cache_idx > bidi_cache_start)
     {
+      if (bidi_cache_last_idx == -1)
+        bidi_cache_last_idx = bidi_cache_idx - 1;
       if (charpos < bidi_cache[bidi_cache_last_idx].charpos)
         {
           dir = -1;
@@ -333,7 +383,7 @@ bidi_cache_search (EMACS_INT charpos, int level, int dir)
       if (dir < 0)
         {
           /* Linear search for now; FIXME!  */
-          for (i = i_start; i >= 0; i--)
+          for (i = i_start; i >= bidi_cache_start; i--)
             if (bidi_cache[i].charpos <= charpos
                 && charpos < bidi_cache[i].charpos + bidi_cache[i].nchars
                 && (level == -1 || bidi_cache[i].resolved_level <= level))
@@ -355,8 +405,9 @@ bidi_cache_search (EMACS_INT charpos, int level, int dir)
 /* Find a cached state where the resolved level changes to a value
    that is lower than LEVEL, and return its cache slot index.  DIR is
    the direction to search, starting with the last used cache slot.
-   BEFORE, if non-zero, means return the index of the slot that is
-   ``before'' the level change in the search direction.  That is,
+   If DIR is zero, we search backwards from the last occupied cache
+   slot.  BEFORE, if non-zero, means return the index of the slot that
+   is ``before'' the level change in the search direction.  That is,
    given the cached levels like this:
 
          1122333442211
@@ -366,14 +417,16 @@ bidi_cache_search (EMACS_INT charpos, int level, int dir)
    C, searching backwards (DIR = -1) for LEVEL = 2 will return the
    index of slot B or A, depending whether BEFORE is, respectively,
    non-zero or zero.  */
-static int
+static EMACS_INT
 bidi_cache_find_level_change (int level, int dir, int before)
 {
   if (bidi_cache_idx)
     {
-      int i = dir ? bidi_cache_last_idx : bidi_cache_idx - 1;
+      EMACS_INT i = dir ? bidi_cache_last_idx : bidi_cache_idx - 1;
       int incr = before ? 1 : 0;
 
+      xassert (!dir || bidi_cache_last_idx >= 0);
+
       if (!dir)
         dir = -1;
       else if (!incr)
@@ -381,7 +434,7 @@ bidi_cache_find_level_change (int level, int dir, int before)
 
       if (dir < 0)
         {
-          while (i >= incr)
+          while (i >= bidi_cache_start + incr)
             {
               if (bidi_cache[i - incr].resolved_level >= 0
                   && bidi_cache[i - incr].resolved_level < level)
@@ -405,9 +458,22 @@ bidi_cache_find_level_change (int level, int dir, int before)
 }
 
 static inline void
+bidi_cache_ensure_space (EMACS_INT idx)
+{
+  /* Enlarge the cache as needed.  */
+  if (idx >= bidi_cache_size)
+    {
+      while (idx >= bidi_cache_size)
+        bidi_cache_size += BIDI_CACHE_CHUNK;
+      bidi_cache =
+        (struct bidi_it *) xrealloc (bidi_cache, bidi_cache_size * elsz);
+    }
+}
+
+static inline void
 bidi_cache_iterator_state (struct bidi_it *bidi_it, int resolved)
 {
-  int idx;
+  EMACS_INT idx;
 
   /* We should never cache on backward scans.  */
   if (bidi_it->scan_dir == -1)
@@ -417,23 +483,17 @@ bidi_cache_iterator_state (struct bidi_it *bidi_it, int resolved)
   if (idx < 0)
     {
       idx = bidi_cache_idx;
-      /* Enlarge the cache as needed.  */
-      if (idx >= bidi_cache_size)
-        {
-          bidi_cache_size += BIDI_CACHE_CHUNK;
-          bidi_cache =
-            (struct bidi_it *) xrealloc (bidi_cache, bidi_cache_size * elsz);
-        }
+      bidi_cache_ensure_space (idx);
       /* Character positions should correspond to cache positions 1:1.
          If we are outside the range of cached positions, the cache is
          useless and must be reset.  */
-      if (idx > 0 &&
+      if (idx > bidi_cache_start &&
           (bidi_it->charpos > (bidi_cache[idx - 1].charpos
                                + bidi_cache[idx - 1].nchars)
-           || bidi_it->charpos < bidi_cache[0].charpos))
+           || bidi_it->charpos < bidi_cache[bidi_cache_start].charpos))
         {
           bidi_cache_reset ();
-          idx = 0;
+          idx = bidi_cache_start;
         }
       if (bidi_it->nchars <= 0)
         abort ();
@@ -468,9 +528,9 @@ bidi_cache_iterator_state (struct bidi_it *bidi_it, int resolved)
 static inline bidi_type_t
 bidi_cache_find (EMACS_INT charpos, int level, struct bidi_it *bidi_it)
 {
-  int i = bidi_cache_search (charpos, level, bidi_it->scan_dir);
+  EMACS_INT i = bidi_cache_search (charpos, level, bidi_it->scan_dir);
 
-  if (i >= 0)
+  if (i >= bidi_cache_start)
     {
       bidi_dir_t current_scan_dir = bidi_it->scan_dir;
 
@@ -488,69 +548,245 @@ bidi_cache_find (EMACS_INT charpos, int level, struct bidi_it *bidi_it)
 static inline int
 bidi_peek_at_next_level (struct bidi_it *bidi_it)
 {
-  if (bidi_cache_idx == 0 || bidi_cache_last_idx == -1)
+  if (bidi_cache_idx == bidi_cache_start || bidi_cache_last_idx == -1)
     abort ();
   return bidi_cache[bidi_cache_last_idx + bidi_it->scan_dir].resolved_level;
 }
 
-/* Check if buffer position CHARPOS/BYTEPOS is the end of a paragraph.
-   Value is the non-negative length of the paragraph separator
-   following the buffer position, -1 if position is at the beginning
-   of a new paragraph, or -2 if position is neither at beginning nor
-   at end of a paragraph.  */
-static EMACS_INT
-bidi_at_paragraph_end (EMACS_INT charpos, EMACS_INT bytepos)
+
+/***********************************************************************
+             Pushing and popping the bidi iterator state
+ ***********************************************************************/
+/* 5-slot stack for saving the start of the previous level of the
+   cache.  xdisp.c maintains a 5-slot stack for its iterator state,
+   and we need the same size of our stack.  */
+static EMACS_INT bidi_cache_start_stack[IT_STACK_SIZE];
+static int bidi_cache_sp;
+
+/* Push the bidi iterator state in preparation for reordering a
+   different object, e.g. display string found at certain buffer
+   position.  Pushing the bidi iterator boils down to saving its
+   entire state on the cache and starting a new cache "stacked" on top
+   of the current cache.  */
+void
+bidi_push_it (struct bidi_it *bidi_it)
 {
-  Lisp_Object sep_re;
-  Lisp_Object start_re;
-  EMACS_INT val;
+  /* Save the current iterator state in its entirety after the last
+     used cache slot.  */
+  bidi_cache_ensure_space (bidi_cache_idx);
+  memcpy (&bidi_cache[bidi_cache_idx++], bidi_it, sizeof (struct bidi_it));
 
-  sep_re = paragraph_separate_re;
-  start_re = paragraph_start_re;
+  /* Push the current cache start onto the stack.  */
+  xassert (bidi_cache_sp < IT_STACK_SIZE);
+  bidi_cache_start_stack[bidi_cache_sp++] = bidi_cache_start;
 
-  val = fast_looking_at (sep_re, charpos, bytepos, ZV, ZV_BYTE, Qnil);
-  if (val < 0)
+  /* Start a new level of cache, and make it empty.  */
+  bidi_cache_start = bidi_cache_idx;
+  bidi_cache_last_idx = -1;
+}
+
+/* Restore the iterator state saved by bidi_push_it and return the
+   cache to the corresponding state.  */
+void
+bidi_pop_it (struct bidi_it *bidi_it)
+{
+  if (bidi_cache_start <= 0)
+    abort ();
+
+  /* Reset the next free cache slot index to what it was before the
+     call to bidi_push_it.  */
+  bidi_cache_idx = bidi_cache_start - 1;
+
+  /* Restore the bidi iterator state saved in the cache.  */
+  memcpy (bidi_it, &bidi_cache[bidi_cache_idx], sizeof (struct bidi_it));
+
+  /* Pop the previous cache start from the stack.  */
+  if (bidi_cache_sp <= 0)
+    abort ();
+  bidi_cache_start = bidi_cache_start_stack[--bidi_cache_sp];
+
+  /* Invalidate the last-used cache slot data.  */
+  bidi_cache_last_idx = -1;
+}
+
+/* Stash away a copy of the cache and its control variables.  */
+void *
+bidi_shelve_cache (void)
+{
+  unsigned char *databuf;
+
+  if (bidi_cache_idx == 0)
+    return NULL;
+
+  databuf = xmalloc (sizeof (bidi_cache_idx)
+                     + bidi_cache_idx * sizeof (struct bidi_it)
+                     + sizeof (bidi_cache_start_stack)
+                     + sizeof (bidi_cache_sp) + sizeof (bidi_cache_start)
+                     + sizeof (bidi_cache_last_idx));
+  memcpy (databuf, &bidi_cache_idx, sizeof (bidi_cache_idx));
+  memcpy (databuf + sizeof (bidi_cache_idx),
+          bidi_cache, bidi_cache_idx * sizeof (struct bidi_it));
+  memcpy (databuf + sizeof (bidi_cache_idx)
+          + bidi_cache_idx * sizeof (struct bidi_it),
+          bidi_cache_start_stack, sizeof (bidi_cache_start_stack));
+  memcpy (databuf + sizeof (bidi_cache_idx)
+          + bidi_cache_idx * sizeof (struct bidi_it)
+          + sizeof (bidi_cache_start_stack),
+          &bidi_cache_sp, sizeof (bidi_cache_sp));
+  memcpy (databuf + sizeof (bidi_cache_idx)
+          + bidi_cache_idx * sizeof (struct bidi_it)
+          + sizeof (bidi_cache_start_stack) + sizeof (bidi_cache_sp),
+          &bidi_cache_start, sizeof (bidi_cache_start));
+  memcpy (databuf + sizeof (bidi_cache_idx)
+          + bidi_cache_idx * sizeof (struct bidi_it)
+          + sizeof (bidi_cache_start_stack) + sizeof (bidi_cache_sp)
+          + sizeof (bidi_cache_start),
+          &bidi_cache_last_idx, sizeof (bidi_cache_last_idx));
+
+  return databuf;
+}
+
+/* Restore the cache state from a copy stashed away by bidi_shelve_cache.  */
+void
+bidi_unshelve_cache (void *databuf)
+{
+  unsigned char *p = databuf;
+
+  if (!p)
     {
-      if (fast_looking_at (start_re, charpos, bytepos, ZV, ZV_BYTE, Qnil) >= 0)
-        val = -1;
-      else
-        val = -2;
+      /* A NULL pointer means an empty cache.  */
+      bidi_cache_start = 0;
+      bidi_cache_sp = 0;
+      bidi_cache_reset ();
     }
+  else
+    {
+      memcpy (&bidi_cache_idx, p, sizeof (bidi_cache_idx));
+      bidi_cache_ensure_space (bidi_cache_idx);
+      memcpy (bidi_cache, p + sizeof (bidi_cache_idx),
+              bidi_cache_idx * sizeof (struct bidi_it));
+      memcpy (bidi_cache_start_stack,
+              p + sizeof (bidi_cache_idx)
+              + bidi_cache_idx * sizeof (struct bidi_it),
+              sizeof (bidi_cache_start_stack));
+      memcpy (&bidi_cache_sp,
+              p + sizeof (bidi_cache_idx)
+              + bidi_cache_idx * sizeof (struct bidi_it)
+              + sizeof (bidi_cache_start_stack),
+              sizeof (bidi_cache_sp));
+      memcpy (&bidi_cache_start,
+              p + sizeof (bidi_cache_idx)
+              + bidi_cache_idx * sizeof (struct bidi_it)
+              + sizeof (bidi_cache_start_stack) + sizeof (bidi_cache_sp),
+              sizeof (bidi_cache_start));
+      memcpy (&bidi_cache_last_idx,
+              p + sizeof (bidi_cache_idx)
+              + bidi_cache_idx * sizeof (struct bidi_it)
+              + sizeof (bidi_cache_start_stack) + sizeof (bidi_cache_sp)
+              + sizeof (bidi_cache_start),
+              sizeof (bidi_cache_last_idx));
+
+      xfree (p);
+    }
+}
 
-  return val;
+
+/***********************************************************************
+                        Initialization
+ ***********************************************************************/
+static void
+bidi_initialize (void)
+{
+
+#include "biditype.h"
+#include "bidimirror.h"
+
+  int i;
+
+  bidi_type_table = Fmake_char_table (Qnil, make_number (STRONG_L));
+  staticpro (&bidi_type_table);
+
+  for (i = 0; i < sizeof bidi_type / sizeof bidi_type[0]; i++)
+    char_table_set_range (bidi_type_table, bidi_type[i].from, bidi_type[i].to,
+                          make_number (bidi_type[i].type));
+
+  bidi_mirror_table = Fmake_char_table (Qnil, Qnil);
+  staticpro (&bidi_mirror_table);
+
+  for (i = 0; i < sizeof bidi_mirror / sizeof bidi_mirror[0]; i++)
+    char_table_set (bidi_mirror_table, bidi_mirror[i].from,
+                    make_number (bidi_mirror[i].to));
+
+  Qparagraph_start = intern ("paragraph-start");
+  staticpro (&Qparagraph_start);
+  paragraph_start_re = Fsymbol_value (Qparagraph_start);
+  if (!STRINGP (paragraph_start_re))
+    paragraph_start_re = build_string ("\f\\|[ \t]*$");
+  staticpro (&paragraph_start_re);
+  Qparagraph_separate = intern ("paragraph-separate");
+  staticpro (&Qparagraph_separate);
+  paragraph_separate_re = Fsymbol_value (Qparagraph_separate);
+  if (!STRINGP (paragraph_separate_re))
+    paragraph_separate_re = build_string ("[ \t\f]*$");
+  staticpro (&paragraph_separate_re);
+
+  bidi_cache_sp = 0;
+
+  bidi_initialized = 1;
 }
 
-/* Determine the start-of-run (sor) directional type given the two
-   embedding levels on either side of the run boundary.  Also, update
-   the saved info about previously seen characters, since that info is
-   generally valid for a single level run.  */
+/* Do whatever UAX#9 clause X8 says should be done at paragraph's
+   end.  */
 static inline void
-bidi_set_sor_type (struct bidi_it *bidi_it, int level_before, int level_after)
+bidi_set_paragraph_end (struct bidi_it *bidi_it)
 {
-  int higher_level = level_before > level_after ? level_before : level_after;
-
-  /* The prev_was_pdf gork is required for when we have several PDFs
-     in a row.  In that case, we want to compute the sor type for the
-     next level run only once: when we see the first PDF.  That's
-     because the sor type depends only on the higher of the two levels
-     that we find on the two sides of the level boundary (see UAX#9,
-     clause X10), and so we don't need to know the final embedding
-     level to which we descend after processing all the PDFs.  */
-  if (!bidi_it->prev_was_pdf || level_before < level_after)
-    /* FIXME: should the default sor direction be user selectable?  */
-    bidi_it->sor = (higher_level & 1) != 0 ? R2L : L2R;
-  if (level_before > level_after)
-    bidi_it->prev_was_pdf = 1;
+  bidi_it->invalid_levels = 0;
+  bidi_it->invalid_rl_levels = -1;
+  bidi_it->stack_idx = 0;
+  bidi_it->resolved_level = bidi_it->level_stack[0].level;
+}
 
-  bidi_it->prev.type = UNKNOWN_BT;
+/* Initialize the bidi iterator from buffer/string position CHARPOS.  */
+void
+bidi_init_it (EMACS_INT charpos, EMACS_INT bytepos, int frame_window_p,
+              struct bidi_it *bidi_it)
+{
+  if (! bidi_initialized)
+    bidi_initialize ();
+  if (charpos >= 0)
+    bidi_it->charpos = charpos;
+  if (bytepos >= 0)
+    bidi_it->bytepos = bytepos;
+  bidi_it->frame_window_p = frame_window_p;
+  bidi_it->nchars = -1; /* to be computed in bidi_resolve_explicit_1 */
+  bidi_it->first_elt = 1;
+  bidi_set_paragraph_end (bidi_it);
+  bidi_it->new_paragraph = 1;
+  bidi_it->separator_limit = -1;
+  bidi_it->type = NEUTRAL_B;
+  bidi_it->type_after_w1 = NEUTRAL_B;
+  bidi_it->orig_type = NEUTRAL_B;
+  bidi_it->prev_was_pdf = 0;
+  bidi_it->prev.type = bidi_it->prev.type_after_w1 =
+    bidi_it->prev.orig_type = UNKNOWN_BT;
   bidi_it->last_strong.type = bidi_it->last_strong.type_after_w1 =
     bidi_it->last_strong.orig_type = UNKNOWN_BT;
-  bidi_it->prev_for_neutral.type = bidi_it->sor == R2L ? STRONG_R : STRONG_L;
-  bidi_it->prev_for_neutral.charpos = bidi_it->charpos;
-  bidi_it->prev_for_neutral.bytepos = bidi_it->bytepos;
-  bidi_it->next_for_neutral.type = bidi_it->next_for_neutral.type_after_w1 =
+  bidi_it->next_for_neutral.charpos = -1;
+  bidi_it->next_for_neutral.type =
+    bidi_it->next_for_neutral.type_after_w1 =
     bidi_it->next_for_neutral.orig_type = UNKNOWN_BT;
-  bidi_it->ignore_bn_limit = 0; /* meaning it's unknown */
+  bidi_it->prev_for_neutral.charpos = -1;
+  bidi_it->prev_for_neutral.type =
+    bidi_it->prev_for_neutral.type_after_w1 =
+    bidi_it->prev_for_neutral.orig_type = UNKNOWN_BT;
+  bidi_it->sor = L2R;    /* FIXME: should it be user-selectable? */
+  bidi_it->disp_pos = -1;       /* invalid/unknown */
+  /* We can only shrink the cache if we are at the bottom level of its
+     "stack".  */
+  if (bidi_cache_start == 0)
+    bidi_cache_shrink ();
+  else
+    bidi_cache_reset ();
 }
 
 /* Perform initializations for reordering a new line of bidi text.  */
@@ -571,6 +807,57 @@ bidi_line_init (struct bidi_it *bidi_it)
   bidi_cache_reset ();
 }
 
+
+/***********************************************************************
+                        Fetching characters
+ ***********************************************************************/
+
+/* Count bytes in string S between BEG/BEGBYTE and END.  BEG and END
+   are zero-based character positions in S, BEGBYTE is byte position
+   corresponding to BEG.  UNIBYTE, if non-zero, means S is a unibyte
+   string.  */
+static inline EMACS_INT
+bidi_count_bytes (const unsigned char *s, const EMACS_INT beg,
+                  const EMACS_INT begbyte, const EMACS_INT end, int unibyte)
+{
+  EMACS_INT pos = beg;
+  const unsigned char *p = s + begbyte, *start = p;
+
+  if (unibyte)
+    p = s + end;
+  else
+    {
+      if (!CHAR_HEAD_P (*p))
+        abort ();
+
+      while (pos < end)
+        {
+          p += BYTES_BY_CHAR_HEAD (*p);
+          pos++;
+        }
+    }
+
+  return p - start;
+}
+
+/* Fetch and returns the character at byte position BYTEPOS.  If S is
+   non-NULL, fetch the character from string S; otherwise fetch the
+   character from the current buffer.  UNIBYTE non-zero means S is a
+   unibyte string.  */
+static inline int
+bidi_char_at_pos (EMACS_INT bytepos, const unsigned char *s, int unibyte)
+{
+  if (s)
+    {
+      if (unibyte)
+        return s[bytepos];
+      else
+        return STRING_CHAR (s + bytepos);
+    }
+  else
+    return FETCH_MULTIBYTE_CHAR (bytepos);
+}
+
 /* Fetch and return the character at BYTEPOS/CHARPOS.  If that
    character is covered by a display string, treat the entire run of
    covered characters as a single character u+FFFC, and return their
@@ -578,26 +865,34 @@ bidi_line_init (struct bidi_it *bidi_it)
    character position of the next display string, or -1 if not yet
    computed.  When the next character is at or beyond that position,
    the function updates DISP_POS with the position of the next display
-   string.  */
+   string.  STRING->s is the C string to iterate, or NULL if iterating
+   over a buffer or a Lisp string; in the latter case, STRING->lstring
+   is the Lisp string.  */
 static inline int
 bidi_fetch_char (EMACS_INT bytepos, EMACS_INT charpos, EMACS_INT *disp_pos,
+                 struct bidi_string_data *string,
                  int frame_window_p, EMACS_INT *ch_len, EMACS_INT *nchars)
 {
   int ch;
+  EMACS_INT endpos =
+    (string->s || STRINGP (string->lstring)) ? string->schars : ZV;
+  struct text_pos pos;
 
-  /* FIXME: Support strings in addition to buffers.  */
   /* If we got past the last known position of display string, compute
-     the position of the next one.  That position could be at BYTEPOS.  */
-  if (charpos < ZV && charpos > *disp_pos)
-    *disp_pos = compute_display_string_pos (charpos, frame_window_p);
+     the position of the next one.  That position could be at CHARPOS.  */
+  if (charpos < endpos && charpos > *disp_pos)
+    {
+      SET_TEXT_POS (pos, charpos, bytepos);
+      *disp_pos = compute_display_string_pos (&pos, string, frame_window_p);
+    }
 
   /* Fetch the character at BYTEPOS.  */
-  if (bytepos >= ZV_BYTE)
+  if (charpos >= endpos)
     {
       ch = BIDI_EOB;
       *ch_len = 1;
       *nchars = 1;
-      *disp_pos = ZV;
+      *disp_pos = endpos;
     }
   else if (charpos >= *disp_pos)
     {
@@ -608,28 +903,105 @@ bidi_fetch_char (EMACS_INT bytepos, EMACS_INT charpos, EMACS_INT *disp_pos,
       if (charpos > *disp_pos)
         abort ();
       /* Return the Unicode Object Replacement Character to represent
-         the entire run of characters covered by the display
-         string.  */
+         the entire run of characters covered by the display string.  */
       ch = 0xFFFC;
-      disp_end_pos = compute_display_string_end (*disp_pos);
+      disp_end_pos = compute_display_string_end (*disp_pos, string);
       *nchars = disp_end_pos - *disp_pos;
-      *ch_len = CHAR_TO_BYTE (disp_end_pos) - bytepos;
+      if (*nchars <= 0)
+        abort ();
+      if (string->s)
+        *ch_len = bidi_count_bytes (string->s, *disp_pos, bytepos,
+                                    disp_end_pos, string->unibyte);
+      else if (STRINGP (string->lstring))
+        *ch_len = bidi_count_bytes (SDATA (string->lstring), *disp_pos,
+                                    bytepos, disp_end_pos, string->unibyte);
+      else
+        *ch_len = CHAR_TO_BYTE (disp_end_pos) - bytepos;
     }
   else
     {
-      ch = FETCH_MULTIBYTE_CHAR (bytepos);
+      if (string->s)
+        {
+          int len;
+
+          if (!string->unibyte)
+            {
+              ch = STRING_CHAR_AND_LENGTH (string->s + bytepos, len);
+              *ch_len = len;
+            }
+          else
+            {
+              ch = UNIBYTE_TO_CHAR (string->s[bytepos]);
+              *ch_len = 1;
+            }
+        }
+      else if (STRINGP (string->lstring))
+        {
+          int len;
+
+          if (!string->unibyte)
+            {
+              ch = STRING_CHAR_AND_LENGTH (SDATA (string->lstring) + bytepos,
+                                           len);
+              *ch_len = len;
+            }
+          else
+            {
+              ch = UNIBYTE_TO_CHAR (SREF (string->lstring, bytepos));
+              *ch_len = 1;
+            }
+        }
+      else
+        {
+          ch = FETCH_MULTIBYTE_CHAR (bytepos);
+          *ch_len = CHAR_BYTES (ch);
+        }
       *nchars = 1;
-      *ch_len = CHAR_BYTES (ch);
     }
 
   /* If we just entered a run of characters covered by a display
      string, compute the position of the next display string.  */
-  if (charpos + *nchars <= ZV && charpos + *nchars > *disp_pos)
-    *disp_pos = compute_display_string_pos (charpos + *nchars, frame_window_p);
+  if (charpos + *nchars <= endpos && charpos + *nchars > *disp_pos)
+    {
+      SET_TEXT_POS (pos, charpos + *nchars, bytepos + *ch_len);
+      *disp_pos = compute_display_string_pos (&pos, string, frame_window_p);
+    }
 
   return ch;
 }
 
+
+/***********************************************************************
+                        Determining paragraph direction
+ ***********************************************************************/
+
+/* Check if buffer position CHARPOS/BYTEPOS is the end of a paragraph.
+   Value is the non-negative length of the paragraph separator
+   following the buffer position, -1 if position is at the beginning
+   of a new paragraph, or -2 if position is neither at beginning nor
+   at end of a paragraph.  */
+static EMACS_INT
+bidi_at_paragraph_end (EMACS_INT charpos, EMACS_INT bytepos)
+{
+  Lisp_Object sep_re;
+  Lisp_Object start_re;
+  EMACS_INT val;
+
+  sep_re = paragraph_separate_re;
+  start_re = paragraph_start_re;
+
+  val = fast_looking_at (sep_re, charpos, bytepos, ZV, ZV_BYTE, Qnil);
+  if (val < 0)
+    {
+      if (fast_looking_at (start_re, charpos, bytepos, ZV, ZV_BYTE, Qnil) >= 0)
+        val = -1;
+      else
+        val = -2;
+    }
+
+  return val;
+}
+
 /* Find the beginning of this paragraph by looking back in the buffer.
    Value is the byte position of the paragraph's beginning.  */
 static EMACS_INT
@@ -670,13 +1042,19 @@ void
 bidi_paragraph_init (bidi_dir_t dir, struct bidi_it *bidi_it, int no_default_p)
 {
   EMACS_INT bytepos = bidi_it->bytepos;
+  int string_p = bidi_it->string.s != NULL || STRINGP (bidi_it->string.lstring);
   EMACS_INT pstartbyte;
+  /* Note that begbyte is a byte position, while end is a character
+     position.  Yes, this is ugly, but we are trying to avoid costly
+     calls to BYTE_TO_CHAR and its ilk.  */
+  EMACS_INT begbyte = string_p ? 0 : BEGV_BYTE;
+  EMACS_INT end = string_p ? bidi_it->string.schars : ZV;
 
   /* Special case for an empty buffer. */
-  if (bytepos == BEGV_BYTE && bytepos == ZV_BYTE)
+  if (bytepos == begbyte && bidi_it->charpos == end)
     dir = L2R;
   /* We should never be called at EOB or before BEGV.  */
-  else if (bytepos >= ZV_BYTE || bytepos < BEGV_BYTE)
+  else if (bidi_it->charpos >= end || bytepos < begbyte)
     abort ();
 
   if (dir == L2R)
@@ -695,6 +1073,7 @@ bidi_paragraph_init (bidi_dir_t dir, struct bidi_it *bidi_it, int no_default_p)
       EMACS_INT ch_len, nchars;
       EMACS_INT pos, disp_pos = -1;
       bidi_type_t type;
+      const unsigned char *s;
 
       if (!bidi_initialized)
         bidi_initialize ();
@@ -712,7 +1091,10 @@ bidi_paragraph_init (bidi_dir_t dir, struct bidi_it *bidi_it, int no_default_p)
          we are potentially in a new paragraph that doesn't yet
          exist.  */
       pos = bidi_it->charpos;
-      if (bytepos > BEGV_BYTE && FETCH_CHAR (bytepos) == '\n')
+      s = STRINGP (bidi_it->string.lstring) ?
+        SDATA (bidi_it->string.lstring) : bidi_it->string.s;
+      if (bytepos > begbyte
+          && bidi_char_at_pos (bytepos, s, bidi_it->string.unibyte) == '\n')
         {
           bytepos++;
           pos++;
@@ -720,17 +1102,25 @@ bidi_paragraph_init (bidi_dir_t dir, struct bidi_it *bidi_it, int no_default_p)
 
       /* We are either at the beginning of a paragraph or in the
          middle of it.  Find where this paragraph starts.  */
-      pstartbyte = bidi_find_paragraph_start (pos, bytepos);
+      if (string_p)
+        {
+          /* We don't support changes of paragraph direction inside a
+             string.  It is treated as a single paragraph.  */
+          pstartbyte = 0;
+        }
+      else
+        pstartbyte = bidi_find_paragraph_start (pos, bytepos);
       bidi_it->separator_limit = -1;
       bidi_it->new_paragraph = 0;
 
       /* The following loop is run more than once only if NO_DEFAULT_P
-         is non-zero.  */
+         is non-zero, and only if we are iterating on a buffer.  */
       do {
         bytepos = pstartbyte;
-        pos = BYTE_TO_CHAR (bytepos);
-        ch = bidi_fetch_char (bytepos, pos, &disp_pos, bidi_it->frame_window_p,
-                              &ch_len, &nchars);
+        if (!string_p)
+          pos = BYTE_TO_CHAR (bytepos);
+        ch = bidi_fetch_char (bytepos, pos, &disp_pos, &bidi_it->string,
+                              bidi_it->frame_window_p, &ch_len, &nchars);
         type = bidi_get_type (ch, NEUTRAL_DIR);
 
         for (pos += nchars, bytepos += ch_len;
@@ -744,17 +1134,19 @@ bidi_paragraph_init (bidi_dir_t dir, struct bidi_it *bidi_it, int no_default_p)
                        || type == LRE || type == LRO));
              type = bidi_get_type (ch, NEUTRAL_DIR))
           {
-            if (bytepos >= ZV_BYTE)
+            if (pos >= end)
               {
                 /* Pretend there's a paragraph separator at end of
-                   buffer.  */
+                   buffer/string.  */
                 type = NEUTRAL_B;
                 break;
               }
-            if (type == NEUTRAL_B && bidi_at_paragraph_end (pos, bytepos) >= -1)
+            if (!string_p
+                && type == NEUTRAL_B
+                && bidi_at_paragraph_end (pos, bytepos) >= -1)
               break;
             /* Fetch next character and advance to get past it.  */
-            ch = bidi_fetch_char (bytepos, pos, &disp_pos,
+            ch = bidi_fetch_char (bytepos, pos, &disp_pos, &bidi_it->string,
                                   bidi_it->frame_window_p, &ch_len, &nchars);
             pos += nchars;
             bytepos += ch_len;
@@ -763,7 +1155,8 @@ bidi_paragraph_init (bidi_dir_t dir, struct bidi_it *bidi_it, int no_default_p)
           bidi_it->paragraph_dir = R2L;
         else if (type == STRONG_L)
           bidi_it->paragraph_dir = L2R;
-        if (no_default_p && bidi_it->paragraph_dir == NEUTRAL_DIR)
+        if (!string_p
+            && no_default_p && bidi_it->paragraph_dir == NEUTRAL_DIR)
           {
             /* If this paragraph is at BEGV, default to L2R.  */
             if (pstartbyte == BEGV_BYTE)
@@ -786,7 +1179,8 @@ bidi_paragraph_init (bidi_dir_t dir, struct bidi_it *bidi_it, int no_default_p)
                 pstartbyte = prevpbyte;
               }
           }
-      } while (no_default_p && bidi_it->paragraph_dir == NEUTRAL_DIR);
+      } while (!string_p
+               && no_default_p && bidi_it->paragraph_dir == NEUTRAL_DIR);
     }
   else
     abort ();
@@ -804,110 +1198,11 @@ bidi_paragraph_init (bidi_dir_t dir, struct bidi_it *bidi_it, int no_default_p)
   bidi_line_init (bidi_it);
 }
 
-/* Do whatever UAX#9 clause X8 says should be done at paragraph's
-   end.  */
-static inline void
-bidi_set_paragraph_end (struct bidi_it *bidi_it)
-{
-  bidi_it->invalid_levels = 0;
-  bidi_it->invalid_rl_levels = -1;
-  bidi_it->stack_idx = 0;
-  bidi_it->resolved_level = bidi_it->level_stack[0].level;
-}
-
-/* Initialize the bidi iterator from buffer/string position CHARPOS.  */
-void
-bidi_init_it (EMACS_INT charpos, EMACS_INT bytepos, int frame_window_p,
-              struct bidi_it *bidi_it)
-{
-  if (! bidi_initialized)
-    bidi_initialize ();
-  bidi_it->charpos = charpos;
-  bidi_it->bytepos = bytepos;
-  bidi_it->frame_window_p = frame_window_p;
-  bidi_it->nchars = -1; /* to be computed in bidi_resolve_explicit_1 */
-  bidi_it->first_elt = 1;
-  bidi_set_paragraph_end (bidi_it);
-  bidi_it->new_paragraph = 1;
-  bidi_it->separator_limit = -1;
-  bidi_it->type = NEUTRAL_B;
-  bidi_it->type_after_w1 = NEUTRAL_B;
-  bidi_it->orig_type = NEUTRAL_B;
-  bidi_it->prev_was_pdf = 0;
-  bidi_it->prev.type = bidi_it->prev.type_after_w1 =
-    bidi_it->prev.orig_type = UNKNOWN_BT;
-  bidi_it->last_strong.type = bidi_it->last_strong.type_after_w1 =
-    bidi_it->last_strong.orig_type = UNKNOWN_BT;
-  bidi_it->next_for_neutral.charpos = -1;
-  bidi_it->next_for_neutral.type =
-    bidi_it->next_for_neutral.type_after_w1 =
-    bidi_it->next_for_neutral.orig_type = UNKNOWN_BT;
-  bidi_it->prev_for_neutral.charpos = -1;
-  bidi_it->prev_for_neutral.type =
-    bidi_it->prev_for_neutral.type_after_w1 =
-    bidi_it->prev_for_neutral.orig_type = UNKNOWN_BT;
-  bidi_it->sor = L2R;    /* FIXME: should it be user-selectable? */
-  bidi_it->disp_pos = -1;       /* invalid/unknown */
-  bidi_cache_shrink ();
-}
-
-/* Push the current embedding level and override status; reset the
-   current level to LEVEL and the current override status to OVERRIDE.  */
-static inline void
-bidi_push_embedding_level (struct bidi_it *bidi_it,
-                           int level, bidi_dir_t override)
-{
-  bidi_it->stack_idx++;
-  if (bidi_it->stack_idx >= BIDI_MAXLEVEL)
-    abort ();
-  bidi_it->level_stack[bidi_it->stack_idx].level = level;
-  bidi_it->level_stack[bidi_it->stack_idx].override = override;
-}
-
-/* Pop the embedding level and directional override status from the
-   stack, and return the new level.  */
-static inline int
-bidi_pop_embedding_level (struct bidi_it *bidi_it)
-{
-  /* UAX#9 says to ignore invalid PDFs.  */
-  if (bidi_it->stack_idx > 0)
-    bidi_it->stack_idx--;
-  return bidi_it->level_stack[bidi_it->stack_idx].level;
-}
-
-/* Record in SAVED_INFO the information about the current character.  */
-static inline void
-bidi_remember_char (struct bidi_saved_info *saved_info,
-                    struct bidi_it *bidi_it)
-{
-  saved_info->charpos = bidi_it->charpos;
-  saved_info->bytepos = bidi_it->bytepos;
-  saved_info->type = bidi_it->type;
-  bidi_check_type (bidi_it->type);
-  saved_info->type_after_w1 = bidi_it->type_after_w1;
-  bidi_check_type (bidi_it->type_after_w1);
-  saved_info->orig_type = bidi_it->orig_type;
-  bidi_check_type (bidi_it->orig_type);
-}
-
-/* Resolve the type of a neutral character according to the type of
-   surrounding strong text and the current embedding level.  */
-static inline bidi_type_t
-bidi_resolve_neutral_1 (bidi_type_t prev_type, bidi_type_t next_type, int lev)
-{
-  /* N1: European and Arabic numbers are treated as though they were R.  */
-  if (next_type == WEAK_EN || next_type == WEAK_AN)
-    next_type = STRONG_R;
-  if (prev_type == WEAK_EN || prev_type == WEAK_AN)
-    prev_type = STRONG_R;
-
-  if (next_type == prev_type)   /* N1 */
-    return next_type;
-  else if ((lev & 1) == 0)      /* N2 */
-    return STRONG_L;
-  else
-    return STRONG_R;
-}
+
+/***********************************************************************
+                 Resolving explicit and implicit levels.
+  The rest of this file constitutes the core of the UBA implementation.
+ ***********************************************************************/
 
 static inline int
 bidi_explicit_dir_char (int ch)
@@ -934,19 +1229,35 @@ bidi_resolve_explicit_1 (struct bidi_it *bidi_it)
   int current_level;
   int new_level;
   bidi_dir_t override;
+  int string_p = bidi_it->string.s != NULL || STRINGP (bidi_it->string.lstring);
 
   /* If reseat()'ed, don't advance, so as to start iteration from the
      position where we were reseated.  bidi_it->bytepos can be less
      than BEGV_BYTE after reseat to BEGV.  */
-  if (bidi_it->bytepos < BEGV_BYTE
+  if (bidi_it->bytepos < (string_p ? 0 : BEGV_BYTE)
       || bidi_it->first_elt)
     {
       bidi_it->first_elt = 0;
-      if (bidi_it->charpos < BEGV)
-        bidi_it->charpos = BEGV;
-      bidi_it->bytepos = CHAR_TO_BYTE (bidi_it->charpos);
+      if (string_p)
+        {
+          const unsigned char *p =
+            STRINGP (bidi_it->string.lstring)
+            ? SDATA (bidi_it->string.lstring) : bidi_it->string.s;
+
+          if (bidi_it->charpos < 0)
+            bidi_it->charpos = 0;
+          bidi_it->bytepos = bidi_count_bytes (p, 0, 0, bidi_it->charpos,
+                                               bidi_it->string.unibyte);
+        }
+      else
+        {
+          if (bidi_it->charpos < BEGV)
+            bidi_it->charpos = BEGV;
+          bidi_it->bytepos = CHAR_TO_BYTE (bidi_it->charpos);
+        }
     }
-  else if (bidi_it->bytepos < ZV_BYTE)  /* don't move at ZV */
+  /* Don't move at end of buffer/string.  */
+  else if (bidi_it->charpos < (string_p ? bidi_it->string.schars : ZV))
     {
       /* Advance to the next character, skipping characters covered by
          display strings (nchars > 1).  */
@@ -962,12 +1273,12 @@ bidi_resolve_explicit_1 (struct bidi_it *bidi_it)
   override = bidi_it->level_stack[bidi_it->stack_idx].override;
   new_level = current_level;
 
-  if (bidi_it->bytepos >= ZV_BYTE)
+  if (bidi_it->charpos >= (string_p ? bidi_it->string.schars : ZV))
     {
       curchar = BIDI_EOB;
       bidi_it->ch_len = 1;
       bidi_it->nchars = 1;
-      bidi_it->disp_pos = ZV;
+      bidi_it->disp_pos = (string_p ? bidi_it->string.schars : ZV);
     }
   else
     {
@@ -975,7 +1286,8 @@ bidi_resolve_explicit_1 (struct bidi_it *bidi_it)
          display string, treat the entire run of covered characters as
          a single character u+FFFC.  */
       curchar = bidi_fetch_char (bidi_it->bytepos, bidi_it->charpos,
-                                 &bidi_it->disp_pos, bidi_it->frame_window_p,
+                                 &bidi_it->disp_pos, &bidi_it->string,
+                                 bidi_it->frame_window_p,
                                  &bidi_it->ch_len, &bidi_it->nchars);
     }
   bidi_it->ch = curchar;
@@ -1000,7 +1312,7 @@ bidi_resolve_explicit_1 (struct bidi_it *bidi_it)
         bidi_it->type_after_w1 = type;
         bidi_check_type (bidi_it->type_after_w1);
         type = WEAK_BN; /* X9/Retaining */
-        if (bidi_it->ignore_bn_limit <= 0)
+        if (bidi_it->ignore_bn_limit <= -1)
           {
             if (current_level <= BIDI_MAXLEVEL - 4)
               {
@@ -1033,7 +1345,7 @@ bidi_resolve_explicit_1 (struct bidi_it *bidi_it)
         bidi_it->type_after_w1 = type;
         bidi_check_type (bidi_it->type_after_w1);
         type = WEAK_BN; /* X9/Retaining */
-        if (bidi_it->ignore_bn_limit <= 0)
+        if (bidi_it->ignore_bn_limit <= -1)
           {
             if (current_level <= BIDI_MAXLEVEL - 5)
               {
@@ -1068,7 +1380,7 @@ bidi_resolve_explicit_1 (struct bidi_it *bidi_it)
         bidi_it->type_after_w1 = type;
         bidi_check_type (bidi_it->type_after_w1);
         type = WEAK_BN; /* X9/Retaining */
-        if (bidi_it->ignore_bn_limit <= 0)
+        if (bidi_it->ignore_bn_limit <= -1)
           {
             if (!bidi_it->invalid_rl_levels)
               {
@@ -1111,13 +1423,17 @@ bidi_resolve_explicit (struct bidi_it *bidi_it)
 {
   int prev_level = bidi_it->level_stack[bidi_it->stack_idx].level;
   int new_level  = bidi_resolve_explicit_1 (bidi_it);
+  EMACS_INT eob = bidi_it->string.s ? bidi_it->string.schars : ZV;
+  const unsigned char *s = STRINGP (bidi_it->string.lstring)
+    ? SDATA (bidi_it->string.lstring) : bidi_it->string.s;
 
   if (prev_level < new_level
       && bidi_it->type == WEAK_BN
-      && bidi_it->ignore_bn_limit == 0 /* only if not already known */
-      && bidi_it->bytepos < ZV_BYTE    /* not already at EOB */
-      && bidi_explicit_dir_char (FETCH_MULTIBYTE_CHAR (bidi_it->bytepos
-                                                       + bidi_it->ch_len)))
+      && bidi_it->ignore_bn_limit == -1 /* only if not already known */
+      && bidi_it->charpos < eob         /* not already at EOB */
+      && bidi_explicit_dir_char (bidi_char_at_pos (bidi_it->bytepos
+                                                   + bidi_it->ch_len, s,
+                                                   bidi_it->string.unibyte)))
     {
       /* Avoid pushing and popping embedding levels if the level run
          is empty, as this breaks level runs where it shouldn't.
@@ -1129,12 +1445,17 @@ bidi_resolve_explicit (struct bidi_it *bidi_it)
 
       bidi_copy_it (&saved_it, bidi_it);
 
-      while (bidi_explicit_dir_char (FETCH_MULTIBYTE_CHAR (bidi_it->bytepos
-                                                           + bidi_it->ch_len)))
+      while (bidi_explicit_dir_char (bidi_char_at_pos (bidi_it->bytepos
+                                                       + bidi_it->ch_len, s,
+                                                       bidi_it->string.unibyte)))
         {
           /* This advances to the next character, skipping any
              characters covered by display strings.  */
           level = bidi_resolve_explicit_1 (bidi_it);
+          /* If string.lstring was relocated inside bidi_resolve_explicit_1,
+             a pointer to its data is no longer valid.  */
+          if (STRINGP (bidi_it->string.lstring))
+            s = SDATA (bidi_it->string.lstring);
         }
 
       if (bidi_it->nchars <= 0)
@@ -1142,10 +1463,10 @@ bidi_resolve_explicit (struct bidi_it *bidi_it)
       if (level == prev_level)  /* empty embedding */
         saved_it.ignore_bn_limit = bidi_it->charpos + bidi_it->nchars;
       else                      /* this embedding is non-empty */
-        saved_it.ignore_bn_limit = -1;
+        saved_it.ignore_bn_limit = -2;
 
       bidi_copy_it (bidi_it, &saved_it);
-      if (bidi_it->ignore_bn_limit > 0)
+      if (bidi_it->ignore_bn_limit > -1)
         {
           /* We pushed a level, but we shouldn't have.  Undo that. */
           if (!bidi_it->invalid_rl_levels)
@@ -1188,6 +1509,9 @@ bidi_resolve_weak (struct bidi_it *bidi_it)
   int next_char;
   bidi_type_t type_of_next;
   struct bidi_it saved_it;
+  EMACS_INT eob =
+    (STRINGP (bidi_it->string.lstring) || bidi_it->string.s)
+    ? bidi_it->string.schars : ZV;
 
   type = bidi_it->type;
   override = bidi_it->level_stack[bidi_it->stack_idx].override;
@@ -1254,10 +1578,15 @@ bidi_resolve_weak (struct bidi_it *bidi_it)
                         && bidi_it->prev.orig_type == WEAK_EN)
                        || bidi_it->prev.type_after_w1 == WEAK_AN)))
         {
+          const unsigned char *s =
+            STRINGP (bidi_it->string.lstring)
+            ? SDATA (bidi_it->string.lstring) : bidi_it->string.s;
+
           next_char =
-            bidi_it->bytepos + bidi_it->ch_len >= ZV_BYTE
-            ? BIDI_EOB : FETCH_MULTIBYTE_CHAR (bidi_it->bytepos
-                                               + bidi_it->ch_len);
+            bidi_it->charpos + bidi_it->nchars >= eob
+            ? BIDI_EOB
+            : bidi_char_at_pos (bidi_it->bytepos + bidi_it->ch_len, s,
+                                bidi_it->string.unibyte);
           type_of_next = bidi_get_type (next_char, override);
 
           if (type_of_next == WEAK_BN
@@ -1306,13 +1635,17 @@ bidi_resolve_weak (struct bidi_it *bidi_it)
           else                  /* W5: ET/BN with EN after it.  */
             {
               EMACS_INT en_pos = bidi_it->charpos + bidi_it->nchars;
+              const unsigned char *s =
+                STRINGP (bidi_it->string.lstring)
+                ? SDATA (bidi_it->string.lstring) : bidi_it->string.s;
 
               if (bidi_it->nchars <= 0)
                 abort ();
               next_char =
-                bidi_it->bytepos + bidi_it->ch_len >= ZV_BYTE
-                ? BIDI_EOB : FETCH_MULTIBYTE_CHAR (bidi_it->bytepos
-                                                   + bidi_it->ch_len);
+                bidi_it->charpos + bidi_it->nchars >= eob
+                ? BIDI_EOB
+                : bidi_char_at_pos (bidi_it->bytepos + bidi_it->ch_len, s,
+                                    bidi_it->string.unibyte);
               type_of_next = bidi_get_type (next_char, override);
 
               if (type_of_next == WEAK_ET
@@ -1373,6 +1706,25 @@ bidi_resolve_weak (struct bidi_it *bidi_it)
   return type;
 }
 
+/* Resolve the type of a neutral character according to the type of
+   surrounding strong text and the current embedding level.  */
+static inline bidi_type_t
+bidi_resolve_neutral_1 (bidi_type_t prev_type, bidi_type_t next_type, int lev)
+{
+  /* N1: European and Arabic numbers are treated as though they were R.  */
+  if (next_type == WEAK_EN || next_type == WEAK_AN)
+    next_type = STRONG_R;
+  if (prev_type == WEAK_EN || prev_type == WEAK_AN)
+    prev_type = STRONG_R;
+
+  if (next_type == prev_type)   /* N1 */
+    return next_type;
+  else if ((lev & 1) == 0)      /* N2 */
+    return STRONG_L;
+  else
+    return STRONG_R;
+}
+
 static bidi_type_t
 bidi_resolve_neutral (struct bidi_it *bidi_it)
 {
@@ -1509,11 +1861,11 @@ bidi_type_of_next_char (struct bidi_it *bidi_it)
 
   /* Reset the limit until which to ignore BNs if we step out of the
      area where we found only empty levels.  */
-  if ((bidi_it->ignore_bn_limit > 0
+  if ((bidi_it->ignore_bn_limit > -1
        && bidi_it->ignore_bn_limit <= bidi_it->charpos)
-      || (bidi_it->ignore_bn_limit == -1
+      || (bidi_it->ignore_bn_limit == -2
           && !bidi_explicit_dir_char (bidi_it->ch)))
-    bidi_it->ignore_bn_limit = 0;
+    bidi_it->ignore_bn_limit = -1;
 
   type = bidi_resolve_neutral (bidi_it);
 
@@ -1530,12 +1882,16 @@ bidi_level_of_next_char (struct bidi_it *bidi_it)
   bidi_type_t type;
   int level, prev_level = -1;
   struct bidi_saved_info next_for_neutral;
-  EMACS_INT next_char_pos;
+  EMACS_INT next_char_pos = -2;
 
   if (bidi_it->scan_dir == 1)
     {
+      EMACS_INT eob =
+        (bidi_it->string.s || STRINGP (bidi_it->string.lstring))
+        ? bidi_it->string.schars : ZV;
+
       /* There's no sense in trying to advance if we hit end of text.  */
-      if (bidi_it->bytepos >= ZV_BYTE)
+      if (bidi_it->charpos >= eob)
         return bidi_it->resolved_level;
 
       /* Record the info about the previous character.  */
@@ -1575,17 +1931,27 @@ bidi_level_of_next_char (struct bidi_it *bidi_it)
   /* Perhaps the character we want is already cached.  If it is, the
      call to bidi_cache_find below will return a type other than
      UNKNOWN_BT.  */
-  if (bidi_cache_idx && !bidi_it->first_elt)
+  if (bidi_cache_idx > bidi_cache_start && !bidi_it->first_elt)
     {
+      int bob =
+        (bidi_it->string.s || STRINGP (bidi_it->string.lstring)) ? 0 : 1;
+
       if (bidi_it->scan_dir > 0)
         {
           if (bidi_it->nchars <= 0)
             abort ();
           next_char_pos = bidi_it->charpos + bidi_it->nchars;
         }
-      else
+      else if (bidi_it->charpos >= bob)
+        /* Implementation note: we allow next_char_pos to be as low as
+           0 for buffers or -1 for strings, and that is okay because
+           that's the "position" of the sentinel iterator state we
+           cached at the beginning of the iteration.  */
         next_char_pos = bidi_it->charpos - 1;
-      type = bidi_cache_find (next_char_pos, -1, bidi_it);
+      if (next_char_pos >= bob - 1)
+        type = bidi_cache_find (next_char_pos, -1, bidi_it);
+      else
+        type = UNKNOWN_BT;
     }
   else
     type = UNKNOWN_BT;
@@ -1652,13 +2018,14 @@ bidi_level_of_next_char (struct bidi_it *bidi_it)
       EMACS_INT cpos = bidi_it->charpos;
       EMACS_INT disp_pos = bidi_it->disp_pos;
       EMACS_INT nc = bidi_it->nchars;
+      struct bidi_string_data bs = bidi_it->string;
       bidi_type_t chtype;
       int fwp = bidi_it->frame_window_p;
 
       if (bidi_it->nchars <= 0)
         abort ();
       do {
-        ch = bidi_fetch_char (bpos += clen, cpos += nc, &disp_pos, fwp,
+        ch = bidi_fetch_char (bpos += clen, cpos += nc, &disp_pos, &bs, fwp,
                               &clen, &nc);
         if (ch == '\n' || ch == BIDI_EOB /* || ch == LINESEP_CHAR */)
           chtype = NEUTRAL_B;
@@ -1756,10 +2123,11 @@ static void
 bidi_find_other_level_edge (struct bidi_it *bidi_it, int level, int end_flag)
 {
   int dir = end_flag ? -bidi_it->scan_dir : bidi_it->scan_dir;
-  int idx;
+  EMACS_INT idx;
 
   /* Try the cache first.  */
-  if ((idx = bidi_cache_find_level_change (level, dir, end_flag)) >= 0)
+  if ((idx = bidi_cache_find_level_change (level, dir, end_flag))
+      >= bidi_cache_start)
     bidi_cache_fetch_state (idx, bidi_it);
   else
     {
@@ -1781,12 +2149,21 @@ bidi_move_to_visually_next (struct bidi_it *bidi_it)
 {
   int old_level, new_level, next_level;
   struct bidi_it sentinel;
+  struct gcpro gcpro1;
+
+  if (bidi_it->charpos < 0 || bidi_it->bytepos < 0)
+    abort ();
 
   if (bidi_it->scan_dir == 0)
     {
       bidi_it->scan_dir = 1;    /* default to logical order */
     }
 
+  /* The code below can call eval, and thus cause GC.  If we are
+     iterating a Lisp string, make sure it won't be GCed.  */
+  if (STRINGP (bidi_it->string.lstring))
+    GCPRO1 (bidi_it->string.lstring);
+
   /* If we just passed a newline, initialize for the next line.  */
   if (!bidi_it->first_elt && bidi_it->orig_type == NEUTRAL_B)
     bidi_line_init (bidi_it);
@@ -1794,7 +2171,7 @@ bidi_move_to_visually_next (struct bidi_it *bidi_it)
   /* Prepare the sentinel iterator state, and cache it.  When we bump
      into it, scanning backwards, we'll know that the last non-base
      level is exhausted.  */
-  if (bidi_cache_idx == 0)
+  if (bidi_cache_idx == bidi_cache_start)
     {
       bidi_copy_it (&sentinel, bidi_it);
       if (bidi_it->first_elt)
@@ -1869,26 +2246,34 @@ bidi_move_to_visually_next (struct bidi_it *bidi_it)
      reordering, whereas we _must_ know the paragraph base direction
      _before_ we process the paragraph's text, since the base
      direction affects the reordering.  */
-  if (bidi_it->scan_dir == 1
-      && bidi_it->orig_type == NEUTRAL_B
-      && bidi_it->bytepos < ZV_BYTE)
+  if (bidi_it->scan_dir == 1 && bidi_it->orig_type == NEUTRAL_B)
     {
-      EMACS_INT sep_len =
-        bidi_at_paragraph_end (bidi_it->charpos + bidi_it->nchars,
-                               bidi_it->bytepos + bidi_it->ch_len);
-      if (bidi_it->nchars <= 0)
-        abort ();
-      if (sep_len >= 0)
+      /* The paragraph direction of the entire string, once
+         determined, is in effect for the entire string.  Setting the
+         separator limit to the end of the string prevents
+         bidi_paragraph_init from being called automatically on this
+         string.  */
+      if (bidi_it->string.s || STRINGP (bidi_it->string.lstring))
+        bidi_it->separator_limit = bidi_it->string.schars;
+      else if (bidi_it->bytepos < ZV_BYTE)
         {
-          bidi_it->new_paragraph = 1;
-          /* Record the buffer position of the last character of the
-             paragraph separator.  */
-          bidi_it->separator_limit =
-            bidi_it->charpos + bidi_it->nchars + sep_len;
+          EMACS_INT sep_len =
+            bidi_at_paragraph_end (bidi_it->charpos + bidi_it->nchars,
+                                   bidi_it->bytepos + bidi_it->ch_len);
+          if (bidi_it->nchars <= 0)
+            abort ();
+          if (sep_len >= 0)
+            {
+              bidi_it->new_paragraph = 1;
+              /* Record the buffer position of the last character of the
+                 paragraph separator.  */
+              bidi_it->separator_limit =
+                bidi_it->charpos + bidi_it->nchars + sep_len;
+            }
         }
     }
 
-  if (bidi_it->scan_dir == 1 && bidi_cache_idx)
+  if (bidi_it->scan_dir == 1 && bidi_cache_idx > bidi_cache_start)
     {
       /* If we are at paragraph's base embedding level and beyond the
          last cached position, the cache's job is done and we can
@@ -1904,6 +2289,9 @@ bidi_move_to_visually_next (struct bidi_it *bidi_it)
       else
         bidi_cache_iterator_state (bidi_it, 1);
     }
+
+  if (STRINGP (bidi_it->string.lstring))
+    UNGCPRO;
 }
 
 /* This is meant to be called from within the debugger, whenever you
@@ -1920,7 +2308,7 @@ bidi_dump_cached_states (void)
       fprintf (stderr, "The cache is empty.\n");
       return;
     }
-  fprintf (stderr, "Total of %d state%s in cache:\n",
+  fprintf (stderr, "Total of  %"pD"d state%s in cache:\n",
            bidi_cache_idx, bidi_cache_idx == 1 ? "" : "s");
 
   for (i = bidi_cache[bidi_cache_idx - 1].charpos; i > 0; i /= 10)
diff --git a/src/buffer.c b/src/buffer.c
index 328963be78c..81c537b9c6a 100644
--- a/src/buffer.c
+++ b/src/buffer.c
@@ -146,7 +146,7 @@ static Lisp_Object Qoverlayp;
 
 Lisp_Object Qpriority, Qbefore_string, Qafter_string;
 
-static Lisp_Object Qclone_number, Qevaporate;
+static Lisp_Object Qevaporate;
 
 Lisp_Object Qmodification_hooks;
 Lisp_Object Qinsert_in_front_hooks;
@@ -361,6 +361,7 @@ even if it is dead.  The return value is never nil.  */)
   BUF_END_UNCHANGED (b) = 0;
   BUF_BEG_UNCHANGED (b) = 0;
   *(BUF_GPT_ADDR (b)) = *(BUF_Z_ADDR (b)) = 0; /* Put an anchor '\0'.  */
+  b->text->inhibit_shrinking = 0;
 
   b->newline_cache = 0;
   b->width_run_cache = 0;
@@ -471,8 +472,8 @@ clone_per_buffer_values (struct buffer *from, struct buffer *to)
 
   /* buffer-local Lisp variables start at `undo_list',
      tho only the ones from `name' on are GC'd normally.  */
-  for (offset = PER_BUFFER_VAR_OFFSET (undo_list);
-       offset < sizeof *to;
+  for (offset = PER_BUFFER_VAR_OFFSET (FIRST_FIELD_PER_BUFFER);
+       offset <= PER_BUFFER_VAR_OFFSET (LAST_FIELD_PER_BUFFER);
        offset += sizeof (Lisp_Object))
     {
       Lisp_Object obj;
@@ -830,8 +831,8 @@ reset_buffer_local_variables (register struct buffer *b, int permanent_too)
 
   /* buffer-local Lisp variables start at `undo_list',
      tho only the ones from `name' on are GC'd normally.  */
-  for (offset = PER_BUFFER_VAR_OFFSET (undo_list);
-       offset < sizeof *b;
+  for (offset = PER_BUFFER_VAR_OFFSET (FIRST_FIELD_PER_BUFFER);
+       offset <= PER_BUFFER_VAR_OFFSET (LAST_FIELD_PER_BUFFER);
        offset += sizeof (Lisp_Object))
     {
       int idx = PER_BUFFER_IDX (offset);
@@ -1055,8 +1056,8 @@ No argument or nil as argument means use current buffer as BUFFER.  */)
 
     /* buffer-local Lisp variables start at `undo_list',
        tho only the ones from `name' on are GC'd normally.  */
-    for (offset = PER_BUFFER_VAR_OFFSET (undo_list);
-         offset < sizeof (struct buffer);
+    for (offset = PER_BUFFER_VAR_OFFSET (FIRST_FIELD_PER_BUFFER);
+         offset <= PER_BUFFER_VAR_OFFSET (LAST_FIELD_PER_BUFFER);
          /* sizeof EMACS_INT == sizeof Lisp_Object */
          offset += (sizeof (EMACS_INT)))
       {
@@ -2900,13 +2901,10 @@ sort_overlays (Lisp_Object *overlay_vec, ptrdiff_t noverlays, struct window *w)
              overlays that are limited to some other window.  */
           if (w)
             {
-              Lisp_Object window, clone_number;
+              Lisp_Object window;
 
               window = Foverlay_get (overlay, Qwindow);
-              clone_number = Foverlay_get (overlay, Qclone_number);
-              if (WINDOWP (window) && XWINDOW (window) != w
-                  && (! NUMBERP (clone_number)
-                      || XFASTINT (clone_number) != XFASTINT (w->clone_number)))
+              if (WINDOWP (window) && XWINDOW (window) != w)
                 continue;
             }
 
@@ -3035,7 +3033,7 @@ record_overlay_string (struct sortstrlist *ssl, Lisp_Object str,
 EMACS_INT
 overlay_strings (EMACS_INT pos, struct window *w, unsigned char **pstr)
 {
-  Lisp_Object overlay, window, clone_number, str;
+  Lisp_Object overlay, window, str;
   struct Lisp_Overlay *ov;
   EMACS_INT startpos, endpos;
   int multibyte = ! NILP (BVAR (current_buffer, enable_multibyte_characters));
@@ -3054,12 +3052,8 @@ overlay_strings (EMACS_INT pos, struct window *w, unsigned char **pstr)
       if (endpos != pos && startpos != pos)
         continue;
       window = Foverlay_get (overlay, Qwindow);
-      clone_number = Foverlay_get (overlay, Qclone_number);
-      if (WINDOWP (window) && XWINDOW (window) != w
-          && (! NUMBERP (clone_number)
-              || XFASTINT (clone_number) != XFASTINT (w->clone_number)))
+      if (WINDOWP (window) && XWINDOW (window) != w)
         continue;
-
       if (startpos == pos
           && (str = Foverlay_get (overlay, Qbefore_string), STRINGP (str)))
         record_overlay_string (&overlay_heads, str,
@@ -3086,10 +3080,7 @@ overlay_strings (EMACS_INT pos, struct window *w, unsigned char **pstr)
       if (endpos != pos && startpos != pos)
         continue;
       window = Foverlay_get (overlay, Qwindow);
-      clone_number = Foverlay_get (overlay, Qclone_number);
-      if (WINDOWP (window) && XWINDOW (window) != w
-          && (! NUMBERP (clone_number)
-              || XFASTINT (clone_number) != XFASTINT (w->clone_number)))
+      if (WINDOWP (window) && XWINDOW (window) != w)
         continue;
       if (startpos == pos
           && (str = Foverlay_get (overlay, Qbefore_string), STRINGP (str)))
@@ -4066,7 +4057,8 @@ DEFUN ("overlay-get", Foverlay_get, Soverlay_get, 2, 2, 0,
 }
 
 DEFUN ("overlay-put", Foverlay_put, Soverlay_put, 3, 3, 0,
-       doc: /* Set one property of overlay OVERLAY: give property PROP value VALUE.  */)
+       doc: /* Set one property of overlay OVERLAY: give property PROP value VALUE.
+VALUE will be returned.*/)
   (Lisp_Object overlay, Lisp_Object prop, Lisp_Object value)
 {
   Lisp_Object tail, buffer;
@@ -4475,24 +4467,40 @@ static int mmap_initialized_p;
 #define MMAP_ALLOCATED_P(start, end) 1
 #endif
 
-/* Function prototypes.  */
+/* Perform necessary intializations for the use of mmap.  */
 
-static int mmap_free_1 (struct mmap_region *);
-static int mmap_enlarge (struct mmap_region *, int);
-static struct mmap_region *mmap_find (POINTER_TYPE *, POINTER_TYPE *);
-static POINTER_TYPE *mmap_alloc (POINTER_TYPE **, size_t);
-static POINTER_TYPE *mmap_realloc (POINTER_TYPE **, size_t);
-static void mmap_free (POINTER_TYPE **ptr);
-static void mmap_init (void);
+static void
+mmap_init (void)
+{
+#if MAP_ANON == 0
+  /* The value of mmap_fd is initially 0 in temacs, and -1
+     in a dumped Emacs.  */
+  if (mmap_fd <= 0)
+    {
+      /* No anonymous mmap -- we need the file descriptor.  */
+      mmap_fd = open ("/dev/zero", O_RDONLY);
+      if (mmap_fd == -1)
+        fatal ("Cannot open /dev/zero: %s", emacs_strerror (errno));
+    }
+#endif /* MAP_ANON == 0 */
 
+  if (mmap_initialized_p)
+    return;
+  mmap_initialized_p = 1;
+
+#if MAP_ANON != 0
+  mmap_fd = -1;
+#endif
+
+  mmap_page_size = getpagesize ();
+}
 
 /* Return a region overlapping address range START...END, or null if
    none.  END is not including, i.e. the last byte in the range
    is at END - 1.  */
 
 static struct mmap_region *
-mmap_find (start, end)
-     POINTER_TYPE *start, *end;
+mmap_find (POINTER_TYPE *start, POINTER_TYPE *end)
 {
   struct mmap_region *r;
   char *s = (char *) start, *e = (char *) end;
@@ -4521,8 +4529,7 @@ mmap_find (start, end)
    the region.  Value is non-zero if successful.  */
 
 static int
-mmap_free_1 (r)
-     struct mmap_region *r;
+mmap_free_1 (struct mmap_region *r)
 {
   if (r->next)
     r->next->prev = r->prev;
@@ -4545,9 +4552,7 @@ mmap_free_1 (r)
    Value is non-zero if successful.  */
 
 static int
-mmap_enlarge (r, npages)
-     struct mmap_region *r;
-     int npages;
+mmap_enlarge (struct mmap_region *r, int npages)
 {
   char *region_end = (char *) r + r->nbytes_mapped;
   size_t nbytes;
@@ -4611,8 +4616,7 @@ mmap_enlarge (r, npages)
    when Emacs starts.  */
 
 void
-mmap_set_vars (restore_p)
-     int restore_p;
+mmap_set_vars (int restore_p)
 {
   struct mmap_region *r;
 
@@ -4645,9 +4649,7 @@ mmap_set_vars (restore_p)
    return null.  */
 
 static POINTER_TYPE *
-mmap_alloc (var, nbytes)
-     POINTER_TYPE **var;
-     size_t nbytes;
+mmap_alloc (POINTER_TYPE **var, size_t nbytes)
 {
   void *p;
   size_t map;
@@ -4684,15 +4686,29 @@ mmap_alloc (var, nbytes)
 }
 
 
+/* Free a block of relocatable storage whose data is pointed to by
+   PTR.  Store 0 in *PTR to show there's no block allocated.  */
+
+static void
+mmap_free (POINTER_TYPE **var)
+{
+  mmap_init ();
+
+  if (*var)
+    {
+      mmap_free_1 (MMAP_REGION (*var));
+      *var = NULL;
+    }
+}
+
+
 /* Given a pointer at address VAR to data allocated with mmap_alloc,
    resize it to size NBYTES.  Change *VAR to reflect the new block,
    and return this value.  If more memory cannot be allocated, then
    leave *VAR unchanged, and return null.  */
 
 static POINTER_TYPE *
-mmap_realloc (var, nbytes)
-     POINTER_TYPE **var;
-     size_t nbytes;
+mmap_realloc (POINTER_TYPE **var, size_t nbytes)
 {
   POINTER_TYPE *result;
 
@@ -4762,51 +4778,6 @@ mmap_realloc (var, nbytes)
 }
 
 
-/* Free a block of relocatable storage whose data is pointed to by
-   PTR.  Store 0 in *PTR to show there's no block allocated.  */
-
-static void
-mmap_free (var)
-     POINTER_TYPE **var;
-{
-  mmap_init ();
-
-  if (*var)
-    {
-      mmap_free_1 (MMAP_REGION (*var));
-      *var = NULL;
-    }
-}
-
-
-/* Perform necessary intializations for the use of mmap.  */
-
-static void
-mmap_init ()
-{
-#if MAP_ANON == 0
-  /* The value of mmap_fd is initially 0 in temacs, and -1
-     in a dumped Emacs.  */
-  if (mmap_fd <= 0)
-    {
-      /* No anonymous mmap -- we need the file descriptor.  */
-      mmap_fd = open ("/dev/zero", O_RDONLY);
-      if (mmap_fd == -1)
-        fatal ("Cannot open /dev/zero: %s", emacs_strerror (errno));
-    }
-#endif /* MAP_ANON == 0 */
-
-  if (mmap_initialized_p)
-    return;
-  mmap_initialized_p = 1;
-
-#if MAP_ANON != 0
-  mmap_fd = -1;
-#endif
-
-  mmap_page_size = getpagesize ();
-}
-
 #endif /* USE_MMAP_FOR_BUFFERS */
 
 
@@ -5229,7 +5200,6 @@ syms_of_buffer (void)
   DEFSYM (Qinsert_behind_hooks, "insert-behind-hooks");
   DEFSYM (Qget_file_buffer, "get-file-buffer");
   DEFSYM (Qpriority, "priority");
-  DEFSYM (Qclone_number, "clone-number");
   DEFSYM (Qbefore_string, "before-string");
   DEFSYM (Qafter_string, "after-string");
   DEFSYM (Qfirst_change_hook, "first-change-hook");
diff --git a/src/buffer.h b/src/buffer.h
index 4643e0d9d0e..06864dd5789 100644
--- a/src/buffer.h
+++ b/src/buffer.h
@@ -612,6 +612,7 @@ struct buffer
   /* Everything from here down must be a Lisp_Object.  */
   /* buffer-local Lisp variables start at `undo_list',
      tho only the ones from `name' on are GC'd normally.  */
+  #define FIRST_FIELD_PER_BUFFER undo_list
 
   /* Changes in the buffer are recorded here for undo.
      t means don't record anything.
@@ -846,6 +847,9 @@ struct buffer
      t means to use hollow box cursor.
      See `cursor-type' for other values.  */
   Lisp_Object BUFFER_INTERNAL_FIELD (cursor_in_non_selected_windows);
+
+  /* This must be the last field in the above list.  */
+  #define LAST_FIELD_PER_BUFFER cursor_in_non_selected_windows
 };
 
 
diff --git a/src/callint.c b/src/callint.c
index 4d0a2a07921..26b161a25b3 100644
--- a/src/callint.c
+++ b/src/callint.c
@@ -105,9 +105,10 @@ Z -- Coding system, nil if no prefix arg.
 
 In addition, if the string begins with `*', an error is signaled if
   the buffer is read-only.
-If the string begins with `@', Emacs searches the key sequence which
- invoked the command for its first mouse click (or any other event
- which specifies a window).
+If `@' appears at the beginning of the string, and if the key sequence
+ used to invoke the command includes any mouse events, then the window
+ associated with the first of those events is selected before the
+ command is run.
 If the string begins with `^' and `shift-select-mode' is non-nil,
  Emacs first calls the function `handle-shift-selection'.
 You may use `@', `*', and `^' together.  They are processed in the
@@ -233,7 +234,7 @@ fix_command (Lisp_Object input, Lisp_Object values)
 }
 
 DEFUN ("call-interactively", Fcall_interactively, Scall_interactively, 1, 3, 0,
-       doc: /* Call FUNCTION, reading args according to its interactive calling specs.
+       doc: /* Call FUNCTION, providing args according to its interactive calling specs.
 Return the value FUNCTION returns.
 The function contains a specification of how to do the argument reading.
 In the case of user-defined functions, this is specified by placing a call
diff --git a/src/callproc.c b/src/callproc.c
index b339f343f62..ad3eddbdd39 100644
--- a/src/callproc.c
+++ b/src/callproc.c
@@ -596,7 +596,7 @@ usage: (call-process PROGRAM &optional INFILE BUFFER DISPLAY &rest ARGS)  */)
     sigemptyset (&blocked);
     sigaddset (&blocked, SIGPIPE);
     sigaction (SIGPIPE, 0, &sigpipe_action);
-    sigprocmask (SIG_BLOCK, &blocked, &procmask);
+    pthread_sigmask (SIG_BLOCK, &blocked, &procmask);
 #endif
 
     BLOCK_INPUT;
@@ -633,7 +633,7 @@ usage: (call-process PROGRAM &optional INFILE BUFFER DISPLAY &rest ARGS)  */)
            in the child.  */
         //signal (SIGPIPE, SIG_DFL);
 #ifdef HAVE_WORKING_VFORK
-        sigprocmask (SIG_SETMASK, &procmask, 0);
+        pthread_sigmask (SIG_SETMASK, &procmask, 0);
 #endif
 
         child_setup (filefd, fd1, fd_error, (char **) new_argv,
@@ -645,7 +645,7 @@ usage: (call-process PROGRAM &optional INFILE BUFFER DISPLAY &rest ARGS)  */)
 #ifdef HAVE_WORKING_VFORK
     /* Restore the signal state.  */
     sigaction (SIGPIPE, &sigpipe_action, 0);
-    sigprocmask (SIG_SETMASK, &procmask, 0);
+    pthread_sigmask (SIG_SETMASK, &procmask, 0);
 #endif
 
 #endif /* not WINDOWSNT */
diff --git a/src/character.c b/src/character.c
index 7fc5d647ff5..8e9b3e3775e 100644
--- a/src/character.c
+++ b/src/character.c
@@ -258,7 +258,8 @@ multibyte_char_to_unibyte_safe (int c)
 }
 
 DEFUN ("characterp", Fcharacterp, Scharacterp, 1, 2, 0,
-       doc: /* Return non-nil if OBJECT is a character.  */)
+       doc: /* Return non-nil if OBJECT is a character.
+usage: (characterp OBJECT)  */)
   (Lisp_Object object, Lisp_Object ignore)
 {
   return (CHARACTERP (object) ? Qt : Qnil);
diff --git a/src/character.h b/src/character.h
index 3bc21ac0f2b..063b5147dc9 100644
--- a/src/character.h
+++ b/src/character.h
@@ -597,6 +597,45 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
    : (c) <= 0xDFFF ? 2                  \
    : 0)
 
+/* Data type for Unicode general category.
+
+   The order of members must be in sync with the 8th element of the
+   member of unidata-prop-alist (in admin/unidata/unidata-getn.el) for
+   Unicode character property `general-category'.  */
+
+typedef enum {
+  UNICODE_CATEGORY_UNKNOWN = 0,
+  UNICODE_CATEGORY_Lu,
+  UNICODE_CATEGORY_Ll,
+  UNICODE_CATEGORY_Lt,
+  UNICODE_CATEGORY_Lm,
+  UNICODE_CATEGORY_Lo,
+  UNICODE_CATEGORY_Mn,
+  UNICODE_CATEGORY_Mc,
+  UNICODE_CATEGORY_Me,
+  UNICODE_CATEGORY_Nd,
+  UNICODE_CATEGORY_Nl,
+  UNICODE_CATEGORY_No,
+  UNICODE_CATEGORY_Pc,
+  UNICODE_CATEGORY_Pd,
+  UNICODE_CATEGORY_Ps,
+  UNICODE_CATEGORY_Pe,
+  UNICODE_CATEGORY_Pi,
+  UNICODE_CATEGORY_Pf,
+  UNICODE_CATEGORY_Po,
+  UNICODE_CATEGORY_Sm,
+  UNICODE_CATEGORY_Sc,
+  UNICODE_CATEGORY_Sk,
+  UNICODE_CATEGORY_So,
+  UNICODE_CATEGORY_Zs,
+  UNICODE_CATEGORY_Zl,
+  UNICODE_CATEGORY_Zp,
+  UNICODE_CATEGORY_Cc,
+  UNICODE_CATEGORY_Cf,
+  UNICODE_CATEGORY_Cs,
+  UNICODE_CATEGORY_Co,
+  UNICODE_CATEGORY_Cn
+} unicode_category_t;
 
 extern int char_resolve_modifier_mask (int);
 extern int char_string (unsigned, unsigned char *);
diff --git a/src/chartab.c b/src/chartab.c
index ed5b238646e..efe23eca83f 100644
--- a/src/chartab.c
+++ b/src/chartab.c
@@ -53,7 +53,38 @@ static const int chartab_bits[4] =
 #define CHARTAB_IDX(c, depth, min_char)         \
   (((c) - (min_char)) >> chartab_bits[(depth)])
 
+
+/* Preamble for uniprop (Unicode character property) tables.  See the
+   comment of "Unicode character property tables".  */
+
+/* Purpose of uniprop tables. */
+static Lisp_Object Qchar_code_property_table;
+
+/* Types of decoder and encoder functions for uniprop values.  */
+typedef Lisp_Object (*uniprop_decoder_t) (Lisp_Object, Lisp_Object);
+typedef Lisp_Object (*uniprop_encoder_t) (Lisp_Object, Lisp_Object);
+
+static Lisp_Object uniprop_table_uncompress (Lisp_Object, int);
+static uniprop_decoder_t uniprop_get_decoder (Lisp_Object);
+
+/* 1 iff TABLE is a uniprop table.  */
+#define UNIPROP_TABLE_P(TABLE)                                  \
+  (EQ (XCHAR_TABLE (TABLE)->purpose, Qchar_code_property_table) \
+   && CHAR_TABLE_EXTRA_SLOTS (XCHAR_TABLE (TABLE)) == 5)
 
+/* Return a decoder for values in the uniprop table TABLE.  */
+#define UNIPROP_GET_DECODER(TABLE)      \
+  (UNIPROP_TABLE_P (TABLE) ? uniprop_get_decoder (TABLE) : NULL)
+
+/* Nonzero iff OBJ is a string representing uniprop values of 128
+   succeeding characters (the bottom level of a char-table) by a
+   compressed format.  We are sure that no property value has a string
+   starting with '\001' nor '\002'.  */
+#define UNIPROP_COMPRESSED_FORM_P(OBJ)  \
+  (STRINGP (OBJ) && SCHARS (OBJ) > 0    \
+   && ((SREF (OBJ, 0) == 1 || (SREF (OBJ, 0) == 2))))
+
+
 DEFUN ("make-char-table", Fmake_char_table, Smake_char_table, 1, 2, 0,
        doc: /* Return a newly created char-table, with purpose PURPOSE.
 Each element is initialized to INIT, which defaults to nil.
@@ -107,7 +138,7 @@ make_sub_char_table (int depth, int min_char, Lisp_Object defalt)
 static Lisp_Object
 char_table_ascii (Lisp_Object table)
 {
-  Lisp_Object sub;
+  Lisp_Object sub, val;
 
   sub = XCHAR_TABLE (table)->contents[0];
   if (! SUB_CHAR_TABLE_P (sub))
@@ -115,7 +146,10 @@ char_table_ascii (Lisp_Object table)
   sub = XSUB_CHAR_TABLE (sub)->contents[0];
   if (! SUB_CHAR_TABLE_P (sub))
     return sub;
-  return XSUB_CHAR_TABLE (sub)->contents[0];
+  val = XSUB_CHAR_TABLE (sub)->contents[0];
+  if (UNIPROP_TABLE_P (table) && UNIPROP_COMPRESSED_FORM_P (val))
+    val = uniprop_table_uncompress (sub, 0);
+  return val;
 }
 
 static Lisp_Object
@@ -169,16 +203,19 @@ copy_char_table (Lisp_Object table)
 }
 
 static Lisp_Object
-sub_char_table_ref (Lisp_Object table, int c)
+sub_char_table_ref (Lisp_Object table, int c, int is_uniprop)
 {
   struct Lisp_Sub_Char_Table *tbl = XSUB_CHAR_TABLE (table);
   int depth = XINT (tbl->depth);
   int min_char = XINT (tbl->min_char);
   Lisp_Object val;
+  int idx = CHARTAB_IDX (c, depth, min_char);
 
-  val = tbl->contents[CHARTAB_IDX (c, depth, min_char)];
+  val = tbl->contents[idx];
+  if (is_uniprop && UNIPROP_COMPRESSED_FORM_P (val))
+    val = uniprop_table_uncompress (table, idx);
   if (SUB_CHAR_TABLE_P (val))
-    val = sub_char_table_ref (val, c);
+    val = sub_char_table_ref (val, c, is_uniprop);
   return val;
 }
 
@@ -198,7 +235,7 @@ char_table_ref (Lisp_Object table, int c)
     {
       val = tbl->contents[CHARTAB_IDX (c, 0, 0)];
       if (SUB_CHAR_TABLE_P (val))
-        val = sub_char_table_ref (val, c);
+        val = sub_char_table_ref (val, c, UNIPROP_TABLE_P (table));
     }
   if (NILP (val))
     {
@@ -210,7 +247,8 @@ char_table_ref (Lisp_Object table, int c)
 }
 
 static Lisp_Object
-sub_char_table_ref_and_range (Lisp_Object table, int c, int *from, int *to, Lisp_Object defalt)
+sub_char_table_ref_and_range (Lisp_Object table, int c, int *from, int *to,
+                              Lisp_Object defalt, int is_uniprop)
 {
   struct Lisp_Sub_Char_Table *tbl = XSUB_CHAR_TABLE (table);
   int depth = XINT (tbl->depth);
@@ -219,8 +257,10 @@ sub_char_table_ref_and_range (Lisp_Object table, int c, int *from, int *to, Lisp
   Lisp_Object val;
 
   val = tbl->contents[chartab_idx];
+  if (is_uniprop && UNIPROP_COMPRESSED_FORM_P (val))
+    val = uniprop_table_uncompress (table, chartab_idx);
   if (SUB_CHAR_TABLE_P (val))
-    val = sub_char_table_ref_and_range (val, c, from, to, defalt);
+    val = sub_char_table_ref_and_range (val, c, from, to, defalt, is_uniprop);
   else if (NILP (val))
     val = defalt;
 
@@ -232,8 +272,11 @@ sub_char_table_ref_and_range (Lisp_Object table, int c, int *from, int *to, Lisp
       c = min_char + idx * chartab_chars[depth] - 1;
       idx--;
       this_val = tbl->contents[idx];
+      if (is_uniprop && UNIPROP_COMPRESSED_FORM_P (this_val))
+        this_val = uniprop_table_uncompress (table, idx);
       if (SUB_CHAR_TABLE_P (this_val))
-        this_val = sub_char_table_ref_and_range (this_val, c, from, to, defalt);
+        this_val = sub_char_table_ref_and_range (this_val, c, from, to, defalt,
+                                                 is_uniprop);
       else if (NILP (this_val))
         this_val = defalt;
 
@@ -251,8 +294,11 @@ sub_char_table_ref_and_range (Lisp_Object table, int c, int *from, int *to, Lisp
 
       chartab_idx++;
       this_val = tbl->contents[chartab_idx];
+      if (is_uniprop && UNIPROP_COMPRESSED_FORM_P (this_val))
+        this_val = uniprop_table_uncompress (table, chartab_idx);
       if (SUB_CHAR_TABLE_P (this_val))
-        this_val = sub_char_table_ref_and_range (this_val, c, from, to, defalt);
+        this_val = sub_char_table_ref_and_range (this_val, c, from, to, defalt,
+                                                 is_uniprop);
       else if (NILP (this_val))
         this_val = defalt;
       if (! EQ (this_val, val))
@@ -277,17 +323,20 @@ char_table_ref_and_range (Lisp_Object table, int c, int *from, int *to)
   struct Lisp_Char_Table *tbl = XCHAR_TABLE (table);
   int chartab_idx = CHARTAB_IDX (c, 0, 0), idx;
   Lisp_Object val;
+  int is_uniprop = UNIPROP_TABLE_P (table);
 
   val = tbl->contents[chartab_idx];
   if (*from < 0)
     *from = 0;
   if (*to < 0)
     *to = MAX_CHAR;
+  if (is_uniprop && UNIPROP_COMPRESSED_FORM_P (val))
+    val = uniprop_table_uncompress (table, chartab_idx);
   if (SUB_CHAR_TABLE_P (val))
-    val = sub_char_table_ref_and_range (val, c, from, to, tbl->defalt);
+    val = sub_char_table_ref_and_range (val, c, from, to, tbl->defalt,
+                                        is_uniprop);
   else if (NILP (val))
     val = tbl->defalt;
-
   idx = chartab_idx;
   while (*from < idx * chartab_chars[0])
     {
@@ -296,9 +345,11 @@ char_table_ref_and_range (Lisp_Object table, int c, int *from, int *to)
       c = idx * chartab_chars[0] - 1;
       idx--;
       this_val = tbl->contents[idx];
+      if (is_uniprop && UNIPROP_COMPRESSED_FORM_P (this_val))
+        this_val = uniprop_table_uncompress (table, idx);
       if (SUB_CHAR_TABLE_P (this_val))
         this_val = sub_char_table_ref_and_range (this_val, c, from, to,
-                                                 tbl->defalt);
+                                                 tbl->defalt, is_uniprop);
       else if (NILP (this_val))
         this_val = tbl->defalt;
 
@@ -315,9 +366,11 @@ char_table_ref_and_range (Lisp_Object table, int c, int *from, int *to)
       chartab_idx++;
       c = chartab_idx * chartab_chars[0];
       this_val = tbl->contents[chartab_idx];
+      if (is_uniprop && UNIPROP_COMPRESSED_FORM_P (this_val))
+        this_val = uniprop_table_uncompress (table, chartab_idx);
       if (SUB_CHAR_TABLE_P (this_val))
         this_val = sub_char_table_ref_and_range (this_val, c, from, to,
-                                                 tbl->defalt);
+                                                 tbl->defalt, is_uniprop);
       else if (NILP (this_val))
         this_val = tbl->defalt;
       if (! EQ (this_val, val))
@@ -332,7 +385,7 @@ char_table_ref_and_range (Lisp_Object table, int c, int *from, int *to)
 
 
 static void
-sub_char_table_set (Lisp_Object table, int c, Lisp_Object val)
+sub_char_table_set (Lisp_Object table, int c, Lisp_Object val, int is_uniprop)
 {
   struct Lisp_Sub_Char_Table *tbl = XSUB_CHAR_TABLE (table);
   int depth = XINT ((tbl)->depth);
@@ -347,11 +400,17 @@ sub_char_table_set (Lisp_Object table, int c, Lisp_Object val)
       sub = tbl->contents[i];
       if (! SUB_CHAR_TABLE_P (sub))
         {
-          sub = make_sub_char_table (depth + 1,
-                                     min_char + i * chartab_chars[depth], sub);
-          tbl->contents[i] = sub;
+          if (is_uniprop && UNIPROP_COMPRESSED_FORM_P (sub))
+            sub = uniprop_table_uncompress (table, i);
+          else
+            {
+              sub = make_sub_char_table (depth + 1,
+                                         min_char + i * chartab_chars[depth],
+                                         sub);
+              tbl->contents[i] = sub;
+            }
         }
-      sub_char_table_set (sub, c, val);
+      sub_char_table_set (sub, c, val, is_uniprop);
     }
 }
 
@@ -376,7 +435,7 @@ char_table_set (Lisp_Object table, int c, Lisp_Object val)
           sub = make_sub_char_table (1, i * chartab_chars[0], sub);
           tbl->contents[i] = sub;
         }
-      sub_char_table_set (sub, c, val);
+      sub_char_table_set (sub, c, val, UNIPROP_TABLE_P (table));
       if (ASCII_CHAR_P (c))
         tbl->ascii = char_table_ascii (table);
     }
@@ -384,30 +443,40 @@ char_table_set (Lisp_Object table, int c, Lisp_Object val)
 }
 
 static void
-sub_char_table_set_range (Lisp_Object *table, int depth, int min_char, int from, int to, Lisp_Object val)
+sub_char_table_set_range (Lisp_Object table, int from, int to, Lisp_Object val,
+                          int is_uniprop)
 {
-  int max_char = min_char + chartab_chars[depth] - 1;
-
-  if (depth == 3 || (from <= min_char && to >= max_char))
-    *table = val;
-  else
+  struct Lisp_Sub_Char_Table *tbl = XSUB_CHAR_TABLE (table);
+  int depth = XINT ((tbl)->depth);
+  int min_char = XINT ((tbl)->min_char);
+  int chars_in_block = chartab_chars[depth];
+  int i, c, lim = chartab_size[depth];
+
+  if (from < min_char)
+    from = min_char;
+  i = CHARTAB_IDX (from, depth, min_char);
+  c = min_char + chars_in_block * i;
+  for (; i < lim; i++, c += chars_in_block)
     {
-      int i;
-      unsigned j;
-
-      depth++;
-      if (! SUB_CHAR_TABLE_P (*table))
-        *table = make_sub_char_table (depth, min_char, *table);
-      if (from < min_char)
-        from = min_char;
-      if (to > max_char)
-        to = max_char;
-      i = CHARTAB_IDX (from, depth, min_char);
-      j = CHARTAB_IDX (to, depth, min_char);
-      min_char += chartab_chars[depth] * i;
-      for (j++; i < j; i++, min_char += chartab_chars[depth])
-        sub_char_table_set_range (XSUB_CHAR_TABLE (*table)->contents + i,
-                                  depth, min_char, from, to, val);
+      if (c > to)
+        break;
+      if (from <= c && c + chars_in_block - 1 <= to)
+        tbl->contents[i] = val;
+      else
+        {
+          Lisp_Object sub = tbl->contents[i];
+          if (! SUB_CHAR_TABLE_P (sub))
+            {
+              if (is_uniprop && UNIPROP_COMPRESSED_FORM_P (sub))
+                sub = uniprop_table_uncompress (table, i);
+              else
+                {
+                  sub = make_sub_char_table (depth + 1, c, sub);
+                  tbl->contents[i] = sub;
+                }
+            }
+          sub_char_table_set_range (sub, from, to, val, is_uniprop);
+        }
     }
 }
 
@@ -416,17 +485,33 @@ Lisp_Object
 char_table_set_range (Lisp_Object table, int from, int to, Lisp_Object val)
 {
   struct Lisp_Char_Table *tbl = XCHAR_TABLE (table);
-  Lisp_Object *contents = tbl->contents;
-  int i;
 
   if (from == to)
     char_table_set (table, from, val);
   else
     {
-      unsigned lim = to / chartab_chars[0] + 1;
-      for (i = CHARTAB_IDX (from, 0, 0); i < lim; i++)
-        sub_char_table_set_range (contents + i, 0, i * chartab_chars[0],
-                                  from, to, val);
+      int is_uniprop = UNIPROP_TABLE_P (table);
+      int lim = CHARTAB_IDX (to, 0, 0);
+      int i, c;
+
+      for (i = CHARTAB_IDX (from, 0, 0), c = 0; i <= lim;
+           i++, c += chartab_chars[0])
+        {
+          if (c > to)
+            break;
+          if (from <= c && c + chartab_chars[0] - 1 <= to)
+            tbl->contents[i] = val;
+          else
+            {
+              Lisp_Object sub = tbl->contents[i];
+              if (! SUB_CHAR_TABLE_P (sub))
+                {
+                  sub = make_sub_char_table (1, i * chartab_chars[0], sub);
+                  tbl->contents[i] = sub;
+                }
+              sub_char_table_set_range (sub, from, to, val, is_uniprop);
+            }
+        }
       if (ASCII_CHAR_P (from))
         tbl->ascii = char_table_ascii (table);
     }
@@ -504,6 +589,8 @@ DEFUN ("set-char-table-extra-slot", Fset_char_table_extra_slot,
   (Lisp_Object char_table, Lisp_Object n, Lisp_Object value)
 {
   CHECK_CHAR_TABLE (char_table);
+  if (EQ (XCHAR_TABLE (char_table)->purpose, Qchar_code_property_table))
+    error ("Can't change extra-slot of char-code-property-table");
   CHECK_NUMBER (n);
   if (XINT (n) < 0
       || XINT (n) >= CHAR_TABLE_EXTRA_SLOTS (XCHAR_TABLE (char_table)))
@@ -532,8 +619,9 @@ a cons of character codes (for characters in the range), or a character code.  *
 
       CHECK_CHARACTER_CAR (range);
       CHECK_CHARACTER_CDR (range);
-      val = char_table_ref_and_range (char_table, XFASTINT (XCAR (range)),
-                                      &from, &to);
+      from = XFASTINT (XCAR (range));
+      to = XFASTINT (XCDR (range));
+      val = char_table_ref_and_range (char_table, from, &from, &to);
       /* Not yet implemented. */
     }
   else
@@ -655,8 +743,7 @@ equivalent and can be merged.  It defaults to `equal'.  */)
 /* Map C_FUNCTION or FUNCTION over TABLE (top or sub char-table),
    calling it for each character or group of characters that share a
    value.  RANGE is a cons (FROM . TO) specifying the range of target
-   characters, VAL is a value of FROM in TABLE, DEFAULT_VAL is the
-   default value of the char-table, PARENT is the parent of the
+   characters, VAL is a value of FROM in TABLE, TOP is the top
    char-table.
 
    ARG is passed to C_FUNCTION when that is called.
@@ -669,10 +756,8 @@ equivalent and can be merged.  It defaults to `equal'.  */)
 static Lisp_Object
 map_sub_char_table (void (*c_function) (Lisp_Object, Lisp_Object, Lisp_Object),
                     Lisp_Object function, Lisp_Object table, Lisp_Object arg, Lisp_Object val,
-                    Lisp_Object range, Lisp_Object default_val, Lisp_Object parent)
+                    Lisp_Object range, Lisp_Object top)
 {
-  /* Pointer to the elements of TABLE. */
-  Lisp_Object *contents;
   /* Depth of TABLE.  */
   int depth;
   /* Minimum and maxinum characters covered by TABLE. */
@@ -681,20 +766,20 @@ map_sub_char_table (void (*c_function) (Lisp_Object, Lisp_Object, Lisp_Object),
   int chars_in_block;
   int from = XINT (XCAR (range)), to = XINT (XCDR (range));
   int i, c;
+  int is_uniprop = UNIPROP_TABLE_P (top);
+  uniprop_decoder_t decoder = UNIPROP_GET_DECODER (top);
 
   if (SUB_CHAR_TABLE_P (table))
     {
       struct Lisp_Sub_Char_Table *tbl = XSUB_CHAR_TABLE (table);
 
       depth = XINT (tbl->depth);
-      contents = tbl->contents;
       min_char = XINT (tbl->min_char);
       max_char = min_char + chartab_chars[depth - 1] - 1;
     }
   else
     {
       depth = 0;
-      contents = XCHAR_TABLE (table)->contents;
       min_char = 0;
       max_char = MAX_CHAR;
     }
@@ -710,28 +795,33 @@ map_sub_char_table (void (*c_function) (Lisp_Object, Lisp_Object, Lisp_Object),
   for (c = min_char + chars_in_block * i; c <= max_char;
        i++, c += chars_in_block)
     {
-      Lisp_Object this = contents[i];
+      Lisp_Object this = (SUB_CHAR_TABLE_P (table)
+                          ? XSUB_CHAR_TABLE (table)->contents[i]
+                          : XCHAR_TABLE (table)->contents[i]);
       int nextc = c + chars_in_block;
 
+      if (is_uniprop && UNIPROP_COMPRESSED_FORM_P (this))
+        this = uniprop_table_uncompress (table, i);
       if (SUB_CHAR_TABLE_P (this))
         {
           if (to >= nextc)
             XSETCDR (range, make_number (nextc - 1));
           val = map_sub_char_table (c_function, function, this, arg,
-                                    val, range, default_val, parent);
+                                    val, range, top);
         }
       else
         {
           if (NILP (this))
-            this = default_val;
+            this = XCHAR_TABLE (top)->defalt;
           if (!EQ (val, this))
             {
               int different_value = 1;
 
               if (NILP (val))
                 {
-                  if (! NILP (parent))
+                  if (! NILP (XCHAR_TABLE (top)->parent))
                     {
+                      Lisp_Object parent = XCHAR_TABLE (top)->parent;
                       Lisp_Object temp = XCHAR_TABLE (parent)->parent;
 
                       /* This is to get a value of FROM in PARENT
@@ -742,8 +832,7 @@ map_sub_char_table (void (*c_function) (Lisp_Object, Lisp_Object, Lisp_Object),
                       XSETCDR (range, make_number (c - 1));
                       val = map_sub_char_table (c_function, function,
                                                 parent, arg, val, range,
-                                                XCHAR_TABLE (parent)->defalt,
-                                                XCHAR_TABLE (parent)->parent);
+                                                parent);
                       if (EQ (val, this))
                         different_value = 0;
                     }
@@ -756,14 +845,22 @@ map_sub_char_table (void (*c_function) (Lisp_Object, Lisp_Object, Lisp_Object),
                       if (c_function)
                         (*c_function) (arg, XCAR (range), val);
                       else
-                        call2 (function, XCAR (range), val);
+                        {
+                          if (decoder)
+                            val = decoder (top, val);
+                          call2 (function, XCAR (range), val);
+                        }
                     }
                   else
                     {
                       if (c_function)
                         (*c_function) (arg, range, val);
                       else
-                        call2 (function, range, val);
+                        {
+                          if (decoder)
+                            val = decoder (top, val);
+                          call2 (function, range, val);
+                        }
                     }
                 }
               val = this;
@@ -783,35 +880,39 @@ map_sub_char_table (void (*c_function) (Lisp_Object, Lisp_Object, Lisp_Object),
    ARG is passed to C_FUNCTION when that is called.  */
 
 void
-map_char_table (void (*c_function) (Lisp_Object, Lisp_Object, Lisp_Object), Lisp_Object function, Lisp_Object table, Lisp_Object arg)
+map_char_table (void (*c_function) (Lisp_Object, Lisp_Object, Lisp_Object),
+                Lisp_Object function, Lisp_Object table, Lisp_Object arg)
 {
-  Lisp_Object range, val;
-  struct gcpro gcpro1, gcpro2, gcpro3;
+  Lisp_Object range, val, parent;
+  struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
+  uniprop_decoder_t decoder = UNIPROP_GET_DECODER (table);
 
   range = Fcons (make_number (0), make_number (MAX_CHAR));
-  GCPRO3 (table, arg, range);
+  parent = XCHAR_TABLE (table)->parent;
+
+  GCPRO4 (table, arg, range, parent);
   val = XCHAR_TABLE (table)->ascii;
   if (SUB_CHAR_TABLE_P (val))
     val = XSUB_CHAR_TABLE (val)->contents[0];
   val = map_sub_char_table (c_function, function, table, arg, val, range,
-                            XCHAR_TABLE (table)->defalt,
-                            XCHAR_TABLE (table)->parent);
+                            table);
+
   /* If VAL is nil and TABLE has a parent, we must consult the parent
      recursively.  */
   while (NILP (val) && ! NILP (XCHAR_TABLE (table)->parent))
     {
-      Lisp_Object parent = XCHAR_TABLE (table)->parent;
-      Lisp_Object temp = XCHAR_TABLE (parent)->parent;
+      Lisp_Object temp;
       int from = XINT (XCAR (range));
 
+      parent = XCHAR_TABLE (table)->parent;
+      temp = XCHAR_TABLE (parent)->parent;
       /* This is to get a value of FROM in PARENT without checking the
          parent of PARENT.  */
       XCHAR_TABLE (parent)->parent = Qnil;
       val = CHAR_TABLE_REF (parent, from);
       XCHAR_TABLE (parent)->parent = temp;
       val = map_sub_char_table (c_function, function, parent, arg, val, range,
-                                XCHAR_TABLE (parent)->defalt,
-                                XCHAR_TABLE (parent)->parent);
+                                parent);
       table = parent;
     }
 
@@ -822,14 +923,22 @@ map_char_table (void (*c_function) (Lisp_Object, Lisp_Object, Lisp_Object), Lisp
           if (c_function)
             (*c_function) (arg, XCAR (range), val);
           else
-            call2 (function, XCAR (range), val);
+            {
+              if (decoder)
+                val = decoder (table, val);
+              call2 (function, XCAR (range), val);
+            }
         }
       else
         {
           if (c_function)
             (*c_function) (arg, range, val);
           else
-            call2 (function, range, val);
+            {
+              if (decoder)
+                val = decoder (table, val);
+              call2 (function, range, val);
+            }
         }
     }
 
@@ -984,9 +1093,314 @@ map_char_table_for_charset (void (*c_function) (Lisp_Object, Lisp_Object),
 }
 
 
+/* Unicode character property tables.
+
+   This section provides a convenient and efficient way to get a
+   Unicode character property from C code (from Lisp, you must use
+   get-char-code-property).
+
+   The typical usage is to get a char-table for a specific property at
+   a proper initialization time as this:
+
+        Lisp_Object bidi_class_table = uniprop_table (intern ("bidi-class"));
+
+   and get a property value for character CH as this:
+
+        Lisp_Object bidi_class = CHAR_TABLE_REF (CH, bidi_class_table);
+
+   In this case, what you actually get is an index number to the
+   vector of property values (symbols nil, L, R, etc).
+
+   A table for Unicode character property has these characteristics:
+
+   o The purpose is `char-code-property-table', which implies that the
+   table has 5 extra slots.
+
+   o The second extra slot is a Lisp function, an index (integer) to
+   the array uniprop_decoder[], or nil.  If it is a Lisp function, we
+   can't use such a table from C (at the moment).  If it is nil, it
+   means that we don't have to decode values.
+
+   o The third extra slot is a Lisp function, an index (integer) to
+   the array uniprop_enncoder[], or nil.  If it is a Lisp function, we
+   can't use such a table from C (at the moment).  If it is nil, it
+   means that we don't have to encode values.  */
+
+
+/* Uncompress the IDXth element of sub-char-table TABLE.  */
+
+static Lisp_Object
+uniprop_table_uncompress (Lisp_Object table, int idx)
+{
+  Lisp_Object val = XSUB_CHAR_TABLE (table)->contents[idx];
+  int min_char = (XINT (XSUB_CHAR_TABLE (table)->min_char)
+                  + chartab_chars[2] * idx);
+  Lisp_Object sub = make_sub_char_table (3, min_char, Qnil);
+  struct Lisp_Sub_Char_Table *subtbl = XSUB_CHAR_TABLE (sub);
+  const unsigned char *p, *pend;
+
+  XSUB_CHAR_TABLE (table)->contents[idx] = sub;
+  p = SDATA (val), pend = p + SBYTES (val);
+  if (*p == 1)
+    {
+      /* SIMPLE TABLE */
+      p++;
+      idx = STRING_CHAR_ADVANCE (p);
+      while (p < pend && idx < chartab_chars[2])
+        {
+          int v = STRING_CHAR_ADVANCE (p);
+          subtbl->contents[idx++] = v > 0 ? make_number (v) : Qnil;
+        }
+    }
+  else if (*p == 2)
+    {
+      /* RUN-LENGTH TABLE */
+      p++;
+      for (idx = 0; p < pend; )
+        {
+          int v = STRING_CHAR_ADVANCE (p);
+          int count = 1;
+          int len;
+
+          if (p < pend)
+            {
+              count = STRING_CHAR_AND_LENGTH (p, len);
+              if (count < 128)
+                count = 1;
+              else
+                {
+                  count -= 128;
+                  p += len;
+                }
+            }
+          while (count-- > 0)
+            subtbl->contents[idx++] = make_number (v);
+        }
+    }
+/* It seems that we don't need this function because C code won't need
+   to get a property that is compressed in this form.  */
+#if 0
+  else if (*p == 0)
+    {
+      /* WORD-LIST TABLE */
+    }
+#endif
+  return sub;
+}
+
+
+/* Decode VALUE as an elemnet of char-table TABLE.  */
+
+static Lisp_Object
+uniprop_decode_value_run_length (Lisp_Object table, Lisp_Object value)
+{
+  if (VECTORP (XCHAR_TABLE (table)->extras[4]))
+    {
+      Lisp_Object valvec = XCHAR_TABLE (table)->extras[4];
+
+      if (XINT (value) >= 0 && XINT (value) < ASIZE (valvec))
+        value = AREF (valvec, XINT (value));
+    }
+  return value;
+}
+
+static uniprop_decoder_t uniprop_decoder [] =
+  { uniprop_decode_value_run_length };
+
+static int uniprop_decoder_count
+  = (sizeof uniprop_decoder) / sizeof (uniprop_decoder[0]);
+
+
+/* Return the decoder of char-table TABLE or nil if none.  */
+
+static uniprop_decoder_t
+uniprop_get_decoder (Lisp_Object table)
+{
+  int i;
+
+  if (! INTEGERP (XCHAR_TABLE (table)->extras[1]))
+    return NULL;
+  i = XINT (XCHAR_TABLE (table)->extras[1]);
+  if (i < 0 || i >= uniprop_decoder_count)
+    return NULL;
+  return uniprop_decoder[i];
+}
+
+
+/* Encode VALUE as an element of char-table TABLE which contains
+   characters as elements.  */
+
+static Lisp_Object
+uniprop_encode_value_character (Lisp_Object table, Lisp_Object value)
+{
+  if (! NILP (value) && ! CHARACTERP (value))
+    wrong_type_argument (Qintegerp, value);
+  return value;
+}
+
+
+/* Encode VALUE as an element of char-table TABLE which adopts RUN-LENGTH
+   compression.  */
+
+static Lisp_Object
+uniprop_encode_value_run_length (Lisp_Object table, Lisp_Object value)
+{
+  Lisp_Object *value_table = XVECTOR (XCHAR_TABLE (table)->extras[4])->contents;
+  int i, size = ASIZE (XCHAR_TABLE (table)->extras[4]);
+
+  for (i = 0; i < size; i++)
+    if (EQ (value, value_table[i]))
+      break;
+  if (i == size)
+    wrong_type_argument (build_string ("Unicode property value"), value);
+  return make_number (i);
+}
+
+
+/* Encode VALUE as an element of char-table TABLE which adopts RUN-LENGTH
+   compression and contains numbers as elements .  */
+
+static Lisp_Object
+uniprop_encode_value_numeric (Lisp_Object table, Lisp_Object value)
+{
+  Lisp_Object *value_table = XVECTOR (XCHAR_TABLE (table)->extras[4])->contents;
+  int i, size = ASIZE (XCHAR_TABLE (table)->extras[4]);
+
+  CHECK_NUMBER (value);
+  for (i = 0; i < size; i++)
+    if (EQ (value, value_table[i]))
+      break;
+  value = make_number (i);
+  if (i == size)
+    {
+      Lisp_Object args[2];
+
+      args[0] = XCHAR_TABLE (table)->extras[4];
+      args[1] = Fmake_vector (make_number (1), value);
+      XCHAR_TABLE (table)->extras[4] = Fvconcat (2, args);
+    }
+  return make_number (i);
+}
+
+static uniprop_encoder_t uniprop_encoder[] =
+  { uniprop_encode_value_character,
+    uniprop_encode_value_run_length,
+    uniprop_encode_value_numeric };
+
+static int uniprop_encoder_count
+  = (sizeof uniprop_encoder) / sizeof (uniprop_encoder[0]);
+
+
+/* Return the encoder of char-table TABLE or nil if none.  */
+
+static uniprop_decoder_t
+uniprop_get_encoder (Lisp_Object table)
+{
+  int i;
+
+  if (! INTEGERP (XCHAR_TABLE (table)->extras[2]))
+    return NULL;
+  i = XINT (XCHAR_TABLE (table)->extras[2]);
+  if (i < 0 || i >= uniprop_encoder_count)
+    return NULL;
+  return uniprop_encoder[i];
+}
+
+/* Return a char-table for Unicode character property PROP.  This
+   function may load a Lisp file and thus may cause
+   garbage-collection.  */
+
+static Lisp_Object
+uniprop_table (Lisp_Object prop)
+{
+  Lisp_Object val, table, result;
+
+  val = Fassq (prop, Vchar_code_property_alist);
+  if (! CONSP (val))
+    return Qnil;
+  table = XCDR (val);
+  if (STRINGP (table))
+    {
+      struct gcpro gcpro1;
+      GCPRO1 (val);
+      result = Fload (concat2 (build_string ("international/"), table),
+                      Qt, Qt, Qt, Qt);
+      UNGCPRO;
+      if (NILP (result))
+        return Qnil;
+      table = XCDR (val);
+    }
+  if (! CHAR_TABLE_P (table)
+      || ! UNIPROP_TABLE_P (table))
+    return Qnil;
+  val = XCHAR_TABLE (table)->extras[1];
+  if (INTEGERP (val)
+      ? (XINT (val) < 0 || XINT (val) >= uniprop_decoder_count)
+      : ! NILP (val))
+    return Qnil;
+  /* Prepare ASCII values in advance for CHAR_TABLE_REF.  */
+  XCHAR_TABLE (table)->ascii = char_table_ascii (table);
+  return table;
+}
+
+DEFUN ("unicode-property-table-internal", Funicode_property_table_internal,
+       Sunicode_property_table_internal, 1, 1, 0,
+       doc: /* Return a char-table for Unicode character property PROP.
+Use `get-unicode-property-internal' and
+`put-unicode-property-internal' instead of `aref' and `aset' to get
+and put an element value.  */)
+  (Lisp_Object prop)
+{
+  Lisp_Object table = uniprop_table (prop);
+
+  if (CHAR_TABLE_P (table))
+    return table;
+  return Fcdr (Fassq (prop, Vchar_code_property_alist));
+}
+
+DEFUN ("get-unicode-property-internal", Fget_unicode_property_internal,
+       Sget_unicode_property_internal, 2, 2, 0,
+       doc: /* Return an element of CHAR-TABLE for character CH.
+CHAR-TABLE must be what returned by `unicode-property-table-internal'. */)
+  (Lisp_Object char_table, Lisp_Object ch)
+{
+  Lisp_Object val;
+  uniprop_decoder_t decoder;
+
+  CHECK_CHAR_TABLE (char_table);
+  CHECK_CHARACTER (ch);
+  if (! UNIPROP_TABLE_P (char_table))
+    error ("Invalid Unicode property table");
+  val = CHAR_TABLE_REF (char_table, XINT (ch));
+  decoder = uniprop_get_decoder (char_table);
+  return (decoder ? decoder (char_table, val) : val);
+}
+
+DEFUN ("put-unicode-property-internal", Fput_unicode_property_internal,
+       Sput_unicode_property_internal, 3, 3, 0,
+       doc: /* Set an element of CHAR-TABLE for character CH to VALUE.
+CHAR-TABLE must be what returned by `unicode-property-table-internal'. */)
+  (Lisp_Object char_table, Lisp_Object ch, Lisp_Object value)
+{
+  uniprop_encoder_t encoder;
+
+  CHECK_CHAR_TABLE (char_table);
+  CHECK_CHARACTER (ch);
+  if (! UNIPROP_TABLE_P (char_table))
+    error ("Invalid Unicode property table");
+  encoder = uniprop_get_encoder (char_table);
+  if (encoder)
+    value = encoder (char_table, value);
+  CHAR_TABLE_SET (char_table, XINT (ch), value);
+  return Qnil;
+}
+
+
 void
 syms_of_chartab (void)
 {
+  DEFSYM (Qchar_code_property_table, "char-code-property-table");
+
   defsubr (&Smake_char_table);
   defsubr (&Schar_table_parent);
   defsubr (&Schar_table_subtype);
@@ -998,4 +1412,19 @@ syms_of_chartab (void)
   defsubr (&Sset_char_table_default);
   defsubr (&Soptimize_char_table);
   defsubr (&Smap_char_table);
+  defsubr (&Sunicode_property_table_internal);
+  defsubr (&Sget_unicode_property_internal);
+  defsubr (&Sput_unicode_property_internal);
+
+  /* Each element has the form (PROP . TABLE).
+     PROP is a symbol representing a character property.
+     TABLE is a char-table containing the property value for each character.
+     TABLE may be a name of file to load to build a char-table.
+     This variable should be modified only through
+     `define-char-code-property'. */
+
+  DEFVAR_LISP ("char-code-property-alist", Vchar_code_property_alist,
+               doc: /* Alist of character property name vs char-table containing property values.
+Internal use only.  */);
+  Vchar_code_property_alist = Qnil;
 }
diff --git a/src/cm.c b/src/cm.c
index 42f855f1694..609632eba11 100644
--- a/src/cm.c
+++ b/src/cm.c
@@ -305,7 +305,8 @@ done:
 }
 
 #if 0
-losecursor ()
+void
+losecursor (void)
 {
   curY = -1;
 }
diff --git a/src/coding.c b/src/coding.c
index 9939774ea82..65c8a767c2b 100644
--- a/src/coding.c
+++ b/src/coding.c
@@ -9000,7 +9000,7 @@ not fully specified.)  */)
   (Lisp_Object string, Lisp_Object coding_system, Lisp_Object nocopy, Lisp_Object buffer)
 {
   return code_convert_string (string, coding_system, buffer,
-                              1, ! NILP (nocopy), 1);
+                              1, ! NILP (nocopy), 0);
 }
 
 
diff --git a/src/composite.c b/src/composite.c
index de9775d18f5..d402d5ad0c4 100644
--- a/src/composite.c
+++ b/src/composite.c
@@ -967,7 +967,6 @@ autocmp_chars (Lisp_Object rule, EMACS_INT charpos, EMACS_INT bytepos, EMACS_INT
 }
 
 static Lisp_Object _work_val;
-static int _work_char;
 
 /* 1 iff the character C is composable.  Characters of general
    category Z? or C? are not composable except for ZWNJ and ZWJ. */
@@ -976,9 +975,8 @@ static int _work_char;
   ((C) > ' '                                                            \
    && ((C) == 0x200C || (C) == 0x200D                                   \
        || (_work_val = CHAR_TABLE_REF (Vunicode_category_table, (C)),   \
-           (SYMBOLP (_work_val)                                         \
-            && (_work_char = SDATA (SYMBOL_NAME (_work_val))[0]) != 'C' \
-            && _work_char != 'Z'))))
+           (INTEGERP (_work_val)                                        \
+            && (XINT (_work_val) <= UNICODE_CATEGORY_So)))))
 
 /* Update cmp_it->stop_pos to the next position after CHARPOS (and
    BYTEPOS) where character composition may happen.  If BYTEPOS is
@@ -1027,6 +1025,7 @@ composition_compute_stop_pos (struct composition_it *cmp_it, EMACS_INT charpos,
   /* FIXME: Bidi is not yet handled well in static composition.  */
   if (charpos < endpos
       && find_composition (charpos, endpos, &start, &end, &prop, string)
+      && start >= charpos
       && COMPOSITION_VALID_P (start, end, prop))
     {
       cmp_it->stop_pos = endpos = start;
diff --git a/src/data.c b/src/data.c
index 6b4ea32ac9e..7bc04592c57 100644
--- a/src/data.c
+++ b/src/data.c
@@ -2736,8 +2736,7 @@ Both must be integers or markers.  */)
 
 #ifndef HAVE_FMOD
 double
-fmod (f1, f2)
-     double f1, f2;
+fmod (double f1, double f2)
 {
   double r = f1;
 
diff --git a/src/dispextern.h b/src/dispextern.h
index 31ad7af4a84..ec1bdab815c 100644
--- a/src/dispextern.h
+++ b/src/dispextern.h
@@ -1779,7 +1779,11 @@ extern int face_change_count;
 /* Data type for describing the bidirectional character types.  The
    first 7 must be at the beginning, because they are the only values
    valid in the `bidi_type' member of `struct glyph'; we only reserve
-   3 bits for it, so we cannot use there values larger than 7.  */
+   3 bits for it, so we cannot use there values larger than 7.
+
+   The order of members must be in sync with the 8th element of the
+   member of unidata-prop-alist (in admin/unidata/unidata-getn.el) for
+   Unicode character property `bidi-class'.  */
 typedef enum {
   UNKNOWN_BT = 0,
   STRONG_L,     /* strong left-to-right */
@@ -1822,9 +1826,21 @@ struct bidi_stack {
   bidi_dir_t override;
 };
 
+/* Data type for storing information about a string being iterated on.  */
+struct bidi_string_data {
+  Lisp_Object lstring;          /* Lisp string to reorder, or nil */
+  const unsigned char *s;       /* string data, or NULL if reordering buffer */
+  EMACS_INT schars;             /* the number of characters in the string,
+                                   excluding the terminating null */
+  EMACS_INT bufpos;             /* buffer position of lstring, or 0 if N/A */
+  unsigned from_disp_str : 1;   /* 1 means the string comes from a
+                                   display property */
+  unsigned unibyte : 1;         /* 1 means the string is unibyte */
+};
+
 /* Data type for reordering bidirectional text.  */
 struct bidi_it {
-  EMACS_INT bytepos;            /* iterator's position in buffer */
+  EMACS_INT bytepos;            /* iterator's position in buffer/string */
   EMACS_INT charpos;
   int ch;                       /* character at that position, or u+FFFC
                                    ("object replacement character") for a run
@@ -1854,12 +1870,13 @@ struct bidi_it {
      iterator state is saved, pushed, or popped.  So only put here
      stuff that is not part of the bidi iterator's state!  */
   struct bidi_stack level_stack[BIDI_MAXLEVEL]; /* stack of embedding levels */
-  int first_elt;                /* if non-zero, examine current char first */
+  struct bidi_string_data string;       /* string to reorder */
   bidi_dir_t paragraph_dir;     /* current paragraph direction */
-  int new_paragraph;            /* if non-zero, we expect a new paragraph */
-  int frame_window_p;           /* non-zero if displaying on a GUI frame */
   EMACS_INT separator_limit;    /* where paragraph separator should end */
   EMACS_INT disp_pos;           /* position of display string after ch */
+  unsigned first_elt : 1;       /* if non-zero, examine current char first */
+  unsigned new_paragraph : 1;   /* if non-zero, we expect a new paragraph */
+  unsigned frame_window_p : 1;  /* non-zero if displaying on a GUI frame */
 };
 
 /* Value is non-zero when the bidi iterator is at base paragraph
@@ -2139,6 +2156,10 @@ struct it
      Don't handle some `display' properties in these strings.  */
   unsigned string_from_display_prop_p : 1;
 
+  /* 1 means we are iterating an object that came from a value of a
+     `display' property.  */
+  unsigned from_disp_prop_p : 1;
+
   /* When METHOD == next_element_from_display_vector,
      this is 1 if we're doing an ellipsis.  Otherwise meaningless.  */
   unsigned ellipsis_p : 1;
@@ -2158,7 +2179,9 @@ struct it
   Lisp_Object *dpvec, *dpend;
 
   /* Length in bytes of the char that filled dpvec.  A value of zero
-     means that no such character is involved.  */
+     means that no such character is involved.  A negative value means
+     the rest of the line from the current iterator position onwards
+     is hidden by selective display or ellipsis.  */
   int dpvec_char_len;
 
   /* Face id to use for all characters in display vector.  -1 if unused. */
@@ -2256,10 +2279,13 @@ struct it
     Lisp_Object from_overlay;
     enum glyph_row_area area;
     enum it_method method;
+    bidi_dir_t paragraph_embedding;
     unsigned multibyte_p : 1;
     unsigned string_from_display_prop_p : 1;
     unsigned display_ellipsis_p : 1;
     unsigned avoid_cursor_p : 1;
+    unsigned bidi_p:1;
+    unsigned from_disp_prop_p : 1;
     enum line_wrap_method line_wrap;
 
     /* properties from display property that are reset by another display property. */
@@ -2484,7 +2510,7 @@ struct it
 
   /* Non-zero means we need to reorder bidirectional text for display
      in the visual order.  */
-  int bidi_p;
+  unsigned bidi_p : 1;
 
   /* For iterating over bidirectional text.  */
   struct bidi_it bidi_it;
@@ -2966,6 +2992,10 @@ extern void bidi_init_it (EMACS_INT, EMACS_INT, int, struct bidi_it *);
 extern void bidi_move_to_visually_next (struct bidi_it *);
 extern void bidi_paragraph_init (bidi_dir_t, struct bidi_it *, int);
 extern int  bidi_mirror_char (int);
+extern void bidi_push_it (struct bidi_it *);
+extern void bidi_pop_it (struct bidi_it *);
+extern void *bidi_shelve_cache (void);
+extern void bidi_unshelve_cache (void *);
 
 /* Defined in xdisp.c */
 
@@ -3023,8 +3053,10 @@ extern void reseat_at_previous_visible_line_start (struct it *);
 extern Lisp_Object lookup_glyphless_char_display (int, struct it *);
 extern int calc_pixel_width_or_height (double *, struct it *, Lisp_Object,
                                        struct font *, int, int *);
-extern EMACS_INT compute_display_string_pos (EMACS_INT, int);
-extern EMACS_INT compute_display_string_end (EMACS_INT);
+extern EMACS_INT compute_display_string_pos (struct text_pos *,
+                                             struct bidi_string_data *, int);
+extern EMACS_INT compute_display_string_end (EMACS_INT,
+                                             struct bidi_string_data *);
 
 #ifdef HAVE_WINDOW_SYSTEM
 
diff --git a/src/dispnew.c b/src/dispnew.c
index bde90d847ce..bfd4b3a7ecf 100644
--- a/src/dispnew.c
+++ b/src/dispnew.c
@@ -1065,8 +1065,7 @@ increment_row_positions (struct glyph_row *row,
    B without changing glyph pointers in A and B.  */
 
 static void
-swap_glyphs_in_rows (a, b)
-     struct glyph_row *a, *b;
+swap_glyphs_in_rows (struct glyph_row *a, struct glyph_row *b)
 {
   int area;
 
@@ -5284,10 +5283,12 @@ buffer_posn_from_coords (struct window *w, int *x, int *y, struct display_pos *p
   struct image *img = 0;
 #endif
   int x0, x1, to_x;
+  void *itdata = NULL;
 
   /* We used to set current_buffer directly here, but that does the
      wrong thing with `face-remapping-alist' (bug#2044).  */
   Fset_buffer (w->buffer);
+  itdata = bidi_shelve_cache ();
   SET_TEXT_POS_FROM_MARKER (startp, w->start);
   CHARPOS (startp) = min (ZV, max (BEGV, CHARPOS (startp)));
   BYTEPOS (startp) = min (ZV_BYTE, max (BEGV_BYTE, BYTEPOS (startp)));
@@ -5321,6 +5322,7 @@ buffer_posn_from_coords (struct window *w, int *x, int *y, struct display_pos *p
      argument is ZV to prevent move_it_in_display_line from matching
      based on buffer positions.  */
   move_it_in_display_line (&it, ZV, to_x, MOVE_TO_X);
+  bidi_unshelve_cache (itdata);
 
   Fset_buffer (old_current_buffer);
 
diff --git a/src/editfns.c b/src/editfns.c
index 5328b714b0f..b20c38faacd 100644
--- a/src/editfns.c
+++ b/src/editfns.c
@@ -194,8 +194,12 @@ DEFUN ("byte-to-string", Fbyte_to_string, Sbyte_to_string, 1, 1, 0,
 }
 
 DEFUN ("string-to-char", Fstring_to_char, Sstring_to_char, 1, 1, 0,
-       doc: /* Convert arg STRING to a character, the first character of that string.
-A multibyte character is handled correctly.  */)
+       doc: /* Return the first character in STRING.
+A multibyte character is handled correctly.
+The value returned is a Unicode codepoint if it is below #x110000 (in
+hex).  Codepoints beyond that are Emacs extensions of Unicode.  In
+particular, eight-bit characters are returned as codepoints in the
+range #x3FFF80 through #x3FFFFF, inclusive.  */)
   (register Lisp_Object string)
 {
   register Lisp_Object val;
@@ -1700,7 +1704,7 @@ For example, to produce full ISO 8601 format, use "%Y-%m-%dT%T%z".  */)
   (Lisp_Object format_string, Lisp_Object timeval, Lisp_Object universal)
 {
   time_t value;
-  int size;
+  ptrdiff_t size;
   int usec;
   int ns;
   struct tm *tm;
@@ -1717,7 +1721,9 @@ For example, to produce full ISO 8601 format, use "%Y-%m-%dT%T%z".  */)
                                                 Vlocale_coding_system, 1);
 
   /* This is probably enough.  */
-  size = SBYTES (format_string) * 6 + 50;
+  size = SBYTES (format_string);
+  if (size <= (STRING_BYTES_BOUND - 50) / 6)
+    size = size * 6 + 50;
 
   BLOCK_INPUT;
   tm = ut ? gmtime (&value) : localtime (&value);
@@ -1730,7 +1736,7 @@ For example, to produce full ISO 8601 format, use "%Y-%m-%dT%T%z".  */)
   while (1)
     {
       char *buf = (char *) alloca (size + 1);
-      int result;
+      size_t result;
 
       buf[0] = '\1';
       BLOCK_INPUT;
@@ -1749,6 +1755,8 @@ For example, to produce full ISO 8601 format, use "%Y-%m-%dT%T%z".  */)
                                 SBYTES (format_string),
                                 tm, ut, ns);
       UNBLOCK_INPUT;
+      if (STRING_BYTES_BOUND <= result)
+        string_overflow ();
       size = result + 1;
     }
 }
@@ -3152,10 +3160,9 @@ It returns the number of characters changed.  */)
 }
 
 DEFUN ("delete-region", Fdelete_region, Sdelete_region, 2, 2, "r",
-       doc: /* Delete the text between point and mark.
-
-When called from a program, expects two arguments,
-positions (integers or markers) specifying the stretch to be deleted.  */)
+       doc: /* Delete the text between START and END.
+If called interactively, delete the region between point and mark.
+This command deletes buffer text without modifying the kill ring.  */)
   (Lisp_Object start, Lisp_Object end)
 {
   validate_region (&start, &end);
@@ -3557,7 +3564,8 @@ The width specifier supplies a lower limit for the length of the
 printed representation.  The padding, if any, normally goes on the
 left, but it goes on the right if the - flag is present.  The padding
 character is normally a space, but it is 0 if the 0 flag is present.
-The - flag takes precedence over the 0 flag.
+The 0 flag is ignored if the - flag is present, or the format sequence
+is something other than %d, %e, %f, and %g.
 
 For %e, %f, and %g sequences, the number after the "." in the
 precision specifier says how many decimal places to show; if zero, the
diff --git a/src/emacs.c b/src/emacs.c
index bfefa2bfa51..1de10c0b5dc 100644
--- a/src/emacs.c
+++ b/src/emacs.c
@@ -131,6 +131,10 @@ Lisp_Object empty_unibyte_string, empty_multibyte_string;
   on subsequent starts.  */
 int initialized;
 
+#ifdef DARWIN_OS
+extern void unexec_init_emacs_zone (void);
+#endif
+
 #ifdef DOUG_LEA_MALLOC
 /* Preserves a pointer to the memory allocated that copies that
    static data inside glibc's malloc.  */
@@ -352,8 +356,7 @@ fatal_error_signal (int sig)
 
 /* Handler for SIGDANGER.  */
 void
-memory_warning_signal (sig)
-     int sig;
+memory_warning_signal (int sig)
 {
   signal (sig, memory_warning_signal);
   SIGNAL_THREAD_CHECK (sig);
diff --git a/src/eval.c b/src/eval.c
index 6ca8eacb100..90d0df61858 100644
--- a/src/eval.c
+++ b/src/eval.c
@@ -32,25 +32,14 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include "xterm.h"
 #endif
 
-/* This definition is duplicated in alloc.c and keyboard.c.  */
-/* Putting it in lisp.h makes cc bomb out!  */
-
 struct backtrace
 {
   struct backtrace *next;
   Lisp_Object *function;
   Lisp_Object *args;    /* Points to vector of args.  */
-#define NARGS_BITS (BITS_PER_INT - 2)
-  /* Let's not use size_t because we want to allow negative values (for
-     UNEVALLED).  Also let's steal 2 bits so we save a word (or more for
-     alignment).  In any case I doubt Emacs would survive a function call with
-     more than 500M arguments.  */
-  int nargs : NARGS_BITS; /* Length of vector.
-                             If nargs is UNEVALLED, args points
-                             to slot holding list of unevalled args.  */
-  char evalargs : 1;
+  ptrdiff_t nargs;      /* Length of vector.  */
   /* Nonzero means call value of debugger when done with this operation.  */
-  char debug_on_exit : 1;
+  unsigned int debug_on_exit : 1;
 };
 
 static struct backtrace *backtrace_list;
@@ -1651,8 +1640,7 @@ internal_condition_case_n (Lisp_Object (*bfun) (ptrdiff_t, Lisp_Object *),
 }
 
 
-static Lisp_Object find_handler_clause (Lisp_Object, Lisp_Object,
-                                        Lisp_Object, Lisp_Object);
+static Lisp_Object find_handler_clause (Lisp_Object, Lisp_Object);
 static int maybe_call_debugger (Lisp_Object conditions, Lisp_Object sig,
                                 Lisp_Object data);
 
@@ -1728,8 +1716,7 @@ See also the function `condition-case'.  */)
 
   for (h = handlerlist; h; h = h->next)
     {
-      clause = find_handler_clause (h->handler, conditions,
-                                    error_symbol, data);
+      clause = find_handler_clause (h->handler, conditions);
       if (!NILP (clause))
         break;
     }
@@ -1900,8 +1887,10 @@ skip_debugger (Lisp_Object conditions, Lisp_Object data)
 }
 
 /* Call the debugger if calling it is currently enabled for CONDITIONS.
-   SIG and DATA describe the signal, as in find_handler_clause.  */
-
+   SIG and DATA describe the signal.  There are two ways to pass them:
+    = SIG is the error symbol, and DATA is the rest of the data.
+    = SIG is nil, and DATA is (SYMBOL . REST-OF-DATA).
+      This is for memory-full errors only.  */
 static int
 maybe_call_debugger (Lisp_Object conditions, Lisp_Object sig, Lisp_Object data)
 {
@@ -1928,19 +1917,8 @@ maybe_call_debugger (Lisp_Object conditions, Lisp_Object sig, Lisp_Object data)
   return 0;
 }
 
-/* Value of Qlambda means we have called debugger and user has continued.
-   There are two ways to pass SIG and DATA:
-    = SIG is the error symbol, and DATA is the rest of the data.
-    = SIG is nil, and DATA is (SYMBOL . REST-OF-DATA).
-       This is for memory-full errors only.
-
-   We need to increase max_specpdl_size temporarily around
-   anything we do that can push on the specpdl, so as not to get
-   a second error here in case we're handling specpdl overflow.  */
-
 static Lisp_Object
-find_handler_clause (Lisp_Object handlers, Lisp_Object conditions,
-                     Lisp_Object sig, Lisp_Object data)
+find_handler_clause (Lisp_Object handlers, Lisp_Object conditions)
 {
   register Lisp_Object h;
 
@@ -2291,7 +2269,6 @@ eval_sub (Lisp_Object form)
   backtrace.function = &original_fun; /* This also protects them from gc.  */
   backtrace.args = &original_args;
   backtrace.nargs = UNEVALLED;
-  backtrace.evalargs = 1;
   backtrace.debug_on_exit = 0;
 
   if (debug_on_next_call)
@@ -2325,10 +2302,7 @@ eval_sub (Lisp_Object form)
         xsignal2 (Qwrong_number_of_arguments, original_fun, numargs);
 
       else if (XSUBR (fun)->max_args == UNEVALLED)
-        {
-          backtrace.evalargs = 0;
-          val = (XSUBR (fun)->function.aUNEVALLED) (args_left);
-        }
+        val = (XSUBR (fun)->function.aUNEVALLED) (args_left);
       else if (XSUBR (fun)->max_args == MANY)
         {
           /* Pass a vector of evaluated arguments.  */
@@ -2984,7 +2958,6 @@ usage: (funcall FUNCTION &rest ARGUMENTS)  */)
   backtrace.function = &args[0];
   backtrace.args = &args[1];
   backtrace.nargs = nargs - 1;
-  backtrace.evalargs = 0;
   backtrace.debug_on_exit = 0;
 
   if (debug_on_next_call)
@@ -3141,7 +3114,6 @@ apply_lambda (Lisp_Object fun, Lisp_Object args)
 
   backtrace_list->args = arg_vector;
   backtrace_list->nargs = i;
-  backtrace_list->evalargs = 0;
   tem = funcall_lambda (fun, numargs, arg_vector);
 
   /* Do the debug-on-exit now, while arg_vector still exists.  */
@@ -3190,7 +3162,7 @@ funcall_lambda (Lisp_Object fun, ptrdiff_t nargs,
            shouldn't bind any arguments, instead just call the byte-code
            interpreter directly; it will push arguments as necessary.
 
-           Byte-code objects with either a non-existant, or a nil value for
+           Byte-code objects with either a non-existent, or a nil value for
            the `push args' slot (the default), have dynamically-bound
            arguments, and use the argument-binding code below instead (as do
            all interpreted functions, even lexically bound ones).  */
diff --git a/src/fileio.c b/src/fileio.c
index 27fef42960a..c6f8dfe4683 100644
--- a/src/fileio.c
+++ b/src/fileio.c
@@ -1755,6 +1755,10 @@ barf_or_query_if_file_exists (Lisp_Object absname, const char *querystring,
      regardless of what access permissions it has.  */
   if (lstat (SSDATA (encoded_filename), &statbuf) >= 0)
     {
+      if (S_ISDIR (statbuf.st_mode))
+        xsignal2 (Qfile_error,
+                  build_string ("File is a directory"), absname);
+
       if (! interactive)
         xsignal2 (Qfile_already_exists,
                   build_string ("File already exists"), absname);
diff --git a/src/floatfns.c b/src/floatfns.c
index b5c8b4af5c3..e003f492fe6 100644
--- a/src/floatfns.c
+++ b/src/floatfns.c
@@ -961,8 +961,7 @@ Rounds the value toward zero.  */)
 
 #ifdef FLOAT_CATCH_SIGILL
 static void
-float_error (signo)
-     int signo;
+float_error (int signo)
 {
   if (! in_float)
     fatal_error_signal (signo);
diff --git a/src/fns.c b/src/fns.c
index b6fe2a7f7b6..0ca731ed331 100644
--- a/src/fns.c
+++ b/src/fns.c
@@ -79,10 +79,14 @@ Other values of LIMIT are ignored.  */)
 {
   EMACS_INT val;
   Lisp_Object lispy_val;
-  EMACS_UINT denominator;
 
   if (EQ (limit, Qt))
-    seed_random (getpid () + time (NULL));
+    {
+      EMACS_TIME t;
+      EMACS_GET_TIME (t);
+      seed_random (getpid () ^ EMACS_SECS (t) ^ EMACS_USECS (t));
+    }
+
   if (NATNUMP (limit) && XFASTINT (limit) != 0)
     {
       /* Try to take our random number from the higher bits of VAL,
@@ -92,7 +96,7 @@ Other values of LIMIT are ignored.  */)
          it's possible to get a quotient larger than n; discarding
          these values eliminates the bias that would otherwise appear
          when using a large n.  */
-      denominator = ((EMACS_UINT) 1 << VALBITS) / XFASTINT (limit);
+      EMACS_INT denominator = (INTMASK + 1) / XFASTINT (limit);
       do
         val = get_random () / denominator;
       while (val >= XFASTINT (limit));
@@ -2613,6 +2617,7 @@ is not loaded; so load the file FILENAME.
 If FILENAME is omitted, the printname of FEATURE is used as the file name,
 and `load' will try to load this name appended with the suffix `.elc' or
 `.el', in that order.  The name without appended suffix will not be used.
+See `get-load-suffixes' for the complete list of suffixes.
 If the optional third argument NOERROR is non-nil,
 then return nil if the file is not found instead of signaling an error.
 Normally the return value is FEATURE.
diff --git a/src/font.c b/src/font.c
index 14390335f3c..5f8d22157d6 100644
--- a/src/font.c
+++ b/src/font.c
@@ -1738,8 +1738,7 @@ font_parse_family_registry (Lisp_Object family, Lisp_Object registry, Lisp_Objec
 #define LGSTRING_GLYPH_SIZE 8
 
 static int
-check_gstring (gstring)
-     Lisp_Object gstring;
+check_gstring (Lisp_Object gstring)
 {
   Lisp_Object val;
   int i, j;
@@ -1793,8 +1792,7 @@ check_gstring (gstring)
 }
 
 static void
-check_otf_features (otf_features)
-     Lisp_Object otf_features;
+check_otf_features (Lisp_Object otf_features)
 {
   Lisp_Object val;
 
@@ -1827,8 +1825,7 @@ check_otf_features (otf_features)
 Lisp_Object otf_list;
 
 static Lisp_Object
-otf_tag_symbol (tag)
-     OTF_Tag tag;
+otf_tag_symbol (OTF_Tag tag)
 {
   char name[5];
 
@@ -1837,8 +1834,7 @@ otf_tag_symbol (tag)
 }
 
 static OTF *
-otf_open (file)
-     Lisp_Object file;
+otf_open (Lisp_Object file)
 {
   Lisp_Object val = Fassoc (file, otf_list);
   OTF *otf;
@@ -1860,8 +1856,7 @@ otf_open (file)
    (struct font_driver).otf_capability.  */
 
 Lisp_Object
-font_otf_capability (font)
-     struct font *font;
+font_otf_capability (struct font *font)
 {
   OTF *otf;
   Lisp_Object capability = Fcons (Qnil, Qnil);
@@ -1935,9 +1930,7 @@ font_otf_capability (font)
    FEATURES.  */
 
 static void
-generate_otf_features (spec, features)
-     Lisp_Object spec;
-     char *features;
+generate_otf_features (Lisp_Object spec, char *features)
 {
   Lisp_Object val;
   char *p;
@@ -1972,8 +1965,7 @@ generate_otf_features (spec, features)
 }
 
 Lisp_Object
-font_otf_DeviceTable (device_table)
-     OTF_DeviceTable *device_table;
+font_otf_DeviceTable (OTF_DeviceTable *device_table)
 {
   int len = device_table->StartSize - device_table->EndSize + 1;
 
@@ -1982,9 +1974,7 @@ font_otf_DeviceTable (device_table)
 }
 
 Lisp_Object
-font_otf_ValueRecord (value_format, value_record)
-     int value_format;
-     OTF_ValueRecord *value_record;
+font_otf_ValueRecord (int value_format, OTF_ValueRecord *value_record)
 {
   Lisp_Object val = Fmake_vector (make_number (8), Qnil);
 
@@ -2008,8 +1998,7 @@ font_otf_ValueRecord (value_format, value_record)
 }
 
 Lisp_Object
-font_otf_Anchor (anchor)
-     OTF_Anchor *anchor;
+font_otf_Anchor (OTF_Anchor *anchor)
 {
   Lisp_Object val;
 
@@ -3739,8 +3728,9 @@ font_range (EMACS_INT pos, EMACS_INT *limit, struct window *w, struct face *face
       else
         FETCH_STRING_CHAR_ADVANCE_NO_CHECK (c, string, pos, pos_byte);
       category = CHAR_TABLE_REF (Vunicode_category_table, c);
-      if (EQ (category, QCf)
-          || CHAR_VARIATION_SELECTOR_P (c))
+      if (INTEGERP (category)
+          && (XINT (category) == UNICODE_CATEGORY_Cf
+              || CHAR_VARIATION_SELECTOR_P (c)))
         continue;
       if (NILP (font_object))
         {
diff --git a/src/gnutls.c b/src/gnutls.c
index 2a055ac40f0..3761951b866 100644
--- a/src/gnutls.c
+++ b/src/gnutls.c
@@ -143,10 +143,12 @@ static int
 init_gnutls_functions (Lisp_Object libraries)
 {
   HMODULE library;
+  Lisp_Object gnutls_log_level = Fsymbol_value (Qgnutls_log_level);
+  int max_log_level = 1;
 
   if (!(library = w32_delayed_load (libraries, Qgnutls_dll)))
     {
-      GNUTLS_LOG (1, 1, "GnuTLS library not found");
+      GNUTLS_LOG (1, max_log_level, "GnuTLS library not found");
       return 0;
     }
 
@@ -189,7 +191,10 @@ init_gnutls_functions (Lisp_Object libraries)
   LOAD_GNUTLS_FN (library, gnutls_x509_crt_import);
   LOAD_GNUTLS_FN (library, gnutls_x509_crt_init);
 
-  GNUTLS_LOG2 (1, 1, "GnuTLS library loaded:",
+  if (NUMBERP (gnutls_log_level))
+    max_log_level = XINT (gnutls_log_level);
+
+  GNUTLS_LOG2 (1, max_log_level, "GnuTLS library loaded:",
                SDATA (Fget (Qgnutls_dll, QCloaded_from)));
   return 1;
 }
@@ -379,7 +384,7 @@ emacs_gnutls_read (struct Lisp_Process *proc, char *buf, EMACS_INT nbyte)
     /* non-fatal error */
     return -1;
   else {
-    /* a fatal error occured */
+    /* a fatal error occurred */
     return 0;
   }
 }
@@ -638,9 +643,6 @@ certificates for `gnutls-x509pki'.
 :verify-flags is a bitset as per GnuTLS'
 gnutls_certificate_set_verify_flags.
 
-:verify-error, if non-nil, makes failure of the certificate validation
-an error.  Otherwise it will be just a series of warnings.
-
 :verify-hostname-error, if non-nil, makes a hostname mismatch an
 error.  Otherwise it will be just a warning.
 
@@ -1100,36 +1102,35 @@ syms_of_gnutls (void)
 {
   gnutls_global_initialized = 0;
 
-  DEFSYM(Qgnutls_dll, "gnutls");
-  DEFSYM(Qgnutls_log_level, "gnutls-log-level");
-  DEFSYM(Qgnutls_code, "gnutls-code");
-  DEFSYM(Qgnutls_anon, "gnutls-anon");
-  DEFSYM(Qgnutls_x509pki, "gnutls-x509pki");
-  DEFSYM(Qgnutls_bootprop_hostname, ":hostname");
-  DEFSYM(Qgnutls_bootprop_priority, ":priority");
-  DEFSYM(Qgnutls_bootprop_trustfiles, ":trustfiles");
-  DEFSYM(Qgnutls_bootprop_keylist, ":keylist");
-  DEFSYM(Qgnutls_bootprop_crlfiles, ":crlfiles");
-  DEFSYM(Qgnutls_bootprop_callbacks, ":callbacks");
-  DEFSYM(Qgnutls_bootprop_callbacks_verify, "verify");
-  DEFSYM(Qgnutls_bootprop_loglevel, ":loglevel");
-  DEFSYM(Qgnutls_bootprop_verify_flags, ":verify-flags");
-  DEFSYM(Qgnutls_bootprop_verify_hostname_error, ":verify-error");
-  DEFSYM(Qgnutls_bootprop_verify_hostname_error, ":verify-hostname-error");
-
-  DEFSYM(Qgnutls_e_interrupted, "gnutls-e-interrupted");
+  DEFSYM (Qgnutls_dll, "gnutls");
+  DEFSYM (Qgnutls_log_level, "gnutls-log-level");
+  DEFSYM (Qgnutls_code, "gnutls-code");
+  DEFSYM (Qgnutls_anon, "gnutls-anon");
+  DEFSYM (Qgnutls_x509pki, "gnutls-x509pki");
+  DEFSYM (Qgnutls_bootprop_hostname, ":hostname");
+  DEFSYM (Qgnutls_bootprop_priority, ":priority");
+  DEFSYM (Qgnutls_bootprop_trustfiles, ":trustfiles");
+  DEFSYM (Qgnutls_bootprop_keylist, ":keylist");
+  DEFSYM (Qgnutls_bootprop_crlfiles, ":crlfiles");
+  DEFSYM (Qgnutls_bootprop_callbacks, ":callbacks");
+  DEFSYM (Qgnutls_bootprop_callbacks_verify, "verify");
+  DEFSYM (Qgnutls_bootprop_loglevel, ":loglevel");
+  DEFSYM (Qgnutls_bootprop_verify_flags, ":verify-flags");
+  DEFSYM (Qgnutls_bootprop_verify_hostname_error, ":verify-hostname-error");
+
+  DEFSYM (Qgnutls_e_interrupted, "gnutls-e-interrupted");
   Fput (Qgnutls_e_interrupted, Qgnutls_code,
         make_number (GNUTLS_E_INTERRUPTED));
 
-  DEFSYM(Qgnutls_e_again, "gnutls-e-again");
+  DEFSYM (Qgnutls_e_again, "gnutls-e-again");
   Fput (Qgnutls_e_again, Qgnutls_code,
         make_number (GNUTLS_E_AGAIN));
 
-  DEFSYM(Qgnutls_e_invalid_session, "gnutls-e-invalid-session");
+  DEFSYM (Qgnutls_e_invalid_session, "gnutls-e-invalid-session");
   Fput (Qgnutls_e_invalid_session, Qgnutls_code,
         make_number (GNUTLS_E_INVALID_SESSION));
 
-  DEFSYM(Qgnutls_e_not_ready_for_handshake, "gnutls-e-not-ready-for-handshake");
+  DEFSYM (Qgnutls_e_not_ready_for_handshake, "gnutls-e-not-ready-for-handshake");
   Fput (Qgnutls_e_not_ready_for_handshake, Qgnutls_code,
         make_number (GNUTLS_E_APPLICATION_ERROR_MIN));
 
diff --git a/src/gtkutil.c b/src/gtkutil.c
index 48571bef275..1a16246f2b8 100644
--- a/src/gtkutil.c
+++ b/src/gtkutil.c
@@ -633,6 +633,9 @@ qttip_cb (GtkWidget  *widget,
   struct x_output *x = f->output_data.x;
   if (x->ttip_widget == NULL)
     {
+      GtkWidget *p;
+      GList *list, *iter;
+
       g_object_set (G_OBJECT (widget), "has-tooltip", FALSE, NULL);
       x->ttip_widget = tooltip;
       g_object_ref (G_OBJECT (tooltip));
@@ -640,6 +643,18 @@ qttip_cb (GtkWidget  *widget,
       g_object_ref (G_OBJECT (x->ttip_lbl));
       gtk_tooltip_set_custom (tooltip, x->ttip_lbl);
       x->ttip_window = GTK_WINDOW (gtk_widget_get_toplevel (x->ttip_lbl));
+
+      /* Change stupid Gtk+ default line wrapping.  */
+      p = gtk_widget_get_parent (x->ttip_lbl);
+      list = gtk_container_get_children (GTK_CONTAINER (p));
+      for (iter = list; iter; iter = g_list_next (iter))
+        {
+          GtkWidget *w = GTK_WIDGET (iter->data);
+          if (GTK_IS_LABEL (w))
+            gtk_label_set_line_wrap (GTK_LABEL (w), FALSE);
+        }
+      g_list_free (list);
+
       /* ATK needs an empty title for some reason.  */
       gtk_window_set_title (x->ttip_window, "");
       /* Realize so we can safely get screen later on.  */
@@ -659,8 +674,8 @@ qttip_cb (GtkWidget  *widget,
 
 int
 xg_prepare_tooltip (FRAME_PTR f,
-                      Lisp_Object string,
-                      int *width,
+                    Lisp_Object string,
+                    int *width,
                     int *height)
 {
 #ifndef USE_GTK_TOOLTIP
@@ -697,10 +712,9 @@ xg_prepare_tooltip (FRAME_PTR f,
                      (gtk_widget_get_display (GTK_WIDGET (x->ttip_window))),
                      "gdk-display-current-tooltip", NULL);
 
-  /* Put out dummy widget in so we can get callbacks for unrealize and
+  /* Put our dummy widget in so we can get callbacks for unrealize and
      hierarchy-changed.  */
   gtk_tooltip_set_custom (x->ttip_widget, widget);
-
   gtk_tooltip_set_text (x->ttip_widget, SSDATA (encoded_string));
   gtk_widget_get_preferred_size (GTK_WIDGET (x->ttip_window), NULL, &req);
   if (width) *width = req.width;
@@ -731,7 +745,7 @@ xg_show_tooltip (FRAME_PTR f, int root_x, int root_y)
 }
 
 /* Hide tooltip if shown.  Do nothing if not shown.
-   Return non-zero if tip was hidden, non-ero if not (i.e. not using
+   Return non-zero if tip was hidden, non-zero if not (i.e. not using
    system tooltips).  */
 
 int
diff --git a/src/image.c b/src/image.c
index 6e8440fb431..fa39ff12681 100644
--- a/src/image.c
+++ b/src/image.c
@@ -5007,9 +5007,7 @@ pbm_scan_number (unsigned char **s, unsigned char *end)
    occurred.  *SIZE is set to the size of the file.  */
 
 static char *
-pbm_read_file (file, size)
-     Lisp_Object file;
-     int *size;
+pbm_read_file (Lisp_Object file, int *size)
 {
   FILE *fp = NULL;
   char *buf = NULL;
diff --git a/src/indent.c b/src/indent.c
index 02d99d14ded..aaeaaf591ef 100644
--- a/src/indent.c
+++ b/src/indent.c
@@ -725,8 +725,7 @@ current_column_1 (void)
    If END is nil, that stands for the end of STRING.  */
 
 static double
-string_display_width (string, beg, end)
-     Lisp_Object string, beg, end;
+string_display_width (Lisp_Object string, Lisp_Object beg, Lisp_Object end)
 {
   register int col;
   register unsigned char *ptr, *stop;
@@ -1986,9 +1985,11 @@ whether or not it is currently displayed in some window.  */)
   struct text_pos pt;
   struct window *w;
   Lisp_Object old_buffer;
-  struct gcpro gcpro1;
+  EMACS_INT old_charpos IF_LINT (= 0), old_bytepos IF_LINT (= 0);
+  struct gcpro gcpro1, gcpro2, gcpro3;
   Lisp_Object lcols = Qnil;
   double cols IF_LINT (= 0);
+  void *itdata = NULL;
 
   /* Allow LINES to be of the form (HPOS . VPOS) aka (COLUMNS . LINES).  */
   if (CONSP (lines) && (NUMBERP (XCAR (lines))))
@@ -2006,12 +2007,16 @@ whether or not it is currently displayed in some window.  */)
   w = XWINDOW (window);
 
   old_buffer = Qnil;
-  GCPRO1 (old_buffer);
+  GCPRO3 (old_buffer, old_charpos, old_bytepos);
   if (XBUFFER (w->buffer) != current_buffer)
     {
       /* Set the window's buffer temporarily to the current buffer.  */
       old_buffer = w->buffer;
+      old_charpos = XMARKER (w->pointm)->charpos;
+      old_bytepos = XMARKER (w->pointm)->bytepos;
       XSETBUFFER (w->buffer, current_buffer);
+      set_marker_both
+        (w->pointm, w->buffer, BUF_PT (current_buffer), BUF_PT_BYTE (current_buffer));
     }
 
   if (noninteractive)
@@ -2025,6 +2030,7 @@ whether or not it is currently displayed in some window.  */)
       EMACS_INT it_start;
       int first_x, it_overshoot_expected IF_LINT (= 0);
 
+      itdata = bidi_shelve_cache ();
       SET_TEXT_POS (pt, PT, PT_BYTE);
       start_display (&it, w, pt);
       first_x = it.first_visible_x;
@@ -2129,10 +2135,14 @@ whether or not it is currently displayed in some window.  */)
         }
 
       SET_PT_BOTH (IT_CHARPOS (it), IT_BYTEPOS (it));
+      bidi_unshelve_cache (itdata);
     }
 
   if (BUFFERP (old_buffer))
-    w->buffer = old_buffer;
+    {
+      w->buffer = old_buffer;
+      set_marker_both (w->pointm, w->buffer, old_charpos, old_bytepos);
+    }
 
   RETURN_UNGCPRO (make_number (it.vpos));
 }
diff --git a/src/intervals.c b/src/intervals.c
index 4de001f2ffc..2063655cdb9 100644
--- a/src/intervals.c
+++ b/src/intervals.c
@@ -247,8 +247,7 @@ static int zero_length;
 INTERVAL search_interval, found_interval;
 
 void
-check_for_interval (i)
-     register INTERVAL i;
+check_for_interval (INTERVAL i)
 {
   if (i == search_interval)
     {
@@ -258,8 +257,7 @@ check_for_interval (i)
 }
 
 INTERVAL
-search_for_interval (i, tree)
-     register INTERVAL i, tree;
+search_for_interval (INTERVAL i, INTERVAL tree)
 {
   icount = 0;
   search_interval = i;
@@ -269,8 +267,7 @@ search_for_interval (i, tree)
 }
 
 static void
-inc_interval_count (i)
-     INTERVAL i;
+inc_interval_count (INTERVAL i)
 {
   icount++;
   if (LENGTH (i) == 0)
@@ -280,8 +277,7 @@ inc_interval_count (i)
 }
 
 int
-count_intervals (i)
-     register INTERVAL i;
+count_intervals (INTERVAL i)
 {
   icount = 0;
   idepth = 0;
@@ -292,8 +288,7 @@ count_intervals (i)
 }
 
 static INTERVAL
-root_interval (interval)
-     INTERVAL interval;
+root_interval (INTERVAL interval)
 {
   register INTERVAL i = interval;
 
@@ -804,9 +799,8 @@ update_interval (register INTERVAL i, EMACS_INT pos)
    to the root.  */
 
 static INTERVAL
-adjust_intervals_for_insertion (tree, position, length)
-     INTERVAL tree;
-     EMACS_INT position, length;
+adjust_intervals_for_insertion (INTERVAL tree, EMACS_INT position,
+                                EMACS_INT length)
 {
   register EMACS_INT relative_position;
   register INTERVAL this;
@@ -1615,9 +1609,7 @@ reproduce_tree_obj (INTERVAL source, Lisp_Object parent)
    interval.  */
 
 static INTERVAL
-make_new_interval (intervals, start, length)
-     INTERVAL intervals;
-     EMACS_INT start, length;
+make_new_interval (INTERVAL intervals, EMACS_INT start, EMACS_INT length)
 {
   INTERVAL slot;
 
diff --git a/src/keyboard.c b/src/keyboard.c
index 2d9643d455c..60c6283dab5 100644
--- a/src/keyboard.c
+++ b/src/keyboard.c
@@ -1540,7 +1540,18 @@ command_loop_1 (void)
           message_with_string ("%s is undefined", keys, 0);
           KVAR (current_kboard, defining_kbd_macro) = Qnil;
           update_mode_lines = 1;
-          KVAR (current_kboard, Vprefix_arg) = Qnil;
+          /* If this is a down-mouse event, don't reset prefix-arg;
+             pass it to the command run by the up event.  */
+          if (EVENT_HAS_PARAMETERS (last_command_event))
+            {
+              Lisp_Object breakdown
+                = parse_modifiers (EVENT_HEAD (last_command_event));
+              int modifiers = XINT (XCAR (XCDR (breakdown)));
+              if (!(modifiers & down_modifier))
+                KVAR (current_kboard, Vprefix_arg) = Qnil;
+            }
+          else
+            KVAR (current_kboard, Vprefix_arg) = Qnil;
         }
       else
         {
@@ -7478,7 +7489,7 @@ menu_bar_items (Lisp_Object old)
         if (CONSP (def))
           {
             menu_bar_one_keymap_changed_items = Qnil;
-            map_keymap (def, menu_bar_item, Qnil, NULL, 1);
+            map_keymap_canonical (def, menu_bar_item, Qnil, NULL);
           }
       }
 
@@ -7819,7 +7830,7 @@ parse_menu_item (Lisp_Object item, int inmenubar)
   /* If we got no definition, this item is just unselectable text which
      is OK in a submenu but not in the menubar.  */
   if (NILP (def))
-    return (inmenubar ? 0 : 1);
+    return (!inmenubar);
 
   /* See if this is a separate pane or a submenu.  */
   def = AREF (item_properties, ITEM_PROPERTY_DEF);
@@ -10640,7 +10651,8 @@ DEFUN ("recursion-depth", Frecursion_depth, Srecursion_depth, 0, 0, 0,
 DEFUN ("open-dribble-file", Fopen_dribble_file, Sopen_dribble_file, 1, 1,
        "FOpen dribble file: ",
        doc: /* Start writing all keyboard characters to a dribble file called FILE.
-If FILE is nil, close any open dribble file.  */)
+If FILE is nil, close any open dribble file.
+The file will be closed when Emacs exits.  */)
   (Lisp_Object file)
 {
   if (dribble)
diff --git a/src/keymap.c b/src/keymap.c
index ac7f651e283..0169276bef9 100644
--- a/src/keymap.c
+++ b/src/keymap.c
@@ -16,6 +16,27 @@ GNU General Public License for more details.
 You should have received a copy of the GNU General Public License
 along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 
+/* Old BUGS:
+   - [M-C-a] != [?\M-\C-a]
+   - [M-f2] != [?\e f2].
+   - (define-key map [menu-bar foo] <bla>) does not always place <bla>
+     at the head of the menu (if `foo' was already bound earlier and
+     then unbound, for example).
+   TODO:
+   - allow many more Meta -> ESC mappings (like Hyper -> C-e for Emacspeak)
+   - Think about the various defaulting that's currently hard-coded in
+     keyboard.c (uppercase->lowercase, char->charset, button-events, ...)
+     and make it more generic.  Maybe we should allow mappings of the
+     form (PREDICATE . BINDING) as generalization of the default binding,
+     tho probably a cleaner way to attack this is to allow functional
+     keymaps (i.e. keymaps that are implemented as functions that implement
+     a few different methods like `lookup', `map', ...).
+   - Make [a] equivalent to [?a].
+   BEWARE:
+   - map-keymap should work meaningfully even if entries are added/removed
+     to the keymap while iterating through it:
+       start - removed <= visited <= start + added
+ */
 
 #include <config.h>
 #include <stdio.h>
@@ -73,7 +94,6 @@ static Lisp_Object where_is_cache_keymaps;
 
 static Lisp_Object Flookup_key (Lisp_Object, Lisp_Object, Lisp_Object);
 static Lisp_Object store_in_keymap (Lisp_Object, Lisp_Object, Lisp_Object);
-static void fix_submap_inheritance (Lisp_Object, Lisp_Object, Lisp_Object);
 
 static Lisp_Object define_as_prefix (Lisp_Object, Lisp_Object);
 static void describe_command (Lisp_Object, Lisp_Object);
@@ -130,6 +150,17 @@ in case you use it as a menu with `x-popup-menu'.  */)
   return Fcons (Qkeymap, Qnil);
 }
 
+DEFUN ("make-composed-keymap", Fmake_composed_keymap, Smake_composed_keymap,
+       0, MANY, 0,
+       doc: /* Construct and return a new keymap composed of KEYMAPS.
+When looking up a key in the returned map, the key is looked in each
+keymap in turn until a binding is found.
+usage: (make-composed-keymap &rest KEYMAPS)  */)
+  (ptrdiff_t nargs, Lisp_Object *args)
+{
+  return Fcons (Qkeymap, Flist (nargs, args));
+}
+
 /* This function is used for installing the standard key bindings
    at initialization time.
 
@@ -174,6 +205,12 @@ when reading a key-sequence to be looked-up in this keymap.  */)
       Lisp_Object tem = XCAR (map);
       if (STRINGP (tem))
         return tem;
+      else if (KEYMAPP (tem))
+        {
+          tem = Fkeymap_prompt (tem);
+          if (!NILP (tem))
+            return tem;
+        }
       map = XCDR (map);
     }
   return Qnil;
@@ -300,23 +337,16 @@ Return PARENT.  PARENT should be nil or another keymap.  */)
 {
   Lisp_Object list, prev;
   struct gcpro gcpro1, gcpro2;
-  int i;
 
-  /* Force a keymap flush for the next call to where-is.
-     Since this can be called from within where-is, we don't set where_is_cache
-     directly but only where_is_cache_keymaps, since where_is_cache shouldn't
-     be changed during where-is, while where_is_cache_keymaps is only used at
-     the very beginning of where-is and can thus be changed here without any
-     adverse effect.
-     This is a very minor correctness (rather than safety) issue.  */
-  where_is_cache_keymaps = Qt;
+  /* Flush any reverse-map cache.  */
+  where_is_cache = Qnil; where_is_cache_keymaps = Qt;
 
   GCPRO2 (keymap, parent);
   keymap = get_keymap (keymap, 1, 1);
 
   if (!NILP (parent))
     {
-      parent = get_keymap (parent, 1, 1);
+      parent = get_keymap (parent, 1, 0);
 
       /* Check for cycles.  */
       if (keymap_memberp (keymap, parent))
@@ -332,121 +362,35 @@ Return PARENT.  PARENT should be nil or another keymap.  */)
          If we came to the end, add the parent in PREV.  */
       if (!CONSP (list) || KEYMAPP (list))
         {
-          /* If we already have the right parent, return now
-             so that we avoid the loops below.  */
-          if (EQ (XCDR (prev), parent))
-            RETURN_UNGCPRO (parent);
-
           CHECK_IMPURE (prev);
           XSETCDR (prev, parent);
-          break;
+          RETURN_UNGCPRO (parent);
         }
       prev = list;
     }
-
-  /* Scan through for submaps, and set their parents too.  */
-
-  for (list = XCDR (keymap); CONSP (list); list = XCDR (list))
-    {
-      /* Stop the scan when we come to the parent.  */
-      if (EQ (XCAR (list), Qkeymap))
-        break;
-
-      /* If this element holds a prefix map, deal with it.  */
-      if (CONSP (XCAR (list))
-          && CONSP (XCDR (XCAR (list))))
-        fix_submap_inheritance (keymap, XCAR (XCAR (list)),
-                                XCDR (XCAR (list)));
-
-      if (VECTORP (XCAR (list)))
-        for (i = 0; i < ASIZE (XCAR (list)); i++)
-          if (CONSP (XVECTOR (XCAR (list))->contents[i]))
-            fix_submap_inheritance (keymap, make_number (i),
-                                    XVECTOR (XCAR (list))->contents[i]);
-
-      if (CHAR_TABLE_P (XCAR (list)))
-        {
-          map_char_table (fix_submap_inheritance, Qnil, XCAR (list), keymap);
-        }
-    }
-
-  RETURN_UNGCPRO (parent);
-}
-
-/* EVENT is defined in MAP as a prefix, and SUBMAP is its definition.
-   if EVENT is also a prefix in MAP's parent,
-   make sure that SUBMAP inherits that definition as its own parent.  */
-
-static void
-fix_submap_inheritance (Lisp_Object map, Lisp_Object event, Lisp_Object submap)
-{
-  Lisp_Object map_parent, parent_entry;
-
-  /* SUBMAP is a cons that we found as a key binding.
-     Discard the other things found in a menu key binding.  */
-
-  submap = get_keymap (get_keyelt (submap, 0), 0, 0);
-
-  /* If it isn't a keymap now, there's no work to do.  */
-  if (!CONSP (submap))
-    return;
-
-  map_parent = keymap_parent (map, 0);
-  if (!NILP (map_parent))
-    parent_entry =
-      get_keymap (access_keymap (map_parent, event, 0, 0, 0), 0, 0);
-  else
-    parent_entry = Qnil;
-
-  /* If MAP's parent has something other than a keymap,
-     our own submap shadows it completely.  */
-  if (!CONSP (parent_entry))
-    return;
-
-  if (! EQ (parent_entry, submap))
-    {
-      Lisp_Object submap_parent;
-      submap_parent = submap;
-      while (1)
-        {
-          Lisp_Object tem;
-
-          tem = keymap_parent (submap_parent, 0);
-
-          if (KEYMAPP (tem))
-            {
-              if (keymap_memberp (tem, parent_entry))
-                /* Fset_keymap_parent could create a cycle.  */
-                return;
-              submap_parent = tem;
-            }
-          else
-            break;
-        }
-      Fset_keymap_parent (submap_parent, parent_entry);
-    }
 }
 
+
 /* Look up IDX in MAP.  IDX may be any sort of event.
    Note that this does only one level of lookup; IDX must be a single
    event, not a sequence.
 
+   MAP must be a keymap or a list of keymaps.
+
    If T_OK is non-zero, bindings for Qt are treated as default
    bindings; any key left unmentioned by other tables and bindings is
    given the binding of Qt.
 
    If T_OK is zero, bindings for Qt are not treated specially.
 
-   If NOINHERIT, don't accept a subkeymap found in an inherited keymap.  */
-
-Lisp_Object
-access_keymap (Lisp_Object map, Lisp_Object idx, int t_ok, int noinherit, int autoload)
-{
-  Lisp_Object val;
+   If NOINHERIT, don't accept a subkeymap found in an inherited keymap.
 
-  /* Qunbound in VAL means we have found no binding yet.  */
-  val = Qunbound;
+   Returns Qunbound if no binding was found (and returns Qnil if a nil
+   binding was found).  */
 
+static Lisp_Object
+access_keymap_1 (Lisp_Object map, Lisp_Object idx, int t_ok, int noinherit, int autoload)
+{
   /* If idx is a list (some sort of mouse click, perhaps?),
      the index we want to use is the car of the list, which
      ought to be a symbol.  */
@@ -461,21 +405,21 @@ access_keymap (Lisp_Object map, Lisp_Object idx, int t_ok, int noinherit, int au
        with more than 24 bits of integer.  */
     XSETFASTINT (idx, XINT (idx) & (CHAR_META | (CHAR_META - 1)));
 
-  /* Handle the special meta -> esc mapping. */
+  /* Handle the special meta -> esc mapping.  */
   if (INTEGERP (idx) && XFASTINT (idx) & meta_modifier)
     {
       /* See if there is a meta-map.  If there's none, there is
          no binding for IDX, unless a default binding exists in MAP.  */
       struct gcpro gcpro1;
-      Lisp_Object event_meta_map;
+      Lisp_Object event_meta_binding, event_meta_map;
       GCPRO1 (map);
       /* A strange value in which Meta is set would cause
          infinite recursion.  Protect against that.  */
       if (XINT (meta_prefix_char) & CHAR_META)
         meta_prefix_char = make_number (27);
-      event_meta_map = get_keymap (access_keymap (map, meta_prefix_char,
-                                                  t_ok, noinherit, autoload),
-                                   0, autoload);
+      event_meta_binding = access_keymap_1 (map, meta_prefix_char, t_ok,
+                                            noinherit, autoload);
+      event_meta_map = get_keymap (event_meta_binding, 0, autoload);
       UNGCPRO;
       if (CONSP (event_meta_map))
         {
@@ -486,8 +430,8 @@ access_keymap (Lisp_Object map, Lisp_Object idx, int t_ok, int noinherit, int au
         /* Set IDX to t, so that we only find a default binding.  */
         idx = Qt;
       else
-        /* We know there is no binding.  */
-        return Qnil;
+        /* An explicit nil binding, or no binding at all.  */
+        return NILP (event_meta_binding) ? Qnil : Qunbound;
     }
 
   /* t_binding is where we put a default binding that applies,
@@ -495,25 +439,52 @@ access_keymap (Lisp_Object map, Lisp_Object idx, int t_ok, int noinherit, int au
      for this key sequence.  */
   {
     Lisp_Object tail;
-    Lisp_Object t_binding = Qnil;
+    Lisp_Object t_binding = Qunbound;
+    Lisp_Object retval = Qunbound;
+    Lisp_Object retval_tail = Qnil;
     struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
 
-    GCPRO4 (map, tail, idx, t_binding);
+    GCPRO4 (tail, idx, t_binding, retval);
 
-    for (tail = XCDR (map);
+    for (tail = (CONSP (map) && EQ (Qkeymap, XCAR (map))) ? XCDR (map) : map;
          (CONSP (tail)
           || (tail = get_keymap (tail, 0, autoload), CONSP (tail)));
          tail = XCDR (tail))
       {
-        Lisp_Object binding;
+        /* Qunbound in VAL means we have found no binding.  */
+        Lisp_Object val = Qunbound;
+        Lisp_Object binding = XCAR (tail);
+        Lisp_Object submap = get_keymap (binding, 0, autoload);
 
-        binding = XCAR (tail);
-        if (SYMBOLP (binding))
+        if (EQ (binding, Qkeymap))
+          {
+            if (noinherit || NILP (retval))
+              /* If NOINHERIT, stop here, the rest is inherited.  */
+              break;
+            else if (!EQ (retval, Qunbound))
+              {
+                Lisp_Object parent_entry;
+                eassert (KEYMAPP (retval));
+                parent_entry
+                  = get_keymap (access_keymap_1 (tail, idx,
+                                                 t_ok, 0, autoload),
+                                0, autoload);
+                if (KEYMAPP (parent_entry))
+                  {
+                    if (CONSP (retval_tail))
+                      XSETCDR (retval_tail, parent_entry);
+                    else
+                      {
+                        retval_tail = Fcons (retval, parent_entry);
+                        retval = Fcons (Qkeymap, retval_tail);
+                      }
+                  }
+                break;
+              }
+          }
+        else if (CONSP (submap))
           {
-            /* If NOINHERIT, stop finding prefix definitions
-               after we pass a second occurrence of the `keymap' symbol.  */
-            if (noinherit && EQ (binding, Qkeymap))
-              RETURN_UNGCPRO (Qnil);
+            val = access_keymap_1 (submap, idx, t_ok, noinherit, autoload);
           }
         else if (CONSP (binding))
           {
@@ -556,23 +527,47 @@ access_keymap (Lisp_Object map, Lisp_Object idx, int t_ok, int noinherit, int au
                  (i.e. it shadows any parent binding but not bindings in
                  keymaps of lower precedence).  */
               val = Qnil;
+
             val = get_keyelt (val, autoload);
-            if (KEYMAPP (val))
-              fix_submap_inheritance (map, idx, val);
-            RETURN_UNGCPRO (val);
+
+            if (!KEYMAPP (val))
+              {
+                if (NILP (retval) || EQ (retval, Qunbound))
+                  retval = val;
+                if (!NILP (val))
+                  break;  /* Shadows everything that follows.  */
+              }
+            else if (NILP (retval) || EQ (retval, Qunbound))
+              retval = val;
+            else if (CONSP (retval_tail))
+              {
+                XSETCDR (retval_tail, Fcons (val, Qnil));
+                retval_tail = XCDR (retval_tail);
+              }
+            else
+              {
+                retval_tail = Fcons (val, Qnil);
+                retval = Fcons (Qkeymap, Fcons (retval, retval_tail));
+              }
           }
         QUIT;
       }
     UNGCPRO;
-    return get_keyelt (t_binding, autoload);
+    return EQ (Qunbound, retval) ? get_keyelt (t_binding, autoload) : retval;
   }
 }
 
+Lisp_Object
+access_keymap (Lisp_Object map, Lisp_Object idx,
+               int t_ok, int noinherit, int autoload)
+{
+  Lisp_Object val = access_keymap_1 (map, idx, t_ok, noinherit, autoload);
+  return EQ (val, Qunbound) ? Qnil : val;
+}
+
 static void
 map_keymap_item (map_keymap_function_t fun, Lisp_Object args, Lisp_Object key, Lisp_Object val, void *data)
 {
-  /* We should maybe try to detect bindings shadowed by previous
-     ones and things like that.  */
   if (EQ (val, Qt))
     val = Qnil;
   (*fun) (key, val, args, data);
@@ -583,8 +578,8 @@ map_keymap_char_table_item (Lisp_Object args, Lisp_Object key, Lisp_Object val)
 {
   if (!NILP (val))
     {
-      map_keymap_function_t fun =
-        (map_keymap_function_t) XSAVE_VALUE (XCAR (args))->pointer;
+      map_keymap_function_t fun
+        = (map_keymap_function_t) XSAVE_VALUE (XCAR (args))->pointer;
       args = XCDR (args);
       /* If the key is a range, make a copy since map_char_table modifies
          it in place.  */
@@ -612,7 +607,9 @@ map_keymap_internal (Lisp_Object map,
     {
       Lisp_Object binding = XCAR (tail);
 
-      if (CONSP (binding))
+      if (KEYMAPP (binding))    /* An embedded parent.  */
+        break;
+      else if (CONSP (binding))
         map_keymap_item (fun, args, XCAR (binding), XCDR (binding), data);
       else if (VECTORP (binding))
         {
@@ -644,7 +641,7 @@ map_keymap_call (Lisp_Object key, Lisp_Object val, Lisp_Object fun, void *dummy)
   call2 (fun, key, val);
 }
 
-/* Same as map_keymap_internal, but doesn't traverses parent keymaps as well.
+/* Same as map_keymap_internal, but traverses parent keymaps as well.
    A non-zero AUTOLOAD indicates that autoloaded keymaps should be loaded.  */
 void
 map_keymap (Lisp_Object map, map_keymap_function_t fun, Lisp_Object args, void *data, int autoload)
@@ -654,8 +651,15 @@ map_keymap (Lisp_Object map, map_keymap_function_t fun, Lisp_Object args, void *
   map = get_keymap (map, 1, autoload);
   while (CONSP (map))
     {
-      map = map_keymap_internal (map, fun, args, data);
-      map = get_keymap (map, 0, autoload);
+      if (KEYMAPP (XCAR (map)))
+        {
+          map_keymap (XCAR (map), fun, args, data, autoload);
+          map = XCDR (map);
+        }
+      else
+        map = map_keymap_internal (map, fun, args, data);
+      if (!CONSP (map))
+        map = get_keymap (map, 0, autoload);
     }
   UNGCPRO;
 }
@@ -791,16 +795,10 @@ get_keyelt (Lisp_Object object, int autoload)
         }
 
       /* If the contents are (KEYMAP . ELEMENT), go indirect.  */
+      else if (KEYMAPP (XCAR (object)))
+        error ("Wow, indirect keymap entry!!");
       else
-        {
-          struct gcpro gcpro1;
-          Lisp_Object map;
-          GCPRO1 (object);
-          map = get_keymap (Fcar_safe (object), 0, autoload);
-          UNGCPRO;
-          return (!CONSP (map) ? object /* Invalid keymap */
-                  : access_keymap (map, Fcdr (object), 0, 0, autoload));
-        }
+        return object;
     }
 }
 
@@ -811,6 +809,9 @@ store_in_keymap (Lisp_Object keymap, register Lisp_Object idx, Lisp_Object def)
   where_is_cache = Qnil;
   where_is_cache_keymaps = Qt;
 
+  if (EQ (idx, Qkeymap))
+    error ("`keymap' is reserved for embedded parent maps");
+
   /* If we are preparing to dump, and DEF is a menu element
      with a menu item indicator, copy it to ensure it is not pure.  */
   if (CONSP (def) && PURE_P (def)
@@ -903,7 +904,16 @@ store_in_keymap (Lisp_Object keymap, register Lisp_Object idx, Lisp_Object def)
           }
         else if (CONSP (elt))
           {
-            if (EQ (idx, XCAR (elt)))
+            if (EQ (Qkeymap, XCAR (elt)))
+              { /* A sub keymap.  This might be due to a lookup that found
+                   two matching bindings (maybe because of a sub keymap).
+                   It almost never happens (since the second binding normally
+                   only happens in the inherited part of the keymap), but
+                   if it does, we want to update the sub-keymap since the
+                   main one might be temporary (built by access_keymap).  */
+                tail = insertion_point = elt;
+              }
+            else if (EQ (idx, XCAR (elt)))
               {
                 CHECK_IMPURE (elt);
                 XSETCDR (elt, def);
@@ -1068,7 +1078,13 @@ is not copied.  */)
             ASET (elt, i, copy_keymap_item (AREF (elt, i)));
         }
       else if (CONSP (elt))
-        elt = Fcons (XCAR (elt), copy_keymap_item (XCDR (elt)));
+        {
+          if (EQ (XCAR (elt), Qkeymap))
+            /* This is a sub keymap.  */
+            elt = Fcopy_keymap (elt);
+          else
+            elt = Fcons (XCAR (elt), copy_keymap_item (XCDR (elt)));
+        }
       XSETCDR (tail, Fcons (elt, Qnil));
       tail = XCDR (tail);
       keymap = XCDR (keymap);
@@ -1234,23 +1250,15 @@ remapping in all currently active keymaps.  */)
   ASET (command_remapping_vector, 1, command);
 
   if (NILP (keymaps))
-    return Fkey_binding (command_remapping_vector, Qnil, Qt, position);
+    command = Fkey_binding (command_remapping_vector, Qnil, Qt, position);
   else
-    {
-      Lisp_Object maps, binding;
-
-      for (maps = keymaps; CONSP (maps); maps = XCDR (maps))
-        {
-          binding = Flookup_key (XCAR (maps), command_remapping_vector, Qnil);
-          if (!NILP (binding) && !INTEGERP (binding))
-            return binding;
-        }
-      return Qnil;
-    }
+    command = Flookup_key (Fcons (Qkeymap, keymaps),
+                           command_remapping_vector, Qnil);
+  return INTEGERP (command) ? Qnil : command;
 }
 
 /* Value is number if KEY is too long; nil if valid but has no definition. */
-/* GC is possible in this function if it autoloads a keymap.  */
+/* GC is possible in this function.  */
 
 DEFUN ("lookup-key", Flookup_key, Slookup_key, 2, 3, 0,
        doc: /* In keymap KEYMAP, look up key sequence KEY.  Return the definition.
@@ -1325,10 +1333,6 @@ define_as_prefix (Lisp_Object keymap, Lisp_Object c)
   Lisp_Object cmd;
 
   cmd = Fmake_sparse_keymap (Qnil);
-  /* If this key is defined as a prefix in an inherited keymap,
-     make it a prefix in this map, and make its definition
-     inherit the other prefix definition.  */
-  cmd = nconc2 (cmd, access_keymap (keymap, c, 0, 0, 0));
   store_in_keymap (keymap, c, cmd);
 
   return cmd;
@@ -1530,7 +1534,7 @@ like in the respective argument of `key-binding'. */)
 {
   int count = SPECPDL_INDEX ();
 
-  Lisp_Object keymaps;
+  Lisp_Object keymaps = Fcons (current_global_map, Qnil);
 
   /* If a mouse click position is given, our variables are based on
      the buffer clicked on, not the current buffer.  So we may have to
@@ -1560,12 +1564,11 @@ like in the respective argument of `key-binding'. */)
         }
     }
 
-  keymaps = Fcons (current_global_map, Qnil);
-
   if (!NILP (olp))
     {
       if (!NILP (KVAR (current_kboard, Voverriding_terminal_local_map)))
-        keymaps = Fcons (KVAR (current_kboard, Voverriding_terminal_local_map), keymaps);
+        keymaps = Fcons (KVAR (current_kboard, Voverriding_terminal_local_map),
+                         keymaps);
       /* The doc said that overriding-terminal-local-map should
          override overriding-local-map.  The code used them both,
          but it seems clearer to use just one.  rms, jan 2005.  */
@@ -1576,23 +1579,19 @@ like in the respective argument of `key-binding'. */)
     {
       Lisp_Object *maps;
       int nmaps, i;
-
-      Lisp_Object keymap, local_map;
-      EMACS_INT pt;
-
-      pt = INTEGERP (position) ? XINT (position)
+      EMACS_INT pt
+        = INTEGERP (position) ? XINT (position)
         : MARKERP (position) ? marker_position (position)
         : PT;
-
-      /* Get the buffer local maps, possibly overriden by text or
-         overlay properties */
-
-      local_map = get_local_map (pt, current_buffer, Qlocal_map);
-      keymap = get_local_map (pt, current_buffer, Qkeymap);
+      /* This usually returns the buffer's local map,
+         but that can be overridden by a `local-map' property.  */
+      Lisp_Object local_map = get_local_map (pt, current_buffer, Qlocal_map);
+      /* This returns nil unless there is a `keymap' property.  */
+      Lisp_Object keymap = get_local_map (pt, current_buffer, Qkeymap);
 
       if (CONSP (position))
         {
-          Lisp_Object string;
+          Lisp_Object string = POSN_STRING (position);
 
           /* For a mouse click, get the local text-property keymap
              of the place clicked on, rather than point.  */
@@ -1619,8 +1618,7 @@ like in the respective argument of `key-binding'. */)
              consider `local-map' and `keymap' properties of
              that string.  */
 
-          if (string = POSN_STRING (position),
-              (CONSP (string) && STRINGP (XCAR (string))))
+          if (CONSP (string) && STRINGP (XCAR (string)))
             {
               Lisp_Object pos, map;
 
@@ -1691,12 +1689,7 @@ specified buffer position instead of point are used.
   */)
   (Lisp_Object key, Lisp_Object accept_default, Lisp_Object no_remap, Lisp_Object position)
 {
-  Lisp_Object *maps, value;
-  int nmaps, i;
-  struct gcpro gcpro1, gcpro2;
-  int count = SPECPDL_INDEX ();
-
-  GCPRO2 (key, position);
+  Lisp_Object value;
 
   if (NILP (position) && VECTORP (key))
     {
@@ -1715,145 +1708,9 @@ specified buffer position instead of point are used.
         }
     }
 
-  /* Key sequences beginning with mouse clicks
-     are read using the keymaps of the buffer clicked on, not
-     the current buffer.  So we may have to switch the buffer
-     here. */
-
-  if (CONSP (position))
-    {
-      Lisp_Object window;
+  value = Flookup_key (Fcons (Qkeymap, Fcurrent_active_maps (Qt, position)),
+                       key, accept_default);
 
-      window = POSN_WINDOW (position);
-
-      if (WINDOWP (window)
-          && BUFFERP (XWINDOW (window)->buffer)
-          && XBUFFER (XWINDOW (window)->buffer) != current_buffer)
-        {
-          /* Arrange to go back to the original buffer once we're done
-             processing the key sequence.  We don't use
-             save_excursion_{save,restore} here, in analogy to
-             `read-key-sequence' to avoid saving point.  Maybe this
-             would not be a problem here, but it is easier to keep
-             things the same.
-          */
-
-          record_unwind_protect (Fset_buffer, Fcurrent_buffer ());
-
-          set_buffer_internal (XBUFFER (XWINDOW (window)->buffer));
-        }
-    }
-
-  if (! NILP (KVAR (current_kboard, Voverriding_terminal_local_map)))
-    {
-      value = Flookup_key (KVAR (current_kboard, Voverriding_terminal_local_map),
-                           key, accept_default);
-      if (! NILP (value) && !INTEGERP (value))
-        goto done;
-    }
-  else if (! NILP (Voverriding_local_map))
-    {
-      value = Flookup_key (Voverriding_local_map, key, accept_default);
-      if (! NILP (value) && !INTEGERP (value))
-        goto done;
-    }
-  else
-    {
-      Lisp_Object keymap, local_map;
-      EMACS_INT pt;
-
-      pt = INTEGERP (position) ? XINT (position)
-        : MARKERP (position) ? marker_position (position)
-        : PT;
-
-      local_map = get_local_map (pt, current_buffer, Qlocal_map);
-      keymap = get_local_map (pt, current_buffer, Qkeymap);
-
-      if (CONSP (position))
-        {
-          Lisp_Object string;
-
-          /* For a mouse click, get the local text-property keymap
-             of the place clicked on, rather than point.  */
-
-          if (POSN_INBUFFER_P (position))
-            {
-              Lisp_Object pos;
-
-              pos = POSN_BUFFER_POSN (position);
-              if (INTEGERP (pos)
-                  && XINT (pos) >= BEG && XINT (pos) <= Z)
-                {
-                  local_map = get_local_map (XINT (pos),
-                                             current_buffer, Qlocal_map);
-
-                  keymap = get_local_map (XINT (pos),
-                                          current_buffer, Qkeymap);
-                }
-            }
-
-          /* If on a mode line string with a local keymap,
-             or for a click on a string, i.e. overlay string or a
-             string displayed via the `display' property,
-             consider `local-map' and `keymap' properties of
-             that string.  */
-
-          if (string = POSN_STRING (position),
-              (CONSP (string) && STRINGP (XCAR (string))))
-            {
-              Lisp_Object pos, map;
-
-              pos = XCDR (string);
-              string = XCAR (string);
-              if (INTEGERP (pos)
-                  && XINT (pos) >= 0
-                  && XINT (pos) < SCHARS (string))
-                {
-                  map = Fget_text_property (pos, Qlocal_map, string);
-                  if (!NILP (map))
-                    local_map = map;
-
-                  map = Fget_text_property (pos, Qkeymap, string);
-                  if (!NILP (map))
-                    keymap = map;
-                }
-            }
-
-        }
-
-      if (! NILP (keymap))
-        {
-          value = Flookup_key (keymap, key, accept_default);
-          if (! NILP (value) && !INTEGERP (value))
-            goto done;
-        }
-
-      nmaps = current_minor_maps (0, &maps);
-      /* Note that all these maps are GCPRO'd
-         in the places where we found them.  */
-
-      for (i = 0; i < nmaps; i++)
-        if (! NILP (maps[i]))
-          {
-            value = Flookup_key (maps[i], key, accept_default);
-            if (! NILP (value) && !INTEGERP (value))
-              goto done;
-          }
-
-      if (! NILP (local_map))
-        {
-          value = Flookup_key (local_map, key, accept_default);
-          if (! NILP (value) && !INTEGERP (value))
-            goto done;
-        }
-    }
-
-  value = Flookup_key (current_global_map, key, accept_default);
-
- done:
-  unbind_to (count, Qnil);
-
-  UNGCPRO;
   if (NILP (value) || INTEGERP (value))
     return Qnil;
 
@@ -3094,9 +2951,11 @@ You type        Translation\n\
    to look through.
 
    If MENTION_SHADOW is nonzero, then when something is shadowed by SHADOW,
-   don't omit it; instead, mention it but say it is shadowed.  */
+   don't omit it; instead, mention it but say it is shadowed.
 
-void
+   Return whether something was inserted or not.  */
+
+int
 describe_map_tree (Lisp_Object startmap, int partial, Lisp_Object shadow,
                    Lisp_Object prefix, const char *title, int nomenu, int transl,
                    int always_title, int mention_shadow)
@@ -3206,10 +3065,8 @@ key             binding\n\
     skip: ;
     }
 
-  if (something)
-    insert_string ("\n");
-
   UNGCPRO;
+  return something;
 }
 
 static int previous_description_column;
@@ -3829,31 +3686,6 @@ don't alter it yourself.  */);
   Vminibuffer_local_ns_map = Fmake_sparse_keymap (Qnil);
   Fset_keymap_parent (Vminibuffer_local_ns_map, Vminibuffer_local_map);
 
-  DEFVAR_LISP ("minibuffer-local-completion-map", Vminibuffer_local_completion_map,
-               doc: /* Local keymap for minibuffer input with completion.  */);
-  Vminibuffer_local_completion_map = Fmake_sparse_keymap (Qnil);
-  Fset_keymap_parent (Vminibuffer_local_completion_map, Vminibuffer_local_map);
-
-  DEFVAR_LISP ("minibuffer-local-filename-completion-map",
-               Vminibuffer_local_filename_completion_map,
-               doc: /* Local keymap for minibuffer input with completion for filenames.  */);
-  Vminibuffer_local_filename_completion_map = Fmake_sparse_keymap (Qnil);
-  Fset_keymap_parent (Vminibuffer_local_filename_completion_map,
-                      Vminibuffer_local_completion_map);
-
-
-  DEFVAR_LISP ("minibuffer-local-must-match-map", Vminibuffer_local_must_match_map,
-               doc: /* Local keymap for minibuffer input with completion, for exact match.  */);
-  Vminibuffer_local_must_match_map = Fmake_sparse_keymap (Qnil);
-  Fset_keymap_parent (Vminibuffer_local_must_match_map,
-                      Vminibuffer_local_completion_map);
-
-  DEFVAR_LISP ("minibuffer-local-filename-must-match-map",
-               Vminibuffer_local_filename_must_match_map,
-               doc: /* Local keymap for minibuffer input with completion for filenames with exact match.  */);
-  Vminibuffer_local_filename_must_match_map = Fmake_sparse_keymap (Qnil);
-  Fset_keymap_parent (Vminibuffer_local_filename_must_match_map,
-                      Vminibuffer_local_must_match_map);
 
   DEFVAR_LISP ("minor-mode-map-alist", Vminor_mode_map_alist,
                doc: /* Alist of keymaps to use for minor modes.
@@ -3880,11 +3712,11 @@ the same way.  The "active" keymaps in each alist are used before
   Vemulation_mode_map_alists = Qnil;
 
   DEFVAR_LISP ("where-is-preferred-modifier", Vwhere_is_preferred_modifier,
-               doc: /* Preferred modifier to use for `where-is'.
+               doc: /* Preferred modifier key to use for `where-is'.
 When a single binding is requested, `where-is' will return one that
-uses this modifier if possible.  If nil, or if no such binding exists,
-bindings using keys without modifiers (or only with meta) will be
-preferred.  */);
+uses this modifier key if possible.  If nil, or if no such binding
+exists, bindings using keys without modifiers (or only with meta) will
+be preferred.  */);
   Vwhere_is_preferred_modifier = Qnil;
   where_is_preferred_modifier = 0;
 
@@ -3922,6 +3754,7 @@ preferred.  */);
   defsubr (&Sset_keymap_parent);
   defsubr (&Smake_keymap);
   defsubr (&Smake_sparse_keymap);
+  defsubr (&Smake_composed_keymap);
   defsubr (&Smap_keymap_internal);
   defsubr (&Smap_keymap);
   defsubr (&Scopy_keymap);
diff --git a/src/keymap.h b/src/keymap.h
index 2b9d58b39dc..2c826b64e1f 100644
--- a/src/keymap.h
+++ b/src/keymap.h
@@ -36,8 +36,8 @@ EXFUN (Fcurrent_active_maps, 2);
 extern Lisp_Object access_keymap (Lisp_Object, Lisp_Object, int, int, int);
 extern Lisp_Object get_keymap (Lisp_Object, int, int);
 EXFUN (Fset_keymap_parent, 2);
-extern void describe_map_tree (Lisp_Object, int, Lisp_Object, Lisp_Object,
-                               const char *, int, int, int, int);
+extern int describe_map_tree (Lisp_Object, int, Lisp_Object, Lisp_Object,
+                              const char *, int, int, int, int);
 extern int current_minor_maps (Lisp_Object **, Lisp_Object **);
 extern void initial_define_key (Lisp_Object, int, const char *);
 extern void initial_define_lispy_key (Lisp_Object, const char *, const char *);
diff --git a/src/lread.c b/src/lread.c
index f937fa39f0f..6cb217a21c6 100644
--- a/src/lread.c
+++ b/src/lread.c
@@ -4000,9 +4000,7 @@ defsubr (struct Lisp_Subr *sname)
 
 #ifdef NOTDEF /* use fset in subr.el now */
 void
-defalias (sname, string)
-     struct Lisp_Subr *sname;
-     char *string;
+defalias (struct Lisp_Subr *sname, char *string)
 {
   Lisp_Object sym;
   sym = intern (string);
@@ -4420,9 +4418,11 @@ The remaining ENTRIES in the alist element describe the functions and
 variables defined in that file, the features provided, and the
 features required.  Each entry has the form `(provide . FEATURE)',
 `(require . FEATURE)', `(defun . FUNCTION)', `(autoload . SYMBOL)',
-`(defface . SYMBOL)', or `(t . SYMBOL)'.  In addition, an entry `(t
-. SYMBOL)' may precede an entry `(defun . FUNCTION)', and means that
-SYMBOL was an autoload before this file redefined it as a function.
+`(defface . SYMBOL)', or `(t . SYMBOL)'.  Entries like `(t . SYMBOL)'
+may precede a `(defun . FUNCTION)' entry, and means that SYMBOL was an
+autoload before this file redefined it as a function.  In addition,
+entries may also be single symbols, which means that SYMBOL was
+defined by `defvar' or `defconst'.
 
 During preloading, the file name recorded is relative to the main Lisp
 directory.  These file names are converted to absolute at startup.  */);
diff --git a/src/m/iris4d.h b/src/m/iris4d.h
deleted file mode 100644
index 881f71f846f..00000000000
--- a/src/m/iris4d.h
+++ /dev/null
@@ -1,26 +0,0 @@
-/* machine description file for Iris-4D machines.  Use with s/irix*.h.
-
-Copyright (C) 1987, 2001-2011  Free Software Foundation, Inc.
-
-This file is part of GNU Emacs.
-
-GNU Emacs is free software: you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation, either version 3 of the License, or
-(at your option) any later version.
-
-GNU Emacs is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License
-along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
-
-
-/* DATA_SEG_BITS forces extra bits to be or'd in with any pointers which
-   were stored in a Lisp_Object (as Emacs uses fewer than 32 bits for
-   the value field of a LISP_OBJECT).  */
-#define DATA_START 0x10000000
-#define DATA_SEG_BITS   0x10000000
-
diff --git a/src/nsfns.m b/src/nsfns.m
index cdf350066be..0452086201e 100644
--- a/src/nsfns.m
+++ b/src/nsfns.m
@@ -162,7 +162,7 @@ check_ns_display_info (Lisp_Object frame)
       struct terminal *t = get_terminal (frame, 1);
 
       if (t->type != output_ns)
-        error ("Terminal %d is not a Nextstep display", XINT (frame));
+        error ("Terminal %ld is not a Nextstep display", (long) XINT (frame));
 
       return t->display_info.ns;
     }
@@ -1728,8 +1728,9 @@ terminate Emacs if we can't open the connection.
 
   /* Register our external input/output types, used for determining
      applicable services and also drag/drop eligibility. */
-  ns_send_types = [[NSArray arrayWithObject: NSStringPboardType] retain];
-  ns_return_types = [[NSArray arrayWithObject: NSStringPboardType] retain];
+  ns_send_types = [[NSArray arrayWithObjects: NSStringPboardType, nil] retain];
+  ns_return_types = [[NSArray arrayWithObjects: NSStringPboardType, nil]
+                      retain];
   ns_drag_types = [[NSArray arrayWithObjects:
                             NSStringPboardType,
                             NSTabularTextPboardType,
@@ -1876,6 +1877,10 @@ DEFUN ("ns-list-services", Fns_list_services, Sns_list_services, 0, 0, 0,
        doc: /* List available Nextstep services by querying NSApp.  */)
      (void)
 {
+#if defined (NS_IMPL_COCOA) && MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_6
+  /* You can't get services like this in 10.6+.  */
+  return Qnil;
+#else
   Lisp_Object ret = Qnil;
   NSMenu *svcs;
   id delegate;
@@ -1919,6 +1924,7 @@ DEFUN ("ns-list-services", Fns_list_services, Sns_list_services, 0, 0, 0,
 
   ret = interpret_services_menu (svcs, Qnil, ret);
   return ret;
+#endif
 }
 
 
diff --git a/src/nsgui.h b/src/nsgui.h
index a6955630941..999dc27e310 100644
--- a/src/nsgui.h
+++ b/src/nsgui.h
@@ -30,6 +30,8 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #undef init_process
 #endif  /* NS_IMPL_COCOA */
 
+#undef verify
+
 #import <AppKit/AppKit.h>
 
 #ifdef NS_IMPL_COCOA
@@ -44,6 +46,9 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 
 #endif /* __OBJC__ */
 
+#undef verify
+#undef _GL_VERIFY_H
+#include <verify.h>
 
 /* menu-related */
 #define free_widget_value(wv) xfree (wv)
diff --git a/src/nsimage.m b/src/nsimage.m
index c38cefdc5d5..2cb0c3bff76 100644
--- a/src/nsimage.m
+++ b/src/nsimage.m
@@ -189,7 +189,11 @@ static EmacsImage *ImageList = nil;
   image = [[EmacsImage alloc] initByReferencingFile:
                      [NSString stringWithUTF8String: SDATA (found)]];
 
+#if defined (NS_IMPL_COCOA) && MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_6
+  imgRep = [NSBitmapImageRep imageRepWithData:[image TIFFRepresentation]];
+#else
   imgRep = [image bestRepresentationForDevice: nil];
+#endif
   if (imgRep == nil)
     {
       [image release];
diff --git a/src/nsmenu.m b/src/nsmenu.m
index 2a2f952e751..6a9ee7dd4f5 100644
--- a/src/nsmenu.m
+++ b/src/nsmenu.m
@@ -457,7 +457,6 @@ ns_update_menubar (struct frame *f, int deep_p, EmacsMenu *submenu)
             {
               /* but we need to make sure it will update on demand */
               [svcsMenu setFrame: f];
-              [svcsMenu setDelegate: svcsMenu];
             }
           else
 #endif
@@ -696,9 +695,11 @@ set_frame_menubar (struct frame *f, int first_time, int deep_p)
   if ([[self window] isVisible])
     [self sizeToFit];
 #else
+#if MAC_OS_X_VERSION_MAX_ALLOWED < MAC_OS_X_VERSION_10_2
   if ([self supermenu] == nil)
     [self sizeToFit];
 #endif
+#endif
 }
 
 
diff --git a/src/nsselect.m b/src/nsselect.m
index 950fb1f1f14..867cf3252e5 100644
--- a/src/nsselect.m
+++ b/src/nsselect.m
@@ -175,7 +175,7 @@ ns_string_to_pasteboard_internal (id pb, Lisp_Object str, NSString *gtype)
 }
 
 
-static Lisp_Object
+Lisp_Object
 ns_get_local_selection (Lisp_Object selection_name,
                        Lisp_Object target_type)
 {
@@ -352,16 +352,22 @@ ns_string_from_pasteboard (id pb)
       utfStr = [mstr UTF8String];
       length = [mstr lengthOfBytesUsingEncoding: NSUTF8StringEncoding];
 
+#if ! defined (NS_IMPL_COCOA) || MAC_OS_X_VERSION_MAX_ALLOWED < MAC_OS_X_VERSION_10_4
       if (!utfStr) 
         {
           utfStr = [mstr cString];
           length = strlen (utfStr);
         }
+#endif
     }
   NS_HANDLER
     {
       message1 ("ns_string_from_pasteboard: UTF8String failed\n");
+#if defined (NS_IMPL_COCOA) && MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_4
+      utfStr = "Conversion failed";
+#else
       utfStr = [str lossyCString];
+#endif
       length = strlen (utfStr);
     }
   NS_ENDHANDLER
diff --git a/src/nsterm.h b/src/nsterm.h
index 7459087c988..f419391a11e 100644
--- a/src/nsterm.h
+++ b/src/nsterm.h
@@ -25,6 +25,21 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 
 #ifdef HAVE_NS
 
+#ifdef NS_IMPL_COCOA
+#ifndef MAC_OS_X_VERSION_10_3
+#define MAC_OS_X_VERSION_10_3 1030
+#endif
+#ifndef MAC_OS_X_VERSION_10_4
+#define MAC_OS_X_VERSION_10_4 1040
+#endif
+#ifndef MAC_OS_X_VERSION_10_5
+#define MAC_OS_X_VERSION_10_5 1050
+#endif
+#ifndef MAC_OS_X_VERSION_10_6
+#define MAC_OS_X_VERSION_10_6 1060
+#endif
+#endif /* NS_IMPL_COCOA */
+
 #ifdef __OBJC__
 
 /* ==========================================================================
@@ -55,7 +70,11 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 
 @class EmacsToolbar;
 
-@interface EmacsView : NSView <NSTextInput> /* 10.6+: NSWindowDelegate */
+#if defined (NS_IMPL_COCOA) && MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_6
+@interface EmacsView : NSView <NSTextInput, NSWindowDelegate>
+#else
+@interface EmacsView : NSView <NSTextInput>
+#endif
    {
    char *old_title;
    BOOL windowClosing;
@@ -106,7 +125,11 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 
    ========================================================================== */
 
-@interface EmacsMenu : NSMenu  /* 10.6+: <NSMenuDelegate> */
+#if defined (NS_IMPL_COCOA) && MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_6
+@interface EmacsMenu : NSMenu  <NSMenuDelegate>
+#else
+@interface EmacsMenu : NSMenu
+#endif
 {
   struct frame *frame;
   unsigned long keyEquivModMask;
@@ -133,7 +156,11 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 
 @class EmacsImage;
 
-@interface EmacsToolbar : NSToolbar  /* 10.6+: <NSToolbarDelegate> */
+#if defined (NS_IMPL_COCOA) && MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_6
+@interface EmacsToolbar : NSToolbar <NSToolbarDelegate>
+#else
+@interface EmacsToolbar : NSToolbar
+#endif
    {
      EmacsView *emacsView;
      NSMutableDictionary *identifierToItem;
@@ -176,7 +203,11 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 - (Lisp_Object)runDialogAt: (NSPoint)p;
 @end
 
-@interface EmacsTooltip : NSObject  /* 10.6+: <NSWindowDelegate> */
+#if defined (NS_IMPL_COCOA) && MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_6
+@interface EmacsTooltip : NSObject <NSWindowDelegate>
+#else
+@interface EmacsTooltip : NSObject
+#endif
   {
     NSWindow *win;
     NSTextField *textField;
@@ -700,6 +731,8 @@ extern void check_ns (void);
 extern Lisp_Object ns_map_event_to_object ();
 extern Lisp_Object ns_string_from_pasteboard ();
 extern void ns_string_to_pasteboard ();
+extern Lisp_Object ns_get_local_selection (Lisp_Object selection_name,
+                                           Lisp_Object target_type);
 extern void nxatoms_of_nsselect ();
 extern int ns_lisp_to_cursor_type ();
 extern Lisp_Object ns_cursor_type_to_lisp (int arg);
diff --git a/src/nsterm.m b/src/nsterm.m
index 52e0dc6c2a8..546247ab74a 100644
--- a/src/nsterm.m
+++ b/src/nsterm.m
@@ -134,11 +134,12 @@ static unsigned convert_ns_to_X_keysym[] =
   0x1B,                         0x1B   /* escape */
 };
 
-
 static Lisp_Object Qmodifier_value;
 Lisp_Object Qalt, Qcontrol, Qhyper, Qmeta, Qsuper, Qnone;
 extern Lisp_Object Qcursor_color, Qcursor_type, Qns, Qleft;
 
+static Lisp_Object QUTF8_STRING;
+
 /* On OS X picks up the default NSGlobalDomain AppleAntiAliasingThreshold,
    the maximum font size to NOT antialias.  On GNUstep there is currently
    no way to control this behavior. */
@@ -4514,7 +4515,9 @@ ns_term_shutdown (int sig)
   unsigned fnKeysym = 0;
   int flags;
   static NSMutableArray *nsEvArray;
+#if !defined (NS_IMPL_COCOA) || MAC_OS_X_VERSION_MAX_ALLOWED < MAC_OS_X_VERSION_10_6
   static BOOL firstTime = YES;
+#endif
   int left_is_none;
 
   NSTRACE (keyDown);
@@ -4702,13 +4705,15 @@ ns_term_shutdown (int sig)
         }
     }
 
+  
+#if !defined (NS_IMPL_COCOA) || MAC_OS_X_VERSION_MAX_ALLOWED < MAC_OS_X_VERSION_10_6
   /* if we get here we should send the key for input manager processing */
   if (firstTime && [[NSInputManager currentInputManager]
                      wantsToDelayTextChangeNotifications] == NO)
     fprintf (stderr,
           "Emacs: WARNING: TextInput mgr wants marked text to be permanent!\n");
   firstTime = NO;
-
+#endif
   if (NS_KEYLOG && !processingCompose)
     fprintf (stderr, "keyDown: Begin compose sequence.\n");
 
@@ -5364,6 +5369,9 @@ ns_term_shutdown (int sig)
 
   [self allocateGState];
 
+  [NSApp registerServicesMenuSendTypes: ns_send_types
+                           returnTypes: nil];
+
   ns_window_num++;
   return self;
 }
@@ -5735,13 +5743,16 @@ ns_term_shutdown (int sig)
 }
 
 
-- validRequestorForSendType: (NSString *)typeSent
-                 returnType: (NSString *)typeReturned
+- (id) validRequestorForSendType: (NSString *)typeSent
+                      returnType: (NSString *)typeReturned
 {
   NSTRACE (validRequestorForSendType);
-  if ([ns_send_types indexOfObjectIdenticalTo: typeSent] != NSNotFound &&
-      [ns_return_types indexOfObjectIdenticalTo: typeSent] != NSNotFound)
-    return self;
+  if (typeSent != nil && [ns_send_types indexOfObject: typeSent] != NSNotFound
+      && typeReturned == nil)
+    {
+      if (! NILP (ns_get_local_selection (QPRIMARY, QUTF8_STRING)))
+        return self;
+    }
 
   return [super validRequestorForSendType: typeSent
                                returnType: typeReturned];
@@ -5765,8 +5776,28 @@ ns_term_shutdown (int sig)
 
 - (BOOL) writeSelectionToPasteboard: (NSPasteboard *)pb types: (NSArray *)types
 {
-  /* supposed to write for as many of types as we are able */
-  return NO;
+  NSArray *typesDeclared;
+  Lisp_Object val;
+
+  /* We only support NSStringPboardType */
+  if ([types containsObject:NSStringPboardType] == NO) {
+    return NO;
+  }
+
+  val = ns_get_local_selection (QPRIMARY, QUTF8_STRING);
+  if (CONSP (val) && SYMBOLP (XCAR (val)))
+    {
+      val = XCDR (val);
+      if (CONSP (val) && NILP (XCDR (val)))
+        val = XCAR (val);
+    }
+  if (! STRINGP (val))
+    return NO;
+
+  typesDeclared = [NSArray arrayWithObject:NSStringPboardType];
+  [pb declareTypes:typesDeclared owner:nil];
+  ns_string_to_pasteboard (pb, val);
+  return YES;
 }
 
 
@@ -6038,14 +6069,26 @@ ns_term_shutdown (int sig)
   em_whole = whole;
 
   if (portion >= whole)
-    [self setFloatValue: 0.0 knobProportion: 1.0];
+    {
+#if defined (NS_IMPL_COCOA) && MAC_OS_X_VERSION_MAX_ALLOWED > MAC_OS_X_VERSION_10_5
+      [self setKnobProportion: 1.0];
+      [self setDoubleValue: 1.0];
+#else
+      [self setFloatValue: 0.0 knobProportion: 1.0];
+#endif
+    }
   else
     {
       float pos, por;
       portion = max ((float)whole*min_portion/pixel_height, portion);
       pos = (float)position / (whole - portion);
       por = (float)portion/whole;
+#if defined (NS_IMPL_COCOA) && MAC_OS_X_VERSION_MAX_ALLOWED > MAC_OS_X_VERSION_10_5
+      [self setKnobProportion: por];
+      [self setDoubleValue: pos];
+#else
       [self setFloatValue: pos knobProportion: por];
+#endif
     }
   return self;
 }
@@ -6390,6 +6433,8 @@ syms_of_nsterm (void)
   DEFSYM (Qsuper, "super");
   DEFSYM (Qcontrol, "control");
   DEFSYM (Qnone, "none");
+  DEFSYM (QUTF8_STRING, "UTF8_STRING");
+
   Fput (Qalt, Qmodifier_value, make_number (alt_modifier));
   Fput (Qhyper, Qmodifier_value, make_number (hyper_modifier));
   Fput (Qmeta, Qmodifier_value, make_number (meta_modifier));
diff --git a/src/process.c b/src/process.c
index 0fe7068af3b..1a884357b86 100644
--- a/src/process.c
+++ b/src/process.c
@@ -102,9 +102,9 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include "gnutls.h"
 #endif
 
-#if defined (USE_GTK) || defined (HAVE_GCONF)
+#if defined (USE_GTK) || defined (HAVE_GCONF) || defined (HAVE_GSETTINGS)
 #include "xgselect.h"
-#endif /* defined (USE_GTK) || defined (HAVE_GCONF) */
+#endif
 #ifdef HAVE_NS
 #include "nsterm.h"
 #endif
@@ -1652,7 +1652,7 @@ create_process (Lisp_Object process, char **new_argv, Lisp_Object current_dir)
   sigaddset (&blocked, SIGHUP );  sigaction (SIGHUP , 0, &sighup_action );
 #endif
 #endif /* HAVE_WORKING_VFORK */
-  sigprocmask (SIG_BLOCK, &blocked, &procmask);
+  pthread_sigmask (SIG_BLOCK, &blocked, &procmask);
 
   FD_SET (inchannel, &input_wait_mask);
   FD_SET (inchannel, &non_keyboard_wait_mask);
@@ -1808,7 +1808,7 @@ create_process (Lisp_Object process, char **new_argv, Lisp_Object current_dir)
         signal (SIGPIPE, SIG_DFL);
 
         /* Stop blocking signals in the child.  */
-        sigprocmask (SIG_SETMASK, &procmask, 0);
+        pthread_sigmask (SIG_SETMASK, &procmask, 0);
 
         if (pty_flag)
           child_setup_tty (xforkout);
@@ -1900,7 +1900,7 @@ create_process (Lisp_Object process, char **new_argv, Lisp_Object current_dir)
 #endif
 #endif /* HAVE_WORKING_VFORK */
   /* Stop blocking signals in the parent.  */
-  sigprocmask (SIG_SETMASK, &procmask, 0);
+  pthread_sigmask (SIG_SETMASK, &procmask, 0);
 
   /* Now generate the error if vfork failed.  */
   if (pid < 0)
@@ -4527,7 +4527,7 @@ wait_reading_process_output (int time_limit, int microsecs, int read_kbd,
               process_output_skip = 0;
             }
 #endif
-#if defined (USE_GTK) || defined (HAVE_GCONF)
+#if defined (USE_GTK) || defined (HAVE_GCONF) || defined (HAVE_GSETTINGS)
           nfds = xg_select
 #elif defined (HAVE_NS)
           nfds = ns_select
diff --git a/src/ralloc.c b/src/ralloc.c
index 9c601a0ac24..64a47416202 100644
--- a/src/ralloc.c
+++ b/src/ralloc.c
@@ -1079,7 +1079,7 @@ r_alloc_reinit (void)
 #include <assert.h>
 
 void
-r_alloc_check ()
+r_alloc_check (void)
 {
   int found = 0;
   heap_ptr h, ph = 0;
diff --git a/src/regex.c b/src/regex.c
index 479239897bc..625c59ccf0b 100644
--- a/src/regex.c
+++ b/src/regex.c
@@ -2202,10 +2202,9 @@ extend_range_table_work_area (struct range_table_work_area *work_area)
    Returns -1 if successful, REG_ESPACE if ran out of space.  */
 
 static int
-set_image_of_range_1 (work_area, start, end, translate)
-     RE_TRANSLATE_TYPE translate;
-     struct range_table_work_area *work_area;
-     re_wchar_t start, end;
+set_image_of_range_1 (struct range_table_work_area *work_area,
+                      re_wchar_t start, re_wchar_t end,
+                      RE_TRANSLATE_TYPE translate)
 {
   /* `one_case' indicates a character, or a run of characters,
      each of which is an isolate (no case-equivalents).
@@ -2355,10 +2354,9 @@ set_image_of_range_1 (work_area, start, end, translate)
    Returns -1 if successful, REG_ESPACE if ran out of space.  */
 
 static int
-set_image_of_range (work_area, start, end, translate)
-     RE_TRANSLATE_TYPE translate;
-     struct range_table_work_area *work_area;
-     re_wchar_t start, end;
+set_image_of_range (struct range_table_work_area *work_area,
+                    re_wchar_t start, re_wchar_t end,
+                    RE_TRANSLATE_TYPE translate)
 {
   re_wchar_t cmin, cmax;
 
@@ -2445,8 +2443,7 @@ static re_char **best_regstart, **best_regend;
    but don't make them smaller.  */
 
 static
-regex_grow_registers (num_regs)
-     int num_regs;
+regex_grow_registers (int num_regs)
 {
   if (num_regs > regs_allocated_size)
     {
diff --git a/src/s/irix6-5.h b/src/s/irix6-5.h
index d283571d8fb..26eb7dcde77 100644
--- a/src/s/irix6-5.h
+++ b/src/s/irix6-5.h
@@ -96,3 +96,10 @@ char *_getpty();
 /* Tested on Irix 6.5.  SCM worked on earlier versions.  */
 #define GC_SETJMP_WORKS 1
 #define GC_MARK_STACK GC_MAKE_GCPROS_NOOPS
+
+
+/* DATA_SEG_BITS forces extra bits to be or'd in with any pointers which
+   were stored in a Lisp_Object (as Emacs uses fewer than 32 bits for
+   the value field of a LISP_OBJECT).  */
+#define DATA_START 0x10000000
+#define DATA_SEG_BITS   0x10000000
diff --git a/src/search.c b/src/search.c
index d29a51c695b..a56df784cd2 100644
--- a/src/search.c
+++ b/src/search.c
@@ -2284,6 +2284,10 @@ The match found must start at or after that position.
 Optional third argument, if t, means if fail just return nil (no error).
   If not nil and not t, move to limit of search and return nil.
 Optional fourth argument is repeat count--search for successive occurrences.
+
+Search case-sensitivity is determined by the value of the variable
+`case-fold-search', which see.
+
 See also the functions `match-beginning', `match-end', `match-string',
 and `replace-match'.  */)
   (Lisp_Object regexp, Lisp_Object bound, Lisp_Object noerror, Lisp_Object count)
@@ -2300,6 +2304,10 @@ The match found must not extend after that position.
 Optional third argument, if t, means if fail just return nil (no error).
   If not nil and not t, move to limit of search and return nil.
 Optional fourth argument is repeat count--search for successive occurrences.
+
+Search case-sensitivity is determined by the value of the variable
+`case-fold-search', which see.
+
 See also the functions `match-beginning', `match-end', `match-string',
 and `replace-match'.  */)
   (Lisp_Object regexp, Lisp_Object bound, Lisp_Object noerror, Lisp_Object count)
@@ -2319,6 +2327,10 @@ The match found must start at or after that position.
 Optional third argument, if t, means if fail just return nil (no error).
   If not nil and not t, move to limit of search and return nil.
 Optional fourth argument is repeat count--search for successive occurrences.
+
+Search case-sensitivity is determined by the value of the variable
+`case-fold-search', which see.
+
 See also the functions `match-beginning', `match-end', `match-string',
 and `replace-match'.  */)
   (Lisp_Object regexp, Lisp_Object bound, Lisp_Object noerror, Lisp_Object count)
@@ -2336,6 +2348,10 @@ The match found must not extend after that position.
 Optional third argument, if t, means if fail just return nil (no error).
   If not nil and not t, move to limit of search and return nil.
 Optional fourth argument is repeat count--search for successive occurrences.
+
+Search case-sensitivity is determined by the value of the variable
+`case-fold-search', which see.
+
 See also the functions `match-beginning', `match-end', `match-string',
 and `replace-match'.  */)
   (Lisp_Object regexp, Lisp_Object bound, Lisp_Object noerror, Lisp_Object count)
diff --git a/src/sysdep.c b/src/sysdep.c
index 3a73b1a467b..fc2f846b0dc 100644
--- a/src/sysdep.c
+++ b/src/sysdep.c
@@ -1534,7 +1534,7 @@ sigset_t
 sys_sigblock (sigset_t new_mask)
 {
   sigset_t old_mask;
-  sigprocmask (SIG_BLOCK, &new_mask, &old_mask);
+  pthread_sigmask (SIG_BLOCK, &new_mask, &old_mask);
   return (old_mask);
 }
 
@@ -1542,7 +1542,7 @@ sigset_t
 sys_sigunblock (sigset_t new_mask)
 {
   sigset_t old_mask;
-  sigprocmask (SIG_UNBLOCK, &new_mask, &old_mask);
+  pthread_sigmask (SIG_UNBLOCK, &new_mask, &old_mask);
   return (old_mask);
 }
 
@@ -1550,7 +1550,7 @@ sigset_t
 sys_sigsetmask (sigset_t new_mask)
 {
   sigset_t old_mask;
-  sigprocmask (SIG_SETMASK, &new_mask, &old_mask);
+  pthread_sigmask (SIG_SETMASK, &new_mask, &old_mask);
   return (old_mask);
 }
 
@@ -1783,7 +1783,8 @@ seed_random (long int arg)
 }
 
 /*
- * Build a full Emacs-sized word out of whatever we've got.
+ * Return a nonnegative random integer out of whatever we've got.
+ * It contains enough bits to make a random (signed) Emacs fixnum.
  * This suffices even for a 64-bit architecture with a 15-bit rand.
  */
 EMACS_INT
@@ -1791,16 +1792,17 @@ get_random (void)
 {
   EMACS_UINT val = 0;
   int i;
-  for (i = 0; i < (VALBITS + RAND_BITS - 1) / RAND_BITS; i++)
-    val = (val << RAND_BITS) ^ random ();
-  return val & (((EMACS_INT) 1 << VALBITS) - 1);
+  for (i = 0; i < (FIXNUM_BITS + RAND_BITS - 1) / RAND_BITS; i++)
+    val = (random () ^ (val << RAND_BITS)
+           ^ (val >> (BITS_PER_EMACS_INT - RAND_BITS)));
+  val ^= val >> (BITS_PER_EMACS_INT - FIXNUM_BITS);
+  return val & INTMASK;
 }
 
 #ifndef HAVE_STRERROR
 #ifndef WINDOWSNT
 char *
-strerror (errnum)
-     int errnum;
+strerror (int errnum)
 {
   extern char *sys_errlist[];
   extern int sys_nerr;
diff --git a/src/term.c b/src/term.c
index 9205719b5f4..22056451cb9 100644
--- a/src/term.c
+++ b/src/term.c
@@ -1546,7 +1546,8 @@ produce_glyphs (struct it *it)
   /* Nothing but characters are supported on terminal frames.  */
   xassert (it->what == IT_CHARACTER
            || it->what == IT_COMPOSITION
-           || it->what == IT_STRETCH);
+           || it->what == IT_STRETCH
+           || it->what == IT_GLYPHLESS);
 
   if (it->what == IT_STRETCH)
     {
@@ -3096,7 +3097,6 @@ init_tty (const char *name, const char *terminal_type, int must_succeed)
   char *area = NULL;
   char **address = &area;
   int buffer_size = 4096;
-  register char *p = NULL;
   int status;
   struct tty_display_info *tty = NULL;
   struct terminal *terminal = NULL;
@@ -3504,55 +3504,6 @@ use the Bourne shell command `TERM=... export TERM' (C-shell:\n\
       Down (tty) = 0;
     }
 
-  /* Special handling for certain terminal types known to need it */
-
-  if (!strcmp (terminal_type, "supdup"))
-    {
-      terminal->memory_below_frame = 1;
-      tty->Wcm->cm_losewrap = 1;
-    }
-  if (!strncmp (terminal_type, "c10", 3)
-      || !strcmp (terminal_type, "perq"))
-    {
-      /* Supply a makeshift :wi string.
-         This string is not valid in general since it works only
-         for windows starting at the upper left corner;
-         but that is all Emacs uses.
-
-         This string works only if the frame is using
-         the top of the video memory, because addressing is memory-relative.
-         So first check the :ti string to see if that is true.
-
-         It would be simpler if the :wi string could go in the termcap
-         entry, but it can't because it is not fully valid.
-         If it were in the termcap entry, it would confuse other programs.  */
-      if (!tty->TS_set_window)
-        {
-          const char *m = tty->TS_termcap_modes;
-          while (*m && strcmp (m, "\033v  "))
-            m++;
-          if (*m)
-            tty->TS_set_window = "\033v%C %C %C %C ";
-        }
-      /* Termcap entry often fails to have :in: flag */
-      terminal->must_write_spaces = 1;
-      /* :ti string typically fails to have \E^G! in it */
-      /* This limits scope of insert-char to one line.  */
-      strcpy (area, tty->TS_termcap_modes);
-      strcat (area, "\033\007!");
-      tty->TS_termcap_modes = area;
-      area += strlen (area) + 1;
-      p = AbsPosition (tty);
-      /* Change all %+ parameters to %C, to handle
-         values above 96 correctly for the C100.  */
-      while (*p)
-        {
-          if (p[0] == '%' && p[1] == '+')
-            p[1] = 'C';
-          p++;
-        }
-    }
-
   tty->specified_window = FrameRows (tty);
 
   if (Wcm_init (tty) == -1)     /* can't do cursor motion */
diff --git a/src/termcap.c b/src/termcap.c
index e191f6b3af3..96b9303d62d 100644
--- a/src/termcap.c
+++ b/src/termcap.c
@@ -338,8 +338,7 @@ static int name_match (char *line, char *name);
 
 #ifdef MSDOS /* MW, May 1993 */
 static int
-valid_filename_p (fn)
-     char *fn;
+valid_filename_p (char *fn)
 {
   return *fn == '/' || fn[1] == ':';
 }
@@ -669,9 +668,29 @@ gobble_line (int fd, register struct termcap_buffer *bufp, char *append_end)
 
 #include <stdio.h>
 
-main (argc, argv)
-     int argc;
-     char **argv;
+static void
+tprint (char *cap)
+{
+  char *x = tgetstr (cap, 0);
+  register char *y;
+
+  printf ("%s: ", cap);
+  if (x)
+    {
+      for (y = x; *y; y++)
+        if (*y <= ' ' || *y == 0177)
+          printf ("\\%0o", *y);
+        else
+          putchar (*y);
+      free (x);
+    }
+  else
+    printf ("none");
+  putchar ('\n');
+}
+
+int
+main (int argc, char **argv)
 {
   char *term;
   char *buf;
@@ -693,27 +712,8 @@ main (argc, argv)
 
   printf ("co: %d\n", tgetnum ("co"));
   printf ("am: %d\n", tgetflag ("am"));
-}
-
-tprint (cap)
-     char *cap;
-{
-  char *x = tgetstr (cap, 0);
-  register char *y;
 
-  printf ("%s: ", cap);
-  if (x)
-    {
-      for (y = x; *y; y++)
-        if (*y <= ' ' || *y == 0177)
-          printf ("\\%0o", *y);
-        else
-          putchar (*y);
-      free (x);
-    }
-  else
-    printf ("none");
-  putchar ('\n');
+  return 0;
 }
 
 #endif /* TEST */
diff --git a/src/textprop.c b/src/textprop.c
index 87f1675047b..29425f7a550 100644
--- a/src/textprop.c
+++ b/src/textprop.c
@@ -1707,10 +1707,14 @@ text_property_stickiness (Lisp_Object prop, Lisp_Object pos, Lisp_Object buffer)
 {
   Lisp_Object prev_pos, front_sticky;
   int is_rear_sticky = 1, is_front_sticky = 0; /* defaults */
+  Lisp_Object defalt = Fassq (prop, Vtext_property_default_nonsticky);
 
   if (NILP (buffer))
     XSETBUFFER (buffer, current_buffer);
 
+  if (CONSP (defalt) && !NILP (XCDR (defalt)))
+    is_rear_sticky = 0;
+
   if (XINT (pos) > BUF_BEGV (XBUFFER (buffer)))
     /* Consider previous character.  */
     {
@@ -2230,9 +2234,11 @@ If a character in a buffer has PROPERTY, new text inserted adjacent to
 the character doesn't inherit PROPERTY if NONSTICKINESS is non-nil,
 inherits it if NONSTICKINESS is nil.  The `front-sticky' and
 `rear-nonsticky' properties of the character override NONSTICKINESS.  */);
-  /* Text property `syntax-table' should be nonsticky by default.  */
+  /* Text properties `syntax-table'and `display' should be nonsticky
+     by default.  */
   Vtext_property_default_nonsticky
-    = Fcons (Fcons (intern_c_string ("syntax-table"), Qt), Qnil);
+    = Fcons (Fcons (intern_c_string ("syntax-table"), Qt),
+             Fcons (Fcons (intern_c_string ("display"), Qt), Qnil));
 
   staticpro (&interval_insert_behind_hooks);
   staticpro (&interval_insert_in_front_hooks);
diff --git a/src/tparam.c b/src/tparam.c
index 6aae0b97db9..ed28cd7397f 100644
--- a/src/tparam.c
+++ b/src/tparam.c
@@ -265,9 +265,8 @@ tparam1 (const char *string, char *outstring, int len,
 
 #ifdef DEBUG
 
-main (argc, argv)
-     int argc;
-     char **argv;
+int
+main (int argc, char **argv)
 {
   char buf[50];
   int args[3];
diff --git a/src/unexhp9k800.c b/src/unexhp9k800.c
index f27415a252c..ce65faffd4e 100644
--- a/src/unexhp9k800.c
+++ b/src/unexhp9k800.c
@@ -64,8 +64,7 @@ static long brk_on_dump = 0;
 
 /* Called from main, if we use shared libraries.  */
 int
-run_time_remap (ignored)
-     char *ignored;
+run_time_remap (char *ignored)
 {
   brk ((char *) brk_on_dump);
 }
@@ -74,74 +73,11 @@ run_time_remap (ignored)
 #define roundup(x,n) (((x) + ((n) - 1)) & ~((n) - 1))  /* n is power of 2 */
 #define min(x,y)  (((x) < (y)) ? (x) : (y))
 
-
-/* Create a new a.out file, same as old but with current data space */
-void
-unexec (const char *new_name,      /* name of the new a.out file to be created */
-        const char *old_name)       /* name of the old a.out file */
-{
-  int old, new;
-  int old_size, new_size;
-  struct header hdr;
-  struct som_exec_auxhdr auxhdr;
-  long i;
-
-  /* For the greatest flexibility, should create a temporary file in
-     the same directory as the new file.  When everything is complete,
-     rename the temp file to the new name.
-     This way, a program could update its own a.out file even while
-     it is still executing.  If problems occur, everything is still
-     intact.  NOT implemented.  */
-
-  /* Open the input and output a.out files */
-  old = open (old_name, O_RDONLY);
-  if (old < 0)
-    { perror (old_name); exit (1); }
-  new = open (new_name, O_CREAT|O_RDWR|O_TRUNC, 0777);
-  if (new < 0)
-    { perror (new_name); exit (1); }
-
-  /* Read the old headers */
-  read_header (old, &hdr, &auxhdr);
-
-  brk_on_dump = (long) sbrk (0);
-
-  /* Decide how large the new and old data areas are */
-  old_size = auxhdr.exec_dsize;
-  /* I suspect these two statements are separate
-     to avoid a compiler bug in hpux version 8.  */
-  i = (long) sbrk (0);
-  new_size = i - auxhdr.exec_dmem;
-
-  /* Copy the old file to the new, up to the data space */
-  lseek (old, 0, 0);
-  copy_file (old, new, auxhdr.exec_dfile);
-
-  /* Skip the old data segment and write a new one */
-  lseek (old, old_size, 1);
-  save_data_space (new, &hdr, &auxhdr, new_size);
-
-  /* Copy the rest of the file */
-  copy_rest (old, new);
-
-  /* Update file pointers since we probably changed size of data area */
-  update_file_ptrs (new, &hdr, &auxhdr, auxhdr.exec_dfile, new_size-old_size);
-
-  /* Save the modified header */
-  write_header (new, &hdr, &auxhdr);
-
-  /* Close the binary file */
-  close (old);
-  close (new);
-}
-
 /* Save current data space in the file, update header.  */
 
-save_data_space (file, hdr, auxhdr, size)
-     int file;
-     struct header *hdr;
-     struct som_exec_auxhdr *auxhdr;
-     int size;
+static void
+save_data_space (int file, struct header *hdr, struct som_exec_auxhdr *auxhdr,
+                 int size)
 {
   /* Write the entire data space out to the file */
   if (write (file, auxhdr->exec_dmem, size) != size)
@@ -154,12 +90,9 @@ save_data_space (file, hdr, auxhdr, size)
 
 /* Update the values of file pointers when something is inserted.  */
 
-update_file_ptrs (file, hdr, auxhdr, location, offset)
-     int file;
-     struct header *hdr;
-     struct som_exec_auxhdr *auxhdr;
-     unsigned int location;
-     int offset;
+static void
+update_file_ptrs (int file, struct header *hdr, struct som_exec_auxhdr *auxhdr,
+                  unsigned int location, int offset)
 {
   struct subspace_dictionary_record subspace;
   int i;
@@ -205,10 +138,8 @@ update_file_ptrs (file, hdr, auxhdr, location, offset)
 
 /* Read in the header records from an a.out file.  */
 
-read_header (file, hdr, auxhdr)
-     int file;
-     struct header *hdr;
-     struct som_exec_auxhdr *auxhdr;
+static void
+read_header (int file, struct header *hdr, struct som_exec_auxhdr *auxhdr)
 {
 
   /* Read the header in */
@@ -233,10 +164,8 @@ read_header (file, hdr, auxhdr)
 
 /* Write out the header records into an a.out file.  */
 
-write_header (file, hdr, auxhdr)
-     int file;
-     struct header *hdr;
-     struct som_exec_auxhdr *auxhdr;
+static void
+write_header (int file, struct header *hdr, struct som_exec_auxhdr *auxhdr)
 {
   /* Update the checksum */
   hdr->checksum = calculate_checksum (hdr);
@@ -252,8 +181,8 @@ write_header (file, hdr, auxhdr)
 
 /* Calculate the checksum of a SOM header record. */
 
-calculate_checksum (hdr)
-     struct header *hdr;
+static int
+calculate_checksum (struct header *hdr)
 {
   int checksum, i, *ptr;
 
@@ -267,9 +196,8 @@ calculate_checksum (hdr)
 
 /* Copy size bytes from the old file to the new one.  */
 
-copy_file (old, new, size)
-     int new, old;
-     int size;
+static void
+copy_file (int old, int new, int size)
 {
   int len;
   int buffer[8192];  /* word aligned will be faster */
@@ -286,8 +214,8 @@ copy_file (old, new, size)
 
 /* Copy the rest of the file, up to EOF.  */
 
-copy_rest (old, new)
-     int new, old;
+static void
+copy_rest (int old, int new)
 {
   int buffer[4096];
   int len;
@@ -301,9 +229,8 @@ copy_rest (old, new)
 }
 
 #ifdef  DEBUG
-display_header (hdr, auxhdr)
-     struct header *hdr;
-     struct som_exec_auxhdr *auxhdr;
+static void
+display_header (struct header *hdr, struct som_exec_auxhdr *auxhdr)
 {
   /* Display the header information (debug) */
   printf ("\n\nFILE HEADER\n");
@@ -320,3 +247,64 @@ display_header (hdr, auxhdr)
           hdr->unloadable_sp_location, hdr->unloadable_sp_size);
 }
 #endif /* DEBUG */
+
+
+/* Create a new a.out file, same as old but with current data space */
+void
+unexec (const char *new_name,      /* name of the new a.out file to be created */
+        const char *old_name)       /* name of the old a.out file */
+{
+  int old, new;
+  int old_size, new_size;
+  struct header hdr;
+  struct som_exec_auxhdr auxhdr;
+  long i;
+
+  /* For the greatest flexibility, should create a temporary file in
+     the same directory as the new file.  When everything is complete,
+     rename the temp file to the new name.
+     This way, a program could update its own a.out file even while
+     it is still executing.  If problems occur, everything is still
+     intact.  NOT implemented.  */
+
+  /* Open the input and output a.out files */
+  old = open (old_name, O_RDONLY);
+  if (old < 0)
+    { perror (old_name); exit (1); }
+  new = open (new_name, O_CREAT|O_RDWR|O_TRUNC, 0777);
+  if (new < 0)
+    { perror (new_name); exit (1); }
+
+  /* Read the old headers */
+  read_header (old, &hdr, &auxhdr);
+
+  brk_on_dump = (long) sbrk (0);
+
+  /* Decide how large the new and old data areas are */
+  old_size = auxhdr.exec_dsize;
+  /* I suspect these two statements are separate
+     to avoid a compiler bug in hpux version 8.  */
+  i = (long) sbrk (0);
+  new_size = i - auxhdr.exec_dmem;
+
+  /* Copy the old file to the new, up to the data space */
+  lseek (old, 0, 0);
+  copy_file (old, new, auxhdr.exec_dfile);
+
+  /* Skip the old data segment and write a new one */
+  lseek (old, old_size, 1);
+  save_data_space (new, &hdr, &auxhdr, new_size);
+
+  /* Copy the rest of the file */
+  copy_rest (old, new);
+
+  /* Update file pointers since we probably changed size of data area */
+  update_file_ptrs (new, &hdr, &auxhdr, auxhdr.exec_dfile, new_size-old_size);
+
+  /* Save the modified header */
+  write_header (new, &hdr, &auxhdr);
+
+  /* Close the binary file */
+  close (old);
+  close (new);
+}
diff --git a/src/w32.c b/src/w32.c
index 53bf2e811e2..de72e180c62 100644
--- a/src/w32.c
+++ b/src/w32.c
@@ -1452,6 +1452,14 @@ sigprocmask (int how, const sigset_t *set, sigset_t *oset)
 }
 
 int
+pthread_sigmask (int how, const sigset_t *set, sigset_t *oset)
+{
+  if (sigprocmask (how, set, oset) == -1)
+    return EINVAL;
+  return 0;
+}
+
+int
 setpgrp (int pid, int gid)
 {
   return 0;
diff --git a/src/w32fns.c b/src/w32fns.c
index e4b11b70441..f48e5764b4c 100644
--- a/src/w32fns.c
+++ b/src/w32fns.c
@@ -3273,7 +3273,8 @@ w32_wnd_proc (HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
             {
               /* Free memory used by owner-drawn and help-echo strings.  */
               w32_free_menu_strings (hwnd);
-              f->output_data.w32->menubar_active = 0;
+              if (f)
+                f->output_data.w32->menubar_active = 0;
               menubar_in_use = 0;
             }
         }
@@ -3623,10 +3624,10 @@ w32_wnd_proc (HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
       if (LOWORD (lParam) == HTCLIENT)
         {
           f = x_window_to_frame (dpyinfo, hwnd);
-          if (f->output_data.w32->hourglass_p && !menubar_in_use
-              && !current_popup_menu)
+          if (f && f->output_data.w32->hourglass_p
+              && !menubar_in_use && !current_popup_menu)
             SetCursor (f->output_data.w32->hourglass_cursor);
-          else
+          else if (f)
             SetCursor (f->output_data.w32->current_cursor);
           return 0;
         }
@@ -6805,10 +6806,6 @@ syms_of_w32fns (void)
   DEFSYM (Qfont_param, "font-parameter");
   /* This is the end of symbol initialization.  */
 
-  /* Text property `display' should be nonsticky by default.  */
-  Vtext_property_default_nonsticky
-    = Fcons (Fcons (Qdisplay, Qt), Vtext_property_default_nonsticky);
-
 
   Fput (Qundefined_color, Qerror_conditions,
         pure_cons (Qundefined_color, pure_cons (Qerror, Qnil)));
diff --git a/src/widget.c b/src/widget.c
index 6d871ad7cb2..a09ec2631ad 100644
--- a/src/widget.c
+++ b/src/widget.c
@@ -224,8 +224,7 @@ get_wm_shell (Widget w)
 #if 0 /* Currently not used.  */
 
 static void
-mark_shell_size_user_specified (wmshell)
-     Widget wmshell;
+mark_shell_size_user_specified (Widget wmshell)
 {
   if (! XtIsWMShell (wmshell)) abort ();
   /* This is kind of sleazy, but I can't see how else to tell it to make it
@@ -510,8 +509,7 @@ update_wm_hints (EmacsFrame ew)
 #if 0
 
 static void
-create_frame_gcs (ew)
-     EmacsFrame ew;
+create_frame_gcs (EmacsFrame ew)
 {
   struct frame *s = ew->emacs_frame.frame;
 
diff --git a/src/window.c b/src/window.c
index 3c867145620..d39efa8071d 100644
--- a/src/window.c
+++ b/src/window.c
@@ -56,7 +56,7 @@ Lisp_Object Qwindowp, Qwindow_live_p;
 static Lisp_Object Qwindow_configuration_p, Qrecord_window_buffer;
 static Lisp_Object Qwindow_deletable_p, Qdelete_window, Qdisplay_buffer;
 static Lisp_Object Qreplace_buffer_in_windows, Qget_mru_window;
-static Lisp_Object Qresize_root_window, Qresize_root_window_vertically;
+static Lisp_Object Qwindow_resize_root_window, Qwindow_resize_root_window_vertically;
 static Lisp_Object Qscroll_up, Qscroll_down, Qscroll_command;
 static Lisp_Object Qsafe, Qabove, Qbelow;
 static Lisp_Object Qauto_buffer_name;
@@ -410,14 +410,6 @@ buffer of the selected window before each command.  */)
   return select_window (window, norecord, 0);
 }
 
-DEFUN ("window-clone-number", Fwindow_clone_number, Swindow_clone_number, 0, 1, 0,
-       doc: /* Return WINDOW's clone number.
-WINDOW can be any window and defaults to the selected one.  */)
-     (Lisp_Object window)
-{
-  return decode_any_window (window)->clone_number;
-}
-
 DEFUN ("window-buffer", Fwindow_buffer, Swindow_buffer, 0, 1, 0,
        doc: /* Return the buffer that WINDOW is displaying.
 WINDOW can be any window and defaults to the selected one.
@@ -693,6 +685,7 @@ WINDOW must be a live window and defaults to the selected one.  */)
 
 DEFUN ("set-window-hscroll", Fset_window_hscroll, Sset_window_hscroll, 2, 2, 0,
        doc: /* Set number of columns WINDOW is scrolled from left margin to NCOL.
+If WINDOW is nil, the selected window is used.
 Return NCOL.  NCOL should be zero or positive.
 
 Note that if `automatic-hscrolling' is non-nil, you cannot scroll the
@@ -1360,6 +1353,7 @@ if it isn't already recorded.  */)
       struct text_pos startp;
       struct it it;
       struct buffer *old_buffer = NULL;
+      void *itdata = NULL;
 
       /* Cannot use Fvertical_motion because that function doesn't
          cope with variable-height lines.  */
@@ -1381,11 +1375,13 @@ if it isn't already recorded.  */)
       else
         SET_TEXT_POS_FROM_MARKER (startp, w->start);
 
+      itdata = bidi_shelve_cache ();
       start_display (&it, w, startp);
       move_it_vertically (&it, window_box_height (w));
       if (it.current_y < it.last_visible_y)
         move_it_past_eol (&it);
       value = make_number (IT_CHARPOS (it));
+      bidi_unshelve_cache (itdata);
 
       if (old_buffer)
         set_buffer_internal (old_buffer);
@@ -1420,7 +1416,7 @@ Return POS.  */)
 
 DEFUN ("set-window-start", Fset_window_start, Sset_window_start, 2, 3, 0,
        doc: /* Make display in WINDOW start at position POS in WINDOW's buffer.
-WINDOW defaults to the selected window.  Return POS.
+If WINDOW is nil, the selected window is used.  Return POS.
 Optional third arg NOFORCE non-nil inhibits next redisplay from
 overriding motion of point in order to display at this exact start.  */)
   (Lisp_Object window, Lisp_Object pos, Lisp_Object noforce)
@@ -2578,7 +2574,7 @@ selected frame and no others.  */)
 static Lisp_Object
 resize_root_window (Lisp_Object window, Lisp_Object delta, Lisp_Object horizontal, Lisp_Object ignore)
 {
-  return call4 (Qresize_root_window, window, delta, horizontal, ignore);
+  return call4 (Qwindow_resize_root_window, window, delta, horizontal, ignore);
 }
 
 
@@ -3089,18 +3085,6 @@ set_window_buffer (Lisp_Object window, Lisp_Object buffer, int run_hooks_p, int
   unbind_to (count, Qnil);
 }
 
-DEFUN ("set-window-clone-number", Fset_window_clone_number, Sset_window_clone_number, 2, 2, 0,
-       doc: /* Set WINDOW's clone number to CLONE-NUMBER.
-WINDOW can be any window and defaults to the selected one.  */)
-     (Lisp_Object window, Lisp_Object clone_number)
-{
-  register struct window *w = decode_any_window (window);
-
-  CHECK_NUMBER (clone_number);
-  w->clone_number = clone_number;
-  return w->clone_number;
-}
-
 DEFUN ("set-window-buffer", Fset_window_buffer, Sset_window_buffer, 2, 3, 0,
        doc: /* Make WINDOW display BUFFER-OR-NAME as its contents.
 WINDOW has to be a live window and defaults to the selected one.
@@ -3291,7 +3275,6 @@ make_parent_window (Lisp_Object window, int horflag)
 
   ++sequence_number;
   XSETFASTINT (p->sequence_number, sequence_number);
-  XSETFASTINT (p->clone_number, sequence_number);
 
   replace_window (window, parent, 1);
 
@@ -3337,7 +3320,6 @@ make_window (void)
   XSETFASTINT (w->use_time, 0);
   ++sequence_number;
   XSETFASTINT (w->sequence_number, sequence_number);
-  XSETFASTINT (w->clone_number, sequence_number);
   w->temslot = w->last_modified = w->last_overlay_modified = Qnil;
   XSETFASTINT (w->last_point, 0);
   w->last_had_star = w->vertical_scroll_bar = Qnil;
@@ -4076,7 +4058,8 @@ grow_mini_window (struct window *w, int delta)
 
   root = FRAME_ROOT_WINDOW (f);
   r = XWINDOW (root);
-  value = call2 (Qresize_root_window_vertically, root, make_number (- delta));
+  value = call2 (Qwindow_resize_root_window_vertically,
+                 root, make_number (- delta));
   if (INTEGERP (value) && window_resize_check (r, 0))
     {
       BLOCK_INPUT;
@@ -4110,7 +4093,7 @@ shrink_mini_window (struct window *w)
     {
       root = FRAME_ROOT_WINDOW (f);
       r = XWINDOW (root);
-      value = call2 (Qresize_root_window_vertically,
+      value = call2 (Qwindow_resize_root_window_vertically,
                      root, make_number (size - 1));
       if (INTEGERP (value) && window_resize_check (r, 0))
         {
@@ -4261,6 +4244,7 @@ window_scroll_pixel_based (Lisp_Object window, int n, int whole, int noerror)
   /* True if we fiddled the window vscroll field without really scrolling.  */
   int vscrolled = 0;
   int x, y, rtop, rbot, rowh, vpos;
+  void *itdata = NULL;
 
   SET_TEXT_POS_FROM_MARKER (start, w->start);
 
@@ -4271,6 +4255,7 @@ window_scroll_pixel_based (Lisp_Object window, int n, int whole, int noerror)
 
   if (!pos_visible_p (w, PT, &x, &y, &rtop, &rbot, &rowh, &vpos))
     {
+      itdata = bidi_shelve_cache ();
       /* Move backward half the height of the window.  Performance note:
          vmotion used here is about 10% faster, but would give wrong
          results for variable height lines.  */
@@ -4291,6 +4276,7 @@ window_scroll_pixel_based (Lisp_Object window, int n, int whole, int noerror)
         }
 
       start = it.current.pos;
+      bidi_unshelve_cache (itdata);
     }
   else if (auto_window_vscroll_p)
     {
@@ -4353,6 +4339,7 @@ window_scroll_pixel_based (Lisp_Object window, int n, int whole, int noerror)
       Fset_window_vscroll (window, make_number (0), Qt);
     }
 
+  itdata = bidi_shelve_cache ();
   /* If scroll_preserve_screen_position is non-nil, we try to set
      point in the same window line as it is now, so get that line.  */
   if (!NILP (Vscroll_preserve_screen_position))
@@ -4431,12 +4418,16 @@ window_scroll_pixel_based (Lisp_Object window, int n, int whole, int noerror)
                             - it.current_y + it.max_ascent + it.max_descent);
               adjust_glyphs (it.f);
             }
-          else if (noerror)
-            return;
-          else if (n < 0)       /* could happen with empty buffers */
-            xsignal0 (Qbeginning_of_buffer);
           else
-            xsignal0 (Qend_of_buffer);
+            {
+              bidi_unshelve_cache (itdata);
+              if (noerror)
+                return;
+              else if (n < 0)   /* could happen with empty buffers */
+                xsignal0 (Qbeginning_of_buffer);
+              else
+                xsignal0 (Qend_of_buffer);
+            }
         }
       else
         {
@@ -4444,10 +4435,14 @@ window_scroll_pixel_based (Lisp_Object window, int n, int whole, int noerror)
             /* The first line was only partially visible, make it fully
                visible. */
             w->vscroll = 0;
-          else if (noerror)
-            return;
           else
-            xsignal0 (Qbeginning_of_buffer);
+            {
+              bidi_unshelve_cache (itdata);
+              if (noerror)
+                return;
+              else
+                xsignal0 (Qbeginning_of_buffer);
+            }
         }
 
       /* If control gets here, then we vscrolled.  */
@@ -4591,6 +4586,7 @@ window_scroll_pixel_based (Lisp_Object window, int n, int whole, int noerror)
             SET_PT_BOTH (charpos, bytepos);
         }
     }
+  bidi_unshelve_cache (itdata);
 }
 
 
@@ -4993,6 +4989,7 @@ displayed_window_lines (struct window *w)
   int height = window_box_height (w);
   struct buffer *old_buffer;
   int bottom_y;
+  void *itdata = NULL;
 
   if (XBUFFER (w->buffer) != current_buffer)
     {
@@ -5012,9 +5009,11 @@ displayed_window_lines (struct window *w)
   else
     SET_TEXT_POS_FROM_MARKER (start, w->start);
 
+  itdata = bidi_shelve_cache ();
   start_display (&it, w, start);
   move_it_vertically (&it, height);
   bottom_y = line_bottom_y (&it);
+  bidi_unshelve_cache (itdata);
 
   /* rms: On a non-window display,
      the value of it.vpos at the bottom of the screen
@@ -5113,12 +5112,14 @@ and redisplay normally--don't erase and redraw the frame.  */)
         {
           struct it it;
           struct text_pos pt;
+          void *itdata = bidi_shelve_cache ();
 
           SET_TEXT_POS (pt, PT, PT_BYTE);
           start_display (&it, w, pt);
           move_it_vertically_backward (&it, window_box_height (w) / 2);
           charpos = IT_CHARPOS (it);
           bytepos = IT_BYTEPOS (it);
+          bidi_unshelve_cache (itdata);
         }
       else if (iarg < 0)
         {
@@ -5127,6 +5128,7 @@ and redisplay normally--don't erase and redraw the frame.  */)
           int nlines = -iarg;
           int extra_line_spacing;
           int h = window_box_height (w);
+          void *itdata = bidi_shelve_cache ();
 
           iarg = - max (-iarg, this_scroll_margin);
 
@@ -5164,7 +5166,10 @@ and redisplay normally--don't erase and redraw the frame.  */)
               h -= nlines * (FRAME_LINE_HEIGHT (it.f) + extra_line_spacing);
             }
           if (h <= 0)
-            return Qnil;
+            {
+              bidi_unshelve_cache (itdata);
+              return Qnil;
+            }
 
           /* Now find the new top line (starting position) of the window.  */
           start_display (&it, w, pt);
@@ -5184,6 +5189,8 @@ and redisplay normally--don't erase and redraw the frame.  */)
 
           charpos = IT_CHARPOS (it);
           bytepos = IT_BYTEPOS (it);
+
+          bidi_unshelve_cache (itdata);
         }
       else
         {
@@ -5350,8 +5357,7 @@ struct saved_window
 {
   struct vectorlike_header header;
 
-  Lisp_Object window, clone_number;
-  Lisp_Object buffer, start, pointm, mark;
+  Lisp_Object window, buffer, start, pointm, mark;
   Lisp_Object left_col, top_line, total_cols, total_lines;
   Lisp_Object normal_cols, normal_lines;
   Lisp_Object hscroll, min_hscroll;
@@ -5570,7 +5576,6 @@ the return value is nil.  Otherwise the value is t.  */)
                 }
             }
 
-          w->clone_number = p->clone_number;
           /* If we squirreled away the buffer in the window's height,
              restore it now.  */
           if (BUFFERP (w->total_lines))
@@ -5853,7 +5858,6 @@ save_window_save (Lisp_Object window, struct Lisp_Vector *vector, int i)
 
       XSETFASTINT (w->temslot, i); i++;
       p->window = window;
-      p->clone_number = w->clone_number;
       p->buffer = w->buffer;
       p->left_col = w->left_col;
       p->top_line = w->top_line;
@@ -6457,8 +6461,8 @@ syms_of_window (void)
   DEFSYM (Qwindow_live_p, "window-live-p");
   DEFSYM (Qwindow_deletable_p, "window-deletable-p");
   DEFSYM (Qdelete_window, "delete-window");
-  DEFSYM (Qresize_root_window, "resize-root-window");
-  DEFSYM (Qresize_root_window_vertically, "resize-root-window-vertically");
+  DEFSYM (Qwindow_resize_root_window, "window--resize-root-window");
+  DEFSYM (Qwindow_resize_root_window_vertically, "window--resize-root-window-vertically");
   DEFSYM (Qsafe, "safe");
   DEFSYM (Qdisplay_buffer, "display-buffer");
   DEFSYM (Qreplace_buffer_in_windows, "replace-buffer-in-windows");
@@ -6598,7 +6602,6 @@ function `window-nest' and altered by the function `set-window-nest'.  */);
   defsubr (&Sset_frame_selected_window);
   defsubr (&Spos_visible_in_window_p);
   defsubr (&Swindow_line_height);
-  defsubr (&Swindow_clone_number);
   defsubr (&Swindow_buffer);
   defsubr (&Swindow_parent);
   defsubr (&Swindow_top_child);
@@ -6648,7 +6651,6 @@ function `window-nest' and altered by the function `set-window-nest'.  */);
   defsubr (&Sdelete_window_internal);
   defsubr (&Sresize_mini_window_internal);
   defsubr (&Sset_window_buffer);
-  defsubr (&Sset_window_clone_number);
   defsubr (&Srun_window_configuration_change_hook);
   defsubr (&Sselect_window);
   defsubr (&Sforce_window_update);
diff --git a/src/window.h b/src/window.h
index c3f59e4b116..485734e907e 100644
--- a/src/window.h
+++ b/src/window.h
@@ -165,10 +165,6 @@ struct window
     /* Unique number of window assigned when it was created.  */
     Lisp_Object sequence_number;
 
-    /* Sequence number of window this window was cloned from.  Identic
-       to sequence number if window was not cloned.  */
-    Lisp_Object clone_number;
-
     /* No permanent meaning; used by save-window-excursion's
        bookkeeping.  */
     Lisp_Object temslot;
diff --git a/src/xdisp.c b/src/xdisp.c
index 31506e2247b..c02de7225e1 100644
--- a/src/xdisp.c
+++ b/src/xdisp.c
@@ -129,9 +129,13 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
    argument.
 
    Iteration over things to be displayed is then simple.  It is
-   started by initializing an iterator with a call to init_iterator.
-   Calls to get_next_display_element fill the iterator structure with
-   relevant information about the next thing to display.  Calls to
+   started by initializing an iterator with a call to init_iterator,
+   passing it the buffer position where to start iteration.  For
+   iteration over strings, pass -1 as the position to init_iterator,
+   and call reseat_to_string when the string is ready, to initialize
+   the iterator for that string.  Thereafter, calls to
+   get_next_display_element fill the iterator structure with relevant
+   information about the next thing to display.  Calls to
    set_iterator_to_next move the iterator to the next thing.
 
    Besides this, an iterator also contains information about the
@@ -592,6 +596,29 @@ int current_mode_line_height, current_header_line_height;
 
 #define TEXT_PROP_DISTANCE_LIMIT 100
 
+/* SAVE_IT and RESTORE_IT are called when we save a snapshot of the
+   iterator state and later restore it.  This is needed because the
+   bidi iterator on bidi.c keeps a stacked cache of its states, which
+   is really a singleton.  When we use scratch iterator objects to
+   move around the buffer, we can cause the bidi cache to be pushed or
+   popped, and therefore we need to restore the cache state when we
+   return to the original iterator.  */
+#define SAVE_IT(ITCOPY,ITORIG,CACHE)            \
+  do {                                          \
+    if (CACHE)                                  \
+      xfree (CACHE);                            \
+    ITCOPY = ITORIG;                            \
+    CACHE = bidi_shelve_cache();                \
+  } while (0)
+
+#define RESTORE_IT(pITORIG,pITCOPY,CACHE)       \
+  do {                                          \
+    if (pITORIG != pITCOPY)                     \
+      *(pITORIG) = *(pITCOPY);                  \
+    bidi_unshelve_cache (CACHE);                \
+    CACHE = NULL;                               \
+  } while (0)
+
 #if GLYPH_DEBUG
 
 /* Non-zero means print traces of redisplay if compiled with
@@ -1198,6 +1225,7 @@ pos_visible_p (struct window *w, EMACS_INT charpos, int *x, int *y,
                int *rtop, int *rbot, int *rowh, int *vpos)
 {
   struct it it;
+  void *itdata = bidi_shelve_cache ();
   struct text_pos top;
   int visible_p = 0;
   struct buffer *old_buffer = NULL;
@@ -1228,13 +1256,21 @@ pos_visible_p (struct window *w, EMACS_INT charpos, int *x, int *y,
   move_it_to (&it, charpos, -1, it.last_visible_y-1, -1,
               (charpos >= 0 ? MOVE_TO_POS : 0) | MOVE_TO_Y);
 
-  if (charpos >= 0 && IT_CHARPOS (it) >= charpos)
+  if (charpos >= 0
+      && (((!it.bidi_p || it.bidi_it.scan_dir == 1)
+           && IT_CHARPOS (it) >= charpos)
+          /* When scanning backwards under bidi iteration, move_it_to
+             stops at or _before_ CHARPOS, because it stops at or to
+             the _right_ of the character at CHARPOS. */
+          || (it.bidi_p && it.bidi_it.scan_dir == -1
+              && IT_CHARPOS (it) <= charpos)))
     {
       /* We have reached CHARPOS, or passed it.  How the call to
-         move_it_to can overshoot: (i) If CHARPOS is on invisible
-         text, move_it_to stops at the end of the invisible text,
-         after CHARPOS.  (ii) If CHARPOS is in a display vector,
-         move_it_to stops on its last glyph.  */
+         move_it_to can overshoot: (i) If CHARPOS is on invisible text
+         or covered by a display property, move_it_to stops at the end
+         of the invisible text, to the right of CHARPOS.  (ii) If
+         CHARPOS is in a display vector, move_it_to stops on its last
+         glyph.  */
       int top_x = it.current_x;
       int top_y = it.current_y;
       enum it_method it_method = it.method;
@@ -1283,15 +1319,18 @@ pos_visible_p (struct window *w, EMACS_INT charpos, int *x, int *y,
     }
   else
     {
+      /* We were asked to provide info about WINDOW_END.  */
       struct it it2;
+      void *it2data = NULL;
 
-      it2 = it;
+      SAVE_IT (it2, it, it2data);
       if (IT_CHARPOS (it) < ZV && FETCH_BYTE (IT_BYTEPOS (it)) != '\n')
         move_it_by_lines (&it, 1);
       if (charpos < IT_CHARPOS (it)
           || (it.what == IT_EOB && charpos == IT_CHARPOS (it)))
         {
           visible_p = 1;
+          RESTORE_IT (&it2, &it2, it2data);
           move_it_to (&it2, charpos, -1, -1, -1, MOVE_TO_POS);
           *x = it2.current_x;
           *y = it2.current_y + it2.max_ascent - it2.ascent;
@@ -1304,7 +1343,10 @@ pos_visible_p (struct window *w, EMACS_INT charpos, int *x, int *y,
                                   WINDOW_HEADER_LINE_HEIGHT (w))));
           *vpos = it2.vpos;
         }
+      else
+        xfree (it2data);
     }
+  bidi_unshelve_cache (itdata);
 
   if (old_buffer)
     set_buffer_internal_1 (old_buffer);
@@ -2212,8 +2254,7 @@ safe_call2 (Lisp_Object fn, Lisp_Object arg1, Lisp_Object arg2)
    This is for debugging.  It is too slow to do unconditionally.  */
 
 static void
-check_it (it)
-     struct it *it;
+check_it (struct it *it)
 {
   if (it->method == GET_FROM_STRING)
     {
@@ -2343,6 +2384,10 @@ init_iterator (struct it *it, struct window *w,
   it->base_face_id = remapped_base_face_id;
   it->string = Qnil;
   IT_STRING_CHARPOS (*it) = IT_STRING_BYTEPOS (*it) = -1;
+  it->paragraph_embedding = L2R;
+  it->bidi_it.string.lstring = Qnil;
+  it->bidi_it.string.s = NULL;
+  it->bidi_it.string.bufpos = 0;
 
   /* The window in which we iterate over current_buffer:  */
   XSETWINDOW (it->window, w);
@@ -2399,13 +2444,6 @@ init_iterator (struct it *it, struct window *w,
   /* Are multibyte characters enabled in current_buffer?  */
   it->multibyte_p = !NILP (BVAR (current_buffer, enable_multibyte_characters));
 
-  /* Do we need to reorder bidirectional text?  Not if this is a
-     unibyte buffer: by definition, none of the single-byte characters
-     are strong R2L, so no reordering is needed.  And bidi.c doesn't
-     support unibyte buffers anyway.  */
-  it->bidi_p
-    = !NILP (BVAR (current_buffer, bidi_display_reordering)) && it->multibyte_p;
-
   /* Non-zero if we should highlight the region.  */
   highlight_region_p
     = (!NILP (Vtransient_mark_mode)
@@ -2555,21 +2593,6 @@ init_iterator (struct it *it, struct window *w,
         it->start_of_box_run_p = 1;
     }
 
-  /* If we are to reorder bidirectional text, init the bidi
-     iterator.  */
-  if (it->bidi_p)
-    {
-      /* Note the paragraph direction that this buffer wants to
-         use.  */
-      if (EQ (BVAR (current_buffer, bidi_paragraph_direction), Qleft_to_right))
-        it->paragraph_embedding = L2R;
-      else if (EQ (BVAR (current_buffer, bidi_paragraph_direction), Qright_to_left))
-        it->paragraph_embedding = R2L;
-      else
-        it->paragraph_embedding = NEUTRAL_DIR;
-      bidi_init_it (charpos, bytepos, FRAME_WINDOW_P (it->f), &it->bidi_it);
-    }
-
   /* If a buffer position was specified, set the iterator there,
      getting overlays and face properties from that position.  */
   if (charpos >= BUF_BEG (current_buffer))
@@ -2585,6 +2608,32 @@ init_iterator (struct it *it, struct window *w,
         IT_BYTEPOS (*it) = bytepos;
 
       it->start = it->current;
+      /* Do we need to reorder bidirectional text?  Not if this is a
+         unibyte buffer: by definition, none of the single-byte
+         characters are strong R2L, so no reordering is needed.  And
+         bidi.c doesn't support unibyte buffers anyway.  */
+      it->bidi_p =
+        !NILP (BVAR (current_buffer, bidi_display_reordering))
+        && it->multibyte_p;
+
+      /* If we are to reorder bidirectional text, init the bidi
+         iterator.  */
+      if (it->bidi_p)
+        {
+          /* Note the paragraph direction that this buffer wants to
+             use.  */
+          if (EQ (BVAR (current_buffer, bidi_paragraph_direction),
+                  Qleft_to_right))
+            it->paragraph_embedding = L2R;
+          else if (EQ (BVAR (current_buffer, bidi_paragraph_direction),
+                       Qright_to_left))
+            it->paragraph_embedding = R2L;
+          else
+            it->paragraph_embedding = NEUTRAL_DIR;
+          bidi_unshelve_cache (NULL);
+          bidi_init_it (charpos, IT_BYTEPOS (*it), FRAME_WINDOW_P (it->f),
+                        &it->bidi_it);
+        }
 
       /* Compute faces etc.  */
       reseat (it, it->current.pos, 1);
@@ -2906,6 +2955,7 @@ handle_stop (struct it *it)
                 {
                   it->ignore_overlay_strings_at_pos_p = 1;
                   it->string_from_display_prop_p = 0;
+                  it->from_disp_prop_p = 0;
                   handle_overlay_change_p = 0;
                 }
               handled = HANDLED_RECOMPUTE_PROPS;
@@ -3087,37 +3137,50 @@ next_overlay_change (EMACS_INT pos)
   return endpos;
 }
 
-/* Return the character position of a display string at or after CHARPOS.
-   If no display string exists at or after CHARPOS, return ZV.  A
-   display string is either an overlay with `display' property whose
-   value is a string, or a `display' text property whose value is a
-   string.  FRAME_WINDOW_P is non-zero when we are displaying a window
+/* Return the character position of a display string at or after
+   position specified by POSITION.  If no display string exists at or
+   after POSITION, return ZV.  A display string is either an overlay
+   with `display' property whose value is a string, or a `display'
+   text property whose value is a string.  STRING is data about the
+   string to iterate; if STRING->lstring is nil, we are iterating a
+   buffer.  FRAME_WINDOW_P is non-zero when we are displaying a window
    on a GUI frame.  */
 EMACS_INT
-compute_display_string_pos (EMACS_INT charpos, int frame_window_p)
+compute_display_string_pos (struct text_pos *position,
+                            struct bidi_string_data *string, int frame_window_p)
 {
-  /* FIXME: Support display properties on strings (object = Qnil means
-     current buffer).  */
-  Lisp_Object object = Qnil;
+  /* OBJECT = nil means current buffer.  */
+  Lisp_Object object =
+    (string && STRINGP (string->lstring)) ? string->lstring : Qnil;
   Lisp_Object pos, spec;
-  struct text_pos position;
-  EMACS_INT bufpos;
-
-  if (charpos >= ZV)
-    return ZV;
+  int string_p = (string && (STRINGP (string->lstring) || string->s));
+  EMACS_INT eob = string_p ? string->schars : ZV;
+  EMACS_INT begb = string_p ? 0 : BEGV;
+  EMACS_INT bufpos, charpos = CHARPOS (*position);
+  struct text_pos tpos;
+
+  if (charpos >= eob
+      /* We don't support display properties whose values are strings
+         that have display string properties.  */
+      || string->from_disp_str
+      /* C strings cannot have display properties.  */
+      || (string->s && !STRINGP (object)))
+    return eob;
 
   /* If the character at CHARPOS is where the display string begins,
      return CHARPOS.  */
   pos = make_number (charpos);
-  CHARPOS (position) = charpos;
-  BYTEPOS (position) = CHAR_TO_BYTE (charpos);
-  bufpos = charpos;     /* FIXME! support strings as well */
+  if (STRINGP (object))
+    bufpos = string->bufpos;
+  else
+    bufpos = charpos;
+  tpos = *position;
   if (!NILP (spec = Fget_char_property (pos, Qdisplay, object))
-      && (charpos <= BEGV
+      && (charpos <= begb
           || !EQ (Fget_char_property (make_number (charpos - 1), Qdisplay,
                                       object),
                   spec))
-      && handle_display_spec (NULL, spec, object, Qnil, &position, bufpos,
+      && handle_display_spec (NULL, spec, object, Qnil, &tpos, bufpos,
                               frame_window_p))
     return charpos;
 
@@ -3125,17 +3188,21 @@ compute_display_string_pos (EMACS_INT charpos, int frame_window_p)
      that will replace the underlying text when displayed.  */
   do {
     pos = Fnext_single_char_property_change (pos, Qdisplay, object, Qnil);
-    CHARPOS (position) = XFASTINT (pos);
-    BYTEPOS (position) = CHAR_TO_BYTE (CHARPOS (position));
-    if (CHARPOS (position) >= ZV)
+    CHARPOS (tpos) = XFASTINT (pos);
+    if (STRINGP (object))
+      BYTEPOS (tpos) = string_char_to_byte (object, CHARPOS (tpos));
+    else
+      BYTEPOS (tpos) = CHAR_TO_BYTE (CHARPOS (tpos));
+    if (CHARPOS (tpos) >= eob)
       break;
     spec = Fget_char_property (pos, Qdisplay, object);
-    bufpos = CHARPOS (position);        /* FIXME! support strings as well */
+    if (!STRINGP (object))
+      bufpos = CHARPOS (tpos);
   } while (NILP (spec)
-           || !handle_display_spec (NULL, spec, object, Qnil, &position, bufpos,
+           || !handle_display_spec (NULL, spec, object, Qnil, &tpos, bufpos,
                                     frame_window_p));
 
-  return CHARPOS (position);
+  return CHARPOS (tpos);
 }
 
 /* Return the character position of the end of the display string that
@@ -3143,15 +3210,17 @@ compute_display_string_pos (EMACS_INT charpos, int frame_window_p)
    `display' property whose value is a string or a `display' text
    property whose value is a string.  */
 EMACS_INT
-compute_display_string_end (EMACS_INT charpos)
+compute_display_string_end (EMACS_INT charpos, struct bidi_string_data *string)
 {
-  /* FIXME: Support display properties on strings (object = Qnil means
-     current buffer).  */
-  Lisp_Object object = Qnil;
+  /* OBJECT = nil means current buffer.  */
+  Lisp_Object object =
+    (string && STRINGP (string->lstring)) ? string->lstring : Qnil;
   Lisp_Object pos = make_number (charpos);
+  EMACS_INT eob =
+    (STRINGP (object) || (string && string->s)) ? string->schars : ZV;
 
-  if (charpos >= ZV)
-    return ZV;
+  if (charpos >= eob || (string->s && !STRINGP (object)))
+    return eob;
 
   if (NILP (Fget_char_property (pos, Qdisplay, object)))
     abort ();
@@ -3444,21 +3513,23 @@ underlying_face_id (struct it *it)
 
 
 /* Compute the face one character before or after the current position
-   of IT.  BEFORE_P non-zero means get the face in front of IT's
-   position.  Value is the id of the face.  */
+   of IT, in the visual order.  BEFORE_P non-zero means get the face
+   in front (to the left in L2R paragraphs, to the right in R2L
+   paragraphs) of IT's screen position.  Value is the ID of the face.  */
 
 static int
 face_before_or_after_it_pos (struct it *it, int before_p)
 {
   int face_id, limit;
   EMACS_INT next_check_charpos;
-  struct text_pos pos;
+  struct it it_copy;
+  void *it_copy_data = NULL;
 
   xassert (it->s == NULL);
 
   if (STRINGP (it->string))
     {
-      EMACS_INT bufpos;
+      EMACS_INT bufpos, charpos;
       int base_face_id;
 
       /* No face change past the end of the string (for the case
@@ -3468,16 +3539,59 @@ face_before_or_after_it_pos (struct it *it, int before_p)
           || (IT_STRING_CHARPOS (*it) == 0 && before_p))
         return it->face_id;
 
-      /* Set pos to the position before or after IT's current position.  */
-      if (before_p)
-        pos = string_pos (IT_STRING_CHARPOS (*it) - 1, it->string);
+      if (!it->bidi_p)
+        {
+          /* Set charpos to the position before or after IT's current
+             position, in the logical order, which in the non-bidi
+             case is the same as the visual order.  */
+          if (before_p)
+            charpos = IT_STRING_CHARPOS (*it) - 1;
+          else if (it->what == IT_COMPOSITION)
+            /* For composition, we must check the character after the
+               composition.  */
+            charpos = IT_STRING_CHARPOS (*it) + it->cmp_it.nchars;
+          else
+            charpos = IT_STRING_CHARPOS (*it) + 1;
+        }
       else
-        /* For composition, we must check the character after the
-           composition.  */
-        pos = (it->what == IT_COMPOSITION
-               ? string_pos (IT_STRING_CHARPOS (*it)
-                             + it->cmp_it.nchars, it->string)
-               : string_pos (IT_STRING_CHARPOS (*it) + 1, it->string));
+        {
+          if (before_p)
+            {
+              /* With bidi iteration, the character before the current
+                 in the visual order cannot be found by simple
+                 iteration, because "reverse" reordering is not
+                 supported.  Instead, we need to use the move_it_*
+                 family of functions.  */
+              /* Ignore face changes before the first visible
+                 character on this display line.  */
+              if (it->current_x <= it->first_visible_x)
+                return it->face_id;
+              SAVE_IT (it_copy, *it, it_copy_data);
+              /* Implementation note: Since move_it_in_display_line
+                 works in the iterator geometry, and thinks the first
+                 character is always the leftmost, even in R2L lines,
+                 we don't need to distinguish between the R2L and L2R
+                 cases here.  */
+              move_it_in_display_line (&it_copy, SCHARS (it_copy.string),
+                                       it_copy.current_x - 1, MOVE_TO_X);
+              charpos = IT_STRING_CHARPOS (it_copy);
+              RESTORE_IT (it, it, it_copy_data);
+            }
+          else
+            {
+              /* Set charpos to the string position of the character
+                 that comes after IT's current position in the visual
+                 order.  */
+              int n = (it->what == IT_COMPOSITION ? it->cmp_it.nchars : 1);
+
+              it_copy = *it;
+              while (n--)
+                bidi_move_to_visually_next (&it_copy.bidi_it);
+
+              charpos = it_copy.bidi_it.charpos;
+            }
+        }
+      xassert (0 <= charpos && charpos <= SCHARS (it->string));
 
       if (it->current.overlay_string_index >= 0)
         bufpos = IT_CHARPOS (*it);
@@ -3489,7 +3603,7 @@ face_before_or_after_it_pos (struct it *it, int before_p)
       /* Get the face for ASCII, or unibyte.  */
       face_id = face_at_string_position (it->w,
                                          it->string,
-                                         CHARPOS (pos),
+                                         charpos,
                                          bufpos,
                                          it->region_beg_charpos,
                                          it->region_end_charpos,
@@ -3501,16 +3615,19 @@ face_before_or_after_it_pos (struct it *it, int before_p)
          suitable for unibyte text if IT->string is unibyte.  */
       if (STRING_MULTIBYTE (it->string))
         {
-          const unsigned char *p = SDATA (it->string) + BYTEPOS (pos);
+          struct text_pos pos1 = string_pos (charpos, it->string);
+          const unsigned char *p = SDATA (it->string) + BYTEPOS (pos1);
           int c, len;
           struct face *face = FACE_FROM_ID (it->f, face_id);
 
           c = string_char_and_length (p, &len);
-          face_id = FACE_FOR_CHAR (it->f, face, c, CHARPOS (pos), it->string);
+          face_id = FACE_FOR_CHAR (it->f, face, c, charpos, it->string);
         }
     }
   else
     {
+      struct text_pos pos;
+
       if ((IT_CHARPOS (*it) >= ZV && !before_p)
           || (IT_CHARPOS (*it) <= BEGV && before_p))
         return it->face_id;
@@ -3518,17 +3635,63 @@ face_before_or_after_it_pos (struct it *it, int before_p)
       limit = IT_CHARPOS (*it) + TEXT_PROP_DISTANCE_LIMIT;
       pos = it->current.pos;
 
-      if (before_p)
-        DEC_TEXT_POS (pos, it->multibyte_p);
+      if (!it->bidi_p)
+        {
+          if (before_p)
+            DEC_TEXT_POS (pos, it->multibyte_p);
+          else
+            {
+              if (it->what == IT_COMPOSITION)
+                {
+                  /* For composition, we must check the position after
+                     the composition.  */
+                  pos.charpos += it->cmp_it.nchars;
+                  pos.bytepos += it->len;
+                }
+              else
+                INC_TEXT_POS (pos, it->multibyte_p);
+            }
+        }
       else
         {
-          if (it->what == IT_COMPOSITION)
-            /* For composition, we must check the position after the
-               composition.  */
-            pos.charpos += it->cmp_it.nchars, pos.bytepos += it->len;
+          if (before_p)
+            {
+              /* With bidi iteration, the character before the current
+                 in the visual order cannot be found by simple
+                 iteration, because "reverse" reordering is not
+                 supported.  Instead, we need to use the move_it_*
+                 family of functions.  */
+              /* Ignore face changes before the first visible
+                 character on this display line.  */
+              if (it->current_x <= it->first_visible_x)
+                return it->face_id;
+              SAVE_IT (it_copy, *it, it_copy_data);
+              /* Implementation note: Since move_it_in_display_line
+                 works in the iterator geometry, and thinks the first
+                 character is always the leftmost, even in R2L lines,
+                 we don't need to distinguish between the R2L and L2R
+                 cases here.  */
+              move_it_in_display_line (&it_copy, ZV,
+                                       it_copy.current_x - 1, MOVE_TO_X);
+              pos = it_copy.current.pos;
+              RESTORE_IT (it, it, it_copy_data);
+            }
           else
-            INC_TEXT_POS (pos, it->multibyte_p);
+            {
+              /* Set charpos to the buffer position of the character
+                 that comes after IT's current position in the visual
+                 order.  */
+              int n = (it->what == IT_COMPOSITION ? it->cmp_it.nchars : 1);
+
+              it_copy = *it;
+              while (n--)
+                bidi_move_to_visually_next (&it_copy.bidi_it);
+
+              SET_TEXT_POS (pos,
+                            it_copy.bidi_it.charpos, it_copy.bidi_it.bytepos);
+            }
         }
+      xassert (BEGV <= CHARPOS (pos) && CHARPOS (pos) <= ZV);
 
       /* Determine face for CHARSET_ASCII, or unibyte.  */
       face_id = face_at_buffer_position (it->w,
@@ -3579,6 +3742,8 @@ handle_invisible_prop (struct it *it)
       if (!NILP (prop)
           && IT_STRING_CHARPOS (*it) < it->end_charpos)
         {
+          EMACS_INT endpos;
+
           handled = HANDLED_RECOMPUTE_PROPS;
 
           /* Get the position at which the next change of the
@@ -3593,12 +3758,37 @@ handle_invisible_prop (struct it *it)
              change in the property is at position end_charpos.
              Move IT's current position to that position.  */
           if (INTEGERP (end_charpos)
-              && XFASTINT (end_charpos) < XFASTINT (limit))
+              && (endpos = XFASTINT (end_charpos)) < XFASTINT (limit))
             {
               struct text_pos old;
+              EMACS_INT oldpos;
+
               old = it->current.string_pos;
-              IT_STRING_CHARPOS (*it) = XFASTINT (end_charpos);
-              compute_string_pos (&it->current.string_pos, old, it->string);
+              oldpos = CHARPOS (old);
+              if (it->bidi_p)
+                {
+                  if (it->bidi_it.first_elt
+                      && it->bidi_it.charpos < SCHARS (it->string))
+                    bidi_paragraph_init (it->paragraph_embedding,
+                                         &it->bidi_it, 1);
+                  /* Bidi-iterate out of the invisible text.  */
+                  do
+                    {
+                      bidi_move_to_visually_next (&it->bidi_it);
+                    }
+                  while (oldpos <= it->bidi_it.charpos
+                         && it->bidi_it.charpos < endpos);
+
+                  IT_STRING_CHARPOS (*it) = it->bidi_it.charpos;
+                  IT_STRING_BYTEPOS (*it) = it->bidi_it.bytepos;
+                  if (IT_CHARPOS (*it) >= endpos)
+                    it->prev_stop = endpos;
+                }
+              else
+                {
+                  IT_STRING_CHARPOS (*it) = XFASTINT (end_charpos);
+                  compute_string_pos (&it->current.string_pos, old, it->string);
+                }
             }
           else
             {
@@ -4250,6 +4440,7 @@ handle_single_display_spec (struct it *it, Lisp_Object spec, Lisp_Object object,
           it->method = GET_FROM_IMAGE;
           it->from_overlay = Qnil;
           it->face_id = face_id;
+          it->from_disp_prop_p = 1;
 
           /* Say that we haven't consumed the characters with
              `display' property yet.  The call to pop_it in
@@ -4332,6 +4523,7 @@ handle_single_display_spec (struct it *it, Lisp_Object spec, Lisp_Object object,
          when we are finished with the glyph property value.  */
       push_it (it, position);
       it->from_overlay = overlay;
+      it->from_disp_prop_p = 1;
 
       if (NILP (location))
         it->area = TEXT_AREA;
@@ -4349,12 +4541,34 @@ handle_single_display_spec (struct it *it, Lisp_Object spec, Lisp_Object object,
           it->end_charpos = it->string_nchars = SCHARS (it->string);
           it->method = GET_FROM_STRING;
           it->stop_charpos = 0;
+          it->prev_stop = 0;
+          it->base_level_stop = 0;
           it->string_from_display_prop_p = 1;
           /* Say that we haven't consumed the characters with
              `display' property yet.  The call to pop_it in
              set_iterator_to_next will clean this up.  */
           if (BUFFERP (object))
             *position = start_pos;
+
+          /* Force paragraph direction to be that of the parent
+             object.  If the parent object's paragraph direction is
+             not yet determined, default to L2R.  */
+          if (it->bidi_p && it->bidi_it.paragraph_dir == R2L)
+            it->paragraph_embedding = it->bidi_it.paragraph_dir;
+          else
+            it->paragraph_embedding = L2R;
+
+          /* Set up the bidi iterator for this display string.  */
+          if (it->bidi_p)
+            {
+              it->bidi_it.string.lstring = it->string;
+              it->bidi_it.string.s = NULL;
+              it->bidi_it.string.schars = it->end_charpos;
+              it->bidi_it.string.bufpos = bufpos;
+              it->bidi_it.string.from_disp_str = 1;
+              it->bidi_it.string.unibyte = !it->multibyte_p;
+              bidi_init_it (0, 0, FRAME_WINDOW_P (it->f), &it->bidi_it);
+            }
         }
       else if (CONSP (value) && EQ (XCAR (value), Qspace))
         {
@@ -4610,6 +4824,11 @@ handle_composition_prop (struct it *it)
       && COMPOSITION_VALID_P (start, end, prop)
       && (STRINGP (it->string) || (PT <= start || PT >= end)))
     {
+      if (start < pos)
+        /* As we can't handle this situation (perhaps font-lock added
+           a new composition), we just return here hoping that next
+           redisplay will detect this composition much earlier.  */
+        return HANDLED_NORMALLY;
       if (start != pos)
         {
           if (STRINGP (it->string))
@@ -4718,6 +4937,20 @@ next_overlay_string (struct it *it)
       it->stop_charpos = 0;
       if (it->cmp_it.stop_pos >= 0)
         it->cmp_it.stop_pos = 0;
+      it->prev_stop = 0;
+      it->base_level_stop = 0;
+
+      /* Set up the bidi iterator for this overlay string.  */
+      if (it->bidi_p)
+        {
+          it->bidi_it.string.lstring = it->string;
+          it->bidi_it.string.s = NULL;
+          it->bidi_it.string.schars = SCHARS (it->string);
+          it->bidi_it.string.bufpos = it->overlay_strings_charpos;
+          it->bidi_it.string.from_disp_str = it->string_from_display_prop_p;
+          it->bidi_it.string.unibyte = !it->multibyte_p;
+          bidi_init_it (0, 0, FRAME_WINDOW_P (it->f), &it->bidi_it);
+        }
     }
 
   CHECK_IT (it);
@@ -4984,8 +5217,32 @@ get_overlay_strings_1 (struct it *it, EMACS_INT charpos, int compute_stop_p)
       it->stop_charpos = 0;
       xassert (STRINGP (it->string));
       it->end_charpos = SCHARS (it->string);
+      it->prev_stop = 0;
+      it->base_level_stop = 0;
       it->multibyte_p = STRING_MULTIBYTE (it->string);
       it->method = GET_FROM_STRING;
+      it->from_disp_prop_p = 0;
+
+      /* Force paragraph direction to be that of the parent
+         buffer.  */
+      if (it->bidi_p && it->bidi_it.paragraph_dir == R2L)
+        it->paragraph_embedding = it->bidi_it.paragraph_dir;
+      else
+        it->paragraph_embedding = L2R;
+
+      /* Set up the bidi iterator for this overlay string.  */
+      if (it->bidi_p)
+        {
+          EMACS_INT pos = (charpos > 0 ? charpos : IT_CHARPOS (*it));
+
+          it->bidi_it.string.lstring = it->string;
+          it->bidi_it.string.s = NULL;
+          it->bidi_it.string.schars = SCHARS (it->string);
+          it->bidi_it.string.bufpos = pos;
+          it->bidi_it.string.from_disp_str = it->string_from_display_prop_p;
+          it->bidi_it.string.unibyte = !it->multibyte_p;
+          bidi_init_it (0, 0, FRAME_WINDOW_P (it->f), &it->bidi_it);
+        }
       return 1;
     }
 
@@ -5064,19 +5321,30 @@ push_it (struct it *it, struct text_pos *position)
   p->string_from_display_prop_p = it->string_from_display_prop_p;
   p->display_ellipsis_p = 0;
   p->line_wrap = it->line_wrap;
+  p->bidi_p = it->bidi_p;
+  p->paragraph_embedding = it->paragraph_embedding;
+  p->from_disp_prop_p = it->from_disp_prop_p;
   ++it->sp;
+
+  /* Save the state of the bidi iterator as well. */
+  if (it->bidi_p)
+    bidi_push_it (&it->bidi_it);
 }
 
 static void
 iterate_out_of_display_property (struct it *it)
 {
+  int buffer_p = BUFFERP (it->object);
+  EMACS_INT eob = (buffer_p ? ZV : it->end_charpos);
+  EMACS_INT bob = (buffer_p ? BEGV : 0);
+
   /* Maybe initialize paragraph direction.  If we are at the beginning
      of a new paragraph, next_element_from_buffer may not have a
      chance to do that.  */
-  if (it->bidi_it.first_elt && it->bidi_it.charpos < ZV)
+  if (it->bidi_it.first_elt && it->bidi_it.charpos < eob)
     bidi_paragraph_init (it->paragraph_embedding, &it->bidi_it, 1);
   /* prev_stop can be zero, so check against BEGV as well.  */
-  while (it->bidi_it.charpos >= BEGV
+  while (it->bidi_it.charpos >= bob
          && it->prev_stop <= it->bidi_it.charpos
          && it->bidi_it.charpos < CHARPOS (it->position))
     bidi_move_to_visually_next (&it->bidi_it);
@@ -5090,7 +5358,10 @@ iterate_out_of_display_property (struct it *it)
     {
       SET_TEXT_POS (it->position,
                     it->bidi_it.charpos, it->bidi_it.bytepos);
-      it->current.pos = it->position;
+      if (buffer_p)
+        it->current.pos = it->position;
+      else
+        it->current.string_pos = it->position;
     }
 }
 
@@ -5104,6 +5375,7 @@ static void
 pop_it (struct it *it)
 {
   struct iterator_stack_entry *p;
+  int from_display_prop = it->from_disp_prop_p;
 
   xassert (it->sp > 0);
   --it->sp;
@@ -5131,22 +5403,10 @@ pop_it (struct it *it)
       it->object = p->u.xwidget.object;
       break;
     case GET_FROM_STRETCH:
-      it->object = p->u.comp.object;
+      it->object = p->u.stretch.object;
       break;
     case GET_FROM_BUFFER:
       it->object = it->w->buffer;
-      if (it->bidi_p)
-        {
-          /* Bidi-iterate until we get out of the portion of text, if
-             any, covered by a `display' text property or an overlay
-             with `display' property.  (We cannot just jump there,
-             because the internal coherency of the bidi iterator state
-             can not be preserved across such jumps.)  We also must
-             determine the paragraph base direction if the overlay we
-             just processed is at the beginning of a new
-             paragraph.  */
-          iterate_out_of_display_property (it);
-        }
       break;
     case GET_FROM_STRING:
       it->object = it->string;
@@ -5172,6 +5432,30 @@ pop_it (struct it *it)
   it->voffset = p->voffset;
   it->string_from_display_prop_p = p->string_from_display_prop_p;
   it->line_wrap = p->line_wrap;
+  it->bidi_p = p->bidi_p;
+  it->paragraph_embedding = p->paragraph_embedding;
+  it->from_disp_prop_p = p->from_disp_prop_p;
+  if (it->bidi_p)
+    {
+      bidi_pop_it (&it->bidi_it);
+      /* Bidi-iterate until we get out of the portion of text, if any,
+         covered by a `display' text property or by an overlay with
+         `display' property.  (We cannot just jump there, because the
+         internal coherency of the bidi iterator state can not be
+         preserved across such jumps.)  We also must determine the
+         paragraph base direction if the overlay we just processed is
+         at the beginning of a new paragraph.  */
+      if (from_display_prop
+          && (it->method == GET_FROM_BUFFER || it->method == GET_FROM_STRING))
+        iterate_out_of_display_property (it);
+
+      xassert ((BUFFERP (it->object)
+                && IT_CHARPOS (*it) == it->bidi_it.charpos
+                && IT_BYTEPOS (*it) == it->bidi_it.bytepos)
+               || (STRINGP (it->object)
+                   && IT_STRING_CHARPOS (*it) == it->bidi_it.charpos
+                   && IT_STRING_BYTEPOS (*it) == it->bidi_it.bytepos));
+    }
 }
 
 
@@ -5255,15 +5539,16 @@ forward_to_next_line_start (struct it *it, int *skipped_p)
 
       xassert (!STRINGP (it->string));
 
-      /* If there isn't any `display' property in sight, and no
-         overlays, we can just use the position of the newline in
-         buffer text.  */
-      if (it->stop_charpos >= limit
-          || ((pos = Fnext_single_property_change (make_number (start),
-                                                   Qdisplay,
-                                                   Qnil, make_number (limit)),
-               NILP (pos))
-              && next_overlay_change (start) == ZV))
+      /* If we are not bidi-reordering, and there isn't any `display'
+         property in sight, and no overlays, we can just use the
+         position of the newline in buffer text.  */
+      if (!it->bidi_p
+          && (it->stop_charpos >= limit
+              || ((pos = Fnext_single_property_change (make_number (start),
+                                                       Qdisplay, Qnil,
+                                                       make_number (limit)),
+                   NILP (pos))
+                  && next_overlay_change (start) == ZV)))
         {
           IT_CHARPOS (*it) = limit;
           IT_BYTEPOS (*it) = CHAR_TO_BYTE (limit);
@@ -5321,10 +5606,13 @@ back_to_previous_visible_line_start (struct it *it)
 
       {
         struct it it2;
+        void *it2data = NULL;
         EMACS_INT pos;
         EMACS_INT beg, end;
         Lisp_Object val, overlay;
 
+        SAVE_IT (it2, *it, it2data);
+
         /* 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))
@@ -5332,20 +5620,25 @@ back_to_previous_visible_line_start (struct it *it)
 
         /* 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;
+        bidi_unshelve_cache (NULL);
         it2.string_from_display_prop_p = 0;
+        it2.from_disp_prop_p = 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;
+          {
+            RESTORE_IT (it, it, it2data);
+            goto replaced;
+          }
 
         /* Newline is not replaced by anything -- so we are done.  */
+        RESTORE_IT (it, it, it2data);
         break;
 
       replaced:
@@ -5412,14 +5705,29 @@ reseat_at_next_visible_line_start (struct it *it, int on_newline_p)
         {
           if (IT_STRING_CHARPOS (*it) > 0)
             {
-              --IT_STRING_CHARPOS (*it);
-              --IT_STRING_BYTEPOS (*it);
+              if (!it->bidi_p)
+                {
+                  --IT_STRING_CHARPOS (*it);
+                  --IT_STRING_BYTEPOS (*it);
+                }
+              else
+                /* Setting this flag will cause
+                   bidi_move_to_visually_next not to advance, but
+                   instead deliver the current character (newline),
+                   which is what the ON_NEWLINE_P flag wants.  */
+                it->bidi_it.first_elt = 1;
             }
         }
       else if (IT_CHARPOS (*it) > BEGV)
         {
-          --IT_CHARPOS (*it);
-          --IT_BYTEPOS (*it);
+          if (!it->bidi_p)
+            {
+              --IT_CHARPOS (*it);
+              --IT_BYTEPOS (*it);
+            }
+          /* With bidi iteration, the call to `reseat' will cause
+             bidi_move_to_visually_next deliver the current character,
+             the newline, instead of advancing.  */
           reseat (it, it->current.pos, 0);
         }
     }
@@ -5501,19 +5809,24 @@ reseat_1 (struct it *it, struct text_pos pos, int set_stop_p)
   IT_STRING_CHARPOS (*it) = -1;
   IT_STRING_BYTEPOS (*it) = -1;
   it->string = Qnil;
-  it->string_from_display_prop_p = 0;
   it->method = GET_FROM_BUFFER;
   it->object = it->w->buffer;
   it->area = TEXT_AREA;
   it->multibyte_p = !NILP (BVAR (current_buffer, enable_multibyte_characters));
   it->sp = 0;
   it->string_from_display_prop_p = 0;
+  it->from_disp_prop_p = 0;
   it->face_before_selective_p = 0;
   if (it->bidi_p)
     {
-      it->bidi_it.first_elt = 1;
+      bidi_init_it (IT_CHARPOS (*it), IT_BYTEPOS (*it), FRAME_WINDOW_P (it->f),
+                    &it->bidi_it);
+      bidi_unshelve_cache (NULL);
       it->bidi_it.paragraph_dir = NEUTRAL_DIR;
-      it->bidi_it.disp_pos = -1;
+      it->bidi_it.string.s = NULL;
+      it->bidi_it.string.lstring = Qnil;
+      it->bidi_it.string.bufpos = 0;
+      it->bidi_it.string.unibyte = 0;
     }
 
   if (set_stop_p)
@@ -5564,6 +5877,10 @@ reseat_to_string (struct it *it, const char *s, Lisp_Object string,
   if (multibyte >= 0)
     it->multibyte_p = multibyte > 0;
 
+  /* Bidirectional reordering of strings is controlled by the default
+     value of bidi-display-reordering.  */
+  it->bidi_p = !NILP (BVAR (&buffer_defaults, bidi_display_reordering));
+
   if (s == NULL)
     {
       xassert (STRINGP (string));
@@ -5572,6 +5889,18 @@ reseat_to_string (struct it *it, const char *s, Lisp_Object string,
       it->end_charpos = it->string_nchars = SCHARS (string);
       it->method = GET_FROM_STRING;
       it->current.string_pos = string_pos (charpos, string);
+
+      if (it->bidi_p)
+        {
+          it->bidi_it.string.lstring = string;
+          it->bidi_it.string.s = NULL;
+          it->bidi_it.string.schars = it->end_charpos;
+          it->bidi_it.string.bufpos = 0;
+          it->bidi_it.string.from_disp_str = 0;
+          it->bidi_it.string.unibyte = !it->multibyte_p;
+          bidi_init_it (charpos, IT_STRING_BYTEPOS (*it),
+                        FRAME_WINDOW_P (it->f), &it->bidi_it);
+        }
     }
   else
     {
@@ -5592,13 +5921,28 @@ reseat_to_string (struct it *it, const char *s, Lisp_Object string,
           it->end_charpos = it->string_nchars = strlen (s);
         }
 
+      if (it->bidi_p)
+        {
+          it->bidi_it.string.lstring = Qnil;
+          it->bidi_it.string.s = (const unsigned char *) s;
+          it->bidi_it.string.schars = it->end_charpos;
+          it->bidi_it.string.bufpos = 0;
+          it->bidi_it.string.from_disp_str = 0;
+          it->bidi_it.string.unibyte = !it->multibyte_p;
+          bidi_init_it (charpos, IT_BYTEPOS (*it), FRAME_WINDOW_P (it->f),
+                        &it->bidi_it);
+        }
       it->method = GET_FROM_C_STRING;
     }
 
   /* PRECISION > 0 means don't return more than PRECISION characters
      from the string.  */
   if (precision > 0 && it->end_charpos - charpos > precision)
-    it->end_charpos = it->string_nchars = charpos + precision;
+    {
+      it->end_charpos = it->string_nchars = charpos + precision;
+      if (it->bidi_p)
+        it->bidi_it.string.schars = it->end_charpos;
+    }
 
   /* FIELD_WIDTH > 0 means pad with spaces until FIELD_WIDTH
      characters have been returned.  FIELD_WIDTH == 0 means don't pad,
@@ -5606,6 +5950,9 @@ reseat_to_string (struct it *it, const char *s, Lisp_Object string,
      padding with `-' at the end of a mode line.  */
   if (field_width < 0)
     field_width = INFINITY;
+  /* Implementation note: We deliberately don't enlarge
+     it->bidi_it.string.schars here to fit it->end_charpos, because
+     the bidi iterator cannot produce characters out of thin air.  */
   if (field_width > it->end_charpos - charpos)
     it->end_charpos = charpos + field_width;
 
@@ -5614,6 +5961,14 @@ reseat_to_string (struct it *it, const char *s, Lisp_Object string,
     it->dp = XCHAR_TABLE (Vstandard_display_table);
 
   it->stop_charpos = charpos;
+  it->prev_stop = charpos;
+  it->base_level_stop = 0;
+  if (it->bidi_p)
+    {
+      it->bidi_it.first_elt = 1;
+      it->bidi_it.paragraph_dir = NEUTRAL_DIR;
+      it->bidi_it.disp_pos = -1;
+    }
   if (s == NULL && it->multibyte_p)
     {
       EMACS_INT endpos = SCHARS (it->string);
@@ -6249,8 +6604,22 @@ set_iterator_to_next (struct it *it, int reseat_p)
 
     case GET_FROM_C_STRING:
       /* Current display element of IT is from a C string.  */
-      IT_BYTEPOS (*it) += it->len;
-      IT_CHARPOS (*it) += 1;
+      if (!it->bidi_p
+          /* If the string position is beyond string's end, it means
+             next_element_from_c_string is padding the string with
+             blanks, in which case we bypass the bidi iterator,
+             because it cannot deal with such virtual characters.  */
+          || IT_CHARPOS (*it) >= it->bidi_it.string.schars)
+        {
+          IT_BYTEPOS (*it) += it->len;
+          IT_CHARPOS (*it) += 1;
+        }
+      else
+        {
+          bidi_move_to_visually_next (&it->bidi_it);
+          IT_BYTEPOS (*it) = it->bidi_it.bytepos;
+          IT_CHARPOS (*it) = it->bidi_it.charpos;
+        }
       break;
 
     case GET_FROM_DISPLAY_VECTOR:
@@ -6304,23 +6673,95 @@ set_iterator_to_next (struct it *it, int reseat_p)
       xassert (it->s == NULL && STRINGP (it->string));
       if (it->cmp_it.id >= 0)
         {
-          IT_STRING_CHARPOS (*it) += it->cmp_it.nchars;
-          IT_STRING_BYTEPOS (*it) += it->cmp_it.nbytes;
-          if (it->cmp_it.to < it->cmp_it.nglyphs)
-            it->cmp_it.from = it->cmp_it.to;
+          int i;
+
+          if (! it->bidi_p)
+            {
+              IT_STRING_CHARPOS (*it) += it->cmp_it.nchars;
+              IT_STRING_BYTEPOS (*it) += it->cmp_it.nbytes;
+              if (it->cmp_it.to < it->cmp_it.nglyphs)
+                it->cmp_it.from = it->cmp_it.to;
+              else
+                {
+                  it->cmp_it.id = -1;
+                  composition_compute_stop_pos (&it->cmp_it,
+                                                IT_STRING_CHARPOS (*it),
+                                                IT_STRING_BYTEPOS (*it),
+                                                it->end_charpos, it->string);
+                }
+            }
+          else if (! it->cmp_it.reversed_p)
+            {
+              for (i = 0; i < it->cmp_it.nchars; i++)
+                bidi_move_to_visually_next (&it->bidi_it);
+              IT_STRING_BYTEPOS (*it) = it->bidi_it.bytepos;
+              IT_STRING_CHARPOS (*it) = it->bidi_it.charpos;
+
+              if (it->cmp_it.to < it->cmp_it.nglyphs)
+                it->cmp_it.from = it->cmp_it.to;
+              else
+                {
+                  EMACS_INT stop = it->end_charpos;
+                  if (it->bidi_it.scan_dir < 0)
+                    stop = -1;
+                  composition_compute_stop_pos (&it->cmp_it,
+                                                IT_STRING_CHARPOS (*it),
+                                                IT_STRING_BYTEPOS (*it), stop,
+                                                it->string);
+                }
+            }
           else
             {
-              it->cmp_it.id = -1;
-              composition_compute_stop_pos (&it->cmp_it,
-                                            IT_STRING_CHARPOS (*it),
-                                            IT_STRING_BYTEPOS (*it),
-                                            it->end_charpos, it->string);
+              for (i = 0; i < it->cmp_it.nchars; i++)
+                bidi_move_to_visually_next (&it->bidi_it);
+              IT_STRING_BYTEPOS (*it) = it->bidi_it.bytepos;
+              IT_STRING_CHARPOS (*it) = it->bidi_it.charpos;
+              if (it->cmp_it.from > 0)
+                it->cmp_it.to = it->cmp_it.from;
+              else
+                {
+                  EMACS_INT stop = it->end_charpos;
+                  if (it->bidi_it.scan_dir < 0)
+                    stop = -1;
+                  composition_compute_stop_pos (&it->cmp_it,
+                                                IT_STRING_CHARPOS (*it),
+                                                IT_STRING_BYTEPOS (*it), stop,
+                                                it->string);
+                }
             }
         }
       else
         {
-          IT_STRING_BYTEPOS (*it) += it->len;
-          IT_STRING_CHARPOS (*it) += 1;
+          if (!it->bidi_p
+              /* If the string position is beyond string's end, it
+                 means next_element_from_string is padding the string
+                 with blanks, in which case we bypass the bidi
+                 iterator, because it cannot deal with such virtual
+                 characters.  */
+              || IT_STRING_CHARPOS (*it) >= it->bidi_it.string.schars)
+            {
+              IT_STRING_BYTEPOS (*it) += it->len;
+              IT_STRING_CHARPOS (*it) += 1;
+            }
+          else
+            {
+              int prev_scan_dir = it->bidi_it.scan_dir;
+
+              bidi_move_to_visually_next (&it->bidi_it);
+              IT_STRING_BYTEPOS (*it) = it->bidi_it.bytepos;
+              IT_STRING_CHARPOS (*it) = it->bidi_it.charpos;
+              if (prev_scan_dir != it->bidi_it.scan_dir)
+                {
+                  EMACS_INT stop = it->end_charpos;
+
+                  if (it->bidi_it.scan_dir < 0)
+                    stop = -1;
+                  composition_compute_stop_pos (&it->cmp_it,
+                                                IT_STRING_CHARPOS (*it),
+                                                IT_STRING_BYTEPOS (*it), stop,
+                                                it->string);
+                }
+            }
         }
 
     consider_string_end:
@@ -6427,6 +6868,107 @@ next_element_from_display_vector (struct it *it)
   return 1;
 }
 
+/* Get the first element of string/buffer in the visual order, after
+   being reseated to a new position in a string or a buffer.  */
+static void
+get_visually_first_element (struct it *it)
+{
+  int string_p = STRINGP (it->string) || it->s;
+  EMACS_INT eob = (string_p ? it->bidi_it.string.schars : ZV);
+  EMACS_INT bob = (string_p ? 0 : BEGV);
+
+  if (STRINGP (it->string))
+    {
+      it->bidi_it.charpos = IT_STRING_CHARPOS (*it);
+      it->bidi_it.bytepos = IT_STRING_BYTEPOS (*it);
+    }
+  else
+    {
+      it->bidi_it.charpos = IT_CHARPOS (*it);
+      it->bidi_it.bytepos = IT_BYTEPOS (*it);
+    }
+
+  if (it->bidi_it.charpos == eob)
+    {
+      /* Nothing to do, but reset the FIRST_ELT flag, like
+         bidi_paragraph_init does, because we are not going to
+         call it.  */
+      it->bidi_it.first_elt = 0;
+    }
+  else if (it->bidi_it.charpos == bob
+           || (!string_p
+               /* FIXME: Should support all Unicode line separators.  */
+               && (FETCH_CHAR (it->bidi_it.bytepos - 1) == '\n'
+                   || FETCH_CHAR (it->bidi_it.bytepos) == '\n')))
+    {
+      /* If we are at the beginning of a line/string, we can produce
+         the next element right away.  */
+      bidi_paragraph_init (it->paragraph_embedding, &it->bidi_it, 1);
+      bidi_move_to_visually_next (&it->bidi_it);
+    }
+  else
+    {
+      EMACS_INT orig_bytepos = it->bidi_it.bytepos;
+
+      /* We need to prime the bidi iterator starting at the line's or
+         string's beginning, before we will be able to produce the
+         next element.  */
+      if (string_p)
+        it->bidi_it.charpos = it->bidi_it.bytepos = 0;
+      else
+        {
+          it->bidi_it.charpos = find_next_newline_no_quit (IT_CHARPOS (*it),
+                                                           -1);
+          it->bidi_it.bytepos = CHAR_TO_BYTE (it->bidi_it.charpos);
+        }
+      bidi_paragraph_init (it->paragraph_embedding, &it->bidi_it, 1);
+      do
+        {
+          /* Now return to buffer/string position where we were asked
+             to get the next display element, and produce that.  */
+          bidi_move_to_visually_next (&it->bidi_it);
+        }
+      while (it->bidi_it.bytepos != orig_bytepos
+             && it->bidi_it.charpos < eob);
+    }
+
+  /*  Adjust IT's position information to where we ended up.  */
+  if (STRINGP (it->string))
+    {
+      IT_STRING_CHARPOS (*it) = it->bidi_it.charpos;
+      IT_STRING_BYTEPOS (*it) = it->bidi_it.bytepos;
+    }
+  else
+    {
+      IT_CHARPOS (*it) = it->bidi_it.charpos;
+      IT_BYTEPOS (*it) = it->bidi_it.bytepos;
+    }
+
+  if (STRINGP (it->string) || !it->s)
+    {
+      EMACS_INT stop, charpos, bytepos;
+
+      if (STRINGP (it->string))
+        {
+          xassert (!it->s);
+          stop = SCHARS (it->string);
+          if (stop > it->end_charpos)
+            stop = it->end_charpos;
+          charpos = IT_STRING_CHARPOS (*it);
+          bytepos = IT_STRING_BYTEPOS (*it);
+        }
+      else
+        {
+          stop = it->end_charpos;
+          charpos = IT_CHARPOS (*it);
+          bytepos = IT_BYTEPOS (*it);
+        }
+      if (it->bidi_it.scan_dir < 0)
+        stop = -1;
+      composition_compute_stop_pos (&it->cmp_it, charpos, bytepos, stop,
+                                    it->string);
+    }
+}
 
 /* Load IT with the next display element from Lisp string IT->string.
    IT->current.string_pos is the current position within the string.
@@ -6439,18 +6981,79 @@ next_element_from_string (struct it *it)
   struct text_pos position;
 
   xassert (STRINGP (it->string));
+  xassert (!it->bidi_p || it->string == it->bidi_it.string.lstring);
   xassert (IT_STRING_CHARPOS (*it) >= 0);
   position = it->current.string_pos;
 
+  /* With bidi reordering, the character to display might not be the
+     character at IT_STRING_CHARPOS.  BIDI_IT.FIRST_ELT non-zero means
+     that we were reseat()ed to a new string, whose paragraph
+     direction is not known.  */
+  if (it->bidi_p && it->bidi_it.first_elt)
+    {
+      get_visually_first_element (it);
+      SET_TEXT_POS (position, IT_STRING_CHARPOS (*it), IT_STRING_BYTEPOS (*it));
+    }
+
   /* Time to check for invisible text?  */
-  if (IT_STRING_CHARPOS (*it) < it->end_charpos
-      && IT_STRING_CHARPOS (*it) == it->stop_charpos)
+  if (IT_STRING_CHARPOS (*it) < it->end_charpos)
     {
-      handle_stop (it);
+      if (IT_STRING_CHARPOS (*it) >= it->stop_charpos)
+        {
+          if (!(!it->bidi_p
+                || BIDI_AT_BASE_LEVEL (it->bidi_it)
+                || IT_STRING_CHARPOS (*it) == it->stop_charpos))
+            {
+              /* With bidi non-linear iteration, we could find
+                 ourselves far beyond the last computed stop_charpos,
+                 with several other stop positions in between that we
+                 missed.  Scan them all now, in buffer's logical
+                 order, until we find and handle the last stop_charpos
+                 that precedes our current position.  */
+              handle_stop_backwards (it, it->stop_charpos);
+              return GET_NEXT_DISPLAY_ELEMENT (it);
+            }
+          else
+            {
+              if (it->bidi_p)
+                {
+                  /* Take note of the stop position we just moved
+                     across, for when we will move back across it.  */
+                  it->prev_stop = it->stop_charpos;
+                  /* If we are at base paragraph embedding level, take
+                     note of the last stop position seen at this
+                     level.  */
+                  if (BIDI_AT_BASE_LEVEL (it->bidi_it))
+                    it->base_level_stop = it->stop_charpos;
+                }
+              handle_stop (it);
 
-      /* Since a handler may have changed IT->method, we must
-         recurse here.  */
-      return GET_NEXT_DISPLAY_ELEMENT (it);
+              /* Since a handler may have changed IT->method, we must
+                 recurse here.  */
+              return GET_NEXT_DISPLAY_ELEMENT (it);
+            }
+        }
+      else if (it->bidi_p
+               /* If we are before prev_stop, we may have overstepped
+                  on our way backwards a stop_pos, and if so, we need
+                  to handle that stop_pos.  */
+               && IT_STRING_CHARPOS (*it) < it->prev_stop
+               /* We can sometimes back up for reasons that have nothing
+                  to do with bidi reordering.  E.g., compositions.  The
+                  code below is only needed when we are above the base
+                  embedding level, so test for that explicitly.  */
+               && !BIDI_AT_BASE_LEVEL (it->bidi_it))
+        {
+          /* If we lost track of base_level_stop, we have no better place
+             for handle_stop_backwards to start from than BEGV.  This
+             happens, e.g., when we were reseated to the previous
+             screenful of text by vertical-motion.  */
+          if (it->base_level_stop <= 0
+              || IT_STRING_CHARPOS (*it) < it->base_level_stop)
+            it->base_level_stop = 0;
+          handle_stop_backwards (it, it->base_level_stop);
+          return GET_NEXT_DISPLAY_ELEMENT (it);
+        }
     }
 
   if (it->current.overlay_string_index >= 0)
@@ -6464,7 +7067,10 @@ next_element_from_string (struct it *it)
           return 0;
         }
       else if (CHAR_COMPOSED_P (it, IT_STRING_CHARPOS (*it),
-                                IT_STRING_BYTEPOS (*it), SCHARS (it->string))
+                                IT_STRING_BYTEPOS (*it),
+                                it->bidi_it.scan_dir < 0
+                                ? -1
+                                : SCHARS (it->string))
                && next_element_from_composition (it))
         {
           return 1;
@@ -6499,7 +7105,10 @@ next_element_from_string (struct it *it)
           CHARPOS (position) = BYTEPOS (position) = -1;
         }
       else if (CHAR_COMPOSED_P (it, IT_STRING_CHARPOS (*it),
-                                IT_STRING_BYTEPOS (*it), it->string_nchars)
+                                IT_STRING_BYTEPOS (*it),
+                                it->bidi_it.scan_dir < 0
+                                ? -1
+                                : it->string_nchars)
                && next_element_from_composition (it))
         {
           return 1;
@@ -6538,12 +7147,20 @@ next_element_from_c_string (struct it *it)
   int success_p = 1;
 
   xassert (it->s);
+  xassert (!it->bidi_p || it->s == it->bidi_it.string.s);
   it->what = IT_CHARACTER;
   BYTEPOS (it->position) = CHARPOS (it->position) = 0;
   it->object = Qnil;
 
-  /* IT's position can be greater IT->string_nchars in case a field
-     width or precision has been specified when the iterator was
+  /* With bidi reordering, the character to display might not be the
+     character at IT_CHARPOS.  BIDI_IT.FIRST_ELT non-zero means that
+     we were reseated to a new string, whose paragraph direction is
+     not known.  */
+  if (it->bidi_p && it->bidi_it.first_elt)
+    get_visually_first_element (it);
+
+  /* IT's position can be greater than IT->string_nchars in case a
+     field width or precision has been specified when the iterator was
      initialized.  */
   if (IT_CHARPOS (*it) >= it->end_charpos)
     {
@@ -6630,18 +7247,19 @@ next_element_from_stretch (struct it *it)
   return 1;
 }
 
-/* Scan forward from CHARPOS in the current buffer, until we find a
-   stop position > current IT's position.  Then handle the stop
+/* Scan forward from CHARPOS in the current buffer/string, until we
+   find a stop position > current IT's position.  Then handle the stop
    position before that.  This is called when we bump into a stop
    position while reordering bidirectional text.  CHARPOS should be
-   the last previously processed stop_pos (or BEGV, if none were
+   the last previously processed stop_pos (or BEGV/0, if none were
    processed yet) whose position is less that IT's current
    position.  */
 
 static void
 handle_stop_backwards (struct it *it, EMACS_INT charpos)
 {
-  EMACS_INT where_we_are = IT_CHARPOS (*it);
+  int bufp = !STRINGP (it->string);
+  EMACS_INT where_we_are = (bufp ? IT_CHARPOS (*it) : IT_STRING_CHARPOS (*it));
   struct display_pos save_current = it->current;
   struct text_pos save_position = it->position;
   struct text_pos pos1;
@@ -6652,8 +7270,13 @@ handle_stop_backwards (struct it *it, EMACS_INT charpos)
   do
     {
       it->prev_stop = charpos;
-      SET_TEXT_POS (pos1, charpos, CHAR_TO_BYTE (charpos));
-      reseat_1 (it, pos1, 0);
+      if (bufp)
+        {
+          SET_TEXT_POS (pos1, charpos, CHAR_TO_BYTE (charpos));
+          reseat_1 (it, pos1, 0);
+        }
+      else
+        it->current.string_pos = string_pos (charpos, it->string);
       compute_stop_pos (it);
       /* We must advance forward, right?  */
       if (it->stop_charpos <= it->prev_stop)
@@ -6682,6 +7305,10 @@ next_element_from_buffer (struct it *it)
   int success_p = 1;
 
   xassert (IT_CHARPOS (*it) >= BEGV);
+  xassert (NILP (it->string) && !it->s);
+  xassert (!it->bidi_p
+           || (it->bidi_it.string.lstring == Qnil
+               && it->bidi_it.string.s == NULL));
 
   /* With bidi reordering, the character to display might not be the
      character at IT_CHARPOS.  BIDI_IT.FIRST_ELT non-zero means that
@@ -6689,59 +7316,8 @@ next_element_from_buffer (struct it *it)
      a different paragraph.  */
   if (it->bidi_p && it->bidi_it.first_elt)
     {
-      it->bidi_it.charpos = IT_CHARPOS (*it);
-      it->bidi_it.bytepos = IT_BYTEPOS (*it);
-      if (it->bidi_it.bytepos == ZV_BYTE)
-        {
-          /* Nothing to do, but reset the FIRST_ELT flag, like
-             bidi_paragraph_init does, because we are not going to
-             call it.  */
-          it->bidi_it.first_elt = 0;
-        }
-      else if (it->bidi_it.bytepos == BEGV_BYTE
-          /* FIXME: Should support all Unicode line separators.  */
-          || FETCH_CHAR (it->bidi_it.bytepos - 1) == '\n'
-          || FETCH_CHAR (it->bidi_it.bytepos) == '\n')
-        {
-          /* If we are at the beginning of a line, we can produce the
-             next element right away.  */
-          bidi_paragraph_init (it->paragraph_embedding, &it->bidi_it, 1);
-          bidi_move_to_visually_next (&it->bidi_it);
-        }
-      else
-        {
-          EMACS_INT orig_bytepos = IT_BYTEPOS (*it);
-
-          /* We need to prime the bidi iterator starting at the line's
-             beginning, before we will be able to produce the next
-             element.  */
-          IT_CHARPOS (*it) = find_next_newline_no_quit (IT_CHARPOS (*it), -1);
-          IT_BYTEPOS (*it) = CHAR_TO_BYTE (IT_CHARPOS (*it));
-          it->bidi_it.charpos = IT_CHARPOS (*it);
-          it->bidi_it.bytepos = IT_BYTEPOS (*it);
-          bidi_paragraph_init (it->paragraph_embedding, &it->bidi_it, 1);
-          do
-            {
-              /* Now return to buffer position where we were asked to
-                 get the next display element, and produce that.  */
-              bidi_move_to_visually_next (&it->bidi_it);
-            }
-          while (it->bidi_it.bytepos != orig_bytepos
-                 && it->bidi_it.bytepos < ZV_BYTE);
-        }
-
-      it->bidi_it.first_elt = 0; /* paranoia: bidi.c does this */
-      /*  Adjust IT's position information to where we ended up.  */
-      IT_CHARPOS (*it) = it->bidi_it.charpos;
-      IT_BYTEPOS (*it) = it->bidi_it.bytepos;
+      get_visually_first_element (it);
       SET_TEXT_POS (it->position, IT_CHARPOS (*it), IT_BYTEPOS (*it));
-      {
-        EMACS_INT stop = it->end_charpos;
-        if (it->bidi_it.scan_dir < 0)
-          stop = -1;
-        composition_compute_stop_pos (&it->cmp_it, IT_CHARPOS (*it),
-                                      IT_BYTEPOS (*it), stop, Qnil);
-      }
     }
 
   if (IT_CHARPOS (*it) >= it->stop_charpos)
@@ -6800,17 +7376,23 @@ next_element_from_buffer (struct it *it)
         }
     }
   else if (it->bidi_p
+           /* If we are before prev_stop, we may have overstepped on
+              our way backwards a stop_pos, and if so, we need to
+              handle that stop_pos.  */
+           && IT_CHARPOS (*it) < it->prev_stop
            /* We can sometimes back up for reasons that have nothing
               to do with bidi reordering.  E.g., compositions.  The
               code below is only needed when we are above the base
               embedding level, so test for that explicitly.  */
-           && !BIDI_AT_BASE_LEVEL (it->bidi_it)
-           && IT_CHARPOS (*it) < it->prev_stop)
-    {
-      if (it->base_level_stop <= 0)
+           && !BIDI_AT_BASE_LEVEL (it->bidi_it))
+    {
+      /* If we lost track of base_level_stop, we have no better place
+         for handle_stop_backwards to start from than BEGV.  This
+         happens, e.g., when we were reseated to the previous
+         screenful of text by vertical-motion.  */
+      if (it->base_level_stop <= 0
+          || IT_CHARPOS (*it) < it->base_level_stop)
         it->base_level_stop = BEGV;
-      if (IT_CHARPOS (*it) < it->base_level_stop)
-        abort ();
       handle_stop_backwards (it, it->base_level_stop);
       return GET_NEXT_DISPLAY_ELEMENT (it);
     }
@@ -7014,9 +7596,11 @@ move_it_in_display_line_to (struct it *it,
   enum move_it_result result = MOVE_UNDEFINED;
   struct glyph_row *saved_glyph_row;
   struct it wrap_it, atpos_it, atx_it;
+  void *wrap_data = NULL, *atpos_data = NULL, *atx_data = NULL;
   int may_wrap = 0;
   enum it_method prev_method = it->method;
   EMACS_INT prev_pos = IT_CHARPOS (*it);
+  int saw_smaller_pos = prev_pos < to_charpos;
 
   /* Don't produce glyphs in produce_glyphs.  */
   saved_glyph_row = it->glyph_row;
@@ -7057,15 +7641,16 @@ move_it_in_display_line_to (struct it *it,
   ((IT)->current_x = x, (IT)->max_ascent = ascent,      \
    (IT)->max_descent = descent)
 
-      /* Stop if we move beyond TO_CHARPOS (after an image or stretch
-         glyph).  */
+      /* Stop if we move beyond TO_CHARPOS (after an image or a
+         display string or stretch glyph).  */
       if ((op & MOVE_TO_POS) != 0
           && BUFFERP (it->object)
           && it->method == GET_FROM_BUFFER
           && ((!it->bidi_p && IT_CHARPOS (*it) > to_charpos)
               || (it->bidi_p
                   && (prev_method == GET_FROM_IMAGE
-                      || prev_method == GET_FROM_STRETCH)
+                      || prev_method == GET_FROM_STRETCH
+                      || prev_method == GET_FROM_STRING)
                   /* Passed TO_CHARPOS from left to right.  */
                   && ((prev_pos < to_charpos
                        && IT_CHARPOS (*it) > to_charpos)
@@ -7082,12 +7667,9 @@ move_it_in_display_line_to (struct it *it,
             /* If wrap_it is valid, the current position might be in a
                word that is wrapped.  So, save the iterator in
                atpos_it and continue to see if wrapping happens.  */
-            atpos_it = *it;
+            SAVE_IT (atpos_it, *it, atpos_data);
         }
 
-      prev_method = it->method;
-      if (it->method == GET_FROM_BUFFER)
-        prev_pos = IT_CHARPOS (*it);
       /* Stop when ZV reached.
          We used to stop here when TO_CHARPOS reached as well, but that is
          too soon if this glyph does not fit on this line.  So we handle it
@@ -7119,18 +7701,18 @@ move_it_in_display_line_to (struct it *it,
                      already found, we are done.  */
                   if (atpos_it.sp >= 0)
                     {
-                      *it = atpos_it;
+                      RESTORE_IT (it, &atpos_it, atpos_data);
                       result = MOVE_POS_MATCH_OR_ZV;
                       goto done;
                     }
                   if (atx_it.sp >= 0)
                     {
-                      *it = atx_it;
+                      RESTORE_IT (it, &atx_it, atx_data);
                       result = MOVE_X_REACHED;
                       goto done;
                     }
                   /* Otherwise, we can wrap here.  */
-                  wrap_it = *it;
+                  SAVE_IT (wrap_it, *it, wrap_data);
                   may_wrap = 0;
                 }
             }
@@ -7151,6 +7733,9 @@ move_it_in_display_line_to (struct it *it,
 
       if (it->area != TEXT_AREA)
         {
+          prev_method = it->method;
+          if (it->method == GET_FROM_BUFFER)
+            prev_pos = IT_CHARPOS (*it);
           set_iterator_to_next (it, 1);
           if (IT_CHARPOS (*it) < CHARPOS (this_line_min_pos))
             SET_TEXT_POS (this_line_min_pos,
@@ -7198,7 +7783,7 @@ move_it_in_display_line_to (struct it *it,
                         goto buffer_pos_reached;
                       if (atpos_it.sp < 0)
                         {
-                          atpos_it = *it;
+                          SAVE_IT (atpos_it, *it, atpos_data);
                           IT_RESET_X_ASCENT_DESCENT (&atpos_it);
                         }
                     }
@@ -7212,7 +7797,7 @@ move_it_in_display_line_to (struct it *it,
                         }
                       if (atx_it.sp < 0)
                         {
-                          atx_it = *it;
+                          SAVE_IT (atx_it, *it, atx_data);
                           IT_RESET_X_ASCENT_DESCENT (&atx_it);
                         }
                     }
@@ -7256,12 +7841,15 @@ move_it_in_display_line_to (struct it *it,
                               if (it->line_wrap == WORD_WRAP
                                   && atpos_it.sp < 0)
                                 {
-                                  atpos_it = *it;
+                                  SAVE_IT (atpos_it, *it, atpos_data);
                                   atpos_it.current_x = x_before_this_char;
                                   atpos_it.hpos = hpos_before_this_char;
                                 }
                             }
 
+                          prev_method = it->method;
+                          if (it->method == GET_FROM_BUFFER)
+                            prev_pos = IT_CHARPOS (*it);
                           set_iterator_to_next (it, 1);
                           if (IT_CHARPOS (*it) < CHARPOS (this_line_min_pos))
                             SET_TEXT_POS (this_line_min_pos,
@@ -7301,7 +7889,7 @@ move_it_in_display_line_to (struct it *it,
 
                   if (wrap_it.sp >= 0)
                     {
-                      *it = wrap_it;
+                      RESTORE_IT (it, &wrap_it, wrap_data);
                       atpos_it.sp = -1;
                       atx_it.sp = -1;
                     }
@@ -7318,7 +7906,7 @@ move_it_in_display_line_to (struct it *it,
                     goto buffer_pos_reached;
                   if (it->line_wrap == WORD_WRAP && atpos_it.sp < 0)
                     {
-                      atpos_it = *it;
+                      SAVE_IT (atpos_it, *it, atpos_data);
                       IT_RESET_X_ASCENT_DESCENT (&atpos_it);
                     }
                 }
@@ -7355,10 +7943,20 @@ move_it_in_display_line_to (struct it *it,
       /* Is this a line end?  If yes, we're done.  */
       if (ITERATOR_AT_END_OF_LINE_P (it))
         {
-          result = MOVE_NEWLINE_OR_CR;
+          /* If we are past TO_CHARPOS, but never saw any character
+             positions smaller than TO_CHARPOS, return
+             MOVE_POS_MATCH_OR_ZV, like the unidirectional display
+             did.  */
+          if ((op & MOVE_TO_POS) != 0
+              && !saw_smaller_pos
+              && IT_CHARPOS (*it) > to_charpos)
+            result = MOVE_POS_MATCH_OR_ZV;
+          else
+            result = MOVE_NEWLINE_OR_CR;
           break;
         }
 
+      prev_method = it->method;
       if (it->method == GET_FROM_BUFFER)
         prev_pos = IT_CHARPOS (*it);
       /* The current display element has been consumed.  Advance
@@ -7366,6 +7964,8 @@ move_it_in_display_line_to (struct it *it,
       set_iterator_to_next (it, 1);
       if (IT_CHARPOS (*it) < CHARPOS (this_line_min_pos))
         SET_TEXT_POS (this_line_min_pos, IT_CHARPOS (*it), IT_BYTEPOS (*it));
+      if (IT_CHARPOS (*it) < to_charpos)
+        saw_smaller_pos = 1;
 
       /* Stop if lines are truncated and IT's current x-position is
          past the right edge of the window now.  */
@@ -7398,12 +7998,19 @@ move_it_in_display_line_to (struct it *it,
   /* If we scanned beyond to_pos and didn't find a point to wrap at,
      restore the saved iterator.  */
   if (atpos_it.sp >= 0)
-    *it = atpos_it;
+    RESTORE_IT (it, &atpos_it, atpos_data);
   else if (atx_it.sp >= 0)
-    *it = atx_it;
+    RESTORE_IT (it, &atx_it, atx_data);
 
  done:
 
+  if (atpos_data)
+    xfree (atpos_data);
+  if (atx_data)
+    xfree (atx_data);
+  if (wrap_data)
+    xfree (wrap_data);
+
   /* Restore the iterator settings altered at the beginning of this
      function.  */
   it->glyph_row = saved_glyph_row;
@@ -7419,8 +8026,12 @@ move_it_in_display_line (struct it *it,
   if (it->line_wrap == WORD_WRAP
       && (op & MOVE_TO_X))
     {
-      struct it save_it = *it;
-      int skip = move_it_in_display_line_to (it, to_charpos, to_x, op);
+      struct it save_it;
+      void *save_data = NULL;
+      int skip;
+
+      SAVE_IT (save_it, *it, save_data);
+      skip = move_it_in_display_line_to (it, to_charpos, to_x, op);
       /* When word-wrap is on, TO_X may lie past the end
          of a wrapped line.  Then it->current is the
          character on the next line, so backtrack to the
@@ -7428,10 +8039,12 @@ move_it_in_display_line (struct it *it,
       if (skip == MOVE_LINE_CONTINUED)
         {
           int prev_x = max (it->current_x - 1, 0);
-          *it = save_it;
+          RESTORE_IT (it, &save_it, save_data);
           move_it_in_display_line_to
             (it, -1, prev_x, MOVE_TO_X);
         }
+      else
+        xfree (save_data);
     }
   else
     move_it_in_display_line_to (it, to_charpos, to_x, op);
@@ -7446,14 +8059,15 @@ move_it_in_display_line (struct it *it,
    description of enum move_operation_enum.
 
    If TO_CHARPOS is in invisible text, e.g. a truncated part of a
-   screen line, this function will set IT to the next position >
-   TO_CHARPOS.  */
+   screen line, this function will set IT to the next position that is
+   displayed to the right of TO_CHARPOS on the screen.  */
 
 void
 move_it_to (struct it *it, EMACS_INT to_charpos, int to_x, int to_y, int to_vpos, int op)
 {
   enum move_it_result skip, skip2 = MOVE_X_REACHED;
   int line_height, line_start_x = 0, reached = 0;
+  void *backup_data = NULL;
 
   for (;;)
     {
@@ -7506,7 +8120,7 @@ move_it_to (struct it *it, EMACS_INT to_charpos, int to_x, int to_y, int to_vpos
           struct it it_backup;
 
           if (it->line_wrap == WORD_WRAP)
-            it_backup = *it;
+            SAVE_IT (it_backup, *it, backup_data);
 
           /* TO_Y specified means stop at TO_X in the line containing
              TO_Y---or at TO_CHARPOS if this is reached first.  The
@@ -7540,7 +8154,7 @@ move_it_to (struct it *it, EMACS_INT to_charpos, int to_x, int to_y, int to_vpos
                   reached = 6;
                   break;
                 }
-              it_backup = *it;
+              SAVE_IT (it_backup, *it, backup_data);
               TRACE_MOVE ((stderr, "move_it: from %d\n", IT_CHARPOS (*it)));
               skip2 = move_it_in_display_line_to (it, to_charpos, -1,
                                                   op & MOVE_TO_POS);
@@ -7554,7 +8168,7 @@ move_it_to (struct it *it, EMACS_INT to_charpos, int to_x, int to_y, int to_vpos
                   /* If TO_Y is in this line and TO_X was reached
                      above, we scanned too far.  We have to restore
                      IT's settings to the ones before skipping.  */
-                  *it = it_backup;
+                  RESTORE_IT (it, &it_backup, backup_data);
                   reached = 6;
                 }
               else
@@ -7581,7 +8195,7 @@ move_it_to (struct it *it, EMACS_INT to_charpos, int to_x, int to_y, int to_vpos
                       && it->line_wrap == WORD_WRAP)
                     {
                       int prev_x = max (it->current_x - 1, 0);
-                      *it = it_backup;
+                      RESTORE_IT (it, &it_backup, backup_data);
                       skip = move_it_in_display_line_to
                         (it, -1, prev_x, MOVE_TO_X);
                     }
@@ -7688,6 +8302,9 @@ move_it_to (struct it *it, EMACS_INT to_charpos, int to_x, int to_y, int to_vpos
       last_max_ascent = it->max_ascent;
     }
 
+  if (backup_data)
+    xfree (backup_data);
+
   TRACE_MOVE ((stderr, "move_it_to: reached %d\n", reached));
 }
 
@@ -7705,6 +8322,7 @@ move_it_vertically_backward (struct it *it, int dy)
 {
   int nlines, h;
   struct it it2, it3;
+  void *it2data = NULL, *it3data = NULL;
   EMACS_INT start_pos;
 
  move_further_back:
@@ -7733,7 +8351,7 @@ move_it_vertically_backward (struct it *it, int dy)
      start of the next line so that we get its height.  We need this
      height to be able to tell whether we reached the specified
      y-distance.  */
-  it2 = *it;
+  SAVE_IT (it2, *it, it2data);
   it2.max_ascent = it2.max_descent = 0;
   do
     {
@@ -7742,7 +8360,7 @@ move_it_vertically_backward (struct it *it, int dy)
     }
   while (!IT_POS_VALID_AFTER_MOVE_P (&it2));
   xassert (IT_CHARPOS (*it) >= BEGV);
-  it3 = it2;
+  SAVE_IT (it3, it2, it3data);
 
   move_it_to (&it2, start_pos, -1, -1, -1, MOVE_TO_POS);
   xassert (IT_CHARPOS (*it) >= BEGV);
@@ -7761,8 +8379,10 @@ move_it_vertically_backward (struct it *it, int dy)
     {
       /* DY == 0 means move to the start of the screen line.  The
          value of nlines is > 0 if continuation lines were involved.  */
+      RESTORE_IT (it, it, it2data);
       if (nlines > 0)
         move_it_by_lines (it, nlines);
+      xfree (it3data);
     }
   else
     {
@@ -7770,9 +8390,13 @@ move_it_vertically_backward (struct it *it, int dy)
          Note that H has been subtracted in front of the if-statement.  */
       int target_y = it->current_y + h - dy;
       int y0 = it3.current_y;
-      int y1 = line_bottom_y (&it3);
-      int line_height = y1 - y0;
+      int y1;
+      int line_height;
 
+      RESTORE_IT (&it3, &it3, it3data);
+      y1 = line_bottom_y (&it3);
+      line_height = y1 - y0;
+      RESTORE_IT (it, it, it2data);
       /* If we did not reach target_y, try to move further backward if
          we can.  If we moved too far backward, try to move forward.  */
       if (target_y < it->current_y
@@ -7899,6 +8523,7 @@ move_it_by_lines (struct it *it, int dvpos)
   else
     {
       struct it it2;
+      void *it2data = NULL;
       EMACS_INT start_charpos, i;
 
       /* Start at the beginning of the screen line containing IT's
@@ -7934,7 +8559,7 @@ move_it_by_lines (struct it *it, int dvpos)
 
       /* Above call may have moved too far if continuation lines
          are involved.  Scan forward and see if it did.  */
-      it2 = *it;
+      SAVE_IT (it2, *it, it2data);
       it2.vpos = it2.current_y = 0;
       move_it_to (&it2, start_charpos, -1, -1, -1, MOVE_TO_POS);
       it->vpos -= it2.vpos;
@@ -7945,12 +8570,18 @@ move_it_by_lines (struct it *it, int dvpos)
       if (it2.vpos > -dvpos)
         {
           int delta = it2.vpos + dvpos;
-          it2 = *it;
+
+          RESTORE_IT (&it2, &it2, it2data);
+          SAVE_IT (it2, *it, it2data);
           move_it_to (it, -1, -1, -1, it->vpos + delta, MOVE_TO_VPOS);
           /* Move back again if we got too far ahead.  */
           if (IT_CHARPOS (*it) >= start_charpos)
-            *it = it2;
+            RESTORE_IT (it, &it2, it2data);
+          else
+            xfree (it2data);
         }
+      else
+        RESTORE_IT (it, it, it2data);
     }
 }
 
@@ -10437,7 +11068,7 @@ display_tool_bar_line (struct it *it, int height)
           ++i;
         }
 
-      /* Stop at line ends.  */
+      /* Stop at line end.  */
       if (ITERATOR_AT_END_OF_LINE_P (it))
         break;
 
@@ -10520,6 +11151,7 @@ tool_bar_lines_needed (struct frame *f, int *n_rows)
   it.first_visible_x = 0;
   it.last_visible_x = FRAME_TOTAL_COLS (f) * FRAME_COLUMN_WIDTH (f);
   reseat_to_string (&it, NULL, f->desired_tool_bar_string, 0, 0, 0, -1);
+  it.paragraph_embedding = L2R;
 
   while (!ITERATOR_AT_END_P (&it))
     {
@@ -10553,7 +11185,7 @@ DEFUN ("tool-bar-lines-needed", Ftool_bar_lines_needed, Stool_bar_lines_needed,
   f = XFRAME (frame);
 
   if (WINDOWP (f->tool_bar_window)
-      || (w = XWINDOW (f->tool_bar_window),
+      && (w = XWINDOW (f->tool_bar_window),
           WINDOW_TOTAL_LINES (w) > 0))
     {
       update_tool_bar (f, 1);
@@ -10602,6 +11234,14 @@ redisplay_tool_bar (struct frame *f)
   /* Build a string that represents the contents of the tool-bar.  */
   build_desired_tool_bar_string (f);
   reseat_to_string (&it, NULL, f->desired_tool_bar_string, 0, 0, 0, -1);
+  /* FIXME: This should be controlled by a user option.  But it
+     doesn't make sense to have an R2L tool bar if the menu bar cannot
+     be drawn also R2L, and making the menu bar R2L is tricky due
+     toolkit-specific code that implements it.  If an R2L tool bar is
+     ever supported, display_tool_bar_line should also be augmented to
+     call unproduce_glyphs like display_line and display_string
+     do.  */
+  it.paragraph_embedding = L2R;
 
   if (f->n_tool_bar_rows == 0)
     {
@@ -13296,14 +13936,18 @@ try_scrolling (Lisp_Object window, int just_this_one_p,
              which was computed as distance from window bottom to
              point.  This matters when lines at window top and lines
              below window bottom have different height.  */
-          struct it it1 = it;
+          struct it it1;
+          void *it1data = NULL;
           /* We use a temporary it1 because line_bottom_y can modify
              its argument, if it moves one line down; see there.  */
-          int start_y = line_bottom_y (&it1);
+          int start_y;
 
+          SAVE_IT (it1, it, it1data);
+          start_y = line_bottom_y (&it1);
           do {
+            RESTORE_IT (&it, &it, it1data);
             move_it_by_lines (&it, 1);
-            it1 = it;
+            SAVE_IT (it1, it, it1data);
           } while (line_bottom_y (&it1) - start_y < amount_to_scroll);
         }
 
@@ -14411,10 +15055,13 @@ redisplay_window (Lisp_Object window, int just_this_one_p)
           && BEGV <= CHARPOS (startp) && CHARPOS (startp) <= ZV)
         {
           struct it it1;
+          void *it1data = NULL;
 
+          SAVE_IT (it1, it, it1data);
           start_display (&it1, w, startp);
           move_it_vertically (&it1, margin);
           margin_pos = IT_CHARPOS (it1);
+          RESTORE_IT (&it, &it, it1data);
         }
       scrolling_up = PT > margin_pos;
       aggressive =
@@ -17306,6 +17953,8 @@ cursor_row_p (struct glyph_row *row)
 static int
 push_display_prop (struct it *it, Lisp_Object prop)
 {
+  xassert (it->method == GET_FROM_BUFFER);
+
   push_it (it, NULL);
 
   if (STRINGP (prop))
@@ -17323,6 +17972,29 @@ push_display_prop (struct it *it, Lisp_Object prop)
       it->end_charpos = it->string_nchars = SCHARS (it->string);
       it->method = GET_FROM_STRING;
       it->stop_charpos = 0;
+      it->prev_stop = 0;
+      it->base_level_stop = 0;
+      it->string_from_display_prop_p = 1;
+      it->from_disp_prop_p = 1;
+
+      /* Force paragraph direction to be that of the parent
+         buffer.  */
+      if (it->bidi_p && it->bidi_it.paragraph_dir == R2L)
+        it->paragraph_embedding = it->bidi_it.paragraph_dir;
+      else
+        it->paragraph_embedding = L2R;
+
+      /* Set up the bidi iterator for this display string.  */
+      if (it->bidi_p)
+        {
+          it->bidi_it.string.lstring = it->string;
+          it->bidi_it.string.s = NULL;
+          it->bidi_it.string.schars = it->end_charpos;
+          it->bidi_it.string.bufpos = IT_CHARPOS (*it);
+          it->bidi_it.string.from_disp_str = 1;
+          it->bidi_it.string.unibyte = !it->multibyte_p;
+          bidi_init_it (0, 0, FRAME_WINDOW_P (it->f), &it->bidi_it);
+        }
     }
   else if (CONSP (prop) && EQ (XCAR (prop), Qspace))
     {
@@ -17369,6 +18041,7 @@ static void
 handle_line_prefix (struct it *it)
 {
   Lisp_Object prefix;
+
   if (it->continuation_lines_width > 0)
     {
       prefix = get_it_property (it, Qwrap_prefix);
@@ -17394,9 +18067,9 @@ handle_line_prefix (struct it *it)
 
 
 /* Remove N glyphs at the start of a reversed IT->glyph_row.  Called
-   only for R2L lines from display_line, when it decides that too many
-   glyphs were produced by PRODUCE_GLYPHS, and the line needs to be
-   continued.  */
+   only for R2L lines from display_line and display_string, when they
+   decide that too many glyphs were produced by PRODUCE_GLYPHS, and
+   the line/string needs to be continued on the next glyph row.  */
 static void
 unproduce_glyphs (struct it *it, int n)
 {
@@ -17426,12 +18099,13 @@ find_row_edges (struct it *it, struct glyph_row *row,
      lines' rows is implemented for bidi-reordered rows.  */
 
   /* ROW->minpos is the value of min_pos, the minimal buffer position
-     we have in ROW.  */
-  if (min_pos <= ZV)
+     we have in ROW, or ROW->start.pos if that is smaller.  */
+  if (min_pos <= ZV && min_pos < row->start.pos.charpos)
     SET_TEXT_POS (row->minpos, min_pos, min_bpos);
   else
-    /* We didn't find _any_ valid buffer positions in any of the
-       glyphs, so we must trust the iterator's computed positions.  */
+    /* We didn't find buffer positions smaller than ROW->start, or
+       didn't find _any_ valid buffer positions in any of the glyphs,
+       so we must trust the iterator's computed positions.  */
       row->minpos = row->start.pos;
   if (max_pos <= 0)
     {
@@ -17506,6 +18180,7 @@ display_line (struct it *it)
   struct glyph_row *row = it->glyph_row;
   Lisp_Object overlay_arrow_string;
   struct it wrap_it;
+  void *wrap_data = NULL;
   int may_wrap = 0, wrap_x IF_LINT (= 0);
   int wrap_row_used = -1;
   int wrap_row_ascent IF_LINT (= 0), wrap_row_height IF_LINT (= 0);
@@ -17660,7 +18335,7 @@ display_line (struct it *it)
                 may_wrap = 1;
               else if (may_wrap)
                 {
-                  wrap_it = *it;
+                  SAVE_IT (wrap_it, *it, wrap_data);
                   wrap_x = x;
                   wrap_row_used = row->used[TEXT_AREA];
                   wrap_row_ascent = row->ascent;
@@ -17830,7 +18505,7 @@ display_line (struct it *it)
                       if (row->reversed_p)
                         unproduce_glyphs (it,
                                           row->used[TEXT_AREA] - wrap_row_used);
-                      *it = wrap_it;
+                      RESTORE_IT (it, &wrap_it, wrap_data);
                       it->continuation_lines_width += wrap_x;
                       row->used[TEXT_AREA] = wrap_row_used;
                       row->ascent = wrap_row_ascent;
@@ -18236,6 +18911,8 @@ See also `bidi-paragraph-direction'.  */)
       itb.charpos = pos;
       itb.bytepos = bytepos;
       itb.nchars = -1;
+      itb.string.s = NULL;
+      itb.string.lstring = Qnil;
       itb.frame_window_p = FRAME_WINDOW_P (SELECTED_FRAME ()); /* guesswork */
       itb.first_elt = 1;
       itb.separator_limit = -1;
@@ -18325,6 +19002,11 @@ display_menu_bar (struct window *w)
     }
 #endif /* not USE_X_TOOLKIT */
 
+  /* FIXME: This should be controlled by a user option.  See the
+     comments in redisplay_tool_bar and display_mode_line about
+     this.  */
+  it.paragraph_embedding = L2R;
+
   if (! mode_line_inverse_video)
     /* Force the menu-bar to be displayed in the default face.  */
     it.base_face_id = it.face_id = DEFAULT_FACE_ID;
@@ -18502,6 +19184,11 @@ display_mode_line (struct window *w, enum face_id face_id, Lisp_Object format)
     /* Force the mode-line to be displayed in the default face.  */
     it.base_face_id = it.face_id = DEFAULT_FACE_ID;
 
+  /* FIXME: This should be controlled by a user option.  But
+     supporting such an option is not trivial, since the mode line is
+     made up of many separate strings.  */
+  it.paragraph_embedding = L2R;
+
   record_unwind_protect (unwind_format_mode_line,
                          format_mode_line_unwind_data (NULL, Qnil, 0));
 
@@ -20047,6 +20734,7 @@ display_string (const char *string, Lisp_Object lisp_string, Lisp_Object face_st
   int hpos_at_start = it->hpos;
   int saved_face_id = it->face_id;
   struct glyph_row *row = it->glyph_row;
+  EMACS_INT it_charpos;
 
   /* Initialize the iterator IT for iteration over STRING beginning
      with index START.  */
@@ -20055,10 +20743,10 @@ display_string (const char *string, Lisp_Object lisp_string, Lisp_Object face_st
   if (string && STRINGP (lisp_string))
     /* LISP_STRING is the one returned by decode_mode_spec.  We should
        ignore its text properties.  */
-    it->stop_charpos = -1;
+    it->stop_charpos = it->end_charpos;
 
-  /* If displaying STRING, set up the face of the iterator
-     from LISP_STRING, if that's given.  */
+  /* If displaying STRING, set up the face of the iterator from
+     FACE_STRING, if that's given.  */
   if (STRINGP (face_string))
     {
       EMACS_INT endptr;
@@ -20092,6 +20780,11 @@ display_string (const char *string, Lisp_Object lisp_string, Lisp_Object face_st
   row->phys_height = it->max_phys_ascent + it->max_phys_descent;
   row->extra_line_spacing = it->max_extra_line_spacing;
 
+  if (STRINGP (it->string))
+    it_charpos = IT_STRING_CHARPOS (*it);
+  else
+    it_charpos = IT_CHARPOS (*it);
+
   /* This condition is for the case that we are called with current_x
      past last_visible_x.  */
   while (it->current_x < max_x)
@@ -20104,10 +20797,10 @@ display_string (const char *string, Lisp_Object lisp_string, Lisp_Object face_st
 
       /* Produce glyphs.  */
       x_before = it->current_x;
-      n_glyphs_before = it->glyph_row->used[TEXT_AREA];
+      n_glyphs_before = row->used[TEXT_AREA];
       PRODUCE_GLYPHS (it);
 
-      nglyphs = it->glyph_row->used[TEXT_AREA] - n_glyphs_before;
+      nglyphs = row->used[TEXT_AREA] - n_glyphs_before;
       i = 0;
       x = x_before;
       while (i < nglyphs)
@@ -20121,12 +20814,18 @@ display_string (const char *string, Lisp_Object lisp_string, Lisp_Object face_st
               if (CHAR_GLYPH_PADDING_P (*glyph))
                 {
                   /* A wide character is unbreakable.  */
-                  it->glyph_row->used[TEXT_AREA] = n_glyphs_before;
+                  if (row->reversed_p)
+                    unproduce_glyphs (it, row->used[TEXT_AREA]
+                                      - n_glyphs_before);
+                  row->used[TEXT_AREA] = n_glyphs_before;
                   it->current_x = x_before;
                 }
               else
                 {
-                  it->glyph_row->used[TEXT_AREA] = n_glyphs_before + i;
+                  if (row->reversed_p)
+                    unproduce_glyphs (it, row->used[TEXT_AREA]
+                                      - (n_glyphs_before + i));
+                  row->used[TEXT_AREA] = n_glyphs_before + i;
                   it->current_x = x;
                 }
               break;
@@ -20136,7 +20835,7 @@ display_string (const char *string, Lisp_Object lisp_string, Lisp_Object face_st
               /* Glyph is at least partially visible.  */
               ++it->hpos;
               if (x < it->first_visible_x)
-                it->glyph_row->x = x - it->first_visible_x;
+                row->x = x - it->first_visible_x;
             }
           else
             {
@@ -20168,6 +20867,10 @@ display_string (const char *string, Lisp_Object lisp_string, Lisp_Object face_st
         }
 
       set_iterator_to_next (it, 1);
+      if (STRINGP (it->string))
+        it_charpos = IT_STRING_CHARPOS (*it);
+      else
+        it_charpos = IT_CHARPOS (*it);
 
       /* Stop if truncating at the right edge.  */
       if (it->line_wrap == TRUNCATE
@@ -20175,7 +20878,7 @@ display_string (const char *string, Lisp_Object lisp_string, Lisp_Object face_st
         {
           /* Add truncation mark, but don't do it if the line is
              truncated at a padding space.  */
-          if (IT_CHARPOS (*it) < it->string_nchars)
+          if (it_charpos < it->string_nchars)
             {
               if (!FRAME_WINDOW_P (it->f))
                 {
@@ -20183,9 +20886,20 @@ display_string (const char *string, Lisp_Object lisp_string, Lisp_Object face_st
 
                   if (it->current_x > it->last_visible_x)
                     {
-                      for (ii = row->used[TEXT_AREA] - 1; ii > 0; --ii)
-                        if (!CHAR_GLYPH_PADDING_P (row->glyphs[TEXT_AREA][ii]))
-                          break;
+                      if (!row->reversed_p)
+                        {
+                          for (ii = row->used[TEXT_AREA] - 1; ii > 0; --ii)
+                            if (!CHAR_GLYPH_PADDING_P (row->glyphs[TEXT_AREA][ii]))
+                              break;
+                        }
+                      else
+                        {
+                          for (ii = 0; ii < row->used[TEXT_AREA]; ii++)
+                            if (!CHAR_GLYPH_PADDING_P (row->glyphs[TEXT_AREA][ii]))
+                              break;
+                          unproduce_glyphs (it, ii + 1);
+                          ii = row->used[TEXT_AREA] - (ii + 1);
+                        }
                       for (n = row->used[TEXT_AREA]; ii < n; ++ii)
                         {
                           row->used[TEXT_AREA] = ii;
@@ -20194,7 +20908,7 @@ display_string (const char *string, Lisp_Object lisp_string, Lisp_Object face_st
                     }
                   produce_special_glyphs (it, IT_TRUNCATION);
                 }
-              it->glyph_row->truncated_on_right_p = 1;
+              row->truncated_on_right_p = 1;
             }
           break;
         }
@@ -20202,11 +20916,11 @@ display_string (const char *string, Lisp_Object lisp_string, Lisp_Object face_st
 
   /* Maybe insert a truncation at the left.  */
   if (it->first_visible_x
-      && IT_CHARPOS (*it) > 0)
+      && it_charpos > 0)
     {
       if (!FRAME_WINDOW_P (it->f))
         insert_left_trunc_glyphs (it);
-      it->glyph_row->truncated_on_left_p = 1;
+      row->truncated_on_left_p = 1;
     }
 
   it->face_id = saved_face_id;
@@ -27051,18 +27765,18 @@ but does not change the fact they are interpreted as raw bytes.  */);
   unibyte_display_via_language_environment = 0;
 
   DEFVAR_LISP ("max-mini-window-height", Vmax_mini_window_height,
-    doc: /* *Maximum height for resizing mini-windows.
+    doc: /* *Maximum height for resizing mini-windows (the minibuffer and the echo area).
 If a float, it specifies a fraction of the mini-window frame's height.
 If an integer, it specifies a number of lines.  */);
   Vmax_mini_window_height = make_float (0.25);
 
   DEFVAR_LISP ("resize-mini-windows", Vresize_mini_windows,
-    doc: /* *How to resize mini-windows.
+    doc: /* How to resize mini-windows (the minibuffer and the echo area).
 A value of nil means don't automatically resize mini-windows.
 A value of t means resize them to fit the text displayed in them.
-A value of `grow-only', the default, means let mini-windows grow
-only, until their display becomes empty, at which point the windows
-go back to their normal size.  */);
+A value of `grow-only', the default, means let mini-windows grow only;
+they return to their normal size when the minibuffer is closed, or the
+echo area becomes empty.  */);
   Vresize_mini_windows = Qgrow_only;
 
   DEFVAR_LISP ("blink-cursor-alist", Vblink_cursor_alist,
diff --git a/src/xfaces.c b/src/xfaces.c
index 4f06bd3ba55..c1e75ab3e59 100644
--- a/src/xfaces.c
+++ b/src/xfaces.c
@@ -536,8 +536,7 @@ int color_count[256];
 /* Register color PIXEL as allocated.  */
 
 void
-register_color (pixel)
-     unsigned long pixel;
+register_color (unsigned long pixel)
 {
   xassert (pixel < 256);
   ++color_count[pixel];
@@ -547,8 +546,7 @@ register_color (pixel)
 /* Register color PIXEL as deallocated.  */
 
 void
-unregister_color (pixel)
-     unsigned long pixel;
+unregister_color (unsigned long pixel)
 {
   xassert (pixel < 256);
   if (color_count[pixel] > 0)
@@ -561,9 +559,7 @@ unregister_color (pixel)
 /* Register N colors from PIXELS as deallocated.  */
 
 void
-unregister_colors (pixels, n)
-     unsigned long *pixels;
-     int n;
+unregister_colors (unsigned long *pixels, int n)
 {
   int i;
   for (i = 0; i < n; ++i)
@@ -3813,6 +3809,18 @@ Default face attributes override any local face attributes.  */)
               Fmodify_frame_parameters (frame, Fcons (Fcons (Qfont, name),
                                                       Qnil));
             }
+
+          if (STRINGP (gvec[LFACE_FOREGROUND_INDEX]))
+            Fmodify_frame_parameters (frame,
+                                      Fcons (Fcons (Qforeground_color,
+                                                    gvec[LFACE_FOREGROUND_INDEX]),
+                                             Qnil));
+
+          if (STRINGP (gvec[LFACE_BACKGROUND_INDEX]))
+            Fmodify_frame_parameters (frame,
+                                      Fcons (Fcons (Qbackground_color,
+                                                    gvec[LFACE_BACKGROUND_INDEX]),
+                                             Qnil));
         }
     }
 
diff --git a/src/xfns.c b/src/xfns.c
index b4153973e0d..11bf9ab57e1 100644
--- a/src/xfns.c
+++ b/src/xfns.c
@@ -2001,11 +2001,8 @@ xic_create_fontsetname (const char *base_fontname, int motif)
 
 #ifdef DEBUG_XIC_FONTSET
 static void
-print_fontset_result (xfs, name, missing_list, missing_count)
-     XFontSet xfs;
-     char *name;
-     char **missing_list;
-     int missing_count;
+print_fontset_result (XFontSet xfs, char *name, char **missing_list,
+                      int missing_count)
 {
   if (xfs)
     fprintf (stderr, "XIC Fontset created: %s\n", name);
@@ -5805,10 +5802,6 @@ syms_of_xfns (void)
   DEFSYM (Qfont_param, "font-parameter");
   /* This is the end of symbol initialization.  */
 
-  /* Text property `display' should be nonsticky by default.  */
-  Vtext_property_default_nonsticky
-    = Fcons (Fcons (Qdisplay, Qt), Vtext_property_default_nonsticky);
-
   Fput (Qundefined_color, Qerror_conditions,
         pure_cons (Qundefined_color, pure_cons (Qerror, Qnil)));
   Fput (Qundefined_color, Qerror_message,
diff --git a/src/xgselect.c b/src/xgselect.c
index 0d154f6496a..9ccdd37489f 100644
--- a/src/xgselect.c
+++ b/src/xgselect.c
@@ -15,14 +15,14 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
-along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
+along with GNU Emacs.  If not, see <http§://www.gnu.org/licenses/>.  */
 
 #include <config.h>
 
 #include <setjmp.h>
 #include "xgselect.h"
 
-#if defined (USE_GTK) || defined (HAVE_GCONF)
+#if defined (USE_GTK) || defined (HAVE_GCONF) || defined (HAVE_GSETTINGS)
 
 #include <glib.h>
 #include <errno.h>
@@ -149,13 +149,13 @@ xg_select (int max_fds, SELECT_TYPE *rfds, SELECT_TYPE *wfds, SELECT_TYPE *efds,
 
   return retval;
 }
-#endif /* defined (USE_GTK) || defined (HAVE_GCONF) */
+#endif /* USE_GTK || HAVE_GCONF || HAVE_GSETTINGS */
 
 void
 xgselect_initialize (void)
 {
-#if defined (USE_GTK) || defined (HAVE_GCONF)
+#if defined (USE_GTK) || defined (HAVE_GCONF) || defined (HAVE_GSETTINGS)
   gfds_size = 128;
   gfds = xmalloc (sizeof (*gfds)*gfds_size);
-#endif /* defined (USE_GTK) || defined (HAVE_GCONF) */
+#endif
 }
diff --git a/src/xmenu.c b/src/xmenu.c
index fc629b35104..b4338c1d653 100644
--- a/src/xmenu.c
+++ b/src/xmenu.c
@@ -740,10 +740,13 @@ menu_highlight_callback (GtkWidget *widget, gpointer call_data)
   help = call_data ? cb_data->help : Qnil;
 
   /* If popup_activated_flag is greater than 1 we are in a popup menu.
-     Don't show help for them, they won't appear before the
-     popup is popped down.  */
-  if (popup_activated_flag <= 1)
-    show_help_event (cb_data->cl_data->f, widget, help);
+     Don't pass the frame to show_help_event for those.
+     Passing frame creates an Emacs event.  As we are looping in
+     popup_widget_loop, it won't be handeled.  Passing NULL shows the tip
+     directly without using an Emacs event.  This is what the Lucid code
+     does below.  */
+  show_help_event (popup_activated_flag <= 1 ? cb_data->cl_data->f : NULL,
+                   widget, help);
 }
 #else
 static void
diff --git a/src/xrdb.c b/src/xrdb.c
index e18ff65f799..6a16e3260bd 100644
--- a/src/xrdb.c
+++ b/src/xrdb.c
@@ -651,9 +651,7 @@ typedef char **List;
 #define free_arglist(list)
 
 static List
-member (elt, list)
-     char *elt;
-     List list;
+member (char *elt, List list)
 {
   List p;
 
@@ -665,20 +663,17 @@ member (elt, list)
 }
 
 static void
-fatal (msg, prog, x1, x2, x3, x4, x5)
-    char *msg, *prog;
-    int x1, x2, x3, x4, x5;
+fatal (char *msg, char *prog)
 {
-    if (errno)
-      perror (prog);
+  if (errno)
+    perror (prog);
 
-    (void) fprintf (stderr, msg, prog, x1, x2, x3, x4, x5);
-    exit (1);
+  (void) fprintf (stderr, msg, prog);
+  exit (1);
 }
 
-main (argc, argv)
-    int argc;
-    char **argv;
+int
+main (int argc, char **argv)
 {
   Display *display;
   char *displayname, *resource_string, *class, *name;
@@ -749,5 +744,7 @@ main (argc, argv)
   printf ("\tExit.\n\n");
 
   XCloseDisplay (display);
+
+  return 0;
 }
 #endif /* TESTRM */
diff --git a/src/xselect.c b/src/xselect.c
index 7f4e0b40f62..5e5bdb55eca 100644
--- a/src/xselect.c
+++ b/src/xselect.c
@@ -112,6 +112,7 @@ static Lisp_Object QUTF8_STRING;	/* This is a type of selection.  */
 static Lisp_Object Qcompound_text_with_extensions;
 
 static Lisp_Object Qforeign_selection;
+static Lisp_Object Qx_lost_selection_functions, Qx_sent_selection_functions;
 
 /* If this is a smaller number than the max-request-size of the display,
    emacs will use INCR selection transfer when the selection is larger
@@ -855,7 +856,7 @@ x_handle_selection_request (struct input_event *event)
       && !EQ (Vx_sent_selection_functions, Qunbound))
     {
       Lisp_Object args[4];
-      args[0] = Vx_sent_selection_functions;
+      args[0] = Qx_sent_selection_functions;
       args[1] = selection_symbol;
       args[2] = target_symbol;
       args[3] = success ? Qt : Qnil;
@@ -979,7 +980,7 @@ x_handle_selection_clear (struct input_event *event)
   /* Run the `x-lost-selection-functions' abnormal hook.  */
   {
     Lisp_Object args[2];
-    args[0] = Vx_lost_selection_functions;
+    args[0] = Qx_lost_selection_functions;
     args[1] = selection_symbol;
     Frun_hook_with_args (2, args);
   }
@@ -1020,7 +1021,7 @@ x_clear_frame_selections (FRAME_PTR f)
     {
       /* Run the `x-lost-selection-functions' abnormal hook.  */
       Lisp_Object args[2];
-      args[0] = Vx_lost_selection_functions;
+      args[0] = Qx_lost_selection_functions;
       args[1] = Fcar (Fcar (t->Vselection_alist));
       Frun_hook_with_args (2, args);
 
@@ -1033,7 +1034,7 @@ x_clear_frame_selections (FRAME_PTR f)
         && EQ (frame, XCAR (XCDR (XCDR (XCDR (XCAR (XCDR (rest))))))))
       {
         Lisp_Object args[2];
-        args[0] = Vx_lost_selection_functions;
+        args[0] = Qx_lost_selection_functions;
         args[1] = XCAR (XCAR (XCDR (rest)));
         Frun_hook_with_args (2, args);
         XSETCDR (rest, XCDR (XCDR (rest)));
@@ -2679,4 +2680,6 @@ A value of 0 means wait as long as necessary.  This is initialized from the
   DEFSYM (QNULL, "NULL");
   DEFSYM (Qcompound_text_with_extensions, "compound-text-with-extensions");
   DEFSYM (Qforeign_selection, "foreign-selection");
+  DEFSYM (Qx_lost_selection_functions, "x-lost-selection-functions");
+  DEFSYM (Qx_sent_selection_functions, "x-sent-selection-functions");
 }
diff --git a/src/xsettings.c b/src/xsettings.c
index 5412cf426f8..dadbe68b4cb 100644
--- a/src/xsettings.c
+++ b/src/xsettings.c
@@ -34,9 +34,15 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 
 #include <X11/Xproto.h>
 
+#ifdef HAVE_GSETTINGS
+#include <glib-object.h>
+#include <gio/gio.h>
+#endif
+
 #ifdef HAVE_GCONF
 #include <gconf/gconf-client.h>
 #endif
+
 #ifdef HAVE_XFT
 #include <X11/Xft/Xft.h>
 #endif
@@ -48,10 +54,7 @@ static Lisp_Object Qmonospace_font_name, Qfont_name, Qfont_render,
   Qtool_bar_style;
 static Lisp_Object current_tool_bar_style;
 
-#ifdef HAVE_GCONF
-static GConfClient *gconf_client;
-#endif
-
+/* Store an config changed event in to the event queue.  */
 
 static void
 store_config_changed_event (Lisp_Object arg, Lisp_Object display_name)
@@ -64,6 +67,99 @@ store_config_changed_event (Lisp_Object arg, Lisp_Object display_name)
   kbd_buffer_store_event (&event);
 }
 
+/* Return non-zero if DPYINFO is still valid.  */
+static int
+dpyinfo_valid (struct x_display_info *dpyinfo)
+{
+  int found = 0;
+  if (dpyinfo != NULL)
+    {
+      struct x_display_info *d;
+      for (d = x_display_list; !found && d; d = d->next)
+        found = d == dpyinfo && d->display == dpyinfo->display;
+    }
+  return found;
+}
+
+/* Store a monospace font change event if the monospaced font changed.  */
+
+#if defined HAVE_XFT && (defined HAVE_GSETTINGS || defined HAVE_GCONF)
+static void
+store_monospaced_changed (const char *newfont)
+{
+  if (current_mono_font != NULL && strcmp (newfont, current_mono_font) == 0)
+    return; /* No change. */
+
+  xfree (current_mono_font);
+  current_mono_font = xstrdup (newfont);
+
+  if (dpyinfo_valid (first_dpyinfo) && use_system_font)
+    {
+      store_config_changed_event (Qmonospace_font_name,
+                                  XCAR (first_dpyinfo->name_list_element));
+    }
+}
+#endif
+
+/* Store a font name change event if the font name changed.  */
+
+#ifdef HAVE_XFT
+static void
+store_font_name_changed (const char *newfont)
+{
+  if (current_font != NULL && strcmp (newfont, current_font) == 0)
+    return; /* No change. */
+
+  xfree (current_font);
+  current_font = xstrdup (newfont);
+
+  if (dpyinfo_valid (first_dpyinfo))
+    {
+      store_config_changed_event (Qfont_name,
+                                  XCAR (first_dpyinfo->name_list_element));
+    }
+}
+#endif /* HAVE_XFT */
+
+/* Map TOOL_BAR_STYLE from a string to its correspinding Lisp value.
+   Return Qnil if TOOL_BAR_STYLE is not known.  */
+
+static Lisp_Object
+map_tool_bar_style (const char *tool_bar_style)
+{
+  Lisp_Object style = Qnil;
+  if (tool_bar_style)
+    {
+      if (strcmp (tool_bar_style, "both") == 0)
+        style = Qboth;
+      else if (strcmp (tool_bar_style, "both-horiz") == 0)
+        style = Qboth_horiz;
+      else if (strcmp (tool_bar_style, "icons") == 0)
+        style = Qimage;
+      else if (strcmp (tool_bar_style, "text") == 0)
+        style = Qtext;
+    }
+
+  return style;
+}
+
+/* Store a tool bar style change event if the tool bar style changed.  */
+
+static void
+store_tool_bar_style_changed (const char *newstyle,
+                              struct x_display_info *dpyinfo)
+{
+  Lisp_Object style = map_tool_bar_style (newstyle);
+  if (EQ (current_tool_bar_style, style))
+    return; /* No change. */
+
+  current_tool_bar_style = style;
+  if (dpyinfo_valid (dpyinfo))
+    store_config_changed_event (Qtool_bar_style,
+                                XCAR (dpyinfo->name_list_element));
+}
+
+
 #define XSETTINGS_FONT_NAME       "Gtk/FontName"
 #define XSETTINGS_TOOL_BAR_STYLE  "Gtk/ToolbarStyle"
 
@@ -83,55 +179,128 @@ struct xsettings
   FcBool aa, hinting;
   int rgba, lcdfilter, hintstyle;
   double dpi;
-#endif
 
   char *font;
+#endif
+
   char *tb_style;
 
   unsigned seen;
 };
 
+#ifdef HAVE_GSETTINGS
+#define GSETTINGS_SCHEMA         "org.gnome.desktop.interface"
+#define GSETTINGS_TOOL_BAR_STYLE "toolbar-style"
+
+#ifdef HAVE_XFT
+#define GSETTINGS_MONO_FONT  "monospace-font-name"
+#define GSETTINGS_FONT_NAME  "font-name"
+#endif
+
+
+/* The single GSettings instance, or NULL if not connected to GSettings.  */
+
+static GSettings *gsettings_client;
+
+/* Callback called when something changed in GSettings.  */
+
+static void
+something_changed_gsettingsCB (GSettings *settings,
+                               gchar *key,
+                               gpointer user_data)
+{
+  GVariant *val;
+
+  if (strcmp (key, GSETTINGS_TOOL_BAR_STYLE) == 0)
+    {
+      val = g_settings_get_value (settings, GSETTINGS_TOOL_BAR_STYLE);
+      if (val)
+        {
+          g_variant_ref_sink (val);
+          if (g_variant_is_of_type (val, G_VARIANT_TYPE_STRING))
+            {
+              const gchar *newstyle = g_variant_get_string (val, NULL);
+              store_tool_bar_style_changed (newstyle, first_dpyinfo);
+            }
+          g_variant_unref (val);
+        }
+    }
+#ifdef HAVE_XFT
+  else if (strcmp (key, GSETTINGS_MONO_FONT) == 0)
+    {
+      val = g_settings_get_value (settings, GSETTINGS_MONO_FONT);
+      if (val)
+        {
+          g_variant_ref_sink (val);
+          if (g_variant_is_of_type (val, G_VARIANT_TYPE_STRING))
+            {
+              const gchar *newfont = g_variant_get_string (val, NULL);
+              store_monospaced_changed (newfont);
+            }
+          g_variant_unref (val);
+        }
+    }
+  else if (strcmp (key, GSETTINGS_FONT_NAME) == 0)
+    {
+      val = g_settings_get_value (settings, GSETTINGS_FONT_NAME);
+      if (val)
+        {
+          g_variant_ref_sink (val);
+          if (g_variant_is_of_type (val, G_VARIANT_TYPE_STRING))
+            {
+              const gchar *newfont = g_variant_get_string (val, NULL);
+              store_font_name_changed (newfont);
+            }
+          g_variant_unref (val);
+        }
+    }
+#endif /* HAVE_XFT */
+}
+
+#endif /* HAVE_GSETTINGS */
+
 #ifdef HAVE_GCONF
+#define GCONF_TOOL_BAR_STYLE "/desktop/gnome/interface/toolbar_style"
+#ifdef HAVE_XFT
+#define GCONF_MONO_FONT  "/desktop/gnome/interface/monospace_font_name"
+#define GCONF_FONT_NAME  "/desktop/gnome/interface/font_name"
+#endif
 
-#define SYSTEM_MONO_FONT     "/desktop/gnome/interface/monospace_font_name"
-#define SYSTEM_FONT          "/desktop/gnome/interface/font_name"
+/* The single GConf instance, or NULL if not connected to GConf.  */
+
+static GConfClient *gconf_client;
 
-/* Callback called when something changed in GConf that we care about,
-   that is SYSTEM_MONO_FONT.  */
+/* Callback called when something changed in GConf that we care about.  */
 
 static void
-something_changedCB (GConfClient *client,
-                     guint cnxn_id,
-                     GConfEntry *entry,
-                     gpointer user_data)
+something_changed_gconfCB (GConfClient *client,
+                           guint cnxn_id,
+                           GConfEntry *entry,
+                           gpointer user_data)
 {
   GConfValue *v = gconf_entry_get_value (entry);
+  const char *key = gconf_entry_get_key (entry);
 
-  if (!v) return;
-  if (v->type == GCONF_VALUE_STRING)
+  if (!v || v->type != GCONF_VALUE_STRING || ! key) return;
+  if (strcmp (key, GCONF_TOOL_BAR_STYLE) == 0)
     {
       const char *value = gconf_value_get_string (v);
-      if (current_mono_font != NULL && strcmp (value, current_mono_font) == 0)
-        return; /* No change. */
-
-      xfree (current_mono_font);
-      current_mono_font = xstrdup (value);
+      store_tool_bar_style_changed (value, first_dpyinfo);
     }
-
-
-  if (first_dpyinfo != NULL)
+#ifdef HAVE_XFT
+  else if (strcmp (key, GCONF_MONO_FONT) == 0)
+    {
+      const char *value = gconf_value_get_string (v);
+      store_monospaced_changed (value);
+    }
+  else if (strcmp (key, GCONF_FONT_NAME) == 0)
     {
-      /* Check if display still open */
-      struct x_display_info *dpyinfo;
-      int found = 0;
-      for (dpyinfo = x_display_list; !found && dpyinfo; dpyinfo = dpyinfo->next)
-        found = dpyinfo == first_dpyinfo;
-
-      if (found && use_system_font)
-        store_config_changed_event (Qmonospace_font_name,
-                                    XCAR (first_dpyinfo->name_list_element));
+      const char *value = gconf_value_get_string (v);
+      store_font_name_changed (value);
     }
+#endif /* HAVE_XFT */
 }
+
 #endif /* HAVE_GCONF */
 
 #ifdef HAVE_XFT
@@ -277,10 +446,10 @@ parse_settings (unsigned char *prop,
       want_this =
 #ifdef HAVE_XFT
         (nlen > 6 && strncmp (name, "Xft/", 4) == 0)
+        || strcmp (XSETTINGS_FONT_NAME, name) == 0
         ||
 #endif
-        (strcmp (XSETTINGS_FONT_NAME, name) == 0)
-        || (strcmp (XSETTINGS_TOOL_BAR_STYLE, name) == 0);
+        strcmp (XSETTINGS_TOOL_BAR_STYLE, name) == 0;
 
       switch (type)
         {
@@ -322,17 +491,17 @@ parse_settings (unsigned char *prop,
       if (want_this)
         {
           ++settings_seen;
-          if (strcmp (name, XSETTINGS_FONT_NAME) == 0)
-            {
-              settings->font = xstrdup (sval);
-              settings->seen |= SEEN_FONT;
-            }
-          else if (strcmp (name, XSETTINGS_TOOL_BAR_STYLE) == 0)
+          if (strcmp (name, XSETTINGS_TOOL_BAR_STYLE) == 0)
             {
               settings->tb_style = xstrdup (sval);
               settings->seen |= SEEN_TB_STYLE;
             }
 #ifdef HAVE_XFT
+          else if (strcmp (name, XSETTINGS_FONT_NAME) == 0)
+            {
+              settings->font = xstrdup (sval);
+              settings->seen |= SEEN_FONT;
+            }
           else if (strcmp (name, "Xft/Antialias") == 0)
             {
               settings->seen |= SEEN_AA;
@@ -397,6 +566,10 @@ parse_settings (unsigned char *prop,
   return settings_seen;
 }
 
+/* Read settings from the XSettings property window on display for DPYINFO.
+   Store settings read in SETTINGS.
+   Return non-zero if successful, zero if not.  */
+
 static int
 read_settings (struct x_display_info *dpyinfo, struct xsettings *settings)
 {
@@ -426,6 +599,8 @@ read_settings (struct x_display_info *dpyinfo, struct xsettings *settings)
   return rc != 0;
 }
 
+/* Apply Xft settings in SETTINGS to the Xft library.
+   If SEND_EVENT_P is non-zero store a Lisp event that Xft settings changed.  */
 
 static void
 apply_xft_settings (struct x_display_info *dpyinfo,
@@ -444,9 +619,9 @@ apply_xft_settings (struct x_display_info *dpyinfo,
                         pat);
   FcPatternGetBool (pat, FC_ANTIALIAS, 0, &oldsettings.aa);
   FcPatternGetBool (pat, FC_HINTING, 0, &oldsettings.hinting);
-# ifdef FC_HINT_STYLE
+#ifdef FC_HINT_STYLE
   FcPatternGetInteger (pat, FC_HINT_STYLE, 0, &oldsettings.hintstyle);
-# endif
+#endif
   FcPatternGetInteger (pat, FC_LCD_FILTER, 0, &oldsettings.lcdfilter);
   FcPatternGetInteger (pat, FC_RGBA, 0, &oldsettings.rgba);
   FcPatternGetDouble (pat, FC_DPI, 0, &oldsettings.dpi);
@@ -485,7 +660,7 @@ apply_xft_settings (struct x_display_info *dpyinfo,
       oldsettings.lcdfilter = settings->lcdfilter;
     }
 
-# ifdef FC_HINT_STYLE
+#ifdef FC_HINT_STYLE
   if ((settings->seen & SEEN_HINTSTYLE) != 0
       && oldsettings.hintstyle != settings->hintstyle)
     {
@@ -494,7 +669,7 @@ apply_xft_settings (struct x_display_info *dpyinfo,
       ++changed;
       oldsettings.hintstyle = settings->hintstyle;
     }
-# endif
+#endif
 
   if ((settings->seen & SEEN_DPI) != 0 && oldsettings.dpi != settings->dpi
       && settings->dpi > 0)
@@ -545,11 +720,13 @@ apply_xft_settings (struct x_display_info *dpyinfo,
 #endif /* HAVE_XFT */
 }
 
+/* Read XSettings from the display for DPYINFO.
+   If SEND_EVENT_P is non-zero store a Lisp event settings that changed.  */
+
 static void
 read_and_apply_settings (struct x_display_info *dpyinfo, int send_event_p)
 {
   struct xsettings settings;
-  Lisp_Object dpyname = XCAR (dpyinfo->name_list_element);
 
   if (!read_settings (dpyinfo, &settings))
     return;
@@ -557,38 +734,29 @@ read_and_apply_settings (struct x_display_info *dpyinfo, int send_event_p)
   apply_xft_settings (dpyinfo, True, &settings);
   if (settings.seen & SEEN_TB_STYLE)
     {
-      Lisp_Object style = Qnil;
-      if (strcmp (settings.tb_style, "both") == 0)
-        style = Qboth;
-      else if (strcmp (settings.tb_style, "both-horiz") == 0)
-        style = Qboth_horiz;
-      else if (strcmp (settings.tb_style, "icons") == 0)
-        style = Qimage;
-      else if (strcmp (settings.tb_style, "text") == 0)
-        style = Qtext;
-      if (!NILP (style) && !EQ (style, current_tool_bar_style))
-        {
-          current_tool_bar_style = style;
-          if (send_event_p)
-            store_config_changed_event (Qtool_bar_style, dpyname);
-        }
+      if (send_event_p)
+        store_tool_bar_style_changed (settings.tb_style, dpyinfo);
+      else
+        current_tool_bar_style = map_tool_bar_style (settings.tb_style);
       xfree (settings.tb_style);
     }
-
+#ifdef HAVE_XFT
   if (settings.seen & SEEN_FONT)
     {
-      if (!current_font || strcmp (current_font, settings.font) != 0)
+      if (send_event_p)
+        store_font_name_changed (settings.font);
+      else
         {
           xfree (current_font);
-          current_font = settings.font;
-          if (send_event_p)
-            store_config_changed_event (Qfont_name, dpyname);
+          current_font = xstrdup (settings.font);
         }
-      else
-        xfree (settings.font);
+      xfree (settings.font);
     }
+#endif
 }
 
+/* Check if EVENT for the display in DPYINFO is XSettings related.  */
+
 void
 xft_settings_event (struct x_display_info *dpyinfo, XEvent *event)
 {
@@ -630,41 +798,130 @@ xft_settings_event (struct x_display_info *dpyinfo, XEvent *event)
     read_and_apply_settings (dpyinfo, True);
 }
 
+/* Initialize GSettings and read startup values.  */
+
+static void
+init_gsettings (void)
+{
+#ifdef HAVE_GSETTINGS
+  GVariant *val;
+  const gchar *const *schemas;
+  int schema_found = 0;
+
+#ifdef HAVE_G_TYPE_INIT
+  g_type_init ();
+#endif
+
+  schemas = g_settings_list_schemas();
+  if (schemas == NULL) return;
+  while (! schema_found && *schemas != NULL)
+    schema_found = strcmp (*schemas++, GSETTINGS_SCHEMA) == 0;
+  if (!schema_found) return;
+
+  gsettings_client = g_settings_new (GSETTINGS_SCHEMA);
+  if (!gsettings_client) return;
+  g_object_ref_sink (G_OBJECT (gsettings_client));
+  g_signal_connect (G_OBJECT (gsettings_client), "changed",
+                    G_CALLBACK (something_changed_gsettingsCB), NULL);
+
+  val = g_settings_get_value (gsettings_client, GSETTINGS_TOOL_BAR_STYLE);
+  if (val)
+    {
+      g_variant_ref_sink (val);
+      if (g_variant_is_of_type (val, G_VARIANT_TYPE_STRING))
+        current_tool_bar_style
+          = map_tool_bar_style (g_variant_get_string (val, NULL));
+      g_variant_unref (val);
+    }
+
+#ifdef HAVE_XFT
+  val = g_settings_get_value (gsettings_client, GSETTINGS_MONO_FONT);
+  if (val)
+    {
+      g_variant_ref_sink (val);
+      if (g_variant_is_of_type (val, G_VARIANT_TYPE_STRING))
+        current_mono_font = xstrdup (g_variant_get_string (val, NULL));
+      g_variant_unref (val);
+    }
+
+  val = g_settings_get_value (gsettings_client, GSETTINGS_FONT_NAME);
+  if (val)
+    {
+      g_variant_ref_sink (val);
+      if (g_variant_is_of_type (val, G_VARIANT_TYPE_STRING))
+        current_font = xstrdup (g_variant_get_string (val, NULL));
+      g_variant_unref (val);
+    }
+#endif /* HAVE_XFT */
+
+#endif /* HAVE_GSETTINGS */
+}
+
+/* Init GConf and read startup values.  */
 
 static void
 init_gconf (void)
 {
-#if defined (HAVE_GCONF) && defined (HAVE_XFT)
+#if defined (HAVE_GCONF)
   char *s;
 
 #ifdef HAVE_G_TYPE_INIT
   g_type_init ();
 #endif
+
   gconf_client = gconf_client_get_default ();
-  s = gconf_client_get_string (gconf_client, SYSTEM_MONO_FONT, NULL);
+  gconf_client_set_error_handling (gconf_client, GCONF_CLIENT_HANDLE_NONE);
+  gconf_client_add_dir (gconf_client,
+                        GCONF_TOOL_BAR_STYLE,
+                        GCONF_CLIENT_PRELOAD_ONELEVEL,
+                        NULL);
+  gconf_client_notify_add (gconf_client,
+                           GCONF_TOOL_BAR_STYLE,
+                           something_changed_gconfCB,
+                           NULL, NULL, NULL);
+
+  s = gconf_client_get_string (gconf_client, GCONF_TOOL_BAR_STYLE, NULL);
+  if (s)
+    {
+      current_tool_bar_style = map_tool_bar_style (s);
+      g_free (s);
+    }
+
+#ifdef HAVE_XFT
+  s = gconf_client_get_string (gconf_client, GCONF_MONO_FONT, NULL);
   if (s)
     {
       current_mono_font = xstrdup (s);
       g_free (s);
     }
-  s = gconf_client_get_string (gconf_client, SYSTEM_FONT, NULL);
+  s = gconf_client_get_string (gconf_client, GCONF_FONT_NAME, NULL);
   if (s)
     {
       current_font = xstrdup (s);
       g_free (s);
     }
-  gconf_client_set_error_handling (gconf_client, GCONF_CLIENT_HANDLE_NONE);
   gconf_client_add_dir (gconf_client,
-                        SYSTEM_MONO_FONT,
+                        GCONF_MONO_FONT,
+                        GCONF_CLIENT_PRELOAD_ONELEVEL,
+                        NULL);
+  gconf_client_notify_add (gconf_client,
+                           GCONF_MONO_FONT,
+                           something_changed_gconfCB,
+                           NULL, NULL, NULL);
+  gconf_client_add_dir (gconf_client,
+                        GCONF_FONT_NAME,
                         GCONF_CLIENT_PRELOAD_ONELEVEL,
                         NULL);
   gconf_client_notify_add (gconf_client,
-                           SYSTEM_MONO_FONT,
-                           something_changedCB,
+                           GCONF_FONT_NAME,
+                           something_changed_gconfCB,
                            NULL, NULL, NULL);
-#endif /* HAVE_GCONF && HAVE_XFT */
+#endif /* HAVE_XFT */
+#endif /* HAVE_GCONF */
 }
 
+/* Init Xsettings and read startup values.  */
+
 static void
 init_xsettings (struct x_display_info *dpyinfo)
 {
@@ -689,8 +946,12 @@ xsettings_initialize (struct x_display_info *dpyinfo)
   if (first_dpyinfo == NULL) first_dpyinfo = dpyinfo;
   init_gconf ();
   init_xsettings (dpyinfo);
+  init_gsettings ();
 }
 
+/* Return the system monospaced font.
+   May be NULL if not known.  */
+
 const char *
 xsettings_get_system_font (void)
 {
@@ -698,6 +959,9 @@ xsettings_get_system_font (void)
 }
 
 #ifdef USE_LUCID
+/* Return the system font.
+   May be NULL if not known.  */
+
 const char *
 xsettings_get_system_normal_font (void)
 {
@@ -746,6 +1010,9 @@ syms_of_xsettings (void)
   current_mono_font = NULL;
   current_font = NULL;
   first_dpyinfo = NULL;
+#ifdef HAVE_GSETTINGS
+  gsettings_client = NULL;
+#endif
 #ifdef HAVE_GCONF
   gconf_client = NULL;
 #endif
@@ -769,7 +1036,7 @@ If this variable is nil, Emacs ignores system font changes.  */);
 
 #ifdef HAVE_XFT
   Fprovide (intern_c_string ("font-render-setting"), Qnil);
-#ifdef HAVE_GCONF
+#if defined (HAVE_GCONF) || defined (HAVE_GSETTINGS)
   Fprovide (intern_c_string ("system-font-setting"), Qnil);
 #endif
 #endif