Merge from trunk

74 files changed, 2667 insertions, 2019 deletions

diff --git a/src/ChangeLog.trunk b/src/ChangeLog.trunk
index a3e08cf699d..87b54529f2e 100644
--- a/src/ChangeLog.trunk
+++ b/src/ChangeLog.trunk
@@ -1,9 +1,609 @@
+2010-09-12  Lars Magne Ingebrigtsen  <larsi@gnus.org>
+
+        * xml.c (Fhtml_parse_string, Fxml_parse_string): Mention BASE-URL.
+
+2010-09-12  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * fns.c (Fy_or_n_p): Move to lisp/subr.el.
+        (syms_of_fns): Don't defsubr Sy_or_n_p.
+        * lisp.h: Don't declare Fy_or_n_p.
+        * fileio.c (barf_or_query_if_file_exists): Fy_or_n_p -> y-or-n-p.
+
+2010-09-09  Lars Magne Ingebrigtsen  <larsi@gnus.org>
+
+        * xml.c (Fxml_parse_buffer): New function to parse XML files.
+
+2010-09-08  Lars Magne Ingebrigtsen  <larsi@gnus.org>
+
+        * xml.c: New file.
+        (Fhtml_parse_buffer): New function to interface to the libxml2
+        html parsing function.
+
+2010-09-05  Juanma Barranquero  <lekktu@gmail.com>
+
+        * biditype.h: Regenerate.
+
+2010-09-04  Andreas Schwab  <schwab@linux-m68k.org>
+
+        * nsimage.m (ns_load_image): Check argument types.
+
+        * image.c: Remove all uses of gcpro.
+        (xpm_load): Check all lisp types.
+        (pbm_load): Likewise.
+        (png_load): Likewise.
+        (jpeg_load): Likewise.
+        (tiff_load): Likewise.
+        (gif_load): Likewise.
+        (imagemagick_load_image): Likewise.
+        (imagemagick_load): Likewise.
+        (svg_load): Likewise.
+        (gs_load): Likewise.
+
+2010-09-04  Eli Zaretskii  <eliz@gnu.org>
+
+        * w32uniscribe.c (uniscribe_shape): Update commentary.  Don't
+        try to reorder grapheme clusters, since LGSTRING should always
+        hold them in the logical order.
+        (uniscribe_encode_char, uniscribe_shape): Force ScriptShape to
+        return glyph codes in the logical order.
+
+2010-09-04  Andreas Schwab  <schwab@linux-m68k.org>
+
+        * image.c (imagemagick_image_p): Replace bcopy by memcpy.
+        (imagemagick_load_image): Fix type mismatch.
+        (Fimagemagick_types): Likewise.  Doc fix.
+
+2010-09-02  Jan Djärv  <jan.h.d@swipnet.se>
+
+        * xterm.h (struct dpyinfo): Remove cut_buffers_initialized.
+
+        * xterm.c (x_term_init): Don't set dpyinfo->cut_buffers_initialized.
+
+        * xselect.c: Remove declaration of cut-buffer objects and functions.
+        (symbol_to_x_atom): Remove mapping to XA_CUT_BUFFERn.
+        (x_atom_to_symbol): Remove mapping to QCUT_BUFFERn.
+        (Fx_get_cut_buffer_internal, Fx_store_cut_buffer_internal)
+        (Fx_rotate_cut_buffers_internal): Remove.
+        (syms_of_xselect): Remove defsubr of above.
+        Remove intern of QCUT_BUFFERn.
+
+2010-09-01  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * cmds.c (Vblink_paren_function): Remove.
+        (internal_self_insert): Make it insert N chars at a time.
+        Don't call blink-paren-function.
+        (Fself_insert_command): Adjust accordingly.
+        (syms_of_cmds): Don't declare blink-paren-function.
+
+2010-08-31  Kenichi Handa  <handa@m17n.org>
+
+        * dispextern.h (FACE_FOR_CHAR): Use an ASCII face for 8-bit
+        characters.
+
+        * term.c (encode_terminal_code): Fix the previous change.
+        (produce_glyphs): Don't set it->char_to_display here.
+        Don't handle unibyte-display-via-language-environment here.
+        (produce_special_glyphs): Set temp_it.char_to_display before
+        calling produce_glyphs.
+
+        * xdisp.c (get_next_display_element): Set it->char_to_display
+        here.  Convert all 8-bit bytes from unibyte buffer/string to 8-bit
+        characters.
+        (get_overlay_arrow_glyph_row): Set it.char_to_display too before
+        calling PRODUCE_GLYPHS.
+        (append_space_for_newline): Save and store it->char_to_display.
+        Set it->char_to_display before calling PRODUCE_GLYPHS.
+        (extend_face_to_end_of_line): Set it->char_to_display before
+        calling PRODUCE_GLYPHS.
+        (get_glyph_face_and_encoding): Set the glyph code an 8-bit
+        character to its byte value.
+        (get_char_glyph_code): New function.
+        (produce_stretch_glyph): Set it2.char_to_display too before
+        calling x_produce_glyphs.
+        (x_produce_glyphs): Simplify by using the same code for ASCII and
+        non-ASCII characters.  Don't set it->char_to_display here.  Don't
+        handle unibyte-display-via-language-environment here. For a
+        charater of no glyph, use font->space_width instead of FONT_WIDTH.
+
+2010-08-31  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * keyboard.c (Fwindow_system): Fix compilation for USE_LISP_UNION_TYPE.
+
+2010-08-31  Chong Yidong  <cyd@stupidchicken.com>
+
+        * keyboard.c (command_loop_1): Don't call x-set-selection on tty.
+
+2010-08-30  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * marker.c (Fcopy_marker): Make the first arg optional.
+
+2010-08-30  Kenichi Handa  <handa@m17n.org>
+
+        * composite.c (composition_update_it): Fix computing of
+        cmp_it->width.
+
+2010-08-29  Kenichi Handa  <handa@m17n.org>
+
+        * term.c (encode_terminal_code): Encode byte chars to the
+        corresponding bytes.
+
+2010-08-29  Jan Djärv  <jan.h.d@swipnet.se>
+
+        * nsterm.m (ns_draw_window_cursor): Draw BAR_CURSOR correct for R2L.
+
+2010-08-26  Kenichi Handa  <handa@m17n.org>
+
+        * xdisp.c (compute_stop_pos): Pay attention to bidi scan direction
+        on calling composition_compute_stop_pos.
+
+2010-08-25  Kenichi Handa  <handa@m17n.org>
+
+        * fontset.c (reorder_font_vector): Prefer a font-spec specifying
+        :otf.
+
+        * composite.c (composition_compute_stop_pos): Don't break
+        composition at PT.
+        (composition_reseat_it): Likewise.  Fix calculation of character
+        position starting a composition.
+        (Fcomposition_get_gstring): Don't limit the number of components
+        for automatic composition.
+
+2010-08-25  Kenichi Handa  <handa@m17n.org>
+
+        * composite.c (composition_compute_stop_pos): In forward search,
+        pay attention to the possibility that some character after ENDPOS
+        will be composed with charactrs before ENDPOS.
+
+2010-08-24  Chong Yidong  <cyd@stupidchicken.com>
+
+        * keyboard.c (command_loop_1): Don't clobber primary selection
+        during handle-switch-frame (Bug#6872).
+
+2010-08-23  Michael Albinus  <michael.albinus@gmx.de>
+
+        * dbusbind.c: Accept UNIX domain sockets as bus address.
+        (Fdbus_close_bus): New function.
+        (Vdbus_registered_buses): New variable.
+        (xd_initialize): Implement string as bus address.
+        (Fdbus_init_bus): Add bus to Vdbus_registered_buses).
+        (Fdbus_get_unique_name, Fdbus_call_method)
+        (Fdbus_call_method_asynchronously, Fdbus_method_return_internal)
+        (Fdbus_method_error_internal, Fdbus_send_signal)
+        (Fdbus_register_signal, Fdbus_register_method): Remove bus type
+        check.  This is done in xd_initialize_bus.  Adapt doc string, if
+        necessary.
+        (xd_pending_messages, xd_read_queued_messages): Loop over buses in
+        Vdbus_registered_buses.
+        (Vdbus_registered_objects_table): Create hash.
+
+2010-08-22  Juri Linkov  <juri@jurta.org>
+
+        * keyboard.c (Fexecute_extended_command): Move reading a command name
+        with `completing-read' to a new Elisp function `read-extended-command'.
+        Call it to read a command to `function'  (bug#5364, bug#5214).
+
+2010-08-22  Chong Yidong  <cyd@stupidchicken.com>
+
+        * emacs.c (main): Remove handling of --unibyte arg (Bug#6886).
+
+2010-08-22  Andreas Schwab  <schwab@linux-m68k.org>
+
+        * eval.c (Flet, Feval, Fapply, apply_lambda): Use SAFE_ALLOCA_LISP
+        instead of SAFE_ALLOCA.
+
+2010-08-22  Chong Yidong  <cyd@stupidchicken.com>
+
+        * eval.c (Flet, Feval, Fapply, apply_lambda): Use SAFE_ALLOCA
+        (Bug#6214).
+
+2010-08-22  Jan Djärv  <jan.h.d@swipnet.se>
+
+        * doc.c (Fsnarf_documentation): Set skip_file only if p[1] is S.
+
+2010-08-22  Jan Djärv  <jan.h.d@swipnet.se>
+
+        * doc.c (Fsnarf_documentation): Initialize skip_file before
+        build-files test.
+
+2010-08-22  Peter O'Gorman  <pogma@thewrittenword.com>  (tiny change)
+
+        * s/hpux10-20.h (HAVE_TERMIOS, NO_TERMIO, ORDINARY_LINK):
+        New definitions.
+        (HAVE_TERMIO): Remove.
+
+2010-08-22  Eli Zaretskii  <eliz@gnu.org>
+
+        * deps.mk (sysdep.o, msdos.o): Depend on sysselect.h.
+
+        * sysselect.h [WINDOWSNT]: Don't define the FD_* and select stuff
+        for w32.
+
+        * s/ms-w32.h (HAVE_SYS_TIMEB_H): Don't #undef HAVE_SYS_SELECT_H,
+        it's done in nt/config.nt.
+
+        * makefile.w32-in ($(BLD)/sysdep.$(O)): Depend on sysselect.h.
+
+        * unexcoff.c (report_error, make_hdr, write_segment)
+        (copy_text_and_data, copy_sym, mark_x, adjust_lnnoptrs, unexec):
+        Convert argument lists and prototypes to ANSI C.
+        (make_hdr, write_segment): Remove unused variables.
+        (unexec): Remove commented-out line.  Initialize `new' to shut up
+        compiler warnings.
+
+2010-08-22  Dan Nicolaescu  <dann@ics.uci.edu>
+
+        Simplify termio code.
+        All non-MSDOS non-WINDOWSNT platforms define HAVE_TERMIOS, so
+        HAVE_TERMIO code is obsolete.
+        Replace HAVE_TERMIOS conditionals with !DOS_NT.
+        * systty.h: Do not define HAVE_TCATTR.
+        Remove HAVE_TERMIO, HAVE_LTCHARS and HAVE_TCHARS code.
+        Do not define EMACS_HAVE_TTY_PGRP.  Only define
+        EMACS_GET_TTY_PGRP for !DOS_NT.
+        * sysdep.c: Include sysselect.h unconditionally.  Do not include
+        sys/ioctl.h and termios.h, systty.h does it.  Use
+        HAVE_SYS_UTSNAME_H instead of USG as an include guard.
+        (init_baud_rate): Remove HAVE_TERMIO code.
+        (child_setup_tty): Remove HAVE_TERMIO code.
+        (emacs_get_tty, emacs_set_tty): Remove HAVE_TERMIO, HAVE_TCHARS
+        and HAVE_LTCHARS code.  Use !DOS_NT instead of HAVE_TCATTR.
+        (new_ltchars, new_tchars): Remove, unused.
+        (init_sys_modes): Remove HAVE_TERMIO, HAVE_TCHARS and HAVE_LTCHARS
+        code.  Remove special casing for __mips__, it was a no-op.  Remove
+        HAVE_TCATTR conditional, it is implied by HAVE_TERMIOS.
+        (init_sys_modes): Remove HPUX special case.
+        * process.c: Include stdlib.h unconditionally.  Do not include
+        fcntl.h, systty.h does it.  Remove conditional code for
+        HAVE_SERIAL, it is always true.
+        (process_send_signal): Remove HAVE_TERMIOS conditional, it's
+        always true when SIGNALS_VIA_CHARACTERS is true.
+        (Fcontinue_process, Fprocess_send_eof): Simplify conditionals:
+        !WINDOWSNT means HAVE_TERMIOS.
+        (create_process): Remove HAVE_TERMIOS, it's inside a HAVE_PTYS
+        conditional, which is true for all HAVE_TERMIOS systems.
+        * keyboard.c (init_keyboard): Do not use HAVE_TERMIO, use !DOS_NT
+        instead of HAVE_TERMIOS.
+        * emacs.c (shut_down_emacs): Use !defined DOS_NT instead of
+        EMACS_HAVE_TTY_PGRP.
+        * callproc.c (child_setup): Move EMACS_SET_TTY_PGRP use to the
+        non-MSDOS, non-WINDOWSNT code, it's only defined for such systems
+        anyway.
+
+2010-08-21  Eli Zaretskii  <eliz@gnu.org>
+
+        * dispnew.c (buffer_posn_from_coords): Fix off-by-one error in
+        mirroring pixel positions.
+
+2010-08-20  Dan Nicolaescu  <dann@ics.uci.edu>
+
+        * alloc.c (malloc_sbrk_used, malloc_sbrk_unused): Remove,
+        write only.
+        (init_alloc_once): Remove writes to malloc_sbrk_unused, and
+        malloc_sbrk_used, nothing uses them.
+
+        * puresize.h: Remove code assuming PNTR_COMPARISON_TYPE is not
+        defined, unconditionally defined in lisp.h.
+
+        * term.c: Do not include <termios.h>, systty.h does it.
+
+        * s/unixware.h (HAVE_TCATTR):
+        * s/aix4-2.h (HAVE_TCATTR): Remove definitions, not needed.
+        systty.h defines it when HAVE_TERMIOS is defined.
+
+2010-08-20  Eli Zaretskii  <eliz@gnu.org>
+
+        * dispnew.c (buffer_posn_from_coords): Fix last change for text
+        terminals: add one-character offset for R2L lines.
+
+        * emacs.c <emacs_version>: Add a comment regarding
+        msdos/mainmake.v2's dependency on the syntax of this declaration.
+
+2010-08-20  Eli Zaretskii  <eliz@gnu.org>
+
+        * dispnew.c (buffer_posn_from_coords): Fix calculation of buffer
+        position for R2L lines by mirroring the pixel position wrt the
+        text are box.  Improve commentary.
+
+2010-08-20  Andreas Schwab  <schwab@linux-m68k.org>
+
+        * image.c (imagemagick_clear_image): Remove debugging output.
+
+2010-08-19  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * cmds.c (Vself_insert_face, Vself_insert_face_command): Remove.
+        (Qpost_self_insert_hook, Vpost_self_insert_hook): New vars.
+        (internal_self_insert): Run Qpost_self_insert_hook rather than handle
+        self-insert-face.
+        (syms_of_cmds): Initialize the new vars.
+
+2010-08-19  Jason Rumney  <jasonr@gnu.org>
+
+        * w32menu.c (set_frame_menubar): Remove call to undefined function.
+
+        * w32fns.c (w32_wnd_proc): Don't check context before initializing.
+
+2010-08-19  Jan Djärv  <jan.h.d@swipnet.se>
+
+        * nsselect.m (nxatoms_of_nsselect): Use "Selection" and "Secondary".
+
+2010-08-18  Eli Zaretskii  <eliz@gnu.org>
+
+        * xterm.c (x_draw_bar_cursor):
+        * w32term.c (x_draw_bar_cursor): If the character under cursor is
+        R2L, draw the bar cursor on its right rather than on its left.
+
+2010-08-18  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * eval.c (Fdefmacro): Only obey one declaration.
+
+        * casefiddle.c (casify_region): Setup gl_state.
+
+2010-08-18  Jan Djärv  <jan.h.d@swipnet.se>
+
+        * nsterm.m (ns_define_frame_cursor): Call x_update_cursor (Bug#6868).
+
+2010-08-18  Jan Djärv  <jan.h.d@swipnet.se>
+
+        * gtkutil.c (update_frame_tool_bar): Literal stings are const char*.
+
+2010-08-18  David De La Harpe Golden  <david@harpegolden.net>
+
+        * nsselect.m (QCLIPBOARD, NXPrimaryPboard): Define.
+        (symbol_to_nsstring): Map QCLIPBOARD => NSGeneralPboard,
+        QPRIMARY => NXPrimaryPboard.
+        (ns_string_to_symbol): NSGeneralPboard => QCLIPBOARD,
+        NXPrimaryPboard => QPRIMARY.
+        (nxatoms_of_nsselect): NXPrimaryPboard = PrimarySelection,
+        NXSecondaryPboard = SecondarySelection.
+        (syms_of_nsselect): Intern QCLIPBOARD (Bug#6677).
+
+2010-08-18  Joakim Verona  <joakim@verona.se>
+
+        * image.c: Add support for ImageMagick.  When HAVE_IMAGEMAGICK is
+        defined:
+        (imagemagick_image_p): New function to test for ImageMagic image.
+        (imagemagick_load): New function to load ImageMagick image.
+        (imagemagick_load_image): New function, helper for imagemagick_load.
+        (imagemagick-types): New function.
+        (Qimagemagick): New Lisp_object.
+        (imagemagick-render-type): New variable, decides which renderer to use.
+
+2010-08-17  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * gtkutil.c (update_frame_tool_bar): Don't assume TOOL_BAR_ITEM_LABEL
+        is a string.
+
+2010-08-17  Jan Djärv  <jan.h.d@swipnet.se>
+
+        * nsfns.m (ns_frame_parm_handlers): Add a slot for the
+        x_set_tool_bar_position handler.
+
+2010-08-17  Eli Zaretskii  <eliz@gnu.org>
+
+        * w32fns.c <w32_frame_parm_handlers>: Add a slot for the
+        x_set_tool_bar_position handler, needed to support changes from
+        2010-07-29T16:49:59Z!jan.h.d@swipnet.se for positioning the tool bar.  (Bug#6796)
+
+2010-08-16  Jan Djärv  <jan.h.d@swipnet.se>
+
+        * nsselect.m: include keyboard.h for QPRIMARY, remove its
+        declaration (Bug#6863).
+        (syms_of_nsselect): Don't intern QPRIMARY.
+
+        * xselect.c: Remove declaration of QPRIMARY (Bug#6864).
+
+        * keyboard.h (QPRIMARY): Declare (Bug#6864).
+
+2010-08-16  Chong Yidong  <cyd@stupidchicken.com>
+
+        * keyboard.c (command_loop_1): Avoid setting selection twice,
+        since it's done in deactivate-mark as well.
+        (Vselect_active_regions): Change default to t.  Replace `lazy'
+        with non-default value `only', meaning only set PRIMARY for
+        temporarily active regions.
+
+        * insdel.c (prepare_to_modify_buffer): Handle `only' value of
+        select-active-regions.
+
+2010-08-15  Jan Djärv  <jan.h.d@swipnet.se>
+
+        * keyboard.c (parse_tool_bar_item): Put in a bad label if :label
+        isn't a string.
+
+2010-08-15  Andreas Schwab  <schwab@linux-m68k.org>
+
+        * keyboard.c (parse_tool_bar_item): Avoid excessive use of strlen.
+
+2010-08-15  Jan Djärv  <jan.h.d@swipnet.se>
+
+        * keyboard.c (parse_tool_bar_item): malloc buf.
+        Set TOOL_BAR_ITEM_LABEL to empty string if not set to
+        new_lbl (Bug#6855).
+
+2010-08-14  Eli Zaretskii  <eliz@gnu.org>
+
+        * xterm.c (x_draw_stretch_glyph_string):
+        * w32term.c (x_draw_stretch_glyph_string): In R2L rows, display
+        the cursor on the right edge of the stretch glyph.
+
+        * xdisp.c (window_box_right_offset, window_box_right):
+        Fix commentary.
+
+        * xdisp.c (Fcurrent_bidi_paragraph_direction): Fix paragraph
+        direction when point is inside a run of whitespace characters.
+
+        * bidi.c (bidi_at_paragraph_end): Remove obsolete comment.
+
+2010-08-14  Jason Rumney  <jasonr@gnu.org>
+
+        * keyboard.c (lispy_function_keys): Do not define VK_PACKET (bug#4836)
+
+2010-08-14  Chong Yidong  <cyd@stupidchicken.com>
+
+        * fns.c (Fmake_hash_table): Doc fix (Bug#6851).
+
+2010-08-13  Jason Rumney  <jasonr@gnu.org>
+
+        * w32menu.c (simple_dialog_show): Use unicode message box if available.
+        (MessageBoxW_Proc): New function typedef.
+        (unicode-message-box): New function pointer.
+        (globals_of_w32menu): Import it from user32.dll. (Bug#5629)
+
+2010-08-13  Jan Djärv  <jan.h.d@swipnet.se>
+
+        * frame.h (Qtool_bar_position): Declare.
+
+        * xfns.c (Fx_create_frame): Call x_default_parameter for
+        Qtool_bar_position.
+
+2010-08-13  Eli Zaretskii  <eliz@gnu.org>
+
+        * unexcoff.c: Remove the parts used when "emacs" is not defined.
+        (report_error, report_error_1): Ditto.
+        (write_segment): Remove "#if 0" unused code.
+        (make_hdr): Remove code that was "#ifndef NO_REMAP" before
+        NO_REMAP was removed (in 2010-07-29T03:25:08Z!dann@ics.uci.edu).
+        (start_of_text): Remove unused function (was used only if NO_REMAP
+        was NOT defined).
+
+        * msdos.c (IT_set_face): Fix format string to match argument
+        types.
+        (IT_write_glyphs, IT_note_mode_line_highlight)
+        (IT_set_frame_parameters): Remove unused variables.
+        (x_set_menu_bar_lines): Declare set_menu_bar_lines.
+        (IT_set_terminal_modes): Disambiguate expression in if clause.
+        (Fmsdos_remember_default_colors): Return Qnil.
+        (IT_set_frame_parameters): Add parens to disambiguate boolean
+        expression for logging the cursor type to termscript.
+        (keyboard_layout_list, keypad_translate_map)
+        (grey_key_translate_map): Add braces in inner initializers.
+        (dos_rawgetc): Add parens in condition for mouse-3 button-press.
+        (dos_rawgetc): Remove unused label.
+        (XMenuActivate): Add braces to remove ambiguous `else'.
+        (dos_ttraw): Always return a value.
+        (spawnve): Declare.
+        (run_msdos_command): Cast 3rd arg of spawnve to "char **".
+
+        * dosfns.h (x_set_title): Declare.
+
+        * w16select.c (Fw16_set_clipboard_data, Fw16_get_clipboard_data):
+        Remove unused variables.
+
+        * dosfns.c (Fint86, Fdos_memget, Fdos_memput): Remove unused
+        variables.
+        (init_dosfns): Declare get_lim_data.
+        (system_process_attributes): Declare Fget_internal_run_time.
+
+        * xmenu.c (xmenu_show) [!USE_X_TOOLKIT && !USE_GTK]: Fix argument
+        list to be consistent with menu.h.
+
+        * w32menu.c (add_menu_item, name_is_separator): Shut up compiler
+        warnings due to mixing of "char *" and "const char *".
+
+2010-08-12  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        Introduce a new comment style "c" flag.
+        * syntax.c (SYNTAX_FLAGS_COMMENT_STYLEB)
+        (SYNTAX_FLAGS_COMMENT_STYLEC): New macros.
+        (SYNTAX_FLAGS_COMMENT_STYLE): Use them, add an argument.
+        (syntax_prefix_flag_p): New function.
+        (Fstring_to_syntax): Understand new "c" flag.
+        (Finternal_describe_syntax_value): Recognize new flag; use the
+        SYNTAX_FLAGS_* macros.
+        (scan_sexps_forward, Fparse_partial_sexp): Change representation of
+        comment style to accomodate the new styles.
+        (back_comment, forw_comment, Fforward_comment, scan_lists)
+        (scan_sexps_forward): Update code to obey the new comment style flag.
+
+        * syntax.h: Move SYNTAX_FLAGS_FOO() macros to syntax.c.
+
+        * casefiddle.c (casify_region): Use the new syntax_prefix_flag_p.
+
+2010-08-11  Jan Djärv  <jan.h.d@swipnet.se>
+
+        * xfns.c (x_defined_color): If USE_GTK, call xg_check_special_colors
+        first.
+        (Fx_hide_tip): Check FRAME_LIVE_P (f) before calling xg_hide_tooltip.
+
+        * gtkutil.h (xg_check_special_colors): Declare.
+
+        * gtkutil.c (xg_check_special_colors, style_changed_cb): New functions.
+        (xg_create_frame_widgets): Connect theme name changes to
+        style_changed_cb.
+
+        * xterm.c (emacs_class): New char[] for EMACS_CLASS.
+        (xim_open_dpy, xim_initialize, xim_close_dpy): Use emacs_class.
+        (x_term_init): Use char[] display_opt and name_opt instead of
+        string literal. file is const char*.
+
+        * xsmfns.c (NOSPLASH_OPT): Change to char[].
+        (smc_save_yourself_CB): Do xstrdup on all ->type and ->name for
+        props.  Free them at the end.
+
+        * xselect.c (Fx_get_atom_name): Use char empty[] instead of literal "".
+
+        * xrdb.c (get_system_app): Make path const and use char *p for
+        non-const char.
+
+        * xmenu.c (Fx_popup_dialog): error_name is const char*.
+        (xmenu_show): error parameter is const char **. pane_string is const
+        char *.
+        (button_names): Is const char *.
+        (xdialog_show): error_name and pane_string is const.
+
+        * process.h (synch_process_death): Is const char*.
+
+        * w32menu.c (w32_menu_show):
+        * nsmenu.m (ns_menu_show): error parameter is const char **.
+
+        * menu.h (w32_menu_show, ns_menu_show, xmenu_show): error parameter
+        is const char **.
+
+        * menu.c (Fx_popup_menu): error_name is const.
+
+        * keyboard.h (_widget_value): Add defined USE_GTK.  Replace Boolean
+        with unsigned char and XtPointer with void *.
+
+        * gtkutil.h: Replace widget_value with struct _widget_value.
+        (enum button_type, struct _widget_value): Remove and use the one from
+        keyboard.h.
+
+        * gtkutil.c (get_utf8_string): Always return an allocated string.
+        Parameter is const.
+        (create_dialog, xg_create_one_menuitem, create_menus)
+        (xg_item_label_same_p, xg_update_menu_item): Free result from
+        get_utf8_string.
+        (xg_separator_p, xg_item_label_same_p): label is const.
+
+        * font.h (font_open_by_name): Make name const.
+
+        * font.c (font_open_by_name): Make name const.
+
+        * floatfns.c (matherr): Use a const char* variable for x->name.
+
+        * emacs.c (main): Pass char[] to putenv instead of literal.
+
+        * callproc.c (synch_process_death): Make const.
+        (Fcall_process): Make signame const.
+
+        * nsterm.h (parseKeyEquiv, addSubmenuWithTitle)
+        (addDisplayItemWithImage): Use const char*.
+
+        * nsmenu.m (parseKeyEquiv, addSubmenuWithTitle)
+        (addDisplayItemWithImage, update_frame_tool_bar): Use const char*.
+
+        * nsfont.m (ns_descriptor_to_entity): Use const char*.
+
+        * keyboard.h (_widget_value): name, value and key are const char*.
+
+        * unexmacosx.c (unexec_error): Use const char *.
+
 2010-08-09  Dan Nicolaescu  <dann@ics.uci.edu>
 
         * font.h (font_parse_xlfd, font_parse_fcname, font_unparse_fcname)
-        (font_parse_name): font_open_by_name):
+        (font_parse_name, font_open_by_name):
         * font.c (font_parse_xlfd, font_parse_fcname, font_unparse_fcname)
-        (font_parse_name): font_open_by_name): Remove const.
+        (font_parse_name, font_open_by_name): Remove const.
 
 2010-08-09  Andreas Schwab  <schwab@linux-m68k.org>
 
@@ -64,10 +664,10 @@
 
 2010-08-08  Kenichi Handa  <handa@m17n.org>
 
-        * charset.c: Include <stdlib.h>
+        * charset.c: Include <stdlib.h>.
         (struct charset_sort_data): New struct.
         (charset_compare): New function.
-        (Fsort_charsets): New funciton.
+        (Fsort_charsets): New function.
         (syms_of_charset): Declare Fsort_charsets as a Lisp function.
 
         * coding.c (decode_coding_iso_2022): Fix checking of dimension
@@ -126,17 +726,17 @@
 
         * s/freebsd.h (DECLARE_GETPWUID_WITH_UID_T): Remove, unused.
 
-        * xrdb.c: Remove include guard.  Remove
-        DECLARE_GETPWUID_WITH_UID_T conditional it had no effect.
+        * xrdb.c: Remove include guard.
+        Remove DECLARE_GETPWUID_WITH_UID_T conditional it had no effect.
         Remove #if 0 code.  Replace malloc->xmalloc, free->xfree,
         realloc->xrealloc instead of using #defines.
 
 2010-08-08  Eli Zaretskii  <eliz@gnu.org>
 
         * cmds.c (Fforward_line, Fbeginning_of_line, Fend_of_line):
-        * editfns.c (Fline_beginning_position, Fline_end_position): State
-        in the doc strings that start and end of line are in the logical
-        order.
+        * editfns.c (Fline_beginning_position, Fline_end_position):
+        State in the doc strings that start and end of line are in the
+        logical order.
 
         * xdisp.c (display_line): Move the handling of overlay arrow after
         the call to find_row_edges.  (Bug#6699)
diff --git a/src/Makefile.in b/src/Makefile.in
index a8d400c7c39..d91b95d86e3 100644
--- a/src/Makefile.in
+++ b/src/Makefile.in
@@ -1,3 +1,4 @@
+
 # Makefile for GNU Emacs.
 # Copyright (C) 1985, 1987, 1988, 1993, 1994, 1995, 1999, 2000, 2001, 2002,
 #   2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
@@ -222,6 +223,12 @@ CFLAGS_SOUND= @CFLAGS_SOUND@
 RSVG_LIBS= @RSVG_LIBS@
 RSVG_CFLAGS= @RSVG_CFLAGS@
 
+IMAGEMAGICK_LIBS= @IMAGEMAGICK_LIBS@
+IMAGEMAGICK_CFLAGS= @IMAGEMAGICK_CFLAGS@
+
+LIBXML2_LIBS = @LIBXML2_LIBS@
+LIBXML2_CFLAGS = @LIBXML2_CFLAGS@
+
 ## widget.o if USE_X_TOOLKIT, otherwise empty.
 WIDGET_OBJ=@WIDGET_OBJ@
 
@@ -315,7 +322,8 @@ MKDEPDIR=@MKDEPDIR@
 ## FIXME? MYCPPFLAGS only referenced in etc/DEBUG.
 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} ${DBUS_CFLAGS} \
+  ${C_SWITCH_X_SYSTEM} ${CFLAGS_SOUND} ${RSVG_CFLAGS} ${IMAGEMAGICK_CFLAGS} \
+  ${LIBXML2_CFLAGS} ${DBUS_CFLAGS} \
   ${GCONF_CFLAGS} ${FREETYPE_CFLAGS} ${FONTCONFIG_CFLAGS} \
   ${LIBOTF_CFLAGS} ${M17N_FLT_CFLAGS} ${DEPFLAGS} ${PROFILING_CFLAGS} \
   ${C_WARNINGS_SWITCH} ${CFLAGS}
@@ -344,7 +352,7 @@ obj=    dispnew.o frame.o scroll.o xdisp.o menu.o $(XMENU_OBJ) window.o \
         syntax.o $(UNEXEC_OBJ) bytecode.o \
         process.o callproc.o \
         region-cache.o sound.o atimer.o \
-        doprnt.o strftime.o intervals.o textprop.o composite.o md5.o \
+        doprnt.o strftime.o intervals.o textprop.o composite.o md5.o xml.o \
         $(MSDOS_OBJ) $(MSDOS_X_OBJ) $(NS_OBJ) $(CYGWIN_OBJ) $(FONT_OBJ)
 
 ## Object files used on some machine or other.
@@ -590,7 +598,8 @@ SOME_MACHINE_LISP = ../lisp/mouse.elc \
 ## duplicated symbols.  If the standard libraries were compiled
 ## with GCC, we might need LIB_GCC again after them.
 LIBES = $(LIBS) $(LIBX_BASE) $(LIBX_OTHER) $(LIBSOUND) \
-   $(RSVG_LIBS) $(DBUS_LIBS) $(LIBGPM) $(LIBRESOLV) $(LIBS_SYSTEM) \
+   $(RSVG_LIBS) ${IMAGEMAGICK_LIBS} $(DBUS_LIBS) \
+   ${LIBXML2_LIBS} $(LIBGPM) $(LIBRESOLV) $(LIBS_SYSTEM) \
    $(LIBS_TERMCAP) $(GETLOADAVG_LIBS) ${GCONF_LIBS} ${LIBSELINUX_LIBS} \
    $(FREETYPE_LIBS) $(FONTCONFIG_LIBS) $(LIBOTF_LIBS) $(M17N_FLT_LIBS) \
    $(LIB_GCC) $(LIB_MATH) $(LIB_STANDARD) $(LIB_GCC)
diff --git a/src/alloc.c b/src/alloc.c
index 23debbdf2e8..d83d8937722 100644
--- a/src/alloc.c
+++ b/src/alloc.c
@@ -214,16 +214,6 @@ int abort_on_gc;
 
 int garbage_collection_messages;
 
-#ifndef VIRT_ADDR_VARIES
-extern
-#endif /* VIRT_ADDR_VARIES */
-int malloc_sbrk_used;
-
-#ifndef VIRT_ADDR_VARIES
-extern
-#endif /* VIRT_ADDR_VARIES */
-int malloc_sbrk_unused;
-
 /* Number of live and free conses etc.  */
 
 static int total_conses, total_markers, total_symbols, total_vector_size;
@@ -6234,11 +6224,6 @@ init_alloc_once (void)
   consing_since_gc = 0;
   gc_cons_threshold = 100000 * sizeof (Lisp_Object);
   gc_relative_threshold = 0;
-
-#ifdef VIRT_ADDR_VARIES
-  malloc_sbrk_unused = 1<<22;   /* A large number */
-  malloc_sbrk_used = 100000;    /* as reasonable as any number */
-#endif /* VIRT_ADDR_VARIES */
 }
 
 void
diff --git a/src/bidi.c b/src/bidi.c
index b31de597688..a6d4d1b2506 100644
--- a/src/bidi.c
+++ b/src/bidi.c
@@ -497,7 +497,6 @@ bidi_peek_at_next_level (struct bidi_it *bidi_it)
 static EMACS_INT
 bidi_at_paragraph_end (EMACS_INT charpos, EMACS_INT bytepos)
 {
-  /* FIXME: Why Fbuffer_local_value rather than just Fsymbol_value?  */
   Lisp_Object sep_re;
   Lisp_Object start_re;
   EMACS_INT val;
@@ -1534,7 +1533,7 @@ bidi_level_of_next_char (struct bidi_it *bidi_it)
 
          we want it to be displayed as
 
-             {RLO}STet{PDF}
+             {PDF}STet{RLO}
 
          not as
 
diff --git a/src/biditype.h b/src/biditype.h
index 60fc6374f39..868aabd9ea6 100644
--- a/src/biditype.h
+++ b/src/biditype.h
@@ -83,7 +83,8 @@
         { 0x0671, 0x06D5, STRONG_AL },
         { 0x06D6, 0x06DC, WEAK_NSM },
         { 0x06DD, 0x06DD, WEAK_AN },
-        { 0x06DE, 0x06E4, WEAK_NSM },
+        { 0x06DE, 0x06DE, NEUTRAL_ON },
+        { 0x06DF, 0x06E4, WEAK_NSM },
         { 0x06E5, 0x06E6, STRONG_AL },
         { 0x06E7, 0x06E8, WEAK_NSM },
         { 0x06E9, 0x06E9, NEUTRAL_ON },
@@ -271,7 +272,7 @@
         { 0x2080, 0x2089, WEAK_EN },
         { 0x208A, 0x208B, WEAK_ES },
         { 0x208C, 0x208E, NEUTRAL_ON },
-        { 0x20A0, 0x20B8, WEAK_ET },
+        { 0x20A0, 0x20B9, WEAK_ET },
         { 0x20D0, 0x20F0, WEAK_NSM },
         { 0x2100, 0x2101, NEUTRAL_ON },
         { 0x2103, 0x2106, NEUTRAL_ON },
diff --git a/src/callproc.c b/src/callproc.c
index ca9ff93a6d9..8c1384df6a1 100644
--- a/src/callproc.c
+++ b/src/callproc.c
@@ -115,7 +115,7 @@ Lisp_Object Qbuffer_file_type;
 int synch_process_alive;
 
 /* Nonzero => this is a string explaining death of synchronous subprocess.  */
-char *synch_process_death;
+const char *synch_process_death;
 
 /* Nonzero => this is the signal number that terminated the subprocess.  */
 int synch_process_termsig;
@@ -818,7 +818,7 @@ usage: (call-process PROGRAM &optional INFILE BUFFER DISPLAY &rest ARGS)  */)
 
   if (synch_process_termsig)
     {
-      char *signame;
+      const char *signame;
 
       synchronize_system_messages_locale ();
       signame = strsignal (synch_process_termsig);
@@ -1231,8 +1231,6 @@ child_setup (int in, int out, int err, register char **new_argv, int set_pgrp, L
 #else
   setpgrp (pid, pid);
 #endif /* USG */
-  /* setpgrp_of_tty is incorrect here; it uses input_fd.  */
-  EMACS_SET_TTY_PGRP (0, &pid);
 
 #ifdef MSDOS
   pid = run_msdos_command (new_argv, pwd_var + 4, in, out, err, env);
@@ -1251,6 +1249,9 @@ child_setup (int in, int out, int err, register char **new_argv, int set_pgrp, L
     report_file_error ("Spawning child process", Qnil);
   return cpid;
 #else /* not WINDOWSNT */
+  /* setpgrp_of_tty is incorrect here; it uses input_fd.  */
+  EMACS_SET_TTY_PGRP (0, &pid);
+
   /* execvp does not accept an environment arg so the only way
      to pass this environment is to set environ.  Our caller
      is responsible for restoring the ambient value of environ.  */
diff --git a/src/casefiddle.c b/src/casefiddle.c
index 9545cf697a8..b6551618b2f 100644
--- a/src/casefiddle.c
+++ b/src/casefiddle.c
@@ -221,6 +221,8 @@ casify_region (enum case_action flag, Lisp_Object b, Lisp_Object e)
   start_byte = CHAR_TO_BYTE (start);
   end_byte = CHAR_TO_BYTE (end);
 
+  SETUP_BUFFER_SYNTAX_TABLE();  /* For syntax_prefix_flag_p.  */
+
   while (start < end)
     {
       int c2, len;
@@ -243,7 +245,8 @@ casify_region (enum case_action flag, Lisp_Object b, Lisp_Object e)
                && (!inword || flag != CASE_CAPITALIZE_UP))
         c = UPCASE1 (c);
       if ((int) flag >= (int) CASE_CAPITALIZE)
-        inword = ((SYNTAX (c) == Sword) && (inword || !SYNTAX_PREFIX (c)));
+        inword = ((SYNTAX (c) == Sword)
+                  && (inword || !syntax_prefix_flag_p (c)));
       if (c != c2)
         {
           last = start;
diff --git a/src/cmds.c b/src/cmds.c
index 4cb6ca199e7..f12e759b7a6 100644
--- a/src/cmds.c
+++ b/src/cmds.c
@@ -32,17 +32,11 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include "dispextern.h"
 #include "frame.h"
 
-Lisp_Object Qkill_forward_chars, Qkill_backward_chars, Vblink_paren_function;
+Lisp_Object Qkill_forward_chars, Qkill_backward_chars;
 
 /* A possible value for a buffer's overwrite-mode variable.  */
 Lisp_Object Qoverwrite_mode_binary;
 
-/* Non-nil means put this face on the next self-inserting character.  */
-Lisp_Object Vself_insert_face;
-
-/* This is the command that set up Vself_insert_face.  */
-Lisp_Object Vself_insert_face_command;
-
 static int internal_self_insert (int, int);
 
 DEFUN ("forward-point", Fforward_point, Sforward_point, 1, 1, 0,
@@ -310,50 +304,31 @@ After insertion, the value of `auto-fill-function' is called if the
   {
     int character = translate_char (Vtranslation_table_for_input,
                                     XINT (last_command_event));
-    if (XINT (n) >= 2 && NILP (current_buffer->overwrite_mode))
-      {
-        XSETFASTINT (n, XFASTINT (n) - 2);
-        /* The first one might want to expand an abbrev.  */
-        internal_self_insert (character, 1);
-        /* The bulk of the copies of this char can be inserted simply.
-           We don't have to handle a user-specified face specially
-           because it will get inherited from the first char inserted.  */
-        Finsert_char (make_number (character), n, Qt);
-        /* The last one might want to auto-fill.  */
-        internal_self_insert (character, 0);
-      }
-    else
-      while (XINT (n) > 0)
-        {
-          int val;
-          /* Ok since old and new vals both nonneg */
-          XSETFASTINT (n, XFASTINT (n) - 1);
-          val = internal_self_insert (character, XFASTINT (n) != 0);
-          if (val == 2)
-            nonundocount = 0;
-          frame_make_pointer_invisible ();
-        }
+    int val = internal_self_insert (character, XFASTINT (n));
+    if (val == 2)
+      nonundocount = 0;
+    frame_make_pointer_invisible ();
   }
 
   return Qnil;
 }
 
-/* Insert character C.  If NOAUTOFILL is nonzero, don't do autofill
-   even if it is enabled.
+/* Insert N times character C
 
    If this insertion is suitable for direct output (completely simple),
    return 0.  A value of 1 indicates this *might* not have been simple.
    A value of 2 means this did things that call for an undo boundary.  */
 
 static Lisp_Object Qexpand_abbrev;
+static Lisp_Object Qpost_self_insert_hook, Vpost_self_insert_hook;
 
 static int
-internal_self_insert (int c, int noautofill)
+internal_self_insert (int c, int n)
 {
   int hairy = 0;
   Lisp_Object tem;
   register enum syntaxcode synt;
-  Lisp_Object overwrite, string;
+  Lisp_Object overwrite;
   /* Length of multi-byte form of C.  */
   int len;
   /* Working buffer and pointer for multi-byte form of C.  */
@@ -396,32 +371,22 @@ internal_self_insert (int c, int noautofill)
       /* This is the character after point.  */
       int c2 = FETCH_CHAR (PT_BYTE);
 
-      /* Column the cursor should be placed at after this insertion.
-         The correct value should be calculated only when necessary.  */
-      int target_clm = 0;
-
       /* Overwriting in binary-mode always replaces C2 by C.
          Overwriting in textual-mode doesn't always do that.
          It inserts newlines in the usual way,
          and inserts any character at end of line
          or before a tab if it doesn't use the whole width of the tab.  */
-      if (EQ (overwrite, Qoverwrite_mode_binary)
-          || (c != '\n'
-              && c2 != '\n'
-              && ! (c2 == '\t'
-                    && XINT (current_buffer->tab_width) > 0
-                    && XFASTINT (current_buffer->tab_width) < 20
-                    && (target_clm = ((int) current_column () /* iftc */
-                                      + XINT (Fchar_width (make_number (c)))),
-                        target_clm % XFASTINT (current_buffer->tab_width)))))
+      if (EQ (overwrite, Qoverwrite_mode_binary))
+        chars_to_delete = n;
+      else if (c != '\n' && c2 != '\n')
         {
           int pos = PT;
           int pos_byte = PT_BYTE;
+          /* Column the cursor should be placed at after this insertion.
+             The correct value should be calculated only when necessary.  */
+          int target_clm = ((int) current_column () /* iftc */
+                            + n * XINT (Fchar_width (make_number (c))));
 
-          if (target_clm == 0)
-            chars_to_delete = 1;
-          else
-            {
               /* The actual cursor position after the trial of moving
                  to column TARGET_CLM.  It is greater than TARGET_CLM
                  if the TARGET_CLM is middle of multi-column
@@ -433,14 +398,18 @@ internal_self_insert (int c, int noautofill)
               chars_to_delete = PT - pos;
 
               if (actual_clm > target_clm)
-                {
-                  /* We will delete too many columns.  Let's fill columns
+            { /* We will delete too many columns.  Let's fill columns
                      by spaces so that the remaining text won't move.  */
+              EMACS_INT actual = PT_BYTE;
+              DEC_POS (actual);
+              if (FETCH_CHAR (actual) == '\t')
+                /* Rather than add spaces, let's just keep the tab. */
+                chars_to_delete--;
+              else
                   spaces_to_insert = actual_clm - target_clm;
                 }
-            }
+
           SET_PT_BOTH (pos, pos_byte);
-          hairy = 2;
         }
       hairy = 2;
     }
@@ -451,10 +420,10 @@ internal_self_insert (int c, int noautofill)
       && synt != Sword
       && NILP (current_buffer->read_only)
       && PT > BEGV
-      && (!NILP (current_buffer->enable_multibyte_characters)
-          ? SYNTAX (XFASTINT (Fprevious_char ())) == Sword
-          : (SYNTAX (UNIBYTE_TO_CHAR (XFASTINT (Fprevious_char ())))
-             == Sword)))
+      && (SYNTAX (!NILP (current_buffer->enable_multibyte_characters)
+                  ? XFASTINT (Fprevious_char ())
+                  : UNIBYTE_TO_CHAR (XFASTINT (Fprevious_char ())))
+          == Sword))
     {
       int modiff = MODIFF;
       Lisp_Object sym;
@@ -479,16 +448,30 @@ internal_self_insert (int c, int noautofill)
 
   if (chars_to_delete)
     {
-      string = make_string_from_bytes (str, 1, len);
+      int mc = ((NILP (current_buffer->enable_multibyte_characters)
+                 && SINGLE_BYTE_CHAR_P (c))
+                ? UNIBYTE_TO_CHAR (c) : c);
+      Lisp_Object string = Fmake_string (make_number (n), make_number (mc));
+                                          
       if (spaces_to_insert)
         {
           tem = Fmake_string (make_number (spaces_to_insert),
                               make_number (' '));
-          string = concat2 (tem, string);
+          string = concat2 (string, tem);
         }
 
       replace_range (PT, PT + chars_to_delete, string, 1, 1, 1);
-      Fforward_char (make_number (1 + spaces_to_insert));
+      Fforward_char (make_number (n + spaces_to_insert));
+    }
+  else if (n > 1)
+    {
+      USE_SAFE_ALLOCA;
+      unsigned char *strn, *p;
+      SAFE_ALLOCA (strn, unsigned char*, n * len);
+      for (p = strn; n > 0; n--, p += len)
+        memcpy (p, str, len);
+      insert_and_inherit (strn, p - strn);
+      SAFE_FREE ();
     }
   else
     insert_and_inherit (str, len);
@@ -496,7 +479,6 @@ internal_self_insert (int c, int noautofill)
   if ((CHAR_TABLE_P (Vauto_fill_chars)
        ? !NILP (CHAR_TABLE_REF (Vauto_fill_chars, c))
        : (c == ' ' || c == '\n'))
-      && !noautofill
       && !NILP (current_buffer->auto_fill_function))
     {
       Lisp_Object tem;
@@ -514,22 +496,9 @@ internal_self_insert (int c, int noautofill)
         hairy = 2;
     }
 
-  /* If previous command specified a face to use, use it.  */
-  if (!NILP (Vself_insert_face)
-      && EQ (current_kboard->Vlast_command, Vself_insert_face_command))
-    {
-      Fput_text_property (make_number (PT - 1), make_number (PT),
-                          Qface, Vself_insert_face, Qnil);
-      Vself_insert_face = Qnil;
-    }
+  /* Run hooks for electric keys.  */
+  call1 (Vrun_hooks, Qpost_self_insert_hook);
 
-  if ((synt == Sclose || synt == Smath)
-      && !NILP (Vblink_paren_function) && INTERACTIVE
-      && !noautofill)
-    {
-      call0 (Vblink_paren_function);
-      hairy = 2;
-    }
   return hairy;
 }
 
@@ -550,20 +519,13 @@ syms_of_cmds (void)
   Qexpand_abbrev = intern_c_string ("expand-abbrev");
   staticpro (&Qexpand_abbrev);
 
-  DEFVAR_LISP ("self-insert-face", &Vself_insert_face,
-               doc: /* If non-nil, set the face of the next self-inserting character to this.
-See also `self-insert-face-command'.  */);
-  Vself_insert_face = Qnil;
-
-  DEFVAR_LISP ("self-insert-face-command", &Vself_insert_face_command,
-               doc: /* This is the command that set up `self-insert-face'.
-If `last-command' does not equal this value, we ignore `self-insert-face'.  */);
-  Vself_insert_face_command = Qnil;
+  Qpost_self_insert_hook = intern_c_string ("post-self-insert-hook");
+  staticpro (&Qpost_self_insert_hook);
 
-  DEFVAR_LISP ("blink-paren-function", &Vblink_paren_function,
-               doc: /* Function called, if non-nil, whenever a close parenthesis is inserted.
-More precisely, a char with closeparen syntax is self-inserted.  */);
-  Vblink_paren_function = Qnil;
+  DEFVAR_LISP ("post-self-insert-hook", &Vpost_self_insert_hook,
+               doc: /* Hook run at the end of `self-insert-command'.
+This run is run after inserting the charater.  */);
+  Vpost_self_insert_hook = Qnil;
 
   defsubr (&Sforward_point);
   defsubr (&Sforward_char);
diff --git a/src/composite.c b/src/composite.c
index 392da1ceba1..bc5a67ef6e2 100644
--- a/src/composite.c
+++ b/src/composite.c
@@ -969,7 +969,9 @@ 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.  */
+/* 1 iff the character C is composable.  Characters of general
+   category Z? or C? are not composable except for ZWNJ and ZWJ. */
+
 #define CHAR_COMPOSABLE_P(C)                                            \
   ((C) == 0x200C || (C) == 0x200D                                       \
    || (_work_val = CHAR_TABLE_REF (Vunicode_category_table, (C)),       \
@@ -1028,19 +1030,6 @@ composition_compute_stop_pos (struct composition_it *cmp_it, EMACS_INT charpos,
       cmp_it->stop_pos = endpos = start;
       cmp_it->ch = -1;
     }
-  if (NILP (string))
-    {
-      /* A composition never strides over PT.  */
-      if (PT > charpos)
-        {
-          if (PT < endpos)
-            cmp_it->stop_pos = endpos = PT;
-        }
-      else if (PT < charpos && PT > endpos)
-        {
-          cmp_it->stop_pos = endpos = PT - 1;
-        }
-    }
   if (NILP (current_buffer->enable_multibyte_characters)
       || NILP (Vauto_composition_mode))
     return;
@@ -1091,6 +1080,16 @@ composition_compute_stop_pos (struct composition_it *cmp_it, EMACS_INT charpos,
                 }
             }
         }
+      if (charpos == endpos)
+        {
+          /* We couldn't find a composition point before ENDPOS.  But,
+             some character after ENDPOS may be composed with
+             characters before ENDPOS.  So, we should stop at the safe
+             point.  */
+          charpos = endpos - MAX_AUTO_COMPOSITION_LOOKBACK;
+          if (charpos < start)
+            charpos = start;
+        }
     }
   else if (charpos > endpos)
     {
@@ -1223,23 +1222,8 @@ composition_compute_stop_pos (struct composition_it *cmp_it, EMACS_INT charpos,
 int
 composition_reseat_it (struct composition_it *cmp_it, EMACS_INT charpos, EMACS_INT bytepos, EMACS_INT endpos, struct window *w, struct face *face, Lisp_Object string)
 {
-  if (endpos <= charpos)
-    {
-      if (NILP (string))
-        {
-          if (endpos < 0)
-            endpos = BEGV;
-          if (endpos < PT && PT < charpos)
-            endpos = PT;
-        }
-      else if (endpos < 0)
-        endpos = 0;
-    }
-  else
-    {
-      if (NILP (string) && charpos < PT && PT < endpos)
-        endpos = PT;
-    }
+  if (endpos < 0)
+    endpos = NILP (string) ? BEGV : 0;
 
   if (cmp_it->ch == -2)
     {
@@ -1301,7 +1285,7 @@ composition_reseat_it (struct composition_it *cmp_it, EMACS_INT charpos, EMACS_I
               elt = XCAR (val);
               if (cmp_it->lookback > 0)
                 {
-                  cpos -= cmp_it->lookback;
+                  cpos = charpos - cmp_it->lookback;
                   if (STRINGP (string))
                     bpos = string_char_to_byte (string, cpos);
                   else
@@ -1456,8 +1440,7 @@ composition_update_it (struct composition_it *cmp_it, EMACS_INT charpos, EMACS_I
         {
           c = XINT (LGSTRING_CHAR (gstring, i));
           cmp_it->nbytes += CHAR_BYTES (c);
-          cmp_it->width = (LGLYPH_WIDTH (glyph) > 0
-                           ? CHAR_WIDTH (LGLYPH_CHAR (glyph)) : 0);
+          cmp_it->width += CHAR_WIDTH (c);
         }
     }
   return c;
@@ -1763,8 +1746,6 @@ should be ignored.  */)
 
   CHECK_NATNUM (from);
   CHECK_NATNUM (to);
-  if (XINT (to) > XINT (from) + MAX_COMPOSITION_COMPONENTS)
-    to = make_number (XINT (from) + MAX_COMPOSITION_COMPONENTS);
   if (! FONT_OBJECT_P (font_object))
     {
       struct coding_system *coding;
diff --git a/src/config.in b/src/config.in
index ea17a54d913..199afbd78ba 100644
--- a/src/config.in
+++ b/src/config.in
@@ -294,6 +294,9 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 /* Define to 1 if netdb.h declares h_errno. */
 #undef HAVE_H_ERRNO
 
+/* Define to 1 if using imagemagick. */
+#undef HAVE_IMAGEMAGICK
+
 /* Define to 1 if you have inet sockets. */
 #undef HAVE_INET_SOCKETS
 
@@ -432,6 +435,9 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 /* Define to 1 if you have the <mach/mach.h> header file. */
 #undef HAVE_MACH_MACH_H
 
+/* Define to 1 if you have the `MagickExportImagePixels' function. */
+#undef HAVE_MAGICKEXPORTIMAGEPIXELS
+
 /* Define to 1 if you have the <maillock.h> header file. */
 #undef HAVE_MAILLOCK_H
 
@@ -807,6 +813,9 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 /* Define to 1 if you have the SM library (-lSM). */
 #undef HAVE_X_SM
 
+/* Define to 1 if you have the libxml2 library (-lxml2). */
+#undef HAVE_LIBXML2
+
 /* Define to 1 if you want to use the X window system. */
 #undef HAVE_X_WINDOWS
 
diff --git a/src/dbusbind.c b/src/dbusbind.c
index 683d6f047fa..3b6f0e543bb 100644
--- a/src/dbusbind.c
+++ b/src/dbusbind.c
@@ -31,6 +31,7 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 
 /* Subroutines.  */
 Lisp_Object Qdbus_init_bus;
+Lisp_Object Qdbus_close_bus;
 Lisp_Object Qdbus_get_unique_name;
 Lisp_Object Qdbus_call_method;
 Lisp_Object Qdbus_call_method_asynchronously;
@@ -59,6 +60,9 @@ Lisp_Object QCdbus_type_object_path, QCdbus_type_signature;
 Lisp_Object QCdbus_type_array, QCdbus_type_variant;
 Lisp_Object QCdbus_type_struct, QCdbus_type_dict_entry;
 
+/* Registered buses.  */
+Lisp_Object Vdbus_registered_buses;
+
 /* Hash table which keeps function definitions.  */
 Lisp_Object Vdbus_registered_objects_table;
 
@@ -111,7 +115,7 @@ int xd_in_read_queued_messages = 0;
   } while (0)
 
 /* Macros for debugging.  In order to enable them, build with
-   "make MYCPPFLAGS='-DDBUS_DEBUG -Wall'".  */
+   "MYCPPFLAGS='-DDBUS_DEBUG -Wall' make".  */
 #ifdef DBUS_DEBUG
 #define XD_DEBUG_MESSAGE(...)           \
   do {                                  \
@@ -713,10 +717,10 @@ xd_retrieve_arg (unsigned int dtype, DBusMessageIter *iter)
     }
 }
 
-/* Initialize D-Bus connection.  BUS is a Lisp symbol, either :system
-   or :session.  It tells which D-Bus to initialize.  If RAISE_ERROR
-   is non-zero signal an error when the connection cannot be
-   initialized.  */
+/* Initialize D-Bus connection.  BUS is either a Lisp symbol, :system
+   or :session, or a string denoting the bus address.  It tells which
+   D-Bus to initialize.  If RAISE_ERROR is non-zero, signal an error
+   when the connection cannot be initialized.  */
 static DBusConnection *
 xd_initialize (Lisp_Object bus, int raise_error)
 {
@@ -724,34 +728,66 @@ xd_initialize (Lisp_Object bus, int raise_error)
   DBusError derror;
 
   /* Parameter check.  */
-  CHECK_SYMBOL (bus);
-  if (!(EQ (bus, QCdbus_system_bus) || EQ (bus, QCdbus_session_bus)))
-    if (raise_error)
-      XD_SIGNAL2 (build_string ("Wrong bus name"), bus);
-    else
-      return NULL;
+  if (!STRINGP (bus))
+    {
+      CHECK_SYMBOL (bus);
+      if (!(EQ (bus, QCdbus_system_bus) || EQ (bus, QCdbus_session_bus)))
+        {
+          if (raise_error)
+            XD_SIGNAL2 (build_string ("Wrong bus name"), bus);
+          else
+            return NULL;
+        }
 
-  /* We do not want to have an autolaunch for the session bus.  */
-  if (EQ (bus, QCdbus_session_bus)
-      && getenv ("DBUS_SESSION_BUS_ADDRESS") == NULL)
-    if (raise_error)
-      XD_SIGNAL2 (build_string ("No connection to bus"), bus);
-    else
-      return NULL;
+      /* We do not want to have an autolaunch for the session bus.  */
+      if (EQ (bus, QCdbus_session_bus)
+          && getenv ("DBUS_SESSION_BUS_ADDRESS") == NULL)
+        {
+          if (raise_error)
+            XD_SIGNAL2 (build_string ("No connection to bus"), bus);
+          else
+            return NULL;
+        }
+    }
 
   /* Open a connection to the bus.  */
   dbus_error_init (&derror);
 
-  if (EQ (bus, QCdbus_system_bus))
-    connection = dbus_bus_get (DBUS_BUS_SYSTEM, &derror);
+  if (STRINGP (bus))
+      connection = dbus_connection_open (SDATA (bus), &derror);
   else
-    connection = dbus_bus_get (DBUS_BUS_SESSION, &derror);
+    if (EQ (bus, QCdbus_system_bus))
+      connection = dbus_bus_get (DBUS_BUS_SYSTEM, &derror);
+    else
+      connection = dbus_bus_get (DBUS_BUS_SESSION, &derror);
 
   if (dbus_error_is_set (&derror))
-    if (raise_error)
-      XD_ERROR (derror);
-    else
-      connection = NULL;
+    {
+      if (raise_error)
+        XD_ERROR (derror);
+      else
+        connection = NULL;
+    }
+
+  /* If it is not the system or session bus, we must register
+     ourselves.  Otherwise, we have called dbus_bus_get, which has
+     configured us to exit if the connection closes - we undo this
+     setting.  */
+  if (connection != NULL)
+    {
+      if (STRINGP (bus))
+        dbus_bus_register (connection, &derror);
+      else
+        dbus_connection_set_exit_on_disconnect (connection, FALSE);
+    }
+
+  if (dbus_error_is_set (&derror))
+    {
+      if (raise_error)
+        XD_ERROR (derror);
+      else
+        connection = NULL;
+    }
 
   if (connection == NULL && raise_error)
     XD_SIGNAL2 (build_string ("No connection to bus"), bus);
@@ -794,7 +830,8 @@ xd_add_watch (DBusWatch *watch, void *data)
 }
 
 /* Remove connection file descriptor from input_wait_mask.  DATA is
-   the used bus, either QCdbus_system_bus or QCdbus_session_bus.  */
+   the used bus, either a string or QCdbus_system_bus or
+   QCdbus_session_bus.  */
 void
 xd_remove_watch (DBusWatch *watch, void *data)
 {
@@ -830,15 +867,11 @@ xd_remove_watch (DBusWatch *watch, void *data)
 }
 
 DEFUN ("dbus-init-bus", Fdbus_init_bus, Sdbus_init_bus, 1, 1, 0,
-       doc: /* Initialize connection to D-Bus BUS.
-This is an internal function, it shall not be used outside dbus.el.  */)
+       doc: /* Initialize connection to D-Bus BUS.  */)
   (Lisp_Object bus)
 {
   DBusConnection *connection;
 
-  /* Check parameters.  */
-  CHECK_SYMBOL (bus);
-
   /* Open a connection to the bus.  */
   connection = xd_initialize (bus, TRUE);
 
@@ -850,6 +883,28 @@ This is an internal function, it shall not be used outside dbus.el.  */)
                                             NULL, (void*) XHASH (bus), NULL))
     XD_SIGNAL1 (build_string ("Cannot add watch functions"));
 
+  /* Add bus to list of registered buses.  */
+  Vdbus_registered_buses =  Fcons (bus, Vdbus_registered_buses);
+
+  /* Return.  */
+  return Qnil;
+}
+
+DEFUN ("dbus-close-bus", Fdbus_close_bus, Sdbus_close_bus, 1, 1, 0,
+       doc: /* Close connection to D-Bus BUS.  */)
+  (Lisp_Object bus)
+{
+  DBusConnection *connection;
+
+  /* Open a connection to the bus.  */
+  connection = xd_initialize (bus, TRUE);
+
+  /* Decrement reference count to the bus.  */
+  dbus_connection_unref (connection);
+
+  /* Remove bus from list of registered buses.  */
+  Vdbus_registered_buses = Fdelete (bus, Vdbus_registered_buses);
+
   /* Return.  */
   return Qnil;
 }
@@ -862,9 +917,6 @@ DEFUN ("dbus-get-unique-name", Fdbus_get_unique_name, Sdbus_get_unique_name,
   DBusConnection *connection;
   const char *name;
 
-  /* Check parameters.  */
-  CHECK_SYMBOL (bus);
-
   /* Open a connection to the bus.  */
   connection = xd_initialize (bus, TRUE);
 
@@ -880,7 +932,8 @@ DEFUN ("dbus-get-unique-name", Fdbus_get_unique_name, Sdbus_get_unique_name,
 DEFUN ("dbus-call-method", Fdbus_call_method, Sdbus_call_method, 5, MANY, 0,
        doc: /* Call METHOD on the D-Bus BUS.
 
-BUS is either the symbol `:system' or the symbol `:session'.
+BUS is either a Lisp symbol, `:system' or `:session', or a string
+denoting the bus address.
 
 SERVICE is the D-Bus service name to be used.  PATH is the D-Bus
 object path SERVICE is registered at.  INTERFACE is an interface
@@ -967,7 +1020,6 @@ usage: (dbus-call-method BUS SERVICE PATH INTERFACE METHOD &optional :timeout TI
   interface = args[3];
   method = args[4];
 
-  CHECK_SYMBOL (bus);
   CHECK_STRING (service);
   CHECK_STRING (path);
   CHECK_STRING (interface);
@@ -1082,7 +1134,8 @@ DEFUN ("dbus-call-method-asynchronously", Fdbus_call_method_asynchronously,
        Sdbus_call_method_asynchronously, 6, MANY, 0,
        doc: /* Call METHOD on the D-Bus BUS asynchronously.
 
-BUS is either the symbol `:system' or the symbol `:session'.
+BUS is either a Lisp symbol, `:system' or `:session', or a string
+denoting the bus address.
 
 SERVICE is the D-Bus service name to be used.  PATH is the D-Bus
 object path SERVICE is registered at.  INTERFACE is an interface
@@ -1148,7 +1201,6 @@ usage: (dbus-call-method-asynchronously BUS SERVICE PATH INTERFACE METHOD HANDLE
   method = args[4];
   handler = args[5];
 
-  CHECK_SYMBOL (bus);
   CHECK_STRING (service);
   CHECK_STRING (path);
   CHECK_STRING (interface);
@@ -1271,7 +1323,6 @@ usage: (dbus-method-return-internal BUS SERIAL SERVICE &rest ARGS)  */)
   serial = args[1];
   service = args[2];
 
-  CHECK_SYMBOL (bus);
   CHECK_NUMBER (serial);
   CHECK_STRING (service);
   GCPRO3 (bus, serial, service);
@@ -1363,7 +1414,6 @@ usage: (dbus-method-error-internal BUS SERIAL SERVICE &rest ARGS)  */)
   serial = args[1];
   service = args[2];
 
-  CHECK_SYMBOL (bus);
   CHECK_NUMBER (serial);
   CHECK_STRING (service);
   GCPRO3 (bus, serial, service);
@@ -1436,7 +1486,8 @@ usage: (dbus-method-error-internal BUS SERIAL SERVICE &rest ARGS)  */)
 DEFUN ("dbus-send-signal", Fdbus_send_signal, Sdbus_send_signal, 5, MANY, 0,
        doc: /* Send signal SIGNAL on the D-Bus BUS.
 
-BUS is either the symbol `:system' or the symbol `:session'.
+BUS is either a Lisp symbol, `:system' or `:session', or a string
+denoting the bus address.
 
 SERVICE is the D-Bus service name SIGNAL is sent from.  PATH is the
 D-Bus object path SERVICE is registered at.  INTERFACE is an interface
@@ -1480,7 +1531,6 @@ usage: (dbus-send-signal BUS SERVICE PATH INTERFACE SIGNAL &rest ARGS)  */)
   interface = args[3];
   signal = args[4];
 
-  CHECK_SYMBOL (bus);
   CHECK_STRING (service);
   CHECK_STRING (path);
   CHECK_STRING (interface);
@@ -1552,7 +1602,8 @@ usage: (dbus-send-signal BUS SERVICE PATH INTERFACE SIGNAL &rest ARGS)  */)
 }
 
 /* Check, whether there is pending input in the message queue of the
-   D-Bus BUS.  BUS is a Lisp symbol, either :system or :session.  */
+   D-Bus BUS.  BUS is either a Lisp symbol, :system or :session, or a
+   string denoting the bus address.  */
 int
 xd_get_dispatch_status (Lisp_Object bus)
 {
@@ -1572,24 +1623,31 @@ xd_get_dispatch_status (Lisp_Object bus)
     ? TRUE : FALSE;
 }
 
-/* Check for queued incoming messages from the system and session buses.  */
+/* Check for queued incoming messages from the buses.  */
 int
 xd_pending_messages (void)
 {
+  Lisp_Object busp = Vdbus_registered_buses;
+
+  while (!NILP (busp))
+    {
+      /* We do not want to have an autolaunch for the session bus.  */
+      if (EQ ((CAR_SAFE (busp)), QCdbus_session_bus)
+          && getenv ("DBUS_SESSION_BUS_ADDRESS") == NULL)
+        continue;
 
-  /* Vdbus_registered_objects_table will be initialized as hash table
-     in dbus.el.  When this package isn't loaded yet, it doesn't make
-     sense to handle D-Bus messages.  */
-  return (HASH_TABLE_P (Vdbus_registered_objects_table)
-          ? (xd_get_dispatch_status (QCdbus_system_bus)
-             || ((getenv ("DBUS_SESSION_BUS_ADDRESS") != NULL)
-                 ? xd_get_dispatch_status (QCdbus_session_bus)
-                 : FALSE))
-          : FALSE);
+      if (xd_get_dispatch_status (CAR_SAFE (busp)))
+        return TRUE;
+
+      busp = CDR_SAFE (busp);
+    }
+
+  return FALSE;
 }
 
-/* Read queued incoming message of the D-Bus BUS.  BUS is a Lisp
-   symbol, either :system or :session.  */
+/* Read queued incoming message of the D-Bus BUS.  BUS is either a
+   Lisp symbol, :system or :session, or a string denoting the bus
+   address.  */
 static Lisp_Object
 xd_read_message (Lisp_Object bus)
 {
@@ -1746,29 +1804,28 @@ xd_read_message (Lisp_Object bus)
   RETURN_UNGCPRO (Qnil);
 }
 
-/* Read queued incoming messages from the system and session buses.  */
+/* Read queued incoming messages from all buses.  */
 void
 xd_read_queued_messages (void)
 {
+  Lisp_Object busp = Vdbus_registered_buses;
 
-  /* Vdbus_registered_objects_table will be initialized as hash table
-     in dbus.el.  When this package isn't loaded yet, it doesn't make
-     sense to handle D-Bus messages.  Furthermore, we ignore all Lisp
-     errors during the call.  */
-  if (HASH_TABLE_P (Vdbus_registered_objects_table))
+  xd_in_read_queued_messages = 1;
+  while (!NILP (busp))
     {
-      xd_in_read_queued_messages = 1;
-      internal_catch (Qdbus_error, xd_read_message, QCdbus_system_bus);
-      internal_catch (Qdbus_error, xd_read_message, QCdbus_session_bus);
-      xd_in_read_queued_messages = 0;
+      /* We ignore all Lisp errors during the call.  */
+      internal_catch (Qdbus_error, xd_read_message, CAR_SAFE (busp));
+      busp = CDR_SAFE (busp);
     }
+  xd_in_read_queued_messages = 0;
 }
 
 DEFUN ("dbus-register-signal", Fdbus_register_signal, Sdbus_register_signal,
        6, MANY, 0,
        doc: /* Register for signal SIGNAL on the D-Bus BUS.
 
-BUS is either the symbol `:system' or the symbol `:session'.
+BUS is either a Lisp symbol, `:system' or `:session', or a string
+denoting the bus address.
 
 SERVICE is the D-Bus service name used by the sending D-Bus object.
 It can be either a known name or the unique name of the D-Bus object
@@ -1822,7 +1879,6 @@ usage: (dbus-register-signal BUS SERVICE PATH INTERFACE SIGNAL HANDLER &rest ARG
   signal = args[4];
   handler = args[5];
 
-  CHECK_SYMBOL (bus);
   if (!NILP (service)) CHECK_STRING (service);
   if (!NILP (path)) CHECK_STRING (path);
   CHECK_STRING (interface);
@@ -1915,7 +1971,8 @@ DEFUN ("dbus-register-method", Fdbus_register_method, Sdbus_register_method,
        6, 6, 0,
        doc: /* Register for method METHOD on the D-Bus BUS.
 
-BUS is either the symbol `:system' or the symbol `:session'.
+BUS is either a Lisp symbol, `:system' or `:session', or a string
+denoting the bus address.
 
 SERVICE is the D-Bus service name of the D-Bus object METHOD is
 registered for.  It must be a known name.
@@ -1933,7 +1990,6 @@ used for composing the returning D-Bus message.  */)
   DBusError derror;
 
   /* Check parameters.  */
-  CHECK_SYMBOL (bus);
   CHECK_STRING (service);
   CHECK_STRING (path);
   CHECK_STRING (interface);
@@ -1978,6 +2034,10 @@ syms_of_dbusbind (void)
   staticpro (&Qdbus_init_bus);
   defsubr (&Sdbus_init_bus);
 
+  Qdbus_close_bus = intern_c_string ("dbus-close-bus");
+  staticpro (&Qdbus_close_bus);
+  defsubr (&Sdbus_close_bus);
+
   Qdbus_get_unique_name = intern_c_string ("dbus-get-unique-name");
   staticpro (&Qdbus_get_unique_name);
   defsubr (&Sdbus_get_unique_name);
@@ -2074,18 +2134,25 @@ syms_of_dbusbind (void)
   QCdbus_type_dict_entry = intern_c_string (":dict-entry");
   staticpro (&QCdbus_type_dict_entry);
 
+  DEFVAR_LISP ("dbus-registered-buses",
+               &Vdbus_registered_buses,
+    doc: /* List of D-Bus buses we are polling for messages.  */);
+  Vdbus_registered_buses = Qnil;
+
   DEFVAR_LISP ("dbus-registered-objects-table",
                &Vdbus_registered_objects_table,
     doc: /* Hash table of registered functions for D-Bus.
+
 There are two different uses of the hash table: for accessing
 registered interfaces properties, targeted by signals or method calls,
 and for calling handlers in case of non-blocking method call returns.
 
 In the first case, the key in the hash table is the list (BUS
-INTERFACE MEMBER).  BUS is either the symbol `:system' or the symbol
-`:session'.  INTERFACE is a string which denotes a D-Bus interface,
-and MEMBER, also a string, is either a method, a signal or a property
-INTERFACE is offering.  All arguments but BUS must not be nil.
+INTERFACE MEMBER).  BUS is either a Lisp symbol, `:system' or
+`:session', or a string denoting the bus address.  INTERFACE is a
+string which denotes a D-Bus interface, and MEMBER, also a string, is
+either a method, a signal or a property INTERFACE is offering.  All
+arguments but BUS must not be nil.
 
 The value in the hash table is a list of quadruple lists
 \((UNAME SERVICE PATH OBJECT) (UNAME SERVICE PATH OBJECT) ...).
@@ -2097,15 +2164,18 @@ be called when a D-Bus message, which matches the key criteria,
 arrives (methods and signals), or a cons cell containing the value of
 the property.
 
-In the second case, the key in the hash table is the list (BUS SERIAL).
-BUS is either the symbol `:system' or the symbol `:session'.  SERIAL
-is the serial number of the non-blocking method call, a reply is
-expected.  Both arguments must not be nil.  The value in the hash
-table is HANDLER, the function to be called when the D-Bus reply
-message arrives.  */);
-  /* We initialize Vdbus_registered_objects_table in dbus.el, because
-     we need to define a hash table function first.  */
-  Vdbus_registered_objects_table = Qnil;
+In the second case, the key in the hash table is the list (BUS
+SERIAL).  BUS is either a Lisp symbol, `:system' or `:session', or a
+string denoting the bus address.  SERIAL is the serial number of the
+non-blocking method call, a reply is expected.  Both arguments must
+not be nil.  The value in the hash table is HANDLER, the function to
+be called when the D-Bus reply message arrives.  */);
+  {
+    Lisp_Object args[2];
+    args[0] = QCtest;
+    args[1] = Qequal;
+    Vdbus_registered_objects_table = Fmake_hash_table (2, args);
+  }
 
   DEFVAR_LISP ("dbus-debug", &Vdbus_debug,
     doc: /* If non-nil, debug messages of D-Bus bindings are raised.  */);
diff --git a/src/deps.mk b/src/deps.mk
index 8eeed3822d0..d00be96744b 100644
--- a/src/deps.mk
+++ b/src/deps.mk
@@ -142,7 +142,7 @@ mktime.o: mktime.c $(config_h)
 msdos.o: msdos.c msdos.h dosfns.h systime.h termhooks.h dispextern.h frame.h \
    termopts.h termchar.h character.h coding.h ccl.h disptab.h window.h \
    keyboard.h $(INTERVALS_H) buffer.h commands.h blockinput.h atimer.h \
-   lisp.h $(config_h)
+   lisp.h sysselect.h $(config_h)
 nsfns.o: nsfns.m charset.h nsterm.h nsgui.h frame.h window.h buffer.h \
    dispextern.h fontset.h $(INTERVALS_H) keyboard.h blockinput.h \
    atimer.h systime.h epaths.h termhooks.h coding.h systime.h lisp.h $(config_h)
@@ -176,7 +176,7 @@ syntax.o: syntax.c syntax.h buffer.h commands.h category.h character.h \
 sysdep.o: sysdep.c syssignal.h systty.h systime.h syswait.h blockinput.h \
    process.h dispextern.h termhooks.h termchar.h termopts.h coding.h \
    frame.h atimer.h window.h msdos.h dosfns.h keyboard.h cm.h lisp.h \
-   $(config_h) composite.h
+   $(config_h) composite.h sysselect.h
 term.o: term.c termchar.h termhooks.h termopts.h lisp.h $(config_h) \
    cm.h frame.h disptab.h keyboard.h character.h charset.h coding.h ccl.h \
    xterm.h msdos.h window.h keymap.h blockinput.h atimer.h systime.h \
diff --git a/src/dispextern.h b/src/dispextern.h
index c36db91ea02..5138958b6db 100644
--- a/src/dispextern.h
+++ b/src/dispextern.h
@@ -1718,7 +1718,7 @@ struct face_cache
    This macro is only meaningful for multibyte character CHAR.  */
 
 #define FACE_FOR_CHAR(F, FACE, CHAR, POS, OBJECT)       \
-  (ASCII_CHAR_P (CHAR)                                  \
+  ((ASCII_CHAR_P (CHAR) || CHAR_BYTE8_P (CHAR))         \
    ? (FACE)->ascii_face->id                             \
    : face_for_char ((F), (FACE), (CHAR), (POS), (OBJECT)))
 
@@ -2275,9 +2275,11 @@ struct it
      composition.  */
   struct composition_it cmp_it;
 
-  /* The character to display, possibly translated to multibyte
-     if unibyte_display_via_language_environment is set.  This
-     is set after produce_glyphs has been called.  */
+  /* The character to display, possibly translated to multibyte if
+     multibyte_p is zero or unibyte_display_via_language_environment
+     is set.  This is set after get_next_display_element has been
+     called.  If we are setting it->C directly before calling
+     PRODUCE_GLYPHS, this should be set beforehand too.  */
   int char_to_display;
 
   /* If what == IT_IMAGE, the id of the image to display.  */
diff --git a/src/dispnew.c b/src/dispnew.c
index 35893872c73..9344d792f3d 100644
--- a/src/dispnew.c
+++ b/src/dispnew.c
@@ -5351,9 +5351,15 @@ update_frame_line (struct frame *f, int vpos)
  ***********************************************************************/
 
 /* Determine what's under window-relative pixel position (*X, *Y).
-   Return the object (string or buffer) that's there.
+   Return the OBJECT (string or buffer) that's there.
    Return in *POS the position in that object.
-   Adjust *X and *Y to character positions.  */
+   Adjust *X and *Y to character positions.
+   Return in *DX and *DY the pixel coordinates of the click,
+   relative to the top left corner of OBJECT, or relative to
+   the top left corner of the character glyph at (*X, *Y)
+   if OBJECT is nil.
+   Return WIDTH and HEIGHT of the object at (*X, *Y), or zero
+   if the coordinates point to an empty area of the display.  */
 
 Lisp_Object
 buffer_posn_from_coords (struct window *w, int *x, int *y, struct display_pos *pos, Lisp_Object *object, int *dx, int *dy, int *width, int *height)
@@ -5366,7 +5372,7 @@ buffer_posn_from_coords (struct window *w, int *x, int *y, struct display_pos *p
 #ifdef HAVE_WINDOW_SYSTEM
   struct image *img = 0;
 #endif
-  int x0, x1;
+  int x0, x1, to_x;
 
   /* We used to set current_buffer directly here, but that does the
      wrong thing with `face-remapping-alist' (bug#2044).  */
@@ -5377,8 +5383,33 @@ buffer_posn_from_coords (struct window *w, int *x, int *y, struct display_pos *p
   start_display (&it, w, startp);
 
   x0 = *x - WINDOW_LEFT_MARGIN_WIDTH (w);
-  move_it_to (&it, -1, x0 + it.first_visible_x, *y, -1,
-              MOVE_TO_X | MOVE_TO_Y);
+
+  /* First, move to the beginning of the row corresponding to *Y.  We
+     need to be in that row to get the correct value of base paragraph
+     direction for the text at (*X, *Y).  */
+  move_it_to (&it, -1, 0, *y, -1, MOVE_TO_X | MOVE_TO_Y);
+
+  /* TO_X is the pixel position that the iterator will compute for the
+     glyph at *X.  We add it.first_visible_x because iterator
+     positions include the hscroll.  */
+  to_x = x0 + it.first_visible_x;
+  if (it.bidi_it.paragraph_dir == R2L)
+    /* For lines in an R2L paragraph, we need to mirror TO_X wrt the
+       text area.  This is because the iterator, even in R2L
+       paragraphs, delivers glyphs as if they started at the left
+       margin of the window.  (When we actually produce glyphs for
+       display, we reverse their order in PRODUCE_GLYPHS, but the
+       iterator doesn't know about that.)  The following line adjusts
+       the pixel position to the iterator geometry, which is what
+       move_it_* routines use.  (The -1 is because in a window whose
+       text-area width is W, the rightmost pixel position is W-1, and
+       it should be mirrored into zero pixel position.)  */
+    to_x = window_box_width (w, TEXT_AREA) - to_x - 1;
+
+  /* Now move horizontally in the row to the glyph under *X.  Second
+     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);
 
   Fset_buffer (old_current_buffer);
 
diff --git a/src/doc.c b/src/doc.c
index f08976faf87..86d29a5a5ef 100644
--- a/src/doc.c
+++ b/src/doc.c
@@ -286,8 +286,7 @@ get_doc_string (Lisp_Object filepos, int unibyte, int definition)
                                 to - (get_doc_string_buffer + offset));
   else
     {
-      /* Let the data determine whether the string is multibyte,
-         even if Emacs is running in --unibyte mode.  */
+      /* The data determines whether the string is multibyte.  */
       int nchars = multibyte_chars_in_text (get_doc_string_buffer + offset,
                                             to - (get_doc_string_buffer + offset));
       return make_string_from_bytes (get_doc_string_buffer + offset,
@@ -632,24 +631,28 @@ the same file name is found in the `doc-directory'.  */)
       p = buf;
       end = buf + (filled < 512 ? filled : filled - 128);
       while (p != end && *p != '\037') p++;
-      /* p points to ^_Ffunctionname\n or ^_Vvarname\n.  */
+      /* p points to ^_Ffunctionname\n or ^_Vvarname\n or ^_Sfilename\n.  */
       if (p != end)
         {
           end = strchr (p, '\n');
 
           /* See if this is a file name, and if it is a file in build-files.  */
-          if (p[1] == 'S' && end - p > 4 && end[-2] == '.'
-              && (end[-1] == 'o' || end[-1] == 'c'))
+          if (p[1] == 'S')
             {
-              int len = end - p - 2;
-              char *fromfile = alloca (len + 1);
-              strncpy (fromfile, &p[2], len);
-              fromfile[len] = 0;
-              if (fromfile[len-1] == 'c')
-                fromfile[len-1] = 'o';
-
-              skip_file = NILP (Fmember (build_string (fromfile),
-                                         Vbuild_files));
+              skip_file = 0;
+              if (end - p > 4 && end[-2] == '.'
+                  && (end[-1] == 'o' || end[-1] == 'c'))
+                {
+                  int len = end - p - 2;
+                  char *fromfile = alloca (len + 1);
+                  strncpy (fromfile, &p[2], len);
+                  fromfile[len] = 0;
+                  if (fromfile[len-1] == 'c')
+                    fromfile[len-1] = 'o';
+
+                  skip_file = NILP (Fmember (build_string (fromfile),
+                                             Vbuild_files));
+                }
             }
 
           sym = oblookup (Vobarray, p + 2,
diff --git a/src/dosfns.c b/src/dosfns.c
index 5be0a363da8..e66b50ed3ff 100644
--- a/src/dosfns.c
+++ b/src/dosfns.c
@@ -60,7 +60,6 @@ REGISTERS should be a vector produced by `make-register' and
   register int i;
   int no;
   union REGS inregs, outregs;
-  Lisp_Object val;
 
   CHECK_NUMBER (interrupt);
   no = (unsigned long) XINT (interrupt);
@@ -101,7 +100,6 @@ Return the updated VECTOR.  */)
   register int i;
   int offs, len;
   char *buf;
-  Lisp_Object val;
 
   CHECK_NUMBER (address);
   offs = (unsigned long) XINT (address);
@@ -125,7 +123,6 @@ DEFUN ("msdos-memput", Fdos_memput, Sdos_memput, 2, 2, 0,
   register int i;
   int offs, len;
   char *buf;
-  Lisp_Object val;
 
   CHECK_NUMBER (address);
   offs = (unsigned long) XINT (address);
@@ -286,6 +283,8 @@ init_dosfns (void)
   unsigned long xbuf = _go32_info_block.linear_address_of_transfer_buffer;
 
 #ifndef SYSTEM_MALLOC
+  extern void get_lim_data (void);
+
   get_lim_data (); /* why the hell isn't this called elsewhere? */
 #endif
 
@@ -558,6 +557,7 @@ system_process_attributes (Lisp_Object pid)
       int i;
       Lisp_Object cmd_str, decoded_cmd, tem;
       double pmem;
+      EXFUN (Fget_internal_run_time, 0);
 #ifndef SYSTEM_MALLOC
       extern unsigned long ret_lim_data ();
 #endif
diff --git a/src/dosfns.h b/src/dosfns.h
index 820b6b30e43..d31401247b4 100644
--- a/src/dosfns.h
+++ b/src/dosfns.h
@@ -40,6 +40,7 @@ extern Lisp_Object Vdos_display_scancodes;
 
 extern int         msdos_stdcolor_idx  (const char *);
 extern Lisp_Object msdos_stdcolor_name (int);
+extern void        x_set_title (struct frame *, Lisp_Object);
 #endif
 
 /* arch-tag: a83b8c4c-63c8-451e-9e94-bc72e3e2f8bc
diff --git a/src/emacs.c b/src/emacs.c
index 4dc670e6032..33e0d60630b 100644
--- a/src/emacs.c
+++ b/src/emacs.c
@@ -91,6 +91,8 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #endif
 #endif
 
+/* If you change the following line, remember to update
+   msdos/mainmake.v2 which gleans the Emacs version from it!  */
 static const char emacs_copyright[] = "Copyright (C) 2010 Free Software Foundation, Inc.";
 static const char emacs_version[] = "24.0.50";
 
@@ -839,8 +841,9 @@ main (int argc, char **argv)
           || strcmp (argv[argc-1], "bootstrap") == 0)
       && ! getenv ("EMACS_HEAP_EXEC"))
     {
+      static char heapexec[] = "EMACS_HEAP_EXEC=true";
       /* Set this so we only do this once.  */
-      putenv("EMACS_HEAP_EXEC=true");
+      putenv(heapexec);
 
       /* A flag to turn off address randomization which is introduced
          in linux kernel shipped with fedora core 4 */
@@ -1329,68 +1332,6 @@ main (int argc, char **argv)
   init_atimer ();
   running_asynch_code = 0;
 
-  /* Handle --unibyte and the EMACS_UNIBYTE envvar,
-     but not while dumping.  */
-  if (1)
-    {
-      int inhibit_unibyte = 0;
-
-      /* --multibyte overrides EMACS_UNIBYTE.  */
-      if (argmatch (argv, argc, "-no-unibyte", "--no-unibyte", 4, NULL, &skip_args)
-          || argmatch (argv, argc, "-multibyte", "--multibyte", 4, NULL, &skip_args)
-          /* Ignore EMACS_UNIBYTE before dumping.  */
-          || (!initialized && noninteractive))
-        inhibit_unibyte = 1;
-
-      /* --unibyte requests that we set up to do everything with single-byte
-         buffers and strings.  We need to handle this before calling
-         init_lread, init_editfns and other places that generate Lisp strings
-         from text in the environment.  */
-      /* Actually this shouldn't be needed as of 20.4 in a generally
-         unibyte environment.  As handa says, environment values
-         aren't now decoded; also existing buffers are now made
-         unibyte during startup if .emacs sets unibyte.  Tested with
-         8-bit data in environment variables and /etc/passwd, setting
-         unibyte and Latin-1 in .emacs. -- Dave Love  */
-      if (argmatch (argv, argc, "-unibyte", "--unibyte", 4, NULL, &skip_args)
-          || argmatch (argv, argc, "-no-multibyte", "--no-multibyte", 4, NULL, &skip_args)
-          || (getenv ("EMACS_UNIBYTE") && !inhibit_unibyte))
-        {
-          Lisp_Object old_log_max;
-          Lisp_Object symbol, tail;
-
-          symbol = intern_c_string ("enable-multibyte-characters");
-          Fset_default (symbol, Qnil);
-
-          if (initialized)
-            {
-              /* Erase pre-dump messages in *Messages* now so no abort.  */
-              old_log_max = Vmessage_log_max;
-              XSETFASTINT (Vmessage_log_max, 0);
-              message_dolog ("", 0, 1, 0);
-              Vmessage_log_max = old_log_max;
-            }
-
-          for (tail = Vbuffer_alist; CONSP (tail);
-               tail = XCDR (tail))
-            {
-              Lisp_Object buffer;
-
-              buffer = Fcdr (XCAR (tail));
-              /* Make a multibyte buffer unibyte.  */
-              if (BUF_Z_BYTE (XBUFFER (buffer)) > BUF_Z (XBUFFER (buffer)))
-                {
-                  struct buffer *current = current_buffer;
-
-                  set_buffer_temp (XBUFFER (buffer));
-                  Fset_buffer_multibyte (Qnil);
-                  set_buffer_temp (current);
-                }
-            }
-          message ("Warning: unibyte sessions are obsolete and will disappear");
-        }
-    }
-
   no_loadup
     = argmatch (argv, argc, "-nl", "--no-loadup", 6, NULL, &skip_args);
 
@@ -1603,6 +1544,10 @@ main (int argc, char **argv)
 #endif
 #endif /* HAVE_X_WINDOWS */
 
+#ifdef HAVE_LIBXML2
+      syms_of_xml ();
+#endif
+
       syms_of_menu ();
 
 #ifdef HAVE_NTGUI
@@ -1789,10 +1734,6 @@ const struct standard_args standard_args[] =
   { "-script", "--script", 100, 1 },
   { "-daemon", "--daemon", 99, 0 },
   { "-help", "--help", 90, 0 },
-  { "-no-unibyte", "--no-unibyte", 83, 0 },
-  { "-multibyte", "--multibyte", 82, 0 },
-  { "-unibyte", "--unibyte", 81, 0 },
-  { "-no-multibyte", "--no-multibyte", 80, 0 },
   { "-nl", "--no-loadup", 70, 0 },
   /* -d must come last before the options handled in startup.el.  */
   { "-d", "--display", 60, 1 },
@@ -2093,7 +2034,7 @@ shut_down_emacs (int sig, int no_x, Lisp_Object stuff)
   Vinhibit_redisplay = Qt;
 
   /* If we are controlling the terminal, reset terminal modes.  */
-#ifdef EMACS_HAVE_TTY_PGRP
+#ifndef DOS_NT
   {
     int pgrp = EMACS_GETPGRP (0);
 
diff --git a/src/eval.c b/src/eval.c
index 6d0a49c0d7e..a16d6c59809 100644
--- a/src/eval.c
+++ b/src/eval.c
@@ -722,8 +722,8 @@ usage: (defmacro NAME ARGLIST [DOCSTRING] [DECL] BODY...)  */)
       tail = XCDR (tail);
     }
 
-  while (CONSP (Fcar (tail))
-         && EQ (Fcar (Fcar (tail)), Qdeclare))
+  if (CONSP (Fcar (tail))
+      && EQ (Fcar (Fcar (tail)), Qdeclare))
     {
       if (!NILP (Vmacro_declaration_function))
         {
@@ -1072,12 +1072,13 @@ usage: (let VARLIST BODY...)  */)
   int count = SPECPDL_INDEX ();
   register int argnum;
   struct gcpro gcpro1, gcpro2;
+  USE_SAFE_ALLOCA;
 
   varlist = Fcar (args);
 
   /* Make space to hold the values to give the bound variables */
   elt = Flength (varlist);
-  temps = (Lisp_Object *) alloca (XFASTINT (elt) * sizeof (Lisp_Object));
+  SAFE_ALLOCA_LISP (temps, XFASTINT (elt));
 
   /* Compute the values and store them in `temps' */
 
@@ -1122,7 +1123,7 @@ usage: (let VARLIST BODY...)  */)
     specbind (Qinternal_interpreter_environment, lexenv);
 
   elt = Fprogn (Fcdr (args));
-
+  SAFE_FREE ();
   return unbind_to (count, elt);
 }
 
@@ -2396,8 +2397,9 @@ DEFUN ("eval", Feval, Seval, 1, 1, 0,
           /* Pass a vector of evaluated arguments */
           Lisp_Object *vals;
           register int argnum = 0;
+          USE_SAFE_ALLOCA;
 
-          vals = (Lisp_Object *) alloca (XINT (numargs) * sizeof (Lisp_Object));
+          SAFE_ALLOCA_LISP (vals, XINT (numargs));
 
           GCPRO3 (args_left, fun, fun);
           gcpro3.var = vals;
@@ -2415,6 +2417,7 @@ DEFUN ("eval", Feval, Seval, 1, 1, 0,
 
           val = (XSUBR (fun)->function.aMANY) (XINT (numargs), vals);
           UNGCPRO;
+          SAFE_FREE ();
           goto done;
         }
 
@@ -2536,8 +2539,9 @@ usage: (apply FUNCTION &rest ARGUMENTS)  */)
   register int i, numargs;
   register Lisp_Object spread_arg;
   register Lisp_Object *funcall_args;
-  Lisp_Object fun;
+  Lisp_Object fun, retval;
   struct gcpro gcpro1;
+  USE_SAFE_ALLOCA;
 
   fun = args [0];
   funcall_args = 0;
@@ -2576,8 +2580,7 @@ usage: (apply FUNCTION &rest ARGUMENTS)  */)
         {
           /* Avoid making funcall cons up a yet another new vector of arguments
              by explicitly supplying nil's for optional values */
-          funcall_args = (Lisp_Object *) alloca ((1 + XSUBR (fun)->max_args)
-                                                 * sizeof (Lisp_Object));
+          SAFE_ALLOCA_LISP (funcall_args, 1 + XSUBR (fun)->max_args);
           for (i = numargs; i < XSUBR (fun)->max_args;)
             funcall_args[++i] = Qnil;
           GCPRO1 (*funcall_args);
@@ -2589,8 +2592,7 @@ usage: (apply FUNCTION &rest ARGUMENTS)  */)
      function itself as well as its arguments.  */
   if (!funcall_args)
     {
-      funcall_args = (Lisp_Object *) alloca ((1 + numargs)
-                                             * sizeof (Lisp_Object));
+      SAFE_ALLOCA_LISP (funcall_args, 1 + numargs);
       GCPRO1 (*funcall_args);
       gcpro1.nvars = 1 + numargs;
     }
@@ -2606,7 +2608,11 @@ usage: (apply FUNCTION &rest ARGUMENTS)  */)
     }
 
   /* By convention, the caller needs to gcpro Ffuncall's args.  */
-  RETURN_UNGCPRO (Ffuncall (gcpro1.nvars, funcall_args));
+  retval = Ffuncall (gcpro1.nvars, funcall_args);
+  UNGCPRO;
+  SAFE_FREE ();
+
+  return retval;
 }
 
 /* Run hook variables in various ways.  */
@@ -3212,9 +3218,10 @@ apply_lambda (Lisp_Object fun, Lisp_Object args, int eval_flag,
   struct gcpro gcpro1, gcpro2, gcpro3;
   register int i;
   register Lisp_Object tem;
+  USE_SAFE_ALLOCA;
 
   numargs = Flength (args);
-  arg_vector = (Lisp_Object *) alloca (XINT (numargs) * sizeof (Lisp_Object));
+  SAFE_ALLOCA_LISP (arg_vector, XINT (numargs));
   args_left = args;
 
   GCPRO3 (*arg_vector, args_left, fun);
@@ -3243,6 +3250,7 @@ apply_lambda (Lisp_Object fun, Lisp_Object args, int eval_flag,
     tem = call_debugger (Fcons (Qexit, Fcons (tem, Qnil)));
   /* Don't do it again when we return to eval.  */
   backtrace_list->debug_on_exit = 0;
+  SAFE_FREE ();
   return tem;
 }
 
diff --git a/src/fileio.c b/src/fileio.c
index a04cd4e76f5..3d08e881e8f 100644
--- a/src/fileio.c
+++ b/src/fileio.c
@@ -1842,7 +1842,7 @@ barf_or_query_if_file_exists (Lisp_Object absname, const unsigned char *querystr
       tem = format2 ("File %s already exists; %s anyway? ",
                      absname, build_string (querystring));
       if (quick)
-        tem = Fy_or_n_p (tem);
+        tem = call1 (intern ("y-or-n-p"), tem);
       else
         tem = do_yes_or_no_p (tem);
       UNGCPRO;
diff --git a/src/floatfns.c b/src/floatfns.c
index 1c3e40eefde..29e5c119a1f 100644
--- a/src/floatfns.c
+++ b/src/floatfns.c
@@ -987,16 +987,18 @@ int
 matherr (struct exception *x)
 {
   Lisp_Object args;
+  const char *name = x->name;
+
   if (! in_float)
     /* Not called from emacs-lisp float routines; do the default thing. */
     return 0;
   if (!strcmp (x->name, "pow"))
-    x->name = "expt";
+    name = "expt";
 
   args
-    = Fcons (build_string (x->name),
+    = Fcons (build_string (name),
              Fcons (make_float (x->arg1),
-                    ((!strcmp (x->name, "log") || !strcmp (x->name, "pow"))
+                    ((!strcmp (name, "log") || !strcmp (name, "pow"))
                      ? Fcons (make_float (x->arg2), Qnil)
                      : Qnil)));
   switch (x->type)
diff --git a/src/fns.c b/src/fns.c
index 83b4bd5492d..be4b99d50e6 100644
--- a/src/fns.c
+++ b/src/fns.c
@@ -2447,146 +2447,6 @@ SEQUENCE may be a list, a vector, a bool-vector, or a string.  */)
   return sequence;
 }
 
-/* Anything that calls this function must protect from GC!  */
-
-DEFUN ("y-or-n-p", Fy_or_n_p, Sy_or_n_p, 1, 1, 0,
-       doc: /* Ask user a "y or n" question.  Return t if answer is "y".
-Takes one argument, which is the string to display to ask the question.
-It should end in a space; `y-or-n-p' adds `(y or n) ' to it.
-No confirmation of the answer is requested; a single character is enough.
-Also accepts Space to mean yes, or Delete to mean no.  \(Actually, it uses
-the bindings in `query-replace-map'; see the documentation of that variable
-for more information.  In this case, the useful bindings are `act', `skip',
-`recenter', and `quit'.\)
-
-Under a windowing system a dialog box will be used if `last-nonmenu-event'
-is nil and `use-dialog-box' is non-nil.  */)
-  (Lisp_Object prompt)
-{
-  register Lisp_Object obj, key, def, map;
-  register int answer;
-  Lisp_Object xprompt;
-  Lisp_Object args[2];
-  struct gcpro gcpro1, gcpro2;
-  int count = SPECPDL_INDEX ();
-
-  specbind (Qcursor_in_echo_area, Qt);
-
-  map = Fsymbol_value (intern ("query-replace-map"));
-
-  CHECK_STRING (prompt);
-  xprompt = prompt;
-  GCPRO2 (prompt, xprompt);
-
-#ifdef HAVE_WINDOW_SYSTEM
-  if (display_hourglass_p)
-    cancel_hourglass ();
-#endif
-
-  while (1)
-    {
-
-#ifdef HAVE_MENUS
-      if (FRAME_WINDOW_P (SELECTED_FRAME ())
-          && (NILP (last_nonmenu_event) || CONSP (last_nonmenu_event))
-          && use_dialog_box
-          && have_menus_p ())
-        {
-          Lisp_Object pane, menu;
-          redisplay_preserve_echo_area (3);
-          pane = Fcons (Fcons (build_string ("Yes"), Qt),
-                        Fcons (Fcons (build_string ("No"), Qnil),
-                               Qnil));
-          menu = Fcons (prompt, pane);
-          obj = Fx_popup_dialog (Qt, menu, Qnil);
-          answer = !NILP (obj);
-          break;
-        }
-#endif /* HAVE_MENUS */
-      cursor_in_echo_area = 1;
-      choose_minibuf_frame ();
-
-      {
-        Lisp_Object pargs[3];
-
-        /* Colorize prompt according to `minibuffer-prompt' face.  */
-        pargs[0] = build_string ("%s(y or n) ");
-        pargs[1] = intern ("face");
-        pargs[2] = intern ("minibuffer-prompt");
-        args[0] = Fpropertize (3, pargs);
-        args[1] = xprompt;
-        Fmessage (2, args);
-      }
-
-      if (minibuffer_auto_raise)
-        {
-          Lisp_Object mini_frame;
-
-          mini_frame = WINDOW_FRAME (XWINDOW (minibuf_window));
-
-          Fraise_frame (mini_frame);
-        }
-
-      temporarily_switch_to_single_kboard (SELECTED_FRAME ());
-      obj = read_filtered_event (1, 0, 0, 0, Qnil);
-      cursor_in_echo_area = 0;
-      /* If we need to quit, quit with cursor_in_echo_area = 0.  */
-      QUIT;
-
-      key = Fmake_vector (make_number (1), obj);
-      def = Flookup_key (map, key, Qt);
-
-      if (EQ (def, intern ("skip")))
-        {
-          answer = 0;
-          break;
-        }
-      else if (EQ (def, intern ("act")))
-        {
-          answer = 1;
-          break;
-        }
-      else if (EQ (def, intern ("recenter")))
-        {
-          Frecenter (Qnil);
-          xprompt = prompt;
-          continue;
-        }
-      else if (EQ (def, intern ("quit")))
-        Vquit_flag = Qt;
-      /* We want to exit this command for exit-prefix,
-         and this is the only way to do it.  */
-      else if (EQ (def, intern ("exit-prefix")))
-        Vquit_flag = Qt;
-
-      QUIT;
-
-      /* If we don't clear this, then the next call to read_char will
-         return quit_char again, and we'll enter an infinite loop.  */
-      Vquit_flag = Qnil;
-
-      Fding (Qnil);
-      Fdiscard_input ();
-      if (EQ (xprompt, prompt))
-        {
-          args[0] = build_string ("Please answer y or n.  ");
-          args[1] = prompt;
-          xprompt = Fconcat (2, args);
-        }
-    }
-  UNGCPRO;
-
-  if (! noninteractive)
-    {
-      cursor_in_echo_area = -1;
-      message_with_string (answer ? "%s(y or n) y" : "%s(y or n) n",
-                           xprompt, 0);
-    }
-
-  unbind_to (count, Qnil);
-  return answer ? Qt : Qnil;
-}
-
 /* This is how C code calls `yes-or-no-p' and allows the user
    to redefined it.
 
@@ -4422,13 +4282,13 @@ keys.  Default is `eql'.  Predefined are the tests `eq', `eql', and
 Default is 65.
 
 :rehash-size REHASH-SIZE - Indicates how to expand the table when it
-fills up.  If REHASH-SIZE is an integer, add that many space.  If it
-is a float, it must be > 1.0, and the new size is computed by
-multiplying the old size with that factor.  Default is 1.5.
+fills up.  If REHASH-SIZE is an integer, increase the size by that
+amount.  If it is a float, it must be > 1.0, and the new size is the
+old size multiplied by that factor.  Default is 1.5.
 
 :rehash-threshold THRESHOLD -- THRESHOLD must a float > 0, and <= 1.0.
 Resize the hash table when the ratio (number of entries / table size)
-is greater or equal than THRESHOLD.  Default is 0.8.
+is greater than or equal to THRESHOLD.  Default is 0.8.
 
 :weakness WEAK -- WEAK must be one of nil, t, `key', `value',
 `key-or-value', or `key-and-value'.  If WEAK is not nil, the table
@@ -5061,7 +4921,6 @@ this variable.  */);
   defsubr (&Smapcar);
   defsubr (&Smapc);
   defsubr (&Smapconcat);
-  defsubr (&Sy_or_n_p);
   defsubr (&Syes_or_no_p);
   defsubr (&Sload_average);
   defsubr (&Sfeaturep);
diff --git a/src/font.c b/src/font.c
index eba75c11b2f..ae7211e92fe 100644
--- a/src/font.c
+++ b/src/font.c
@@ -3506,7 +3506,7 @@ font_open_by_spec (FRAME_PTR f, Lisp_Object spec)
    found, return Qnil.  */
 
 Lisp_Object
-font_open_by_name (FRAME_PTR f, char *name)
+font_open_by_name (FRAME_PTR f, const char *name)
 {
   Lisp_Object args[2];
   Lisp_Object spec, ret;
diff --git a/src/font.h b/src/font.h
index 5f1a442b59e..c322b8e590f 100644
--- a/src/font.h
+++ b/src/font.h
@@ -783,7 +783,7 @@ extern void font_prepare_for_face (FRAME_PTR f, struct face *face);
 extern void font_done_for_face (FRAME_PTR f, struct face *face);
 
 extern Lisp_Object font_open_by_spec (FRAME_PTR f, Lisp_Object spec);
-extern Lisp_Object font_open_by_name (FRAME_PTR f, char *name);
+extern Lisp_Object font_open_by_name (FRAME_PTR f, const char *name);
 extern void font_close_object (FRAME_PTR f, Lisp_Object font_object);
 
 extern Lisp_Object font_intern_prop (const char *str, int len, int force_symbol);
diff --git a/src/fontset.c b/src/fontset.c
index b273ace75af..86b9ceb45db 100644
--- a/src/fontset.c
+++ b/src/fontset.c
@@ -283,6 +283,10 @@ fontset_id_valid_p (id)
 #define RFONT_DEF_OBJECT(rfont_def) AREF (rfont_def, 2)
 #define RFONT_DEF_SET_OBJECT(rfont_def, object) \
   ASET ((rfont_def), 2, (object))
+/* Score of RFONT_DEF is an integer value; the lowest 8 bits represent
+   the order of listing by font backends, the higher bits represents
+   the order given by charset priority list.  The smaller value is
+   preferable.  */
 #define RFONT_DEF_SCORE(rfont_def) XINT (AREF (rfont_def, 3))
 #define RFONT_DEF_SET_SCORE(rfont_def, score) \
   ASET ((rfont_def), 3, make_number (score))
@@ -412,8 +416,13 @@ reorder_font_vector (Lisp_Object font_group, struct font *font)
       Lisp_Object font_def = RFONT_DEF_FONT_DEF (rfont_def);
       Lisp_Object font_spec = FONT_DEF_SPEC (font_def);
       int score = RFONT_DEF_SCORE (rfont_def) & 0xFF;
+      Lisp_Object otf_spec = Ffont_get (font_spec, QCotf);
 
-      if (! font_match_p (font_spec, font_object))
+      if (! NILP (otf_spec))
+        /* A font-spec with :otf is preferable regardless of encoding
+           and language..  */
+        ;
+      else if (! font_match_p (font_spec, font_object))
         {
           Lisp_Object encoding = FONT_DEF_ENCODING (font_def);
 
diff --git a/src/frame.h b/src/frame.h
index 088b477dfce..6b307c7c3b1 100644
--- a/src/frame.h
+++ b/src/frame.h
@@ -1050,7 +1050,7 @@ extern Lisp_Object Qbackground_color, Qforeground_color;
 extern Lisp_Object Qicon, Qicon_name, Qicon_type, Qicon_left, Qicon_top;
 extern Lisp_Object Qinternal_border_width;
 extern Lisp_Object Qtooltip;
-extern Lisp_Object Qmenu_bar_lines, Qtool_bar_lines;
+extern Lisp_Object Qmenu_bar_lines, Qtool_bar_lines, Qtool_bar_position;
 extern Lisp_Object Qmouse_color;
 extern Lisp_Object Qname, Qtitle;
 extern Lisp_Object Qparent_id;
diff --git a/src/gtkutil.c b/src/gtkutil.c
index b1591b79f9c..dbd48eb5272 100644
--- a/src/gtkutil.c
+++ b/src/gtkutil.c
@@ -432,20 +432,22 @@ xg_list_remove (xg_list_node *list, xg_list_node *node)
 }
 
 /* Allocate and return a utf8 version of STR.  If STR is already
-   utf8 or NULL, just return STR.
-   If not, a new string is allocated and the caller must free the result
+   utf8 or NULL, just return a copy of STR.
+   A new string is allocated and the caller must free the result
    with g_free.  */
 
 static char *
-get_utf8_string (char *str)
+get_utf8_string (const char *str)
 {
-  char *utf8_str = str;
+  char *utf8_str;
 
   if (!str) return NULL;
 
   /* If not UTF-8, try current locale.  */
   if (!g_utf8_validate (str, -1, NULL))
     utf8_str = g_locale_to_utf8 (str, -1, 0, 0, 0);
+  else
+    return g_strdup (str);
 
   if (!utf8_str)
     {
@@ -504,6 +506,41 @@ get_utf8_string (char *str)
   return utf8_str;
 }
 
+/* Check for special colors used in face spec for region face.
+   The colors are fetched from the Gtk+ theme.
+   Return 1 if color was found, 0 if not.  */
+
+int
+xg_check_special_colors (struct frame *f,
+                         const char *color_name,
+                         XColor *color)
+{
+  int success_p = 0;
+  if (FRAME_GTK_WIDGET (f))
+    {
+      if (strcmp ("gtk_selection_bg_color", color_name) == 0)
+        {
+          GtkStyle *gsty = gtk_widget_get_style (FRAME_GTK_WIDGET (f));
+          color->red = gsty->bg[GTK_STATE_SELECTED].red;
+          color->green = gsty->bg[GTK_STATE_SELECTED].green;
+          color->blue = gsty->bg[GTK_STATE_SELECTED].blue;
+          color->pixel = gsty->bg[GTK_STATE_SELECTED].pixel;
+          success_p = 1;
+        }
+      else if (strcmp ("gtk_selection_fg_color", color_name) == 0)
+        {
+          GtkStyle *gsty = gtk_widget_get_style (FRAME_GTK_WIDGET (f));
+          color->red = gsty->fg[GTK_STATE_SELECTED].red;
+          color->green = gsty->fg[GTK_STATE_SELECTED].green;
+          color->blue = gsty->fg[GTK_STATE_SELECTED].blue;
+          color->pixel = gsty->fg[GTK_STATE_SELECTED].pixel;
+          success_p = 1;
+        }
+    }
+
+  return success_p;
+}
+
 
 
 /***********************************************************************
@@ -896,6 +933,26 @@ xg_pix_to_gcolor (GtkWidget *w, long unsigned int pixel, GdkColor *c)
   gdk_colormap_query_color (map, pixel, c);
 }
 
+/* Callback called when the gtk theme changes.
+   We notify lisp code so it can fix faces used for region for example.  */
+
+static void
+style_changed_cb (GObject *go,
+                  GParamSpec *spec,
+                  gpointer user_data)
+{
+  struct input_event event;
+  GdkDisplay *gdpy = (GdkDisplay *) user_data;
+  const char *display_name = gdk_display_get_name (gdpy);
+
+  EVENT_INIT (event);
+  event.kind = CONFIG_CHANGED_EVENT;
+  event.frame_or_window = make_string (display_name, strlen (display_name));
+  /* Theme doesn't change often, so intern is called seldom.  */
+  event.arg = intern ("theme-name");
+  kbd_buffer_store_event (&event);
+}
+
 /* Create and set up the GTK widgets for frame F.
    Return 0 if creation failed, non-zero otherwise.  */
 
@@ -1021,6 +1078,22 @@ xg_create_frame_widgets (FRAME_PTR f)
   g_signal_connect (wtop, "query-tooltip", G_CALLBACK (qttip_cb), f);
 #endif
 
+  {
+    GdkScreen *screen = gtk_widget_get_screen (wtop);
+    GtkSettings *gs = gtk_settings_get_for_screen (screen);
+    /* Only connect this signal once per screen.  */
+    if (! g_signal_handler_find (G_OBJECT (gs),
+                                 G_SIGNAL_MATCH_FUNC,
+                                 0, 0, 0,
+                                 G_CALLBACK (style_changed_cb),
+                                 0))
+      {
+        g_signal_connect (G_OBJECT (gs), "notify::gtk-theme-name",
+                          G_CALLBACK (style_changed_cb),
+                          gdk_screen_get_display (screen));
+      }
+  }
+
   UNBLOCK_INPUT;
 
   return 1;
@@ -1336,7 +1409,7 @@ create_dialog (widget_value *wv,
             }
         }
 
-     if (utf8_label && utf8_label != item->value)
+     if (utf8_label)
        g_free (utf8_label);
     }
 
@@ -2076,7 +2149,7 @@ static const char* separator_names[] = {
 };
 
 static int
-xg_separator_p (char *label)
+xg_separator_p (const char *label)
 {
   if (! label) return 0;
   else if (strlen (label) > 3
@@ -2174,8 +2247,8 @@ xg_create_one_menuitem (widget_value *item,
 
   w = make_menu_item (utf8_label, utf8_key, item, group);
 
-  if (utf8_label && utf8_label != item->name) g_free (utf8_label);
-  if (utf8_key && utf8_key != item->key) g_free (utf8_key);
+  if (utf8_label) g_free (utf8_label);
+  if (utf8_key) g_free (utf8_key);
 
   cb_data = xmalloc (sizeof (xg_menu_item_cb_data));
 
@@ -2311,7 +2384,7 @@ create_menus (widget_value *data,
           gtk_menu_set_title (GTK_MENU (wmenu), utf8_label);
           w = gtk_menu_item_new_with_label (utf8_label);
           gtk_widget_set_sensitive (w, FALSE);
-          if (utf8_label && utf8_label != item->name) g_free (utf8_label);
+          if (utf8_label) g_free (utf8_label);
         }
       else if (xg_separator_p (item->name))
         {
@@ -2432,7 +2505,7 @@ xg_get_menu_item_label (GtkMenuItem *witem)
 /* Return non-zero if the menu item WITEM has the text LABEL.  */
 
 static int
-xg_item_label_same_p (GtkMenuItem *witem, char *label)
+xg_item_label_same_p (GtkMenuItem *witem, const char *label)
 {
   int is_same = 0;
   char *utf8_label = get_utf8_string (label);
@@ -2443,7 +2516,7 @@ xg_item_label_same_p (GtkMenuItem *witem, char *label)
   else if (old_label && utf8_label)
     is_same = strcmp (utf8_label, old_label) == 0;
 
-  if (utf8_label && utf8_label != label) g_free (utf8_label);
+  if (utf8_label) g_free (utf8_label);
 
   return is_same;
 }
@@ -2590,6 +2663,7 @@ xg_update_menubar (GtkWidget *menubar,
             /* Set the title of the detached window.  */
             gtk_menu_set_title (GTK_MENU (submenu), utf8_label);
 
+          if (utf8_label) g_free (utf8_label);
           iter = g_list_next (iter);
           val = val->next;
           ++pos;
@@ -2729,8 +2803,8 @@ xg_update_menu_item (widget_value *val,
   if (! old_label || strcmp (utf8_label, old_label) != 0)
     gtk_label_set_text (wlbl, utf8_label);
 
-  if (utf8_key && utf8_key != val->key) g_free (utf8_key);
-  if (utf8_label && utf8_label != val->name) g_free (utf8_label);
+  if (utf8_key) g_free (utf8_key);
+  if (utf8_label) g_free (utf8_label);
 
   if (! val->enabled && gtk_widget_get_sensitive (w))
     gtk_widget_set_sensitive (w, FALSE);
@@ -4218,7 +4292,8 @@ update_frame_tool_bar (FRAME_PTR f)
       GtkWidget *wbutton = NULL;
       GtkWidget *weventbox;
       Lisp_Object specified_file;
-      char *label = SSDATA (PROP (TOOL_BAR_ITEM_LABEL));
+      const char *label = (STRINGP (PROP (TOOL_BAR_ITEM_LABEL))
+                           ? SSDATA (PROP (TOOL_BAR_ITEM_LABEL)) : "");
       
       ti = gtk_toolbar_get_nth_item (GTK_TOOLBAR (wtoolbar), i);
 
diff --git a/src/gtkutil.h b/src/gtkutil.h
index 75620c54d10..9b796e1138c 100644
--- a/src/gtkutil.h
+++ b/src/gtkutil.h
@@ -38,14 +38,6 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 /* Key for data that menu items hold.  */
 #define XG_ITEM_DATA "emacs_menuitem"
 
-/* Button types in menus.  */
-enum button_type
-{
-  BUTTON_TYPE_NONE,
-  BUTTON_TYPE_TOGGLE,
-  BUTTON_TYPE_RADIO
-};
-
 /* This is a list node in a generic list implementation.  */
 typedef struct xg_list_node_
 {
@@ -82,48 +74,13 @@ typedef struct xg_menu_item_cb_data_
 } xg_menu_item_cb_data;
 
 
-/* Used to specify menus and dialogs.
-   This is an adaption from lwlib for Gtk so we can use more of the same
-   code as lwlib in xmenu.c.  */
-typedef struct _widget_value
-{
-  /* name of widget */
-  Lisp_Object   lname;
-  char          *name;
-  /* value (meaning depend on widget type) */
-  char          *value;
-  /* keyboard equivalent. no implications for XtTranslations */
-  Lisp_Object   lkey;
-  char          *key;
-  /* Help string or nil if none.
-     GC finds this string through the frame's menu_bar_vector
-     or through menu_items.  */
-  Lisp_Object   help;
-  /* true if enabled */
-  gint          enabled;
-  /* true if selected */
-  gint  selected;
-  /* The type of a button.  */
-  enum button_type button_type;
-  /* Contents of the sub-widgets, also selected slot for checkbox */
-  struct _widget_value  *contents;
-  /* data passed to callback */
-  gpointer      call_data;
-  /* next one in the list */
-  struct _widget_value  *next;
-
-  /* we resource the widget_value structures; this points to the next
-     one on the free list if this one has been deallocated.
-   */
-  struct _widget_value *free_list;
-} widget_value;
-
 #ifdef HAVE_GTK_FILE_SELECTION_NEW
 extern int use_old_gtk_file_dialog;
 #endif
+struct _widget_value;
 
-extern widget_value *malloc_widget_value (void);
-extern void free_widget_value (widget_value *);
+extern struct _widget_value *malloc_widget_value (void);
+extern void free_widget_value (struct _widget_value *);
 
 extern int xg_uses_old_file_dialog (void);
 
@@ -138,14 +95,14 @@ extern char *xg_get_font_name (FRAME_PTR f, const char *);
 extern GtkWidget *xg_create_widget (const char *type,
                                     const char *name,
                                     FRAME_PTR f,
-                                    widget_value *val,
+                                    struct _widget_value *val,
                                     GCallback select_cb,
                                     GCallback deactivate_cb,
                                     GCallback hightlight_cb);
 
 extern void xg_modify_menubar_widgets (GtkWidget *menubar,
                                        FRAME_PTR f,
-                                       widget_value *val,
+                                       struct _widget_value *val,
                                        int deep_p,
                                        GCallback select_cb,
                                        GCallback deactivate_cb,
@@ -199,6 +156,9 @@ extern void x_wm_set_size_hint (FRAME_PTR f,
                                 long flags,
                                 int user_position);
 extern void xg_set_background_color (FRAME_PTR f, unsigned long bg);
+extern int xg_check_special_colors (struct frame *f,
+                                    const char *color_name,
+                                    XColor *color);
 
 extern void xg_set_frame_icon (FRAME_PTR f,
                                Pixmap icon_pixmap,
diff --git a/src/image.c b/src/image.c
index 916fcfe8178..499cbf298c1 100644
--- a/src/image.c
+++ b/src/image.c
@@ -583,7 +583,7 @@ Lisp_Object Qxbm;
 
 Lisp_Object QCascent, QCmargin, QCrelief, Qcount, Qextension_data;
 Lisp_Object QCconversion, QCcolor_symbols, QCheuristic_mask;
-Lisp_Object QCindex, QCmatrix, QCcolor_adjustment, QCmask;
+Lisp_Object QCindex, QCmatrix, QCcolor_adjustment, QCmask, QCgeometry, QCcrop, QCrotation;
 
 /* Other symbols.  */
 
@@ -1735,7 +1735,6 @@ lookup_image (struct frame *f, Lisp_Object spec)
   struct image_cache *c;
   struct image *img;
   unsigned hash;
-  struct gcpro gcpro1;
   EMACS_TIME now;
 
   /* F must be a window-system frame, and SPEC must be a valid image
@@ -1745,8 +1744,6 @@ lookup_image (struct frame *f, Lisp_Object spec)
 
   c = FRAME_IMAGE_CACHE (f);
 
-  GCPRO1 (spec);
-
   /* Look up SPEC in the hash table of the image cache.  */
   hash = sxhash (spec, 0);
   img = search_image_cache (f, spec, hash);
@@ -1838,8 +1835,6 @@ lookup_image (struct frame *f, Lisp_Object spec)
   EMACS_GET_TIME (now);
   img->timestamp = EMACS_SECS (now);
 
-  UNGCPRO;
-
   /* Value is the image id.  */
   return img->id;
 }
@@ -2179,16 +2174,13 @@ Lisp_Object
 x_find_image_file (Lisp_Object file)
 {
   Lisp_Object file_found, search_path;
-  struct gcpro gcpro1, gcpro2;
   int fd;
 
-  file_found = Qnil;
   /* TODO I think this should use something like image-load-path
      instead.  Unfortunately, that can contain non-string elements.  */
   search_path = Fcons (Fexpand_file_name (build_string ("images"),
                                           Vdata_directory),
                        Vx_bitmap_file_path);
-  GCPRO2 (file_found, search_path);
 
   /* Try to find FILE in data-directory/images, then x-bitmap-file-path.  */
   fd = openp (search_path, file, Qnil, &file_found, Qnil);
@@ -2201,7 +2193,6 @@ x_find_image_file (Lisp_Object file)
       close (fd);
     }
 
-  UNGCPRO;
   return file_found;
 }
 
@@ -2875,14 +2866,11 @@ xbm_load (struct frame *f, struct image *img)
       Lisp_Object file;
       unsigned char *contents;
       int size;
-      struct gcpro gcpro1;
 
       file = x_find_image_file (file_name);
-      GCPRO1 (file);
       if (!STRINGP (file))
         {
           image_error ("Cannot find image file `%s'", file_name, Qnil);
-          UNGCPRO;
           return 0;
         }
 
@@ -2890,12 +2878,10 @@ xbm_load (struct frame *f, struct image *img)
       if (contents == NULL)
         {
           image_error ("Error loading XBM image `%s'", img->spec, Qnil);
-          UNGCPRO;
           return 0;
         }
 
       success_p = xbm_load_image (f, img, contents, contents + size);
-      UNGCPRO;
     }
   else
     {
@@ -3456,12 +3442,31 @@ xpm_load (struct frame *f, struct image *img)
            CONSP (tail);
            ++i, tail = XCDR (tail))
         {
-          Lisp_Object name = XCAR (XCAR (tail));
-          Lisp_Object color = XCDR (XCAR (tail));
-          xpm_syms[i].name = (char *) alloca (SCHARS (name) + 1);
-          strcpy (xpm_syms[i].name, SDATA (name));
-          xpm_syms[i].value = (char *) alloca (SCHARS (color) + 1);
-          strcpy (xpm_syms[i].value, SDATA (color));
+          Lisp_Object name;
+          Lisp_Object color;
+
+          if (!CONSP (XCAR (tail)))
+            {
+              xpm_syms[i].name = "";
+              xpm_syms[i].value = "";
+              continue;
+            }
+          name = XCAR (XCAR (tail));
+          color = XCDR (XCAR (tail));
+          if (STRINGP (name))
+            {
+              xpm_syms[i].name = (char *) alloca (SCHARS (name) + 1);
+              strcpy (xpm_syms[i].name, SDATA (name));
+            }
+          else
+            xpm_syms[i].name = "";
+          if (STRINGP (color))
+            {
+              xpm_syms[i].value = (char *) alloca (SCHARS (color) + 1);
+              strcpy (xpm_syms[i].value, SDATA (color));
+            }
+          else
+            xpm_syms[i].value = "";
         }
     }
 
@@ -3487,6 +3492,9 @@ xpm_load (struct frame *f, struct image *img)
       if (!STRINGP (file))
         {
           image_error ("Cannot find image file `%s'", specified_file, Qnil);
+#ifdef ALLOC_XPM_COLORS
+          xpm_free_color_cache ();
+#endif
           return 0;
         }
 
@@ -3505,6 +3513,14 @@ xpm_load (struct frame *f, struct image *img)
   else
     {
       Lisp_Object buffer = image_spec_value (img->spec, QCdata, NULL);
+      if (!STRINGP (buffer))
+        {
+          image_error ("Invalid image data `%s'", buffer, Qnil);
+#ifdef ALLOC_XPM_COLORS
+          xpm_free_color_cache ();
+#endif
+          return 0;
+        }
 #ifdef HAVE_NTGUI
       /* XpmCreatePixmapFromBuffer is not available in the Windows port
          of libxpm.  But XpmCreateImageFromBuffer almost does what we want.  */
@@ -4071,14 +4087,11 @@ xpm_load (struct frame *f,
       Lisp_Object file;
       unsigned char *contents;
       int size;
-      struct gcpro gcpro1;
 
       file = x_find_image_file (file_name);
-      GCPRO1 (file);
       if (!STRINGP (file))
         {
           image_error ("Cannot find image file `%s'", file_name, Qnil);
-          UNGCPRO;
           return 0;
         }
 
@@ -4086,19 +4099,22 @@ xpm_load (struct frame *f,
       if (contents == NULL)
         {
           image_error ("Error loading XPM image `%s'", img->spec, Qnil);
-          UNGCPRO;
           return 0;
         }
 
       success_p = xpm_load_image (f, img, contents, contents + size);
       xfree (contents);
-      UNGCPRO;
     }
   else
     {
       Lisp_Object data;
 
       data = image_spec_value (img->spec, QCdata, NULL);
+      if (!STRINGP (data))
+        {
+          image_error ("Invalid image data `%s'", data, Qnil);
+          return 0;
+        }
       success_p = xpm_load_image (f, img, SDATA (data),
                                   SDATA (data) + SBYTES (data));
     }
@@ -5090,14 +5106,11 @@ pbm_load (struct frame *f, struct image *img)
   XImagePtr ximg;
   Lisp_Object file, specified_file;
   enum {PBM_MONO, PBM_GRAY, PBM_COLOR} type;
-  struct gcpro gcpro1;
   unsigned char *contents = NULL;
   unsigned char *end, *p;
   int size;
 
   specified_file = image_spec_value (img->spec, QCfile, NULL);
-  file = Qnil;
-  GCPRO1 (file);
 
   if (STRINGP (specified_file))
     {
@@ -5105,7 +5118,6 @@ pbm_load (struct frame *f, struct image *img)
       if (!STRINGP (file))
         {
           image_error ("Cannot find image file `%s'", specified_file, Qnil);
-          UNGCPRO;
           return 0;
         }
 
@@ -5113,7 +5125,6 @@ pbm_load (struct frame *f, struct image *img)
       if (contents == NULL)
         {
           image_error ("Error reading `%s'", file, Qnil);
-          UNGCPRO;
           return 0;
         }
 
@@ -5124,6 +5135,11 @@ pbm_load (struct frame *f, struct image *img)
     {
       Lisp_Object data;
       data = image_spec_value (img->spec, QCdata, NULL);
+      if (!STRINGP (data))
+        {
+          image_error ("Invalid image data `%s'", data, Qnil);
+          return 0;
+        }
       p = SDATA (data);
       end = p + SBYTES (data);
     }
@@ -5134,7 +5150,6 @@ pbm_load (struct frame *f, struct image *img)
       image_error ("Not a PBM image: `%s'", img->spec, Qnil);
     error:
       xfree (contents);
-      UNGCPRO;
       return 0;
     }
 
@@ -5336,7 +5351,6 @@ pbm_load (struct frame *f, struct image *img)
      img->width = width;
      img->height = height; */
 
-  UNGCPRO;
   xfree (contents);
   return 1;
 }
@@ -5576,7 +5590,6 @@ png_load (struct frame *f, struct image *img)
   Lisp_Object specified_data;
   int x, y, i;
   XImagePtr ximg, mask_img = NULL;
-  struct gcpro gcpro1;
   png_struct *png_ptr = NULL;
   png_info *info_ptr = NULL, *end_info = NULL;
   FILE *volatile fp = NULL;
@@ -5593,8 +5606,6 @@ png_load (struct frame *f, struct image *img)
   /* Find out what file to load.  */
   specified_file = image_spec_value (img->spec, QCfile, NULL);
   specified_data = image_spec_value (img->spec, QCdata, NULL);
-  file = Qnil;
-  GCPRO1 (file);
 
   if (NILP (specified_data))
     {
@@ -5602,7 +5613,6 @@ png_load (struct frame *f, struct image *img)
       if (!STRINGP (file))
         {
           image_error ("Cannot find image file `%s'", specified_file, Qnil);
-          UNGCPRO;
           return 0;
         }
 
@@ -5611,7 +5621,6 @@ png_load (struct frame *f, struct image *img)
       if (!fp)
         {
           image_error ("Cannot open image file `%s'", file, Qnil);
-          UNGCPRO;
           return 0;
         }
 
@@ -5620,13 +5629,18 @@ png_load (struct frame *f, struct image *img)
           || fn_png_sig_cmp (sig, 0, sizeof sig))
         {
           image_error ("Not a PNG file: `%s'", file, Qnil);
-          UNGCPRO;
           fclose (fp);
           return 0;
         }
     }
   else
     {
+      if (!STRINGP (specified_data))
+        {
+          image_error ("Invalid image data `%s'", specified_data, Qnil);
+          return 0;
+        }
+
       /* Read from memory.  */
       tbr.bytes = SDATA (specified_data);
       tbr.len = SBYTES (specified_data);
@@ -5637,7 +5651,6 @@ png_load (struct frame *f, struct image *img)
           || fn_png_sig_cmp (tbr.bytes, 0, sizeof sig))
         {
           image_error ("Not a PNG image: `%s'", img->spec, Qnil);
-          UNGCPRO;
           return 0;
         }
 
@@ -5653,7 +5666,6 @@ png_load (struct frame *f, struct image *img)
   if (!png_ptr)
     {
       if (fp) fclose (fp);
-      UNGCPRO;
       return 0;
     }
 
@@ -5663,7 +5675,6 @@ png_load (struct frame *f, struct image *img)
     {
       fn_png_destroy_read_struct (&png_ptr, NULL, NULL);
       if (fp) fclose (fp);
-      UNGCPRO;
       return 0;
     }
 
@@ -5673,7 +5684,6 @@ png_load (struct frame *f, struct image *img)
     {
       fn_png_destroy_read_struct (&png_ptr, &info_ptr, NULL);
       if (fp) fclose (fp);
-      UNGCPRO;
       return 0;
     }
 
@@ -5687,7 +5697,6 @@ png_load (struct frame *f, struct image *img)
       xfree (pixels);
       xfree (rows);
       if (fp) fclose (fp);
-      UNGCPRO;
       return 0;
     }
 
@@ -5912,7 +5921,6 @@ png_load (struct frame *f, struct image *img)
       x_destroy_x_image (mask_img);
     }
 
-  UNGCPRO;
   return 1;
 }
 
@@ -6313,13 +6321,10 @@ jpeg_load (struct frame *f, struct image *img)
   int rc;
   unsigned long *colors;
   int width, height;
-  struct gcpro gcpro1;
 
   /* Open the JPEG file.  */
   specified_file = image_spec_value (img->spec, QCfile, NULL);
   specified_data = image_spec_value (img->spec, QCdata, NULL);
-  file = Qnil;
-  GCPRO1 (file);
 
   if (NILP (specified_data))
     {
@@ -6327,7 +6332,6 @@ jpeg_load (struct frame *f, struct image *img)
       if (!STRINGP (file))
         {
           image_error ("Cannot find image file `%s'", specified_file, Qnil);
-          UNGCPRO;
           return 0;
         }
 
@@ -6335,10 +6339,14 @@ jpeg_load (struct frame *f, struct image *img)
       if (fp == NULL)
         {
           image_error ("Cannot open `%s'", file, Qnil);
-          UNGCPRO;
           return 0;
         }
     }
+  else if (!STRINGP (specified_data))
+    {
+      image_error ("Invalid image data `%s'", specified_data, Qnil);
+      return 0;
+    }
 
   /* Customize libjpeg's error handling to call my_error_exit when an
      error is detected.  This function will perform a longjmp.
@@ -6367,8 +6375,6 @@ jpeg_load (struct frame *f, struct image *img)
 
       /* Free pixmap and colors.  */
       x_clear_image (f, img);
-
-      UNGCPRO;
       return 0;
     }
 
@@ -6466,7 +6472,6 @@ jpeg_load (struct frame *f, struct image *img)
   /* Put the image into the pixmap.  */
   x_put_x_image (f, ximg, img->pixmap, width, height);
   x_destroy_x_image (ximg);
-  UNGCPRO;
   return 1;
 }
 
@@ -6741,14 +6746,11 @@ tiff_load (struct frame *f, struct image *img)
   uint32 *buf;
   int rc, rc2;
   XImagePtr ximg;
-  struct gcpro gcpro1;
   tiff_memory_source memsrc;
   Lisp_Object image;
 
   specified_file = image_spec_value (img->spec, QCfile, NULL);
   specified_data = image_spec_value (img->spec, QCdata, NULL);
-  file = Qnil;
-  GCPRO1 (file);
 
   fn_TIFFSetErrorHandler (tiff_error_handler);
   fn_TIFFSetWarningHandler (tiff_warning_handler);
@@ -6760,7 +6762,6 @@ tiff_load (struct frame *f, struct image *img)
       if (!STRINGP (file))
         {
           image_error ("Cannot find image file `%s'", specified_file, Qnil);
-          UNGCPRO;
           return 0;
         }
 
@@ -6770,12 +6771,17 @@ tiff_load (struct frame *f, struct image *img)
       if (tiff == NULL)
         {
           image_error ("Cannot open `%s'", file, Qnil);
-          UNGCPRO;
           return 0;
         }
     }
   else
     {
+      if (!STRINGP (specified_data))
+        {
+          image_error ("Invalid image data `%s'", specified_data, Qnil);
+          return 0;
+        }
+
       /* Memory source! */
       memsrc.bytes = SDATA (specified_data);
       memsrc.len = SBYTES (specified_data);
@@ -6794,7 +6800,6 @@ tiff_load (struct frame *f, struct image *img)
       if (!tiff)
         {
           image_error ("Cannot open memory source for `%s'", img->spec, Qnil);
-          UNGCPRO;
           return 0;
         }
     }
@@ -6808,7 +6813,6 @@ tiff_load (struct frame *f, struct image *img)
           image_error ("Invalid image number `%s' in image `%s'",
                        image, img->spec);
           fn_TIFFClose (tiff);
-          UNGCPRO;
           return 0;
         }
     }
@@ -6822,7 +6826,6 @@ tiff_load (struct frame *f, struct image *img)
     {
       image_error ("Invalid image size (see `max-image-size')", Qnil, Qnil);
       fn_TIFFClose (tiff);
-      UNGCPRO;
       return 0;
     }
 
@@ -6844,7 +6847,6 @@ tiff_load (struct frame *f, struct image *img)
     {
       image_error ("Error reading TIFF image `%s'", img->spec, Qnil);
       xfree (buf);
-      UNGCPRO;
       return 0;
     }
 
@@ -6852,7 +6854,6 @@ tiff_load (struct frame *f, struct image *img)
   if (!x_create_x_image_and_pixmap (f, width, height, 0, &ximg, &img->pixmap))
     {
       xfree (buf);
-      UNGCPRO;
       return 0;
     }
 
@@ -6893,7 +6894,6 @@ tiff_load (struct frame *f, struct image *img)
   x_destroy_x_image (ximg);
   xfree (buf);
 
-  UNGCPRO;
   return 1;
 }
 
@@ -7099,7 +7099,6 @@ gif_load (struct frame *f, struct image *img)
   ColorMapObject *gif_color_map;
   unsigned long pixel_colors[256];
   GifFileType *gif;
-  struct gcpro gcpro1;
   Lisp_Object image;
   int ino, image_height, image_width;
   gif_memory_source memsrc;
@@ -7107,8 +7106,6 @@ gif_load (struct frame *f, struct image *img)
 
   specified_file = image_spec_value (img->spec, QCfile, NULL);
   specified_data = image_spec_value (img->spec, QCdata, NULL);
-  file = Qnil;
-  GCPRO1 (file);
 
   if (NILP (specified_data))
     {
@@ -7116,7 +7113,6 @@ gif_load (struct frame *f, struct image *img)
       if (!STRINGP (file))
         {
           image_error ("Cannot find image file `%s'", specified_file, Qnil);
-          UNGCPRO;
           return 0;
         }
 
@@ -7126,12 +7122,17 @@ gif_load (struct frame *f, struct image *img)
       if (gif == NULL)
         {
           image_error ("Cannot open `%s'", file, Qnil);
-          UNGCPRO;
           return 0;
         }
     }
   else
     {
+      if (!STRINGP (specified_data))
+        {
+          image_error ("Invalid image data `%s'", specified_data, Qnil);
+          return 0;
+        }
+
       /* Read from memory! */
       current_gif_memory_src = &memsrc;
       memsrc.bytes = SDATA (specified_data);
@@ -7143,7 +7144,6 @@ gif_load (struct frame *f, struct image *img)
       if (!gif)
         {
           image_error ("Cannot open memory source `%s'", img->spec, Qnil);
-          UNGCPRO;
           return 0;
         }
     }
@@ -7153,7 +7153,6 @@ gif_load (struct frame *f, struct image *img)
     {
       image_error ("Invalid image size (see `max-image-size')", Qnil, Qnil);
       fn_DGifCloseFile (gif);
-      UNGCPRO;
       return 0;
     }
 
@@ -7163,7 +7162,6 @@ gif_load (struct frame *f, struct image *img)
     {
       image_error ("Error reading `%s'", img->spec, Qnil);
       fn_DGifCloseFile (gif);
-      UNGCPRO;
       return 0;
     }
 
@@ -7174,7 +7172,6 @@ gif_load (struct frame *f, struct image *img)
       image_error ("Invalid image number `%s' in image `%s'",
                    image, img->spec);
       fn_DGifCloseFile (gif);
-      UNGCPRO;
       return 0;
     }
 
@@ -7196,7 +7193,6 @@ gif_load (struct frame *f, struct image *img)
     {
       image_error ("Invalid image size (see `max-image-size')", Qnil, Qnil);
       fn_DGifCloseFile (gif);
-      UNGCPRO;
       return 0;
     }
 
@@ -7204,7 +7200,6 @@ gif_load (struct frame *f, struct image *img)
   if (!x_create_x_image_and_pixmap (f, width, height, 0, &ximg, &img->pixmap))
     {
       fn_DGifCloseFile (gif);
-      UNGCPRO;
       return 0;
     }
 
@@ -7323,7 +7318,6 @@ gif_load (struct frame *f, struct image *img)
   x_put_x_image (f, ximg, img->pixmap, width, height);
   x_destroy_x_image (ximg);
 
-  UNGCPRO;
   return 1;
 }
 
@@ -7342,6 +7336,522 @@ gif_load (struct frame *f, struct image *img)
 #endif /* HAVE_GIF */
 
 
+/***********************************************************************
+                                 imagemagick
+***********************************************************************/
+#if defined (HAVE_IMAGEMAGICK)
+Lisp_Object Vimagemagick_render_type;
+
+/* The symbol `imagemagick' identifying images of this type.  */
+
+Lisp_Object Qimagemagick;
+Lisp_Object Vimagemagick_render_type;
+
+/* Indices of image specification fields in imagemagick_format, below.  */
+
+enum imagemagick_keyword_index
+  {
+    IMAGEMAGICK_TYPE,
+    IMAGEMAGICK_DATA,
+    IMAGEMAGICK_FILE,
+    IMAGEMAGICK_ASCENT,
+    IMAGEMAGICK_MARGIN,
+    IMAGEMAGICK_RELIEF,
+    IMAGEMAGICK_ALGORITHM,
+    IMAGEMAGICK_HEURISTIC_MASK,
+    IMAGEMAGICK_MASK,
+    IMAGEMAGICK_BACKGROUND,
+    IMAGEMAGICK_HEIGHT,
+    IMAGEMAGICK_WIDTH,
+    IMAGEMAGICK_ROTATION,
+    IMAGEMAGICK_CROP,
+    IMAGEMAGICK_LAST
+  };
+
+/* Vector of image_keyword structures describing the format
+   of valid user-defined image specifications.  */
+
+static struct image_keyword imagemagick_format[IMAGEMAGICK_LAST] =
+  {
+    {":type",           IMAGE_SYMBOL_VALUE,                     1},
+    {":data",           IMAGE_STRING_VALUE,                     0},
+    {":file",           IMAGE_STRING_VALUE,                     0},
+    {":ascent",         IMAGE_ASCENT_VALUE,                     0},
+    {":margin",         IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR,   0},
+    {":relief",         IMAGE_INTEGER_VALUE,                    0},
+    {":conversion",     IMAGE_DONT_CHECK_VALUE_TYPE,            0},
+    {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE,            0},
+    {":mask",           IMAGE_DONT_CHECK_VALUE_TYPE,            0},
+    {":background",     IMAGE_STRING_OR_NIL_VALUE,              0},
+    {":height",         IMAGE_INTEGER_VALUE,                    0},
+    {":width",          IMAGE_INTEGER_VALUE,                    0},
+    {":rotation",       IMAGE_NUMBER_VALUE,                     0},
+    {":crop",           IMAGE_DONT_CHECK_VALUE_TYPE,            0}
+  };
+/* Free X resources of imagemagick image IMG which is used on frame F.  */
+
+static void
+imagemagick_clear_image (struct frame *f,
+                         struct image *img)
+{
+  x_clear_image (f, img);
+}
+
+
+
+/* Return non-zero if OBJECT is a valid IMAGEMAGICK image specification.  Do
+   this by calling parse_image_spec and supplying the keywords that
+   identify the IMAGEMAGICK format.   */
+
+static int
+imagemagick_image_p (Lisp_Object object)
+{
+  struct image_keyword fmt[IMAGEMAGICK_LAST];
+  memcpy (fmt, imagemagick_format, sizeof fmt);
+
+  if (!parse_image_spec (object, fmt, IMAGEMAGICK_LAST, Qimagemagick))
+    return 0;
+
+  /* Must specify either the :data or :file keyword.  */
+  return fmt[IMAGEMAGICK_FILE].count + fmt[IMAGEMAGICK_DATA].count == 1;
+}
+
+/* The GIF library also defines DrawRectangle, but its never used in Emacs.
+   Therefore rename the function so it doesnt collide with ImageMagick.  */
+#define DrawRectangle DrawRectangleGif
+#include <wand/MagickWand.h>
+
+/* imagemagick_load_image is a helper function for imagemagick_load,
+   which does the actual loading given contents and size, apart from
+   frame and image structures, passed from imagemagick_load.
+
+   Uses librimagemagick to do most of the image processing.
+
+   non-zero when successful.
+*/
+
+static int
+imagemagick_load_image (/* Pointer to emacs frame structure.  */
+                        struct frame *f,
+                        /* Pointer to emacs image structure.  */
+                        struct image *img,
+                        /* String containing the IMAGEMAGICK data to
+                           be parsed.  */
+                        unsigned char *contents,
+                        /* Size of data in bytes.  */
+                        unsigned int size,
+                        /* Filename, either pass filename or
+                           contents/size.  */
+                        unsigned char *filename)
+{
+  unsigned long width;
+  unsigned long height;
+
+  MagickBooleanType
+    status;
+
+  XImagePtr ximg;
+  Lisp_Object specified_bg;
+  XColor background;
+  int x;
+  int y;
+
+  MagickWand  *image_wand;
+  MagickWand  *ping_wand;
+  PixelIterator *iterator;
+  PixelWand  **pixels;
+  MagickPixelPacket  pixel;
+  Lisp_Object image;
+  Lisp_Object value;
+  Lisp_Object crop, geometry;
+  long ino;
+  int desired_width, desired_height;
+  double rotation;
+  int imagemagick_rendermethod;
+  int pixelwidth;
+  ImageInfo  *image_info;
+  ExceptionInfo *exception;
+  Image * im_image;
+
+
+  /* Handle image index for image types who can contain more than one
+     image.  Interface :index is same as for GIF.  First we "ping" the
+     image to see how many sub-images it contains. Pinging is faster
+     than loading the image to find out things about it.  */
+  image = image_spec_value (img->spec, QCindex, NULL);
+  ino = INTEGERP (image) ? XFASTINT (image) : 0;
+  ping_wand = NewMagickWand ();
+  MagickSetResolution (ping_wand, 2, 2);
+  if (filename != NULL)
+    {
+      status = MagickPingImage (ping_wand, filename);
+    }
+  else
+    {
+      status = MagickPingImageBlob (ping_wand, contents, size);
+    }
+
+  if (ino >= MagickGetNumberImages (ping_wand))
+    {
+      image_error ("Invalid image number `%s' in image `%s'",
+                   image, img->spec);
+      DestroyMagickWand (ping_wand);
+      return 0;
+    }
+
+  if (MagickGetNumberImages(ping_wand) > 1)
+    img->data.lisp_val =
+      Fcons (Qcount,
+             Fcons (make_number (MagickGetNumberImages (ping_wand)),
+                    img->data.lisp_val));
+
+  DestroyMagickWand (ping_wand);
+  /* Now, after pinging, we know how many images are inside the
+     file. If its not a bundle, just one.  */
+
+  if (filename != NULL)
+    {
+      image_info = CloneImageInfo ((ImageInfo *) NULL);
+      (void) strcpy (image_info->filename, filename);
+      image_info->number_scenes = 1;
+      image_info->scene = ino;
+      exception = AcquireExceptionInfo ();
+
+      im_image = ReadImage (image_info, exception);
+      CatchException (exception);
+
+      image_wand = NewMagickWandFromImage (im_image);
+    }
+  else
+    {
+      image_wand = NewMagickWand ();
+      status = MagickReadImageBlob (image_wand, contents, size);
+    }
+  image_error ("im read failed", Qnil, Qnil);
+  if (status == MagickFalse) goto imagemagick_error;
+
+  /* If width and/or height is set in the display spec assume we want
+     to scale to those values.  if either h or w is unspecified, the
+     unspecified should be calculated from the specified to preserve
+     aspect ratio.  */
+
+  value = image_spec_value (img->spec, QCwidth, NULL);
+  desired_width = (INTEGERP (value)  ? XFASTINT (value) : -1);
+  value = image_spec_value (img->spec, QCheight, NULL);
+  desired_height = (INTEGERP (value) ? XFASTINT (value) : -1);
+
+  height = MagickGetImageHeight (image_wand);
+  width = MagickGetImageWidth (image_wand);
+
+  if(desired_width != -1 && desired_height == -1)
+    {
+      /* w known, calculate h.  */
+      desired_height = (double) desired_width / width * height;
+    }
+  if(desired_width == -1 && desired_height != -1)
+    {
+      /* h known, calculate w.  */
+      desired_width = (double) desired_height / height * width;
+    }
+  if(desired_width != -1 && desired_height != -1)
+    {
+      status = MagickScaleImage (image_wand, desired_width, desired_height);
+      if (status == MagickFalse)
+        {
+          image_error ("Imagemagick scale failed", Qnil, Qnil);
+          goto imagemagick_error;
+        }
+    }
+
+
+  /* crop behaves similar to image slicing in Emacs but is more memory
+     efficient.  */
+  crop = image_spec_value (img->spec, QCcrop, NULL);
+
+  if (CONSP (crop) && INTEGERP (XCAR (crop)))
+    {
+      /* After some testing, it seems MagickCropImage is the fastest
+         crop function in ImageMagick.  This crop function seems to do
+         less copying than the alternatives, but it still reads the
+         entire image into memory before croping, which is aparently
+         difficult to avoid when using imagemagick.  */
+
+      int w, h, x, y;
+      w = XFASTINT (XCAR (crop));
+      crop = XCDR (crop);
+      if (CONSP (crop) && INTEGERP (XCAR (crop)))
+        {
+          h = XFASTINT (XCAR (crop));
+          crop = XCDR (crop);
+          if (CONSP (crop) && INTEGERP (XCAR (crop)))
+            {
+              x = XFASTINT (XCAR (crop));
+              crop = XCDR (crop);
+              if (CONSP (crop) && INTEGERP (XCAR (crop)))
+                {
+                  y = XFASTINT (XCAR (crop));
+                  MagickCropImage (image_wand, w, h, x, y);
+                }
+            }
+        }
+    }
+
+  /* Furthermore :rotation. we need background color and angle for
+     rotation.  */
+  /*
+    TODO background handling for rotation specified_bg =
+    image_spec_value (img->spec, QCbackground, NULL); if (!STRINGP
+    (specified_bg).  */
+  value = image_spec_value (img->spec, QCrotation, NULL);
+  if (FLOATP (value))
+    {
+      PixelWand* background = NewPixelWand ();
+      PixelSetColor (background, "#ffffff");/*TODO remove hardcode*/
+
+      rotation = extract_float (value);
+
+      status = MagickRotateImage (image_wand, background, rotation);
+      DestroyPixelWand (background);
+      if (status == MagickFalse)
+        {
+          image_error ("Imagemagick image rotate failed", Qnil, Qnil);
+          goto imagemagick_error;
+        }
+    }
+
+  /* Finaly we are done manipulating the image, figure out resulting
+     width, height, and then transfer ownerwship to Emacs.  */
+  height = MagickGetImageHeight (image_wand);
+  width = MagickGetImageWidth (image_wand);
+  if (status == MagickFalse)
+    {
+      image_error ("Imagemagick image get size failed", Qnil, Qnil);
+      goto imagemagick_error;
+    }
+
+  if (! check_image_size (f, width, height))
+    {
+      image_error ("Invalid image size (see `max-image-size')", Qnil, Qnil);
+      goto imagemagick_error;
+    }
+
+  /* We can now get a valid pixel buffer from the imagemagick file, if all
+     went ok.  */
+
+  init_color_table ();
+  imagemagick_rendermethod = (INTEGERP (Vimagemagick_render_type)
+                              ? XFASTINT (Vimagemagick_render_type) : 0);
+  if (imagemagick_rendermethod == 0)
+    {
+      /* Try to create a x pixmap to hold the imagemagick pixmap.  */
+      if (!x_create_x_image_and_pixmap (f, width, height, 0,
+                                        &ximg, &img->pixmap))
+        {
+          image_error("Imagemagick X bitmap allocation failure", Qnil, Qnil);
+          goto imagemagick_error;
+        }
+
+      /* Copy imagegmagick image to x with primitive yet robust pixel
+         pusher loop.  This has been tested a lot with many different
+         images.  */
+
+      /* Copy pixels from the imagemagick image structure to the x image map. */
+      iterator = NewPixelIterator (image_wand);
+      if (iterator == (PixelIterator *) NULL)
+        {
+          image_error ("Imagemagick pixel iterator creation failed",
+                       Qnil, Qnil);
+          goto imagemagick_error;
+        }
+
+      for (y = 0; y < (long) MagickGetImageHeight (image_wand); y++)
+        {
+          pixels = PixelGetNextIteratorRow (iterator, &width);
+          if (pixels == (PixelWand **) NULL)
+            break;
+          for (x = 0; x < (long) width; x++)
+            {
+              PixelGetMagickColor (pixels[x], &pixel);
+              XPutPixel (ximg, x, y,
+                         lookup_rgb_color (f,
+                                           pixel.red,
+                                           pixel.green,
+                                           pixel.blue));
+            }
+        }
+      DestroyPixelIterator (iterator);
+    }
+
+  if (imagemagick_rendermethod == 1)
+    {
+      /* Magicexportimage is normaly faster than pixelpushing.  This
+         method is also well tested. Some aspects of this method are
+         ad-hoc and needs to be more researched. */
+      int imagedepth = 24;/*MagickGetImageDepth(image_wand);*/
+      char* exportdepth = imagedepth <= 8 ? "I" : "BGRP";/*"RGBP";*/
+      /* Try to create a x pixmap to hold the imagemagick pixmap.  */
+      if (!x_create_x_image_and_pixmap (f, width, height, imagedepth,
+                                        &ximg, &img->pixmap))
+        {
+          image_error("Imagemagick X bitmap allocation failure", Qnil, Qnil);
+          goto imagemagick_error;
+        }
+
+
+      /* Oddly, the below code doesnt seem to work:*/
+      /* switch(ximg->bitmap_unit){ */
+      /* case 8: */
+      /*   pixelwidth=CharPixel; */
+      /*   break; */
+      /* case   16: */
+      /*   pixelwidth=ShortPixel; */
+      /*   break; */
+      /* case   32: */
+      /*   pixelwidth=LongPixel; */
+      /*   break; */
+      /* } */
+      /*
+        Here im just guessing the format of the bitmap.
+        happens to work fine for:
+        - bw djvu images
+        on rgb display.
+        seems about 3 times as fast as pixel pushing(not carefully measured)
+      */
+      pixelwidth = CharPixel;/*??? TODO figure out*/
+#ifdef HAVE_MAGICKEXPORTIMAGEPIXELS
+      MagickExportImagePixels (image_wand,
+                               0, 0,
+                               width, height,
+                               exportdepth,
+                               pixelwidth,
+                               /*&(img->pixmap));*/
+                               ximg->data);
+#else
+      image_error ("You dont have MagickExportImagePixels, upgrade ImageMagick!",
+                   Qnil, Qnil);
+#endif
+    }
+
+
+#ifdef COLOR_TABLE_SUPPORT
+  /* Remember colors allocated for this image.  */
+  img->colors = colors_in_color_table (&img->ncolors);
+  free_color_table ();
+#endif /* COLOR_TABLE_SUPPORT */
+
+
+  img->width  = width;
+  img->height = height;
+
+  /* Put the image into the pixmap, then free the X image and its
+     buffer.  */
+  x_put_x_image (f, ximg, img->pixmap, width, height);
+  x_destroy_x_image (ximg);
+
+
+  /* Final cleanup. image_wand should be the only resource left. */
+  DestroyMagickWand (image_wand);
+
+  return 1;
+
+ imagemagick_error:
+  /* TODO more cleanup.  */
+  image_error ("Error parsing IMAGEMAGICK image `%s'", img->spec, Qnil);
+  return 0;
+}
+
+
+/* Load IMAGEMAGICK image IMG for use on frame F.  Value is non-zero if
+   successful. this function will go into the imagemagick_type structure, and
+   the prototype thus needs to be compatible with that structure.  */
+
+static int
+imagemagick_load (struct frame *f,
+                  struct image *img)
+{
+  int success_p = 0;
+  Lisp_Object file_name;
+
+  /* If IMG->spec specifies a file name, create a non-file spec from it.  */
+  file_name = image_spec_value (img->spec, QCfile, NULL);
+  if (STRINGP (file_name))
+    {
+      Lisp_Object file;
+
+      file = x_find_image_file (file_name);
+      if (!STRINGP (file))
+        {
+          image_error ("Cannot find image file `%s'", file_name, Qnil);
+          return 0;
+        }
+      success_p = imagemagick_load_image (f, img, 0, 0, SDATA (file));
+    }
+  /* Else its not a file, its a lisp object.  Load the image from a
+     lisp object rather than a file.  */
+  else
+    {
+      Lisp_Object data;
+
+      data = image_spec_value (img->spec, QCdata, NULL);
+      if (!STRINGP (data))
+        {
+          image_error ("Invalid image data `%s'", data, Qnil);
+          return 0;
+        }
+      success_p = imagemagick_load_image (f, img, SDATA (data),
+                                          SBYTES (data), NULL);
+    }
+
+  return success_p;
+}
+
+/* Structure describing the image type `imagemagick'.  Its the same
+   type of structure defined for all image formats, handled by Emacs
+   image functions.  See struct image_type in dispextern.h.  */
+
+static struct image_type imagemagick_type =
+  {
+    /* An identifier showing that this is an image structure for the
+       IMAGEMAGICK format.  */
+    &Qimagemagick,
+    /* Handle to a function that can be used to identify a IMAGEMAGICK
+       file.  */
+    imagemagick_image_p,
+    /* Handle to function used to load a IMAGEMAGICK file.  */
+    imagemagick_load,
+    /* Handle to function to free resources for IMAGEMAGICK.  */
+    imagemagick_clear_image,
+    /* An internal field to link to the next image type in a list of
+       image types, will be filled in when registering the format.  */
+    NULL
+  };
+
+
+
+
+DEFUN ("imagemagick-types", Fimagemagick_types, Simagemagick_types, 0, 0, 0,
+       doc: /* Return image file types supported by ImageMagick.
+Since ImageMagick recognizes a lot of file-types that clash with Emacs,
+such as .c, we want to be able to alter the list at the lisp level.  */)
+  (void)
+{
+  Lisp_Object typelist = Qnil;
+  unsigned long numf;
+  ExceptionInfo ex;
+  char **imtypes = GetMagickList ("*", &numf, &ex);
+  int i;
+  Lisp_Object Qimagemagicktype;
+  for (i = 0; i < numf; i++)
+    {
+      Qimagemagicktype = intern (imtypes[i]);
+      typelist = Fcons (Qimagemagicktype, typelist);
+    }
+  return typelist;
+}
+
+#endif  /* defined (HAVE_IMAGEMAGICK) */
+
+
 
 /***********************************************************************
                                  SVG
@@ -7534,14 +8044,11 @@ svg_load (struct frame *f, struct image *img)
       Lisp_Object file;
       unsigned char *contents;
       int size;
-      struct gcpro gcpro1;
 
       file = x_find_image_file (file_name);
-      GCPRO1 (file);
       if (!STRINGP (file))
         {
           image_error ("Cannot find image file `%s'", file_name, Qnil);
-          UNGCPRO;
           return 0;
         }
 
@@ -7550,13 +8057,11 @@ svg_load (struct frame *f, struct image *img)
       if (contents == NULL)
         {
           image_error ("Error loading SVG image `%s'", img->spec, Qnil);
-          UNGCPRO;
           return 0;
         }
       /* If the file was slurped into memory properly, parse it.  */
       success_p = svg_load_image (f, img, contents, size);
       xfree (contents);
-      UNGCPRO;
     }
   /* Else its not a file, its a lisp object.  Load the image from a
      lisp object rather than a file.  */
@@ -7565,6 +8070,11 @@ svg_load (struct frame *f, struct image *img)
       Lisp_Object data;
 
       data = image_spec_value (img->spec, QCdata, NULL);
+      if (!STRINGP (data))
+        {
+          image_error ("Invalid image data `%s'", data, Qnil);
+          return 0;
+        }
       success_p = svg_load_image (f, img, SDATA (data), SBYTES (data));
     }
 
@@ -7864,7 +8374,6 @@ gs_load (struct frame *f, struct image *img)
 {
   char buffer[100];
   Lisp_Object window_and_pixmap_id = Qnil, loader, pt_height, pt_width;
-  struct gcpro gcpro1, gcpro2;
   Lisp_Object frame;
   double in_width, in_height;
   Lisp_Object pixel_colors = Qnil;
@@ -7874,10 +8383,10 @@ gs_load (struct frame *f, struct image *img)
      = 1/72 in, xdpi and ydpi are stored in the frame's X display
      info.  */
   pt_width = image_spec_value (img->spec, QCpt_width, NULL);
-  in_width = XFASTINT (pt_width) / 72.0;
+  in_width = INTEGERP (pt_width) ? XFASTINT (pt_width) / 72.0 : 0;
   img->width = in_width * FRAME_X_DISPLAY_INFO (f)->resx;
   pt_height = image_spec_value (img->spec, QCpt_height, NULL);
-  in_height = XFASTINT (pt_height) / 72.0;
+  in_height = INTEGERP (pt_height) ? XFASTINT (pt_height) / 72.0 : 0;
   img->height = in_height * FRAME_X_DISPLAY_INFO (f)->resy;
 
   if (!check_image_size (f, img->width, img->height))
@@ -7906,8 +8415,6 @@ gs_load (struct frame *f, struct image *img)
      if successful.  We do not record_unwind_protect here because
      other places in redisplay like calling window scroll functions
      don't either.  Let the Lisp loader use `unwind-protect' instead.  */
-  GCPRO2 (window_and_pixmap_id, pixel_colors);
-
   sprintf (buffer, "%lu %lu",
            (unsigned long) FRAME_X_WINDOW (f),
            (unsigned long) img->pixmap);
@@ -7928,7 +8435,6 @@ gs_load (struct frame *f, struct image *img)
                               make_number (img->height),
                               window_and_pixmap_id,
                               pixel_colors);
-  UNGCPRO;
   return PROCESSP (img->data.lisp_val);
 }
 
@@ -8117,6 +8623,16 @@ of `image-library-alist', which see).  */)
     return CHECK_LIB_AVAILABLE (&svg_type, init_svg_functions, libraries);
 #endif
 
+#if defined (HAVE_IMAGEMAGICK)
+  if (EQ (type, Qimagemagick))
+    {
+      /* MagickWandGenesis() initalizes the imagemagick library.  */
+      MagickWandGenesis ();
+      return CHECK_LIB_AVAILABLE (&imagemagick_type, init_imagemagick_functions,
+                                  libraries);
+    }
+#endif
+
 #ifdef HAVE_GHOSTSCRIPT
   if (EQ (type, Qpostscript))
     return CHECK_LIB_AVAILABLE (&gs_type, init_gs_functions, libraries);
@@ -8202,6 +8718,12 @@ non-numeric, there is no explicit limit on the size of images.  */);
   staticpro (&QCheuristic_mask);
   QCindex = intern_c_string (":index");
   staticpro (&QCindex);
+  QCgeometry = intern (":geometry");
+  staticpro (&QCgeometry);
+  QCcrop = intern (":crop");
+  staticpro (&QCcrop);
+  QCrotation = intern (":rotation");
+  staticpro (&QCrotation);
   QCmatrix = intern_c_string (":matrix");
   staticpro (&QCmatrix);
   QCcolor_adjustment = intern_c_string (":color-adjustment");
@@ -8262,6 +8784,12 @@ non-numeric, there is no explicit limit on the size of images.  */);
   ADD_IMAGE_TYPE (Qpng);
 #endif
 
+#if defined (HAVE_IMAGEMAGICK)
+  Qimagemagick = intern ("imagemagick");
+  staticpro (&Qimagemagick);
+  ADD_IMAGE_TYPE (Qimagemagick);
+#endif
+
 #if defined (HAVE_RSVG)
   Qsvg = intern_c_string ("svg");
   staticpro (&Qsvg);
@@ -8278,6 +8806,9 @@ non-numeric, there is no explicit limit on the size of images.  */);
 #endif /* HAVE_RSVG  */
 
   defsubr (&Sinit_image_library);
+#ifdef HAVE_IMAGEMAGICK
+  defsubr (&Simagemagick_types);
+#endif
   defsubr (&Sclear_image_cache);
   defsubr (&Simage_flush);
   defsubr (&Simage_size);
@@ -8308,6 +8839,11 @@ The value can also be nil, meaning the cache is never cleared.
 
 The function `clear-image-cache' disregards this variable.  */);
   Vimage_cache_eviction_delay = make_number (300);
+#ifdef HAVE_IMAGEMAGICK
+  DEFVAR_LISP ("imagemagick-render-type", &Vimagemagick_render_type,
+               doc: /* Choose between ImageMagick render methods.  */);
+#endif
+
 }
 
 void
diff --git a/src/insdel.c b/src/insdel.c
index 00025808e37..2ccc0b8eaac 100644
--- a/src/insdel.c
+++ b/src/insdel.c
@@ -74,7 +74,7 @@ Lisp_Object combine_after_change_buffer;
 
 Lisp_Object Qinhibit_modification_hooks;
 
-extern Lisp_Object Vselect_active_regions, Vsaved_region_selection;
+extern Lisp_Object Vselect_active_regions, Vsaved_region_selection, Qonly;
 
 
 /* Check all markers in the current buffer, looking for something invalid.  */
@@ -2050,10 +2050,12 @@ prepare_to_modify_buffer (EMACS_INT start, EMACS_INT end,
 #endif /* not CLASH_DETECTION */
 
   /* If `select-active-regions' is non-nil, save the region text.  */
-  if (!NILP (Vselect_active_regions)
-      && !NILP (current_buffer->mark_active)
-      && !NILP (Vtransient_mark_mode)
-      && NILP (Vsaved_region_selection))
+  if (!NILP (current_buffer->mark_active)
+      && NILP (Vsaved_region_selection)
+      && (EQ (Vselect_active_regions, Qonly)
+          ? EQ (CAR_SAFE (Vtransient_mark_mode), Qonly)
+          : (!NILP (Vselect_active_regions)
+             && !NILP (Vtransient_mark_mode))))
     {
       int b = XINT (Fmarker_position (current_buffer->mark));
       int e = XINT (make_number (PT));
diff --git a/src/keyboard.c b/src/keyboard.c
index aaa9306eded..95fc275ffe8 100644
--- a/src/keyboard.c
+++ b/src/keyboard.c
@@ -368,7 +368,7 @@ Lisp_Object Vselect_active_regions;
    Used by the `select-active-regions' feature.  */
 Lisp_Object Vsaved_region_selection;
 
-Lisp_Object Qx_set_selection, QPRIMARY, Qlazy;
+Lisp_Object Qx_set_selection, QPRIMARY, Qhandle_switch_frame;
 
 Lisp_Object Qself_insert_command;
 Lisp_Object Qforward_char;
@@ -1493,6 +1493,11 @@ cancel_hourglass_unwind (Lisp_Object arg)
 }
 #endif
 
+/* FIXME: This is wrong rather than test window-system, we should call
+   a new set-selection, which will then dispatch to x-set-selection, or
+   tty-set-selection, or w32-set-selection, ...  */
+EXFUN (Fwindow_system, 1);
+
 Lisp_Object
 command_loop_1 (void)
 {
@@ -1790,27 +1795,36 @@ command_loop_1 (void)
             Vtransient_mark_mode = Qnil;
           else if (EQ (Vtransient_mark_mode, Qonly))
             Vtransient_mark_mode = Qidentity;
-          else if (EQ (Vselect_active_regions, Qlazy)
-                   ? EQ (CAR_SAFE (Vtransient_mark_mode), Qonly)
-                   : (!NILP (Vselect_active_regions)
-                      && !NILP (Vtransient_mark_mode)))
-            {
-              /* Set window selection.  If `select-active-regions' is
-                 `lazy', only do it for temporarily active regions. */
-              int beg = XINT (Fmarker_position (current_buffer->mark));
-              int end = XINT (make_number (PT));
-              if (beg < end)
-                call2 (Qx_set_selection, QPRIMARY,
-                       make_buffer_string (beg, end, 0));
-              else if (beg > end)
-                call2 (Qx_set_selection, QPRIMARY,
-                       make_buffer_string (end, beg, 0));
-            }
 
           if (!NILP (Vdeactivate_mark))
+            /* If `select-active-regions' is non-nil, this call to
+               `deactivate-mark' also sets the PRIMARY selection.  */
             call0 (Qdeactivate_mark);
-          else if (current_buffer != prev_buffer || MODIFF != prev_modiff)
-            call1 (Vrun_hooks, intern ("activate-mark-hook"));
+          else
+            {
+              /* Even if not deactivating the mark, set PRIMARY if
+                 `select-active-regions' is non-nil.  */
+              if (!NILP (Fwindow_system (Qnil))
+                  && (EQ (Vselect_active_regions, Qonly)
+                      ? EQ (CAR_SAFE (Vtransient_mark_mode), Qonly)
+                      : (!NILP (Vselect_active_regions)
+                         && !NILP (Vtransient_mark_mode)))
+                  && !EQ (Vthis_command, Qhandle_switch_frame))
+                {
+                  int beg = XINT (Fmarker_position (current_buffer->mark));
+                  int end = XINT (make_number (PT));
+                  if (beg < end)
+                    call2 (Qx_set_selection, QPRIMARY,
+                           make_buffer_string (beg, end, 0));
+                  else if (beg > end)
+                    call2 (Qx_set_selection, QPRIMARY,
+                           make_buffer_string (end, beg, 0));
+                  /* Don't set empty selections.  */
+                }
+
+              if (current_buffer != prev_buffer || MODIFF != prev_modiff)
+                call1 (Vrun_hooks, intern ("activate-mark-hook"));
+            }
 
           Vsaved_region_selection = Qnil;
         }
@@ -4941,9 +4955,9 @@ char const *lispy_function_keys[] =
     0,               /* VK_OEM_102        0xE2 */
     "ico-help",      /* VK_ICO_HELP       0xE3 */
     "ico-00",        /* VK_ICO_00         0xE4 */
-    0,               /* VK_PROCESSKEY     0xE5 */
+    0,               /* VK_PROCESSKEY     0xE5 - used by IME */
     "ico-clear",     /* VK_ICO_CLEAR      0xE6 */
-    "packet",        /* VK_PACKET         0xE7 */
+    0,               /* VK_PACKET         0xE7  - used to pass unicode chars */
     0,               /*                   0xE8 */
     "reset",         /* VK_OEM_RESET      0xE9 */
     "jump",          /* VK_OEM_JUMP       0xEA */
@@ -8285,12 +8299,15 @@ parse_tool_bar_item (Lisp_Object key, Lisp_Object item)
             return 0;
         }
       else if (EQ (key, QChelp))
-        /* `:help HELP-STRING'.  */
-        PROP (TOOL_BAR_ITEM_HELP) = value;
+        /* `:help HELP-STRING'.  */
+        PROP (TOOL_BAR_ITEM_HELP) = value;
       else if (EQ (key, QClabel))
         {
+          const char *bad_label = "!!?GARBLED ITEM?!!";
           /* `:label LABEL-STRING'.  */
-          PROP (TOOL_BAR_ITEM_LABEL) = value;
+          PROP (TOOL_BAR_ITEM_HELP) = STRINGP (value)
+            ? value
+            : make_string (bad_label, strlen (bad_label));
           have_label = 1;
         }
       else if (EQ (key, QCfilter))
@@ -8328,39 +8345,41 @@ parse_tool_bar_item (Lisp_Object key, Lisp_Object item)
       Lisp_Object capt = PROP (TOOL_BAR_ITEM_CAPTION);
       const char *label = SYMBOLP (key) ? (char *) SDATA (SYMBOL_NAME (key)) : "";
       const char *caption = STRINGP (capt) ? (char *) SDATA (capt) : "";
-      char buf[64];
-      EMACS_INT max_lbl = 2*tool_bar_max_label_size;
+      EMACS_INT max_lbl = 2 * tool_bar_max_label_size;
+      char *buf = (char *) xmalloc (max_lbl + 1);
       Lisp_Object new_lbl;
+      size_t caption_len = strlen (caption);
 
-      if (strlen (caption) < max_lbl && caption[0] != '\0')
+      if (caption_len <= max_lbl && caption[0] != '\0')
         {
           strcpy (buf, caption);
-          while (buf[0] != '\0' &&  buf[strlen (buf) -1] == '.')
-            buf[strlen (buf)-1] = '\0';
-          if (strlen (buf) <= max_lbl)
-            caption = buf;
+          while (caption_len > 0 && buf[caption_len - 1] == '.')
+            caption_len--;
+          buf[caption_len] = '\0';
+          label = caption = buf;
         }
 
-      if (strlen (caption) <= max_lbl)
-        label = caption;
-
       if (strlen (label) <= max_lbl && label[0] != '\0')
         {
           int i;
-          if (label != buf) strcpy (buf, label);
+          if (label != buf)
+            strcpy (buf, label);
 
-          for (i = 0; i < strlen (buf); ++i)
-            {
-              if (buf[i] == '-') buf[i] = ' ';
-            }
+          for (i = 0; buf[i] != '\0'; ++i)
+            if (buf[i] == '-')
+              buf[i] = ' ';
           label = buf;
 
         }
-      else label = "";
+      else
+        label = "";
 
       new_lbl = Fupcase_initials (make_string (label, strlen (label)));
       if (SCHARS (new_lbl) <= tool_bar_max_label_size)
         PROP (TOOL_BAR_ITEM_LABEL) = new_lbl;
+      else
+        PROP (TOOL_BAR_ITEM_LABEL) = make_string ("", 0);
+      free (buf);
     }
 
   /* If got a filter apply it on binding.  */
@@ -10333,13 +10352,12 @@ give to the command you invoke, if it asks for an argument.  */)
   (Lisp_Object prefixarg)
 {
   Lisp_Object function;
-  char buf[40];
   int saved_last_point_position;
   Lisp_Object saved_keys, saved_last_point_position_buffer;
   Lisp_Object bindings, value;
   struct gcpro gcpro1, gcpro2, gcpro3;
 #ifdef HAVE_WINDOW_SYSTEM
-  /* The call to Fcompleting_read wil start and cancel the hourglass,
+  /* The call to Fcompleting_read will start and cancel the hourglass,
      but if the hourglass was already scheduled, this means that no
      hourglass will be shown for the actual M-x command itself.
      So we restart it if it is already scheduled.  Note that checking
@@ -10352,31 +10370,9 @@ give to the command you invoke, if it asks for an argument.  */)
                         XVECTOR (this_command_keys)->contents);
   saved_last_point_position_buffer = last_point_position_buffer;
   saved_last_point_position = last_point_position;
-  buf[0] = 0;
   GCPRO3 (saved_keys, prefixarg, saved_last_point_position_buffer);
 
-  if (EQ (prefixarg, Qminus))
-    strcpy (buf, "- ");
-  else if (CONSP (prefixarg) && XINT (XCAR (prefixarg)) == 4)
-    strcpy (buf, "C-u ");
-  else if (CONSP (prefixarg) && INTEGERP (XCAR (prefixarg)))
-    sprintf (buf, "%ld ", (long) XINT (XCAR (prefixarg)));
-  else if (INTEGERP (prefixarg))
-    sprintf (buf, "%ld ", (long) XINT (prefixarg));
-
-  /* This isn't strictly correct if execute-extended-command
-     is bound to anything else.  Perhaps it should use
-     this_command_keys?  */
-  strcat (buf, "M-x ");
-
-  /* Prompt with buf, and then read a string, completing from and
-     restricting to the set of all defined commands.  Don't provide
-     any initial input.  Save the command read on the extended-command
-     history list. */
-  function = Fcompleting_read (build_string (buf),
-                               Vobarray, Qcommandp,
-                               Qt, Qnil, Qextended_command_history, Qnil,
-                               Qnil);
+  function = call0 (intern ("read-extended-command"));
 
 #ifdef HAVE_WINDOW_SYSTEM
   if (hstarted) start_hourglass ();
@@ -11494,11 +11490,11 @@ init_keyboard (void)
          Emacs on SIGINT when there are no termcap frames on the
          controlling terminal. */
       signal (SIGINT, interrupt_signal);
-#if defined (HAVE_TERMIO) || defined (HAVE_TERMIOS)
+#ifndef DOS_NT
       /* For systems with SysV TERMIO, C-g is set up for both SIGINT and
          SIGQUIT and we can't tell which one it will give us.  */
       signal (SIGQUIT, interrupt_signal);
-#endif /* HAVE_TERMIO */
+#endif /* not DOS_NT */
     }
 /* Note SIGIO has been undef'd if FIONREAD is missing.  */
 #ifdef SIGIO
@@ -11713,8 +11709,8 @@ syms_of_keyboard (void)
   staticpro (&Qx_set_selection);
   QPRIMARY = intern_c_string ("PRIMARY");
   staticpro (&QPRIMARY);
-  Qlazy = intern_c_string ("lazy");
-  staticpro (&Qlazy);
+  Qhandle_switch_frame = intern_c_string ("handle-switch-frame");
+  staticpro (&Qhandle_switch_frame);
 
   Qinput_method_exit_on_first_char = intern_c_string ("input-method-exit-on-first-char");
   staticpro (&Qinput_method_exit_on_first_char);
@@ -12326,16 +12322,11 @@ and tool-bar buttons.  */);
   DEFVAR_LISP ("select-active-regions",
                &Vselect_active_regions,
                doc: /* If non-nil, an active region automatically becomes the window selection.
-This takes effect only when Transient Mark mode is enabled.
-
-If the value is `lazy', Emacs only sets the window selection during
-`deactivate-mark'; unless the region is temporarily active
-(e.g. mouse-drags or shift-selection), in which case it sets the
-window selection after each command.
+If the value is `only', only temporarily active regions (usually made
+by mouse-dragging or shift-selection) set the window selection.
 
-For other non-nil value, Emacs sets the window selection after every
-command.  */);
-  Vselect_active_regions = Qlazy;
+This takes effect only when Transient Mark mode is enabled.  */);
+  Vselect_active_regions = Qt;
 
   DEFVAR_LISP ("saved-region-selection",
                &Vsaved_region_selection,
diff --git a/src/keyboard.h b/src/keyboard.h
index 693137b08f4..a3bb46f4454 100644
--- a/src/keyboard.h
+++ b/src/keyboard.h
@@ -318,10 +318,7 @@ extern Lisp_Object unuse_menu_items (Lisp_Object dummy);
 #define ENCODE_MENU_STRING(str) (str)
 #endif
 
-#if defined (HAVE_NS) || defined (HAVE_NTGUI)
-
-typedef void * XtPointer;
-typedef unsigned char Boolean;
+#if defined (HAVE_NS) || defined (HAVE_NTGUI) || defined (USE_GTK)
 
 /* Definitions copied from lwlib.h */
 
@@ -338,32 +335,35 @@ typedef struct _widget_value
 {
   /* name of widget */
   Lisp_Object   lname;
-  char*         name;
+  const char*   name;
   /* value (meaning depend on widget type) */
-  char*         value;
+  const char*   value;
   /* keyboard equivalent. no implications for XtTranslations */
   Lisp_Object   lkey;
-  char*         key;
+  const char*   key;
   /* Help string or nil if none.
      GC finds this string through the frame's menu_bar_vector
      or through menu_items.  */
   Lisp_Object   help;
   /* true if enabled */
-  Boolean       enabled;
+  unsigned char enabled;
   /* true if selected */
-  Boolean       selected;
+  unsigned char selected;
   /* The type of a button.  */
   enum button_type button_type;
 #if defined (HAVE_NTGUI)
   /* true if menu title */
-  Boolean       title;
+  unsigned char title;
 #endif
   /* Contents of the sub-widgets, also selected slot for checkbox */
   struct _widget_value* contents;
   /* data passed to callback */
-  XtPointer     call_data;
+  void  *call_data;
   /* next one in the list */
   struct _widget_value* next;
+#ifdef USE_GTK
+  struct _widget_value *free_list;
+#endif
 } widget_value;
 
 #endif /* HAVE_NS || HAVE_NTGUI */
@@ -440,6 +440,9 @@ extern int ignore_mouse_drag_p;
 
 extern Lisp_Object Vdouble_click_time;
 
+/* The primary selection.  */
+extern Lisp_Object QPRIMARY;
+
 /* Forward declaration for prototypes.  */
 struct input_event;
 
diff --git a/src/lisp.h b/src/lisp.h
index 94851d157d1..d44c05c661f 100644
--- a/src/lisp.h
+++ b/src/lisp.h
@@ -2542,7 +2542,6 @@ EXFUN (Ffillarray, 2);
 EXFUN (Fnconc, MANY);
 EXFUN (Fmapcar, 2);
 EXFUN (Fmapconcat, 3);
-EXFUN (Fy_or_n_p, 1);
 extern Lisp_Object do_yes_or_no_p (Lisp_Object);
 EXFUN (Frequire, 3);
 EXFUN (Fprovide, 2);
@@ -3607,6 +3606,11 @@ extern char *x_get_keysym_name (int);
 EXFUN (Fmsdos_downcase_filename, 1);
 #endif
 
+#ifdef HAVE_LIBXML2
+/* Defined in xml.c */
+extern void syms_of_xml (void);
+#endif
+
 #ifdef HAVE_MENUS
 /* Defined in (x|w32)fns.c, nsfns.m...  */
 extern int have_menus_p (void);
diff --git a/src/makefile.w32-in b/src/makefile.w32-in
index fc86ae6cb0c..8d99d6cedfe 100644
--- a/src/makefile.w32-in
+++ b/src/makefile.w32-in
@@ -1357,6 +1357,7 @@ $(BLD)/sysdep.$(O) : \
         $(SRC)/frame.h \
         $(SRC)/keyboard.h \
         $(SRC)/process.h \
+        $(SRC)/sysselect.h \
         $(SRC)/syssignal.h \
         $(SRC)/systime.h \
         $(SRC)/systty.h \
diff --git a/src/marker.c b/src/marker.c
index 911d2e57706..b5ea80562df 100644
--- a/src/marker.c
+++ b/src/marker.c
@@ -806,16 +806,18 @@ marker_byte_position (Lisp_Object marker)
   return i;
 }
 
-DEFUN ("copy-marker", Fcopy_marker, Scopy_marker, 1, 2, 0,
+DEFUN ("copy-marker", Fcopy_marker, Scopy_marker, 0, 2, 0,
        doc: /* Return a new marker pointing at the same place as MARKER.
 If argument is a number, makes a new marker pointing
 at that position in the current buffer.
+If MARKER is not specified, the new marker does not point anywhere.
 The optional argument TYPE specifies the insertion type of the new marker;
 see `marker-insertion-type'.  */)
   (register Lisp_Object marker, Lisp_Object type)
 {
   register Lisp_Object new;
 
+  if (!NILP (marker))
   CHECK_TYPE (INTEGERP (marker) || MARKERP (marker), Qinteger_or_marker_p, marker);
 
   new = Fmake_marker ();
diff --git a/src/menu.c b/src/menu.c
index ab20a47fba6..05a296e45fc 100644
--- a/src/menu.c
+++ b/src/menu.c
@@ -1065,7 +1065,7 @@ no quit occurs and `x-popup-menu' returns nil.  */)
   Lisp_Object keymap, tem;
   int xpos = 0, ypos = 0;
   Lisp_Object title;
-  char *error_name = NULL;
+  const char *error_name = NULL;
   Lisp_Object selection = Qnil;
   FRAME_PTR f = NULL;
   Lisp_Object x, y, window;
diff --git a/src/menu.h b/src/menu.h
index c8691169ccb..5e62327da9f 100644
--- a/src/menu.h
+++ b/src/menu.h
@@ -46,11 +46,11 @@ extern void mouse_position_for_popup (FRAME_PTR f, int *x, int *y);
 #endif
 
 extern Lisp_Object w32_menu_show (FRAME_PTR, int, int, int, int,
-                                  Lisp_Object, char **);
+                                  Lisp_Object, const char **);
 extern Lisp_Object ns_menu_show (FRAME_PTR, int, int, int, int,
-                                 Lisp_Object, char **);
+                                 Lisp_Object, const char **);
 extern Lisp_Object xmenu_show (FRAME_PTR, int, int, int, int,
-                               Lisp_Object, char **, EMACS_UINT);
+                               Lisp_Object, const char **, EMACS_UINT);
 #endif /* MENU_H */
 
 /* arch-tag: c32b2778-724d-4e85-81d7-45f98530a988
diff --git a/src/msdos.c b/src/msdos.c
index ad529d00dea..086cad2ff84 100644
--- a/src/msdos.c
+++ b/src/msdos.c
@@ -68,8 +68,10 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include <pc.h>
 #include <ctype.h>
 /* #include <process.h> */
-/* Damn that local process.h!  Instead we can define P_WAIT ourselves.  */
+/* Damn that local process.h!  Instead we can define P_WAIT and
+   spawnve ourselves.  */
 #define P_WAIT 1
+extern int spawnve (int, const char *, char *const [], char *const []);
 
 #ifndef _USE_LFN
 #define _USE_LFN 0
@@ -827,7 +829,7 @@ IT_set_face (int face)
       bg = tem2;
     }
   if (tty->termscript)
-    fprintf (tty->termscript, "<FACE %d: %d/%d[FG:%d/BG:%d]>", face,
+    fprintf (tty->termscript, "<FACE %d: %lu/%lu[FG:%lu/BG:%lu]>", face,
              fp->foreground, fp->background, fg, bg);
   if (fg >= 0 && fg < 16)
     {
@@ -859,12 +861,6 @@ IT_write_glyphs (struct frame *f, struct glyph *str, int str_len)
   struct frame *sf;
   unsigned char *conversion_buffer;
 
-  /* Do we need to consider conversion of unibyte characters to
-     multibyte?  */
-  int convert_unibyte_characters
-    = (NILP (current_buffer->enable_multibyte_characters)
-       && unibyte_display_via_language_environment);
-
   /* If terminal_coding does any conversion, use it, otherwise use
      safe_terminal_coding.  We can't use CODING_REQUIRE_ENCODING here
      because it always returns 1 if terminal_coding.src_multibyte is 1.  */
@@ -1180,8 +1176,6 @@ fast_find_position (struct window *w, int pos, int *hpos, int *vpos)
 static void
 IT_note_mode_line_highlight (struct window *w, int x, int mode_line_p)
 {
-  struct frame *f = XFRAME (w->frame);
-  struct tty_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
   struct glyph_row *row;
 
   if (mode_line_p)
@@ -1192,7 +1186,7 @@ IT_note_mode_line_highlight (struct window *w, int x, int mode_line_p)
   if (row->enabled_p)
     {
       struct glyph *glyph, *end;
-      Lisp_Object help, map;
+      Lisp_Object help;
 
       /* Find the glyph under X.  */
       glyph = (row->glyphs[TEXT_AREA]
@@ -1873,6 +1867,8 @@ IT_delete_glyphs (struct frame *f, int n)
 void
 x_set_menu_bar_lines (struct frame *f, Lisp_Object value, Lisp_Object oldval)
 {
+  extern void set_menu_bar_lines (struct frame *, Lisp_Object, Lisp_Object);
+
   set_menu_bar_lines (f, value, oldval);
 }
 
@@ -1939,7 +1935,7 @@ IT_set_terminal_modes (struct terminal *term)
            already point to the relocated buffer address returned by
            the Int 10h/AX=FEh call above.  DJGPP v2.02 and later sets
            ScreenPrimary to that address at startup under DOS/V.  */
-        if (regs.x.es != (ScreenPrimary >> 4) & 0xffff)
+        if (regs.x.es != ((ScreenPrimary >> 4) & 0xffff))
           screen_old_address = ScreenPrimary;
         screen_virtual_segment = regs.x.es;
         screen_virtual_offset  = regs.x.di;
@@ -2056,6 +2052,8 @@ DEFUN ("msdos-remember-default-colors", Fmsdos_remember_default_colors,
      frame colors are reversed.  */
   initial_screen_colors[0] = FRAME_FOREGROUND_PIXEL (f);
   initial_screen_colors[1] = FRAME_BACKGROUND_PIXEL (f);
+
+  return Qnil;
 }
 
 void
@@ -2071,7 +2069,6 @@ IT_set_frame_parameters (struct frame *f, Lisp_Object alist)
   int reverse = EQ (Fcdr (Fassq (Qreverse, f->param_alist)), Qt);
   int redraw = 0, fg_set = 0, bg_set = 0;
   unsigned long orig_fg, orig_bg;
-  Lisp_Object frame_bg, frame_fg;
   struct tty_display_info *tty = FRAME_TTY (f);
 
   /* If we are creating a new frame, begin with the original screen colors
@@ -2195,9 +2192,10 @@ IT_set_frame_parameters (struct frame *f, Lisp_Object alist)
           IT_set_cursor_type (f, val);
           if (tty->termscript)
             fprintf (tty->termscript, "<CTYPE: %s>\n",
-                     EQ (val, Qbar) || EQ (val, Qhbar)
-                     || CONSP (val) && (EQ (XCAR (val), Qbar)
-                                        || EQ (XCAR (val), Qhbar))
+                     EQ (val, Qbar)
+                     || EQ (val, Qhbar)
+                     || (CONSP (val) && (EQ (XCAR (val), Qbar)
+                                         || EQ (XCAR (val), Qhbar)))
                      ? "bar" : "box");
         }
       else if (EQ (prop, Qtty_type))
@@ -2214,8 +2212,6 @@ IT_set_frame_parameters (struct frame *f, Lisp_Object alist)
      the current frame colors.  */
   if (reverse)
     {
-      Lisp_Object frame;
-
       if (!fg_set)
         {
           FRAME_FOREGROUND_PIXEL (f) = orig_bg;
@@ -2532,11 +2528,11 @@ static struct keyboard_layout_list
   struct dos_keyboard_map *keyboard_map;
 } keyboard_layout_list[] =
 {
-  1, &us_keyboard,
-  33, &fr_keyboard,
-  39, &it_keyboard,
-  45, &dk_keyboard,
-  81, &jp_keyboard
+  { 1, &us_keyboard },
+  { 33, &fr_keyboard },
+  { 39, &it_keyboard },
+  { 45, &dk_keyboard },
+  { 81, &jp_keyboard }
 };
 
 static struct dos_keyboard_map *keyboard;
@@ -2581,17 +2577,17 @@ static struct
   unsigned char keypad_code;    /* keypad code  */
   unsigned char editkey_code;   /* edit key     */
 } keypad_translate_map[] = {
-  '0',  '0',  0xb0, /* kp-0 */          0x63, /* insert */
-  '1',  '1',  0xb1, /* kp-1 */          0x57, /* end */
-  '2',  '2',  0xb2, /* kp-2 */          0x54, /* down */
-  '3',  '3',  0xb3, /* kp-3 */          0x56, /* next */
-  '4',  '4',  0xb4, /* kp-4 */          0x51, /* left */
-  '5',  '5',  0xb5, /* kp-5 */          0xb5, /* kp-5 */
-  '6',  '6',  0xb6, /* kp-6 */          0x53, /* right */
-  '7',  '7',  0xb7, /* kp-7 */          0x50, /* home */
-  '8',  '8',  0xb8, /* kp-8 */          0x52, /* up */
-  '9',  '9',  0xb9, /* kp-9 */          0x55, /* prior */
-  '.',  '-',  0xae, /* kp-decimal */    0xff  /* delete */
+  { '0',  '0',  0xb0, /* kp-0 */                0x63 /* insert */ },
+  { '1',  '1',  0xb1, /* kp-1 */                0x57 /* end */    },
+  { '2',  '2',  0xb2, /* kp-2 */                0x54 /* down */   },
+  { '3',  '3',  0xb3, /* kp-3 */                0x56 /* next */   },
+  { '4',  '4',  0xb4, /* kp-4 */                0x51 /* left */   },
+  { '5',  '5',  0xb5, /* kp-5 */                0xb5 /* kp-5 */   },
+  { '6',  '6',  0xb6, /* kp-6 */                0x53 /* right */  },
+  { '7',  '7',  0xb7, /* kp-7 */                0x50 /* home */   },
+  { '8',  '8',  0xb8, /* kp-8 */                0x52 /* up */     },
+  { '9',  '9',  0xb9, /* kp-9 */                0x55 /* prior */  },
+  { '.',  '-',  0xae, /* kp-decimal */          0xff  /* delete */}
 };
 
 static struct
@@ -2599,11 +2595,11 @@ static struct
   unsigned char char_code;      /* normal code  */
   unsigned char keypad_code;    /* keypad code  */
 } grey_key_translate_map[] = {
-  '/',  0xaf, /* kp-decimal */
-  '*',  0xaa, /* kp-multiply */
-  '-',  0xad, /* kp-subtract */
-  '+',  0xab, /* kp-add */
-  '\r', 0x8d  /* kp-enter */
+  { '/',  0xaf /* kp-decimal */  },
+  { '*',  0xaa /* kp-multiply */ },
+  { '-',  0xad /* kp-subtract */ },
+  { '+',  0xab /* kp-add */      },
+  { '\r', 0x8d  /* kp-enter */   }
 };
 
 static unsigned short
@@ -3129,7 +3125,6 @@ dos_rawgetc (void)
           break;
         }
 
-    make_event:
       if (code == 0)
         continue;
 
@@ -3237,14 +3232,14 @@ dos_rawgetc (void)
                     /* If only one button is pressed, wait 100 msec and
                        check again.  This way, Speedy Gonzales isn't
                        punished, while the slow get their chance.  */
-                    if (press && mouse_pressed (1-but, &x2, &y2)
-                        || !press && mouse_released (1-but, &x2, &y2))
+                    if ((press && mouse_pressed (1-but, &x2, &y2))
+                        || (!press && mouse_released (1-but, &x2, &y2)))
                       button_num = 2;
                     else
                       {
                         delay (100);
-                        if (press && mouse_pressed (1-but, &x2, &y2)
-                            || !press && mouse_released (1-but, &x2, &y2))
+                        if ((press && mouse_pressed (1-but, &x2, &y2))
+                            || (!press && mouse_released (1-but, &x2, &y2)))
                           button_num = 2;
                       }
                   }
@@ -3680,10 +3675,12 @@ XMenuActivate (Display *foo, XMenu *menu, int *pane, int *selidx,
                 if (0 <= dy && dy < state[i].menu->count)
                   {
                     if (!state[i].menu->submenu[dy])
-                      if (state[i].menu->panenumber[dy])
-                        result = XM_SUCCESS;
-                      else
-                        result = XM_IA_SELECT;
+                      {
+                        if (state[i].menu->panenumber[dy])
+                          result = XM_SUCCESS;
+                        else
+                          result = XM_IA_SELECT;
+                      }
                     *pane = state[i].pane - 1;
                     *selidx = dy;
                     /* We hit some part of a menu, so drop extra menus that
@@ -4181,7 +4178,7 @@ dos_ttraw (struct tty_display_info *tty)
   /* If we are called for the initial terminal, it's too early to do
      anything, and termscript isn't set up.  */
   if (tty->terminal->type == output_initial)
-    return;
+    return 2;
 
   break_stat = getcbrk ();
   setcbrk (0);
@@ -4367,7 +4364,7 @@ run_msdos_command (unsigned char **argv, const char *working_dir,
         result = 0;     /* emulate Unixy shell behavior with empty cmd line */
     }
   else
-    result = spawnve (P_WAIT, argv[0], argv, envv);
+    result = spawnve (P_WAIT, argv[0], (char **)argv, envv);
 
   dup2 (inbak, 0);
   dup2 (outbak, 1);
diff --git a/src/nsfns.m b/src/nsfns.m
index aac2ef0ed3a..576131e0bdf 100644
--- a/src/nsfns.m
+++ b/src/nsfns.m
@@ -1041,6 +1041,7 @@ frame_parm_handler ns_frame_parm_handlers[] =
   x_set_font_backend, /* generic OK */
   x_set_alpha,
   0, /* x_set_sticky */  
+  0, /* x_set_tool_bar_position */  
 };
 
 
diff --git a/src/nsfont.m b/src/nsfont.m
index aaa5999e048..115986774d8 100644
--- a/src/nsfont.m
+++ b/src/nsfont.m
@@ -161,7 +161,9 @@ static NSFontDescriptor
 
 /* Converts NSFont descriptor to FONT_WEIGHT, FONT_SLANT, FONT_WIDTH, etc.. */
 static Lisp_Object
-ns_descriptor_to_entity (NSFontDescriptor *desc, Lisp_Object extra, char *style)
+ns_descriptor_to_entity (NSFontDescriptor *desc,
+                         Lisp_Object extra,
+                         const char *style)
 {
     Lisp_Object font_entity = font_make_entity ();
     /*   NSString *psName = [desc postscriptName]; */
diff --git a/src/nsimage.m b/src/nsimage.m
index 13761ba5f71..a42950d1f52 100644
--- a/src/nsimage.m
+++ b/src/nsimage.m
@@ -83,19 +83,21 @@ int
 ns_load_image (struct frame *f, struct image *img,
                Lisp_Object spec_file, Lisp_Object spec_data)
 {
-  EmacsImage *eImg;
+  EmacsImage *eImg = nil;
   NSSize size;
 
   NSTRACE (ns_load_image);
 
-  if (NILP (spec_data))
+  if (STRINGP (spec_file))
     {
       eImg = [EmacsImage allocInitFromFile: spec_file];
     }
-  else
+  else if (STRINGP (spec_data))
     {
-      NSData *data = [NSData dataWithBytes: SDATA (spec_data)
-                                    length: SBYTES (spec_data)];
+      NSData *data;
+
+      data = [NSData dataWithBytes: SDATA (spec_data)
+                            length: SBYTES (spec_data)];
       eImg = [[EmacsImage alloc] initWithData: data];
       [eImg setPixmapData];
     }
diff --git a/src/nsmenu.m b/src/nsmenu.m
index c7ea6bb90fd..9534aec8f2b 100644
--- a/src/nsmenu.m
+++ b/src/nsmenu.m
@@ -600,9 +600,9 @@ name_is_separator ( const char *name)
    NSMenuItem get ignored.  For now we try to display a super-single letter
    combo, and return the others as strings to be appended to the item title.
    (This is signaled by setting keyEquivModMask to 0 for now.) */
--(NSString *)parseKeyEquiv: (char *)key
+-(NSString *)parseKeyEquiv: (const char *)key
 {
-  char *tpos = key;
+  const char *tpos = key;
   keyEquivModMask = NSCommandKeyMask;
 
   if (!key || !strlen (key))
@@ -719,7 +719,7 @@ name_is_separator ( const char *name)
 
 
 /* adds an empty submenu and returns it */
-- (EmacsMenu *)addSubmenuWithTitle: (char *)title forFrame: (struct frame *)f
+- (EmacsMenu *)addSubmenuWithTitle: (const char *)title forFrame: (struct frame *)f
 {
   NSString *titleStr = [NSString stringWithUTF8String: title];
   NSMenuItem *item = [self addItemWithTitle: titleStr
@@ -773,7 +773,7 @@ name_is_separator ( const char *name)
 
 Lisp_Object
 ns_menu_show (FRAME_PTR f, int x, int y, int for_click, int keymaps,
-              Lisp_Object title, char **error)
+              Lisp_Object title, const char **error)
 {
   EmacsMenu *pmenu;
   NSPoint p;
@@ -836,7 +836,7 @@ ns_menu_show (FRAME_PTR f, int x, int y, int for_click, int keymaps,
         {
           /* Create a new pane.  */
           Lisp_Object pane_name, prefix;
-          char *pane_string;
+          const char *pane_string;
 
           pane_name = AREF (menu_items, i + MENU_ITEMS_PANE_NAME);
           prefix = AREF (menu_items, i + MENU_ITEMS_PANE_PREFIX);
@@ -1033,7 +1033,7 @@ update_frame_tool_bar (FRAME_PTR f)
       struct image *img;
       Lisp_Object image;
       Lisp_Object helpObj;
-      char *helpText;
+      const char *helpText;
 
       /* If image is a vector, choose the image according to the
          button state.  */
@@ -1153,7 +1153,7 @@ update_frame_tool_bar (FRAME_PTR f)
 }
 
 - (void) addDisplayItemWithImage: (EmacsImage *)img idx: (int)idx
-                        helpText: (char *)help enabled: (BOOL)enabled
+                        helpText: (const char *)help enabled: (BOOL)enabled
 {
   /* 1) come up w/identifier */
   NSString *identifier
diff --git a/src/nsselect.m b/src/nsselect.m
index 23dede9c38e..9e434515edf 100644
--- a/src/nsselect.m
+++ b/src/nsselect.m
@@ -33,10 +33,11 @@ GNUstep port and post-20 update by Adrian Robert (arobert@cogsci.ucsd.edu)
 #include "lisp.h"
 #include "nsterm.h"
 #include "termhooks.h"
+#include "keyboard.h"
 
 #define CUT_BUFFER_SUPPORT
 
-Lisp_Object QPRIMARY, QSECONDARY, QTEXT, QFILE_NAME;
+Lisp_Object QCLIPBOARD, QSECONDARY, QTEXT, QFILE_NAME;
 
 static Lisp_Object Vns_sent_selection_hooks;
 static Lisp_Object Vns_lost_selection_hooks;
@@ -45,6 +46,8 @@ static Lisp_Object Vselection_converter_alist;
 
 static Lisp_Object Qforeign_selection;
 
+/* NSGeneralPboard is pretty much analogous to X11 CLIPBOARD */
+NSString *NXPrimaryPboard;
 NSString *NXSecondaryPboard;
 
 
@@ -60,7 +63,8 @@ static NSString *
 symbol_to_nsstring (Lisp_Object sym)
 {
   CHECK_SYMBOL (sym);
-  if (EQ (sym, QPRIMARY))     return NSGeneralPboard;
+  if (EQ (sym, QCLIPBOARD))     return NSGeneralPboard;
+  if (EQ (sym, QPRIMARY))     return NXPrimaryPboard;
   if (EQ (sym, QSECONDARY))   return NXSecondaryPboard;
   if (EQ (sym, QTEXT))        return NSStringPboardType;
   return [NSString stringWithUTF8String: SDATA (XSYMBOL (sym)->xname)];
@@ -71,6 +75,8 @@ static Lisp_Object
 ns_string_to_symbol (NSString *t)
 {
   if ([t isEqualToString: NSGeneralPboard])
+    return QCLIPBOARD;
+  if ([t isEqualToString: NXPrimaryPboard])
     return QPRIMARY;
   if ([t isEqualToString: NXSecondaryPboard])
     return QSECONDARY;
@@ -536,13 +542,14 @@ DEFUN ("ns-store-cut-buffer-internal", Fns_store_cut_buffer_internal,
 void
 nxatoms_of_nsselect (void)
 {
-  NXSecondaryPboard = @"Selection";
+  NXPrimaryPboard = @"Selection";
+  NXSecondaryPboard = @"Secondary";
 }
 
 void
 syms_of_nsselect (void)
 {
-  QPRIMARY   = intern ("PRIMARY");      staticpro (&QPRIMARY);
+  QCLIPBOARD = intern ("CLIPBOARD");    staticpro (&QCLIPBOARD);
   QSECONDARY = intern ("SECONDARY");    staticpro (&QSECONDARY);
   QTEXT      = intern ("TEXT");         staticpro (&QTEXT);
   QFILE_NAME = intern ("FILE_NAME");    staticpro (&QFILE_NAME);
diff --git a/src/nsterm.h b/src/nsterm.h
index 9b7f0accad1..21b18f15cae 100644
--- a/src/nsterm.h
+++ b/src/nsterm.h
@@ -114,10 +114,10 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 - initWithTitle: (NSString *)title frame: (struct frame *)f;
 - (void)setFrame: (struct frame *)f;
 - (void)menuNeedsUpdate: (NSMenu *)menu; /* (delegate method) */
-- (NSString *)parseKeyEquiv: (char *)key;
+- (NSString *)parseKeyEquiv: (const char *)key;
 - (NSMenuItem *)addItemWithWidgetValue: (void *)wvptr;
 - (void)fillWithWidgetValue: (void *)wvptr;
-- (EmacsMenu *)addSubmenuWithTitle: (char *)title forFrame: (struct frame *)f;
+- (EmacsMenu *)addSubmenuWithTitle: (const char *)title forFrame: (struct frame *)f;
 - (void) clear;
 - (Lisp_Object)runMenuAt: (NSPoint)p forFrame: (struct frame *)f
                  keymaps: (int)keymaps;
@@ -144,7 +144,7 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 - (void) clearActive;
 - (BOOL) changed;
 - (void) addDisplayItemWithImage: (EmacsImage *)img idx: (int)idx
-                        helpText: (char *)help
+                        helpText: (const char *)help
                          enabled: (BOOL)enabled;
 /* delegate methods */
 - (NSToolbarItem *)toolbar: (NSToolbar *)toolbar
diff --git a/src/nsterm.m b/src/nsterm.m
index 88d47d41972..f0efb948ab9 100644
--- a/src/nsterm.m
+++ b/src/nsterm.m
@@ -1792,6 +1792,9 @@ ns_define_frame_cursor (struct frame *f, Cursor cursor)
       EmacsView *view = FRAME_NS_VIEW (f);
       FRAME_POINTER_TYPE (f) = cursor;
       [[view window] invalidateCursorRectsForView: view];
+      /* Redisplay assumes this function also draws the changed frame
+         cursor, but this function doesn't, so do it explicitly.  */
+      x_update_cursor (f, 1);
     }
 }
 
@@ -2248,6 +2251,11 @@ ns_draw_window_cursor (struct window *w, struct glyph_row *glyph_row,
   struct frame *f = WINDOW_XFRAME (w);
   struct glyph *phys_cursor_glyph;
   int overspill;
+  struct glyph *cursor_glyph;
+
+  /* If cursor is out of bounds, don't draw garbage.  This can happen
+     in mini-buffer windows when switching between echo area glyphs
+     and mini-buffer.  */
 
   NSTRACE (dumpcursor);
 //fprintf(stderr, "drawcursor (%d,%d) activep = %d\tonp = %d\tc_type = %d\twidth = %d\n",x,y, active_p,on_p,cursor_type,cursor_width);
@@ -2325,6 +2333,13 @@ ns_draw_window_cursor (struct window *w, struct glyph_row *glyph_row,
     case BAR_CURSOR:
       s = r;
       s.size.width = min (cursor_width, 2); //FIXME(see above)
+
+      /* If the character under cursor is R2L, draw the bar cursor
+         on the right of its glyph, rather than on the left.  */
+      cursor_glyph = get_phys_cursor_glyph (w);
+      if ((cursor_glyph->resolved_level & 1) != 0)
+        s.origin.x += cursor_glyph->pixel_width - s.size.width;
+
       NSRectFill (s);
       break;
     }
diff --git a/src/process.c b/src/process.c
index 4a658623077..f348dca7d35 100644
--- a/src/process.c
+++ b/src/process.c
@@ -31,9 +31,7 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #ifdef HAVE_INTTYPES_H
 #include <inttypes.h>
 #endif
-#ifdef STDC_HEADERS
 #include <stdlib.h>
-#endif
 
 #ifdef HAVE_UNISTD_H
 #include <unistd.h>
@@ -61,9 +59,6 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 
 #if defined(HAVE_SYS_IOCTL_H)
 #include <sys/ioctl.h>
-#if !defined (O_NDELAY) && defined (HAVE_PTYS) && !defined(USG5)
-#include <fcntl.h>
-#endif /* HAVE_PTYS and no O_NDELAY */
 #if defined(HAVE_NET_IF_H)
 #include <net/if.h>
 #endif /* HAVE_NET_IF_H */
@@ -182,16 +177,9 @@ extern Lisp_Object QCfilter;
 
 extern const char *get_operating_system_release (void);
 
-/* Serial processes require termios or Windows.  */
-#if defined (HAVE_TERMIOS) || defined (WINDOWSNT)
-#define HAVE_SERIAL
-#endif
-
-#ifdef HAVE_SERIAL
 /* From sysdep.c or w32.c  */
 extern int serial_open (char *port);
 extern void serial_configure (struct Lisp_Process *p, Lisp_Object contact);
-#endif
 
 #ifndef HAVE_H_ERRNO
 extern int h_errno;
@@ -1903,7 +1891,7 @@ create_process (Lisp_Object process, char **new_argv, Lisp_Object current_dir)
         setpgrp ();
 #endif /* USG */
 #endif /* not HAVE_SETSID */
-#if defined (HAVE_TERMIOS) && defined (LDISC1)
+#if defined (LDISC1)
         if (pty_flag && xforkin >= 0)
           {
             struct termios t;
@@ -2569,7 +2557,6 @@ OPTION is not a supported option, return nil instead; otherwise return t.  */)
 }
 
 
-#ifdef HAVE_SERIAL
 DEFUN ("serial-process-configure",
        Fserial_process_configure,
        Sserial_process_configure,
@@ -2865,7 +2852,6 @@ usage:  (make-serial-process &rest ARGS)  */)
   UNGCPRO;
   return proc;
 }
-#endif /* HAVE_SERIAL  */
 
 /* Create a network stream/datagram client/server process.  Treated
    exactly like a normal process when reading and writing.  Primary
@@ -5801,9 +5787,6 @@ process_send_signal (Lisp_Object process, int signo, Lisp_Object current_group,
       /* If possible, send signals to the entire pgrp
          by sending an input character to it.  */
 
-      /* TERMIOS is the latest and bestest, and seems most likely to
-         work.  If the system has it, use it.  */
-#ifdef HAVE_TERMIOS
       struct termios t;
       cc_t *sig_char = NULL;
 
@@ -5835,65 +5818,6 @@ process_send_signal (Lisp_Object process, int signo, Lisp_Object current_group,
         }
       /* If we can't send the signal with a character,
          fall through and send it another way.  */
-#else /* ! HAVE_TERMIOS */
-
-      /* On Berkeley descendants, the following IOCTL's retrieve the
-         current control characters.  */
-#if defined (TIOCGLTC) && defined (TIOCGETC)
-
-      struct tchars c;
-      struct ltchars lc;
-
-      switch (signo)
-        {
-        case SIGINT:
-          ioctl (p->infd, TIOCGETC, &c);
-          send_process (proc, &c.t_intrc, 1, Qnil);
-          return;
-        case SIGQUIT:
-          ioctl (p->infd, TIOCGETC, &c);
-          send_process (proc, &c.t_quitc, 1, Qnil);
-          return;
-#ifdef SIGTSTP
-        case SIGTSTP:
-          ioctl (p->infd, TIOCGLTC, &lc);
-          send_process (proc, &lc.t_suspc, 1, Qnil);
-          return;
-#endif /* ! defined (SIGTSTP) */
-        }
-
-#else /* ! defined (TIOCGLTC) && defined (TIOCGETC) */
-
-      /* On SYSV descendants, the TCGETA ioctl retrieves the current control
-         characters.  */
-#ifdef TCGETA
-      struct termio t;
-      switch (signo)
-        {
-        case SIGINT:
-          ioctl (p->infd, TCGETA, &t);
-          send_process (proc, &t.c_cc[VINTR], 1, Qnil);
-          return;
-        case SIGQUIT:
-          ioctl (p->infd, TCGETA, &t);
-          send_process (proc, &t.c_cc[VQUIT], 1, Qnil);
-          return;
-#ifdef SIGTSTP
-        case SIGTSTP:
-          ioctl (p->infd, TCGETA, &t);
-          send_process (proc, &t.c_cc[VSWTCH], 1, Qnil);
-          return;
-#endif /* ! defined (SIGTSTP) */
-        }
-#else /* ! defined (TCGETA) */
-      Your configuration files are messed up.
-      /* If your system configuration files define SIGNALS_VIA_CHARACTERS,
-         you'd better be using one of the alternatives above!  */
-#endif /* ! defined (TCGETA) */
-#endif /* ! defined (TIOCGLTC) && defined (TIOCGETC) */
-        /* In this case, the code above should alway return.  */
-        abort ();
-#endif /* ! defined HAVE_TERMIOS */
 
       /* The code above may fall through if it can't
          handle the signal.  */
@@ -6065,10 +5989,9 @@ traffic.  */)
 #ifdef WINDOWSNT
           if (fd_info[ p->infd ].flags & FILE_SERIAL)
             PurgeComm (fd_info[ p->infd ].hnd, PURGE_RXABORT | PURGE_RXCLEAR);
-#endif
-#ifdef HAVE_TERMIOS
+#else /* not WINDOWSNT */
           tcflush (p->infd, TCIFLUSH);
-#endif
+#endif /* not WINDOWSNT */
         }
       p->command = Qnil;
       return process;
@@ -6282,10 +6205,10 @@ process has been transmitted to the serial port.  */)
     send_process (proc, "\004", 1, Qnil);
   else if (EQ (XPROCESS (proc)->type, Qserial))
     {
-#ifdef HAVE_TERMIOS
+#ifndef WINDOWSNT
       if (tcdrain (XPROCESS (proc)->outfd) != 0)
         error ("tcdrain() failed: %s", emacs_strerror (errno));
-#endif
+#endif /* not WINDOWSNT */
       /* Do nothing on Windows because writes are blocking.  */
     }
   else
@@ -7672,10 +7595,8 @@ The variable takes effect when `start-process' is called.  */);
   defsubr (&Slist_processes);
   defsubr (&Sprocess_list);
   defsubr (&Sstart_process);
-#ifdef HAVE_SERIAL
   defsubr (&Sserial_process_configure);
   defsubr (&Smake_serial_process);
-#endif /* HAVE_SERIAL  */
   defsubr (&Sset_network_process_option);
   defsubr (&Smake_network_process);
   defsubr (&Sformat_network_address);
diff --git a/src/process.h b/src/process.h
index 6d4832ffde8..35b01aba6a4 100644
--- a/src/process.h
+++ b/src/process.h
@@ -142,7 +142,7 @@ extern int synch_process_alive;
    to Fcall_process.  */
 
 /* Nonzero => this is a string explaining death of synchronous subprocess.  */
-extern char *synch_process_death;
+extern const char *synch_process_death;
 
 /* Nonzero => this is the signal number that terminated the subprocess.  */
 extern int synch_process_termsig;
diff --git a/src/puresize.h b/src/puresize.h
index 682e8926135..3c7f92228a0 100644
--- a/src/puresize.h
+++ b/src/puresize.h
@@ -87,7 +87,6 @@ extern EMACS_INT pure[];
   && (PNTR_COMPARISON_TYPE) XPNTR (obj) >= (PNTR_COMPARISON_TYPE) pure)
 
 #else /* not VIRT_ADDR_VARIES */
-#ifdef PNTR_COMPARISON_TYPE
 /* When PNTR_COMPARISON_TYPE is not the default (unsigned int).  */
 
 extern char my_edata[];
@@ -95,14 +94,6 @@ extern char my_edata[];
 #define PURE_P(obj) \
   ((PNTR_COMPARISON_TYPE) XPNTR (obj) < (PNTR_COMPARISON_TYPE) my_edata)
 
-#else /* not VIRT_ADDRESS_VARIES, not PNTR_COMPARISON_TYPE */
-
-extern char my_edata[];
-
-#define PURE_P(obj) \
-  (XPNTR (obj) < (unsigned int) my_edata)
-
-#endif /* PNTR_COMPARISON_TYPE */
 #endif /* VIRT_ADDRESS_VARIES */
 
 /* arch-tag: fd9b0a91-a70e-4729-a75a-6bb4ca1ce14f
diff --git a/src/s/aix4-2.h b/src/s/aix4-2.h
index 84920f888e1..0a3d48db639 100644
--- a/src/s/aix4-2.h
+++ b/src/s/aix4-2.h
@@ -55,10 +55,6 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 
 /* Special items needed to make Emacs run on this system.  */
 
-/* The following definition seems to be needed in AIX version 3.1.6.8.
-   It may not have been needed in certain earlier versions.  */
-#define HAVE_TCATTR
-
 /* AIX doesn't define this.  */
 #define unix 1
 
diff --git a/src/s/hpux10-20.h b/src/s/hpux10-20.h
index ee0fa9abe02..d34ff16104b 100644
--- a/src/s/hpux10-20.h
+++ b/src/s/hpux10-20.h
@@ -35,9 +35,10 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
    if system supports pty's.  'p' means it is /dev/ptym/ptyp0  */
 #define FIRST_PTY_LETTER 'p'
 
-/* Define HAVE_TERMIO if the system provides sysV-style ioctls
-   for terminal control.  */
-#define HAVE_TERMIO
+#define HAVE_TERMIOS
+#define NO_TERMIO
+
+#define ORDINARY_LINK
 
 /* Define HAVE_PTYS if the system supports pty devices.  */
 #define HAVE_PTYS
diff --git a/src/s/ms-w32.h b/src/s/ms-w32.h
index f61fae57eff..4ae5f32e873 100644
--- a/src/s/ms-w32.h
+++ b/src/s/ms-w32.h
@@ -106,7 +106,6 @@ struct sigaction {
 #define HAVE_SOUND  1
 #define LISP_FLOAT_TYPE 1
 
-#undef  HAVE_SYS_SELECT_H
 #define HAVE_SYS_TIMEB_H 1
 #define HAVE_SYS_TIME_H 1
 #define HAVE_UNISTD_H 1
diff --git a/src/s/unixware.h b/src/s/unixware.h
index ac989d48e2c..81b1b3d97fa 100644
--- a/src/s/unixware.h
+++ b/src/s/unixware.h
@@ -21,8 +21,6 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 
 #include "usg5-4-common.h"
 
-/* fnf@cygnus.com says these exist.  */
-#define HAVE_TCATTR
 /* #define HAVE_GETWD  (appears to be buggy on SVR4.2) */
 #undef HAVE_GETWD
 
diff --git a/src/syntax.c b/src/syntax.c
index 9b707c6c3b7..f0a7dca42dc 100644
--- a/src/syntax.c
+++ b/src/syntax.c
@@ -34,6 +34,60 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 
 #include "syntax.h"
 #include "intervals.h"
+#include "category.h"
+
+/* Then there are seven single-bit flags that have the following meanings:
+  1. This character is the first of a two-character comment-start sequence.
+  2. This character is the second of a two-character comment-start sequence.
+  3. This character is the first of a two-character comment-end sequence.
+  4. This character is the second of a two-character comment-end sequence.
+  5. This character is a prefix, for backward-prefix-chars.
+  6. The char is part of a delimiter for comments of style "b".
+  7. This character is part of a nestable comment sequence.
+  8. The char is part of a delimiter for comments of style "c".
+  Note that any two-character sequence whose first character has flag 1
+  and whose second character has flag 2 will be interpreted as a comment start.
+
+  bit 6 and 8 are used to discriminate between different comment styles.
+  Languages such as C++ allow two orthogonal syntax start/end pairs
+  and bit 6 is used to determine whether a comment-end or Scommentend
+  ends style a or b.  Comment markers can start style a, b, c, or bc.
+  Style a is always the default.
+  For 2-char comment markers, the style b flag is only looked up on the second
+  char of the comment marker and on the first char of the comment ender.
+  For style c (like to for the nested flag), the flag can be placed on any
+  one of the chars.
+  */
+
+/* These macros extract specific flags from an integer
+   that holds the syntax code and the flags.  */
+
+#define SYNTAX_FLAGS_COMSTART_FIRST(flags) (((flags) >> 16) & 1)
+
+#define SYNTAX_FLAGS_COMSTART_SECOND(flags) (((flags) >> 17) & 1)
+
+#define SYNTAX_FLAGS_COMEND_FIRST(flags) (((flags) >> 18) & 1)
+
+#define SYNTAX_FLAGS_COMEND_SECOND(flags) (((flags) >> 19) & 1)
+
+#define SYNTAX_FLAGS_PREFIX(flags) (((flags) >> 20) & 1)
+
+#define SYNTAX_FLAGS_COMMENT_STYLEB(flags) (((flags) >> 21) & 1)
+#define SYNTAX_FLAGS_COMMENT_STYLEC(flags) (((flags) >> 22) & 2)
+/* FLAGS should be the flags of the main char of the comment marker, e.g.
+   the second for comstart and the first for comend.  */
+#define SYNTAX_FLAGS_COMMENT_STYLE(flags, other_flags) \
+  (SYNTAX_FLAGS_COMMENT_STYLEB (flags) \
+   | SYNTAX_FLAGS_COMMENT_STYLEC (flags) \
+   | SYNTAX_FLAGS_COMMENT_STYLEC (other_flags))
+
+#define SYNTAX_FLAGS_COMMENT_NESTED(flags) (((flags) >> 22) & 1)
+
+/* These macros extract a particular flag for a given character.  */
+
+#define SYNTAX_COMEND_FIRST(c) \
+  (SYNTAX_FLAGS_COMEND_FIRST (SYNTAX_WITH_FLAGS (c)))
+#define SYNTAX_PREFIX(c) (SYNTAX_FLAGS_PREFIX (SYNTAX_WITH_FLAGS (c)))
 
 /* We use these constants in place for comment-style and
    string-ender-char to distinguish  comments/strings started by
@@ -41,7 +95,6 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 
 #define ST_COMMENT_STYLE (256 + 1)
 #define ST_STRING_STYLE (256 + 2)
-#include "category.h"
 
 Lisp_Object Qsyntax_table_p, Qsyntax_table, Qscan_error;
 
@@ -106,6 +159,11 @@ static void scan_sexps_forward (struct lisp_parse_state *,
                                 int, Lisp_Object, int);
 static int in_classes (int, Lisp_Object);
 
+/* Whether the syntax of the character C has the prefix flag set.  */
+int syntax_prefix_flag_p (int c)
+{
+  return SYNTAX_PREFIX (c);
+}
 
 struct gl_state_s gl_state;             /* Global state of syntax parser.  */
 
@@ -514,7 +572,8 @@ back_comment (EMACS_INT from, EMACS_INT from_byte, EMACS_INT stop, int comnested
       /* Check for 2-char comment markers.  */
       com2start = (SYNTAX_FLAGS_COMSTART_FIRST (syntax)
                    && SYNTAX_FLAGS_COMSTART_SECOND (prev_syntax)
-                   && comstyle == SYNTAX_FLAGS_COMMENT_STYLE (prev_syntax)
+                   && (comstyle
+                       == SYNTAX_FLAGS_COMMENT_STYLE (prev_syntax, syntax))
                    && (SYNTAX_FLAGS_COMMENT_NESTED (prev_syntax)
                        || SYNTAX_FLAGS_COMMENT_NESTED (syntax)) == comnested);
       com2end = (SYNTAX_FLAGS_COMEND_FIRST (syntax)
@@ -543,7 +602,8 @@ back_comment (EMACS_INT from, EMACS_INT from_byte, EMACS_INT stop, int comnested
                && SYNTAX_FLAGS_COMEND_FIRST (next_syntax))
               || ((com2end || comnested)
                   && SYNTAX_FLAGS_COMSTART_SECOND (syntax)
-                  && comstyle == SYNTAX_FLAGS_COMMENT_STYLE (syntax)
+                  && (comstyle
+                      == SYNTAX_FLAGS_COMMENT_STYLE (syntax, prev_syntax))
                   && SYNTAX_FLAGS_COMSTART_FIRST (next_syntax)))
             goto lossage;
           /* UPDATE_SYNTAX_TABLE_FORWARD (next + 1); */
@@ -563,7 +623,7 @@ back_comment (EMACS_INT from, EMACS_INT from_byte, EMACS_INT stop, int comnested
         code = Scomment;
       /* Ignore comment starters of a different style.  */
       else if (code == Scomment
-               && (comstyle != SYNTAX_FLAGS_COMMENT_STYLE (syntax)
+               && (comstyle != SYNTAX_FLAGS_COMMENT_STYLE (syntax, 0)
                    || SYNTAX_FLAGS_COMMENT_NESTED (syntax) != comnested))
         continue;
 
@@ -613,7 +673,7 @@ back_comment (EMACS_INT from, EMACS_INT from_byte, EMACS_INT stop, int comnested
           break;
 
         case Sendcomment:
-          if (SYNTAX_FLAGS_COMMENT_STYLE (syntax) == comstyle
+          if (SYNTAX_FLAGS_COMMENT_STYLE (syntax, 0) == comstyle
               && ((com2end && SYNTAX_FLAGS_COMMENT_NESTED (prev_syntax))
                   || SYNTAX_FLAGS_COMMENT_NESTED (syntax)) == comnested)
             /* This is the same style of comment ender as ours. */
@@ -930,6 +990,10 @@ text property.  */)
       case 'n':
         val |= 1 << 22;
         break;
+
+      case 'c':
+        val |= 1 << 23;
+        break;
       }
 
   if (val < XVECTOR (Vsyntax_code_object)->size && NILP (match))
@@ -969,12 +1033,13 @@ Defined flags are the characters 1, 2, 3, 4, b, p, and n.
  3 means CHAR is the start of a two-char comment end sequence.
  4 means CHAR is the second character of such a sequence.
 
-There can be up to two orthogonal comment sequences.  This is to support
+There can be several orthogonal comment sequences.  This is to support
 language modes such as C++.  By default, all comment sequences are of style
 a, but you can set the comment sequence style to b (on the second character
-of a comment-start, or the first character of a comment-end sequence) using
-this flag:
+of a comment-start, and the first character of a comment-end sequence) and/or
+c (on any of its chars) using this flag:
  b means CHAR is part of comment sequence b.
+ c means CHAR is part of comment sequence c.
  n means CHAR is part of a nestable comment sequence.
 
  p means CHAR is a prefix character for `backward-prefix-chars';
@@ -1017,7 +1082,9 @@ DEFUN ("internal-describe-syntax-value", Finternal_describe_syntax_value,
   (Lisp_Object syntax)
 {
   register enum syntaxcode code;
-  char desc, start1, start2, end1, end2, prefix, comstyle, comnested;
+  int syntax_code;
+  char desc, start1, start2, end1, end2, prefix,
+    comstyleb, comstylec, comnested;
   char str[2];
   Lisp_Object first, match_lisp, value = syntax;
 
@@ -1048,14 +1115,16 @@ DEFUN ("internal-describe-syntax-value", Finternal_describe_syntax_value,
       return syntax;
     }
 
-  code = (enum syntaxcode) (XINT (first) & 0377);
-  start1 = (XINT (first) >> 16) & 1;
-  start2 = (XINT (first) >> 17) & 1;
-  end1 = (XINT (first) >> 18) & 1;
-  end2 = (XINT (first) >> 19) & 1;
-  prefix = (XINT (first) >> 20) & 1;
-  comstyle = (XINT (first) >> 21) & 1;
-  comnested = (XINT (first) >> 22) & 1;
+  syntax_code = XINT (first);
+  code = (enum syntaxcode) (syntax_code & 0377);
+  start1 = SYNTAX_FLAGS_COMSTART_FIRST (syntax_code);
+  start2 = SYNTAX_FLAGS_COMSTART_SECOND (syntax_code);;
+  end1 = SYNTAX_FLAGS_COMEND_FIRST (syntax_code);
+  end2 = SYNTAX_FLAGS_COMEND_SECOND (syntax_code);
+  prefix = SYNTAX_FLAGS_PREFIX (syntax_code);
+  comstyleb = SYNTAX_FLAGS_COMMENT_STYLEB (syntax_code);
+  comstylec = SYNTAX_FLAGS_COMMENT_STYLEC (syntax_code);
+  comnested = SYNTAX_FLAGS_COMMENT_NESTED (syntax_code);
 
   if ((int) code < 0 || (int) code >= (int) Smax)
     {
@@ -1084,8 +1153,10 @@ DEFUN ("internal-describe-syntax-value", Finternal_describe_syntax_value,
 
   if (prefix)
     insert ("p", 1);
-  if (comstyle)
+  if (comstyleb)
     insert ("b", 1);
+  if (comstylec)
+    insert ("c", 1);
   if (comnested)
     insert ("n", 1);
 
@@ -1145,8 +1216,10 @@ DEFUN ("internal-describe-syntax-value", Finternal_describe_syntax_value,
     insert_string (",\n\t  is the first character of a comment-end sequence");
   if (end2)
     insert_string (",\n\t  is the second character of a comment-end sequence");
-  if (comstyle)
+  if (comstyleb)
     insert_string (" (comment style b)");
+  if (comstylec)
+    insert_string (" (comment style c)");
   if (comnested)
     insert_string (" (nestable)");
 
@@ -2060,7 +2133,7 @@ in_classes (int c, Lisp_Object iso_classes)
    FROM_BYTE is the bytepos corresponding to FROM.
    Do not move past STOP (a charpos).
    The comment over which we have to jump is of style STYLE
-     (either SYNTAX_COMMENT_STYLE(foo) or ST_COMMENT_STYLE).
+     (either SYNTAX_FLAGS_COMMENT_STYLE(foo) or ST_COMMENT_STYLE).
    NESTING should be positive to indicate the nesting at the beginning
      for nested comments and should be zero or negative else.
      ST_COMMENT_STYLE cannot be nested.
@@ -2087,7 +2160,7 @@ forw_comment (EMACS_INT from, EMACS_INT from_byte, EMACS_INT stop,
 {
   register int c, c1;
   register enum syntaxcode code;
-  register int syntax;
+  register int syntax, other_syntax;
 
   if (nesting <= 0) nesting = -1;
 
@@ -2109,7 +2182,7 @@ forw_comment (EMACS_INT from, EMACS_INT from_byte, EMACS_INT stop,
       syntax = SYNTAX_WITH_FLAGS (c);
       code = syntax & 0xff;
       if (code == Sendcomment
-          && SYNTAX_FLAGS_COMMENT_STYLE (syntax) == style
+          && SYNTAX_FLAGS_COMMENT_STYLE (syntax, 0) == style
           && (SYNTAX_FLAGS_COMMENT_NESTED (syntax) ?
               (nesting > 0 && --nesting == 0) : nesting < 0))
         /* we have encountered a comment end of the same style
@@ -2125,7 +2198,7 @@ forw_comment (EMACS_INT from, EMACS_INT from_byte, EMACS_INT stop,
       if (nesting > 0
           && code == Scomment
           && SYNTAX_FLAGS_COMMENT_NESTED (syntax)
-          && SYNTAX_FLAGS_COMMENT_STYLE (syntax) == style)
+          && SYNTAX_FLAGS_COMMENT_STYLE (syntax, 0) == style)
         /* we have encountered a nested comment of the same style
            as the comment sequence which began this comment section */
         nesting++;
@@ -2134,11 +2207,13 @@ forw_comment (EMACS_INT from, EMACS_INT from_byte, EMACS_INT stop,
 
     forw_incomment:
       if (from < stop && SYNTAX_FLAGS_COMEND_FIRST (syntax)
-          && SYNTAX_FLAGS_COMMENT_STYLE (syntax) == style
           && (c1 = FETCH_CHAR_AS_MULTIBYTE (from_byte),
-              SYNTAX_COMEND_SECOND (c1))
+              other_syntax = SYNTAX_WITH_FLAGS (c1),
+              SYNTAX_FLAGS_COMEND_SECOND (other_syntax))
+          && SYNTAX_FLAGS_COMMENT_STYLE (syntax, other_syntax) == style
           && ((SYNTAX_FLAGS_COMMENT_NESTED (syntax) ||
-               SYNTAX_COMMENT_NESTED (c1)) ? nesting > 0 : nesting < 0))
+               SYNTAX_FLAGS_COMMENT_NESTED (other_syntax))
+              ? nesting > 0 : nesting < 0))
         {
           if (--nesting <= 0)
             /* we have encountered a comment end of the same style
@@ -2155,10 +2230,11 @@ forw_comment (EMACS_INT from, EMACS_INT from_byte, EMACS_INT stop,
           && from < stop
           && SYNTAX_FLAGS_COMSTART_FIRST (syntax)
           && (c1 = FETCH_CHAR_AS_MULTIBYTE (from_byte),
-              SYNTAX_COMMENT_STYLE (c1) == style
-              && SYNTAX_COMSTART_SECOND (c1))
+              other_syntax = SYNTAX_WITH_FLAGS (c1),
+              SYNTAX_FLAGS_COMMENT_STYLE (other_syntax, syntax) == style
+              && SYNTAX_FLAGS_COMSTART_SECOND (other_syntax))
           && (SYNTAX_FLAGS_COMMENT_NESTED (syntax) ||
-              SYNTAX_COMMENT_NESTED (c1)))
+              SYNTAX_FLAGS_COMMENT_NESTED (other_syntax)))
         /* we have encountered a nested comment of the same style
            as the comment sequence which began this comment
            section */
@@ -2209,7 +2285,7 @@ between them, return t; otherwise return nil.  */)
     {
       do
         {
-          int comstart_first;
+          int comstart_first, syntax, other_syntax;
 
           if (from == stop)
             {
@@ -2218,15 +2294,17 @@ between them, return t; otherwise return nil.  */)
               return Qnil;
             }
           c = FETCH_CHAR_AS_MULTIBYTE (from_byte);
+          syntax = SYNTAX_WITH_FLAGS (c);
           code = SYNTAX (c);
-          comstart_first = SYNTAX_COMSTART_FIRST (c);
-          comnested = SYNTAX_COMMENT_NESTED (c);
-          comstyle = SYNTAX_COMMENT_STYLE (c);
+          comstart_first = SYNTAX_FLAGS_COMSTART_FIRST (syntax);
+          comnested = SYNTAX_FLAGS_COMMENT_NESTED (syntax);
+          comstyle = SYNTAX_FLAGS_COMMENT_STYLE (syntax, 0);
           INC_BOTH (from, from_byte);
           UPDATE_SYNTAX_TABLE_FORWARD (from);
           if (from < stop && comstart_first
               && (c1 = FETCH_CHAR_AS_MULTIBYTE (from_byte),
-                  SYNTAX_COMSTART_SECOND (c1)))
+                  other_syntax = SYNTAX_WITH_FLAGS (c1),
+                  SYNTAX_FLAGS_COMSTART_SECOND (other_syntax)))
             {
               /* We have encountered a comment start sequence and we
                  are ignoring all text inside comments.  We must record
@@ -2234,8 +2312,9 @@ between them, return t; otherwise return nil.  */)
                  only a comment end of the same style actually ends
                  the comment section.  */
               code = Scomment;
-              comstyle = SYNTAX_COMMENT_STYLE (c1);
-              comnested = comnested || SYNTAX_COMMENT_NESTED (c1);
+              comstyle = SYNTAX_FLAGS_COMMENT_STYLE (other_syntax, syntax);
+              comnested
+                = comnested || SYNTAX_FLAGS_COMMENT_NESTED (other_syntax);
               INC_BOTH (from, from_byte);
               UPDATE_SYNTAX_TABLE_FORWARD (from);
             }
@@ -2271,7 +2350,7 @@ between them, return t; otherwise return nil.  */)
     {
       while (1)
         {
-          int quoted;
+          int quoted, syntax;
 
           if (from <= stop)
             {
@@ -2284,15 +2363,17 @@ between them, return t; otherwise return nil.  */)
           /* char_quoted does UPDATE_SYNTAX_TABLE_BACKWARD (from).  */
           quoted = char_quoted (from, from_byte);
           c = FETCH_CHAR_AS_MULTIBYTE (from_byte);
+          syntax = SYNTAX_WITH_FLAGS (c);
           code = SYNTAX (c);
           comstyle = 0;
-          comnested = SYNTAX_COMMENT_NESTED (c);
+          comnested = SYNTAX_FLAGS_COMMENT_NESTED (syntax);
           if (code == Sendcomment)
-            comstyle = SYNTAX_COMMENT_STYLE (c);
-          if (from > stop && SYNTAX_COMEND_SECOND (c)
+            comstyle = SYNTAX_FLAGS_COMMENT_STYLE (syntax, 0);
+          if (from > stop && SYNTAX_FLAGS_COMEND_SECOND (syntax)
               && prev_char_comend_first (from, from_byte)
               && !char_quoted (from - 1, dec_bytepos (from_byte)))
             {
+              int other_syntax;
               /* We must record the comment style encountered so that
                  later, we can match only the proper comment begin
                  sequence of the same style.  */
@@ -2301,8 +2382,10 @@ between them, return t; otherwise return nil.  */)
               /* Calling char_quoted, above, set up global syntax position
                  at the new value of FROM.  */
               c1 = FETCH_CHAR_AS_MULTIBYTE (from_byte);
-              comstyle = SYNTAX_COMMENT_STYLE (c1);
-              comnested = comnested || SYNTAX_COMMENT_NESTED (c1);
+              other_syntax = SYNTAX_WITH_FLAGS (c1);
+              comstyle = SYNTAX_FLAGS_COMMENT_STYLE (other_syntax, syntax);
+              comnested
+                = comnested || SYNTAX_FLAGS_COMMENT_NESTED (other_syntax);
             }
 
           if (code == Scomment_fence)
@@ -2349,7 +2432,7 @@ between them, return t; otherwise return nil.  */)
                     {
                       /* Failure: we should go back to the end of this
                          not-quite-endcomment.  */
-                      if (SYNTAX(c) != code)
+                      if (SYNTAX (c) != code)
                         /* It was a two-char Sendcomment.  */
                         INC_BOTH (from, from_byte);
                       goto leave;
@@ -2423,21 +2506,23 @@ scan_lists (register EMACS_INT from, EMACS_INT count, EMACS_INT depth, int sexpf
     {
       while (from < stop)
         {
-          int comstart_first, prefix;
+          int comstart_first, prefix, syntax, other_syntax;
           UPDATE_SYNTAX_TABLE_FORWARD (from);
           c = FETCH_CHAR_AS_MULTIBYTE (from_byte);
+          syntax = SYNTAX_WITH_FLAGS (c);
           code = SYNTAX_WITH_MULTIBYTE_CHECK (c);
-          comstart_first = SYNTAX_COMSTART_FIRST (c);
-          comnested = SYNTAX_COMMENT_NESTED (c);
-          comstyle = SYNTAX_COMMENT_STYLE (c);
-          prefix = SYNTAX_PREFIX (c);
+          comstart_first = SYNTAX_FLAGS_COMSTART_FIRST (syntax);
+          comnested = SYNTAX_FLAGS_COMMENT_NESTED (syntax);
+          comstyle = SYNTAX_FLAGS_COMMENT_STYLE (syntax, 0);
+          prefix = SYNTAX_FLAGS_PREFIX (syntax);
           if (depth == min_depth)
             last_good = from;
           INC_BOTH (from, from_byte);
           UPDATE_SYNTAX_TABLE_FORWARD (from);
           if (from < stop && comstart_first
               && (c = FETCH_CHAR_AS_MULTIBYTE (from_byte),
-                  SYNTAX_COMSTART_SECOND (c))
+                  other_syntax = SYNTAX_WITH_FLAGS (c),
+                  SYNTAX_FLAGS_COMSTART_SECOND (other_syntax))
               && parse_sexp_ignore_comments)
             {
               /* we have encountered a comment start sequence and we
@@ -2446,9 +2531,9 @@ scan_lists (register EMACS_INT from, EMACS_INT count, EMACS_INT depth, int sexpf
                  only a comment end of the same style actually ends
                  the comment section */
               code = Scomment;
-              c1 = FETCH_CHAR_AS_MULTIBYTE (from_byte);
-              comstyle = SYNTAX_COMMENT_STYLE (c1);
-              comnested = comnested || SYNTAX_COMMENT_NESTED (c1);
+              comstyle = SYNTAX_FLAGS_COMMENT_STYLE (other_syntax, syntax);
+              comnested
+                = comnested || SYNTAX_FLAGS_COMMENT_NESTED (other_syntax);
               INC_BOTH (from, from_byte);
               UPDATE_SYNTAX_TABLE_FORWARD (from);
             }
@@ -2592,29 +2677,34 @@ scan_lists (register EMACS_INT from, EMACS_INT count, EMACS_INT depth, int sexpf
     {
       while (from > stop)
         {
+          int syntax;
           DEC_BOTH (from, from_byte);
           UPDATE_SYNTAX_TABLE_BACKWARD (from);
           c = FETCH_CHAR_AS_MULTIBYTE (from_byte);
+          syntax= SYNTAX_WITH_FLAGS (c);
           code = SYNTAX_WITH_MULTIBYTE_CHECK (c);
           if (depth == min_depth)
             last_good = from;
           comstyle = 0;
-          comnested = SYNTAX_COMMENT_NESTED (c);
+          comnested = SYNTAX_FLAGS_COMMENT_NESTED (syntax);
           if (code == Sendcomment)
-            comstyle = SYNTAX_COMMENT_STYLE (c);
-          if (from > stop && SYNTAX_COMEND_SECOND (c)
+            comstyle = SYNTAX_FLAGS_COMMENT_STYLE (syntax, 0);
+          if (from > stop && SYNTAX_FLAGS_COMEND_SECOND (syntax)
               && prev_char_comend_first (from, from_byte)
               && parse_sexp_ignore_comments)
             {
               /* We must record the comment style encountered so that
                  later, we can match only the proper comment begin
                  sequence of the same style.  */
+              int c1, other_syntax;
               DEC_BOTH (from, from_byte);
               UPDATE_SYNTAX_TABLE_BACKWARD (from);
               code = Sendcomment;
               c1 = FETCH_CHAR_AS_MULTIBYTE (from_byte);
-              comstyle = SYNTAX_COMMENT_STYLE (c1);
-              comnested = comnested || SYNTAX_COMMENT_NESTED (c1);
+              other_syntax = SYNTAX_WITH_FLAGS (c1);
+              comstyle = SYNTAX_FLAGS_COMMENT_STYLE (other_syntax, syntax);
+              comnested
+                = comnested || SYNTAX_FLAGS_COMMENT_NESTED (other_syntax);
             }
 
           /* Quoting turns anything except a comment-ender
@@ -2625,7 +2715,7 @@ scan_lists (register EMACS_INT from, EMACS_INT count, EMACS_INT depth, int sexpf
               DEC_BOTH (from, from_byte);
               code = Sword;
             }
-          else if (SYNTAX_PREFIX (c))
+          else if (SYNTAX_FLAGS_PREFIX (syntax))
             continue;
 
           switch (SWITCH_ENUM_CAST (code))
@@ -2949,8 +3039,11 @@ do { prev_from = from;				\
       oldstate = Fcdr (oldstate);
       oldstate = Fcdr (oldstate);
       tem = Fcar (oldstate);
-      state.comstyle = NILP (tem) ? 0 : (EQ (tem, Qsyntax_table)
-                                         ? ST_COMMENT_STYLE : 1);
+      state.comstyle = (NILP (tem)
+                        ? 0
+                        : (EQ (tem, Qsyntax_table)
+                           ? ST_COMMENT_STYLE
+                           : INTEGERP (tem) ? XINT (tem) : 1));
 
       oldstate = Fcdr (oldstate);
       tem = Fcar (oldstate);
@@ -2995,22 +3088,25 @@ do { prev_from = from;				\
 
   while (from < end)
     {
+      int syntax;
       INC_FROM;
       code = prev_from_syntax & 0xff;
 
       if (from < end
           && SYNTAX_FLAGS_COMSTART_FIRST (prev_from_syntax)
           && (c1 = FETCH_CHAR (from_byte),
-              SYNTAX_COMSTART_SECOND (c1)))
+              syntax = SYNTAX_WITH_FLAGS (c1),
+              SYNTAX_FLAGS_COMSTART_SECOND (syntax)))
         /* Duplicate code to avoid a complex if-expression
            which causes trouble for the SGI compiler.  */
         {
           /* Record the comment style we have entered so that only
              the comment-end sequence of the same style actually
              terminates the comment section.  */
-          state.comstyle = SYNTAX_COMMENT_STYLE (c1);
+          state.comstyle
+            = SYNTAX_FLAGS_COMMENT_STYLE (syntax, prev_from_syntax);
           comnested = SYNTAX_FLAGS_COMMENT_NESTED (prev_from_syntax);
-          comnested = comnested || SYNTAX_COMMENT_NESTED (c1);
+          comnested = comnested || SYNTAX_FLAGS_COMMENT_NESTED (syntax);
           state.incomment = comnested ? 1 : -1;
           state.comstr_start = prev_from;
           INC_FROM;
@@ -3028,7 +3124,7 @@ do { prev_from = from;				\
         }
       else if (code == Scomment)
         {
-          state.comstyle = SYNTAX_FLAGS_COMMENT_STYLE (prev_from_syntax);
+          state.comstyle = SYNTAX_FLAGS_COMMENT_STYLE (prev_from_syntax, 0);
           state.incomment = (SYNTAX_FLAGS_COMMENT_NESTED (prev_from_syntax) ?
                              1 : -1);
           state.comstr_start = prev_from;
@@ -3221,8 +3317,7 @@ Value is a list of elements describing final state of parsing:
     else an integer (the current comment nesting).
  5. t if following a quote character.
  6. the minimum paren-depth encountered during this scan.
- 7. t if in a comment of style b; symbol `syntax-table' if the comment
-    should be terminated by a generic comment delimiter.
+ 7. style of comment, if any.
  8. character address of start of comment or string; nil if not in one.
  9. Intermediate data for continuation of parsing (subject to change).
 If third arg TARGETDEPTH is non-nil, parsing stops if the depth
@@ -3258,8 +3353,10 @@ Sixth arg COMMENTSTOP non-nil means stop at the start of a comment.
   SET_PT (state.location);
 
   return Fcons (make_number (state.depth),
-           Fcons (state.prevlevelstart < 0 ? Qnil : make_number (state.prevlevelstart),
-             Fcons (state.thislevelstart < 0 ? Qnil : make_number (state.thislevelstart),
+           Fcons (state.prevlevelstart < 0
+                  ? Qnil : make_number (state.prevlevelstart),
+             Fcons (state.thislevelstart < 0
+                    ? Qnil : make_number (state.thislevelstart),
                Fcons (state.instring >= 0
                       ? (state.instring == ST_STRING_STYLE
                          ? Qt : make_number (state.instring)) : Qnil,
@@ -3270,8 +3367,9 @@ Sixth arg COMMENTSTOP non-nil means stop at the start of a comment.
                      Fcons (make_number (state.mindepth),
                        Fcons ((state.comstyle
                                ? (state.comstyle == ST_COMMENT_STYLE
-                                  ? Qsyntax_table : Qt) :
-                               Qnil),
+                                  ? Qsyntax_table
+                                  : make_number (state.comstyle))
+                               : Qnil),
                               Fcons (((state.incomment
                                        || (state.instring >= 0))
                                       ? make_number (state.comstr_start)
diff --git a/src/syntax.h b/src/syntax.h
index 9eaf553f2e5..48146572d19 100644
--- a/src/syntax.h
+++ b/src/syntax.h
@@ -128,56 +128,9 @@ extern Lisp_Object syntax_temp;
     : Qnil))
 #endif
 
-/* Then there are seven single-bit flags that have the following meanings:
-  1. This character is the first of a two-character comment-start sequence.
-  2. This character is the second of a two-character comment-start sequence.
-  3. This character is the first of a two-character comment-end sequence.
-  4. This character is the second of a two-character comment-end sequence.
-  5. This character is a prefix, for backward-prefix-chars.
-  6. see below
-  7. This character is part of a nestable comment sequence.
-  Note that any two-character sequence whose first character has flag 1
-  and whose second character has flag 2 will be interpreted as a comment start.
 
-  bit 6 is used to discriminate between two different comment styles.
-  Languages such as C++ allow two orthogonal syntax start/end pairs
-  and bit 6 is used to determine whether a comment-end or Scommentend
-  ends style a or b.  Comment start sequences can start style a or b.
-  Style a is always the default.
-  */
-
-/* These macros extract a particular flag for a given character.  */
-
-#define SYNTAX_COMSTART_FIRST(c) ((SYNTAX_WITH_FLAGS (c) >> 16) & 1)
-
-#define SYNTAX_COMSTART_SECOND(c) ((SYNTAX_WITH_FLAGS (c) >> 17) & 1)
-
-#define SYNTAX_COMEND_FIRST(c) ((SYNTAX_WITH_FLAGS (c) >> 18) & 1)
-
-#define SYNTAX_COMEND_SECOND(c) ((SYNTAX_WITH_FLAGS (c) >> 19) & 1)
-
-#define SYNTAX_PREFIX(c) ((SYNTAX_WITH_FLAGS (c) >> 20) & 1)
-
-#define SYNTAX_COMMENT_STYLE(c) ((SYNTAX_WITH_FLAGS (c) >> 21) & 1)
-
-#define SYNTAX_COMMENT_NESTED(c) ((SYNTAX_WITH_FLAGS (c) >> 22) & 1)
-
-/* These macros extract specific flags from an integer
-   that holds the syntax code and the flags.  */
-
-#define SYNTAX_FLAGS_COMSTART_FIRST(flags) (((flags) >> 16) & 1)
-
-#define SYNTAX_FLAGS_COMSTART_SECOND(flags) (((flags) >> 17) & 1)
-
-#define SYNTAX_FLAGS_COMEND_FIRST(flags) (((flags) >> 18) & 1)
-
-#define SYNTAX_FLAGS_COMEND_SECOND(flags) (((flags) >> 19) & 1)
-
-#define SYNTAX_FLAGS_PREFIX(flags) (((flags) >> 20) & 1)
-
-#define SYNTAX_FLAGS_COMMENT_STYLE(flags) (((flags) >> 21) & 1)
-
-#define SYNTAX_FLAGS_COMMENT_NESTED(flags) (((flags) >> 22) & 1)
+/* Whether the syntax of the character C has the prefix flag set.  */
+extern int syntax_prefix_flag_p (int c);
 
 /* This array, indexed by a character, contains the syntax code which that
  character signifies (as a char).  For example,
diff --git a/src/sysdep.c b/src/sysdep.c
index 2ae3c509522..e7d35d46bf7 100644
--- a/src/sysdep.c
+++ b/src/sysdep.c
@@ -35,15 +35,7 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #endif
 
 #include "lisp.h"
-/* Including stdlib.h isn't necessarily enough to get srandom
-   declared, e.g. without __USE_XOPEN_EXTENDED with glibc 2.  */
-
-/* The w32 build defines select stuff in w32.h, which is included by
-   sys/select.h (included below).   */
-#ifndef WINDOWSNT
 #include "sysselect.h"
-#endif
-
 #include "blockinput.h"
 
 #ifdef WINDOWSNT
@@ -84,17 +76,13 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include <fcntl.h>
 #endif
 
-#ifndef MSDOS
-#include <sys/ioctl.h>
-#endif
-
 #include "systty.h"
 #include "syswait.h"
 
-#if defined (USG)
+#ifdef HAVE_SYS_UTSNAME_H
 #include <sys/utsname.h>
 #include <memory.h>
-#endif /* USG */
+#endif /* HAVE_SYS_UTSNAME_H */
 
 #include "keyboard.h"
 #include "frame.h"
@@ -149,17 +137,6 @@ static const int baud_convert[] =
     1800, 2400, 4800, 9600, 19200, 38400
   };
 
-#ifdef HAVE_SPEED_T
-#include <termios.h>
-#else
-#if defined (HAVE_LIBNCURSES) && ! defined (NCURSES_OSPEED_T)
-#else
-#if defined (HAVE_TERMIOS_H) && defined (GNU_LINUX)
-#include <termios.h>
-#endif
-#endif
-#endif
-
 int emacs_ospeed;
 
 void croak (char *) NO_RETURN;
@@ -308,32 +285,11 @@ init_baud_rate (int fd)
 #ifdef DOS_NT
     emacs_ospeed = 15;
 #else  /* not DOS_NT */
-#ifdef HAVE_TERMIOS
       struct termios sg;
 
       sg.c_cflag = B9600;
       tcgetattr (fd, &sg);
       emacs_ospeed = cfgetospeed (&sg);
-#else /* not TERMIOS */
-#ifdef HAVE_TERMIO
-      struct termio sg;
-
-      sg.c_cflag = B9600;
-#ifdef HAVE_TCATTR
-      tcgetattr (fd, &sg);
-#else
-      ioctl (fd, TCGETA, &sg);
-#endif
-      emacs_ospeed = sg.c_cflag & CBAUD;
-#else /* neither TERMIOS nor TERMIO */
-      struct sgttyb sg;
-
-      sg.sg_ospeed = B9600;
-      if (ioctl (fd, TIOCGETP, &sg) < 0)
-        abort ();
-      emacs_ospeed = sg.sg_ospeed;
-#endif /* not HAVE_TERMIO */
-#endif /* not HAVE_TERMIOS */
 #endif /* not DOS_NT */
     }
 
@@ -417,7 +373,7 @@ wait_for_termination (int pid)
 void
 flush_pending_output (int channel)
 {
-#ifdef HAVE_TERMIOS
+#ifndef DOS_NT
   /* If we try this, we get hit with SIGTTIN, because
      the child's tty belongs to the child's pgrp. */
 #else
@@ -447,8 +403,6 @@ child_setup_tty (int out)
   struct emacs_tty s;
 
   EMACS_GET_TTY (out, &s);
-
-#if defined (HAVE_TERMIO) || defined (HAVE_TERMIOS)
   s.main.c_oflag |= OPOST;      /* Enable output postprocessing */
   s.main.c_oflag &= ~ONLCR;     /* Disable map of NL to CR-NL on output */
 #ifdef NLDLY
@@ -526,19 +480,7 @@ child_setup_tty (int out)
   s.main.c_cc[VTIME] = 0;
 #endif
 
-#else /* not HAVE_TERMIO */
-
-  s.main.sg_flags &= ~(ECHO | CRMOD | ANYP | ALLDELAY | RAW | LCASE
-                       | CBREAK | TANDEM);
-  s.main.sg_flags |= LPASS8;
-  s.main.sg_erase = 0377;
-  s.main.sg_kill = 0377;
-  s.lmode = LLITOUT | s.lmode;        /* Don't strip 8th bit */
-
-#endif /* not HAVE_TERMIO */
-
   EMACS_SET_TTY (out, &s, 0);
-
 #endif /* not WINDOWSNT */
 }
 #endif  /* MSDOS */
@@ -841,38 +783,11 @@ int
 emacs_get_tty (int fd, struct emacs_tty *settings)
 {
   /* Retrieve the primary parameters - baud rate, character size, etcetera.  */
-#ifdef HAVE_TCATTR
+#ifndef DOS_NT
   /* We have those nifty POSIX tcmumbleattr functions.  */
   memset (&settings->main, 0, sizeof (settings->main));
   if (tcgetattr (fd, &settings->main) < 0)
     return -1;
-
-#else
-#ifdef HAVE_TERMIO
-  /* The SYSV-style interface?  */
-  if (ioctl (fd, TCGETA, &settings->main) < 0)
-    return -1;
-
-#else
-#ifndef DOS_NT
-  /* I give up - I hope you have the BSD ioctls.  */
-  if (ioctl (fd, TIOCGETP, &settings->main) < 0)
-    return -1;
-#endif /* not DOS_NT */
-#endif
-#endif
-
-  /* Suivant - Do we have to get struct ltchars data?  */
-#ifdef HAVE_LTCHARS
-  if (ioctl (fd, TIOCGLTC, &settings->ltchars) < 0)
-    return -1;
-#endif
-
-  /* How about a struct tchars and a wordful of lmode bits?  */
-#ifdef HAVE_TCHARS
-  if (ioctl (fd, TIOCGETC, &settings->tchars) < 0
-      || ioctl (fd, TIOCLGET, &settings->lmode) < 0)
-    return -1;
 #endif
 
   /* We have survived the tempest.  */
@@ -888,7 +803,7 @@ int
 emacs_set_tty (int fd, struct emacs_tty *settings, int flushp)
 {
   /* Set the primary parameters - baud rate, character size, etcetera.  */
-#ifdef HAVE_TCATTR
+#ifndef DOS_NT
   int i;
   /* We have those nifty POSIX tcmumbleattr functions.
      William J. Smith <wjs@wiis.wang.com> writes:
@@ -926,34 +841,6 @@ emacs_set_tty (int fd, struct emacs_tty *settings, int flushp)
         else
           continue;
       }
-
-#else
-#ifdef HAVE_TERMIO
-  /* The SYSV-style interface?  */
-  if (ioctl (fd, flushp ? TCSETAF : TCSETAW, &settings->main) < 0)
-    return -1;
-
-#else
-#ifndef DOS_NT
-  /* I give up - I hope you have the BSD ioctls.  */
-  if (ioctl (fd, (flushp) ? TIOCSETP : TIOCSETN, &settings->main) < 0)
-    return -1;
-#endif /* not DOS_NT */
-
-#endif
-#endif
-
-  /* Suivant - Do we have to get struct ltchars data?  */
-#ifdef HAVE_LTCHARS
-  if (ioctl (fd, TIOCSLTC, &settings->ltchars) < 0)
-    return -1;
-#endif
-
-  /* How about a struct tchars and a wordful of lmode bits?  */
-#ifdef HAVE_TCHARS
-  if (ioctl (fd, TIOCSETC, &settings->tchars) < 0
-      || ioctl (fd, TIOCLSET, &settings->lmode) < 0)
-    return -1;
 #endif
 
   /* We have survived the tempest.  */
@@ -976,13 +863,6 @@ unsigned char _sobuf[BUFSIZ+8];
 char _sobuf[BUFSIZ];
 #endif
 
-#ifdef HAVE_LTCHARS
-static struct ltchars new_ltchars = {-1,-1,-1,-1,-1,-1};
-#endif
-#ifdef HAVE_TCHARS
-static struct tchars new_tchars = {-1,-1,-1,-1,-1,-1};
-#endif
-
 /* Initialize the terminal mode on all tty devices that are currently
    open. */
 
@@ -1016,7 +896,7 @@ init_sys_modes (struct tty_display_info *tty_out)
 
   tty = *tty_out->old_tty;
 
-#if defined (HAVE_TERMIO) || defined (HAVE_TERMIOS)
+#if !defined (DOS_NT)
   XSETINT (Vtty_erase_char, tty.main.c_cc[VERASE]);
 
   tty.main.c_iflag |= (IGNBRK); /* Ignore break condition */
@@ -1088,12 +968,11 @@ init_sys_modes (struct tty_display_info *tty_out)
                                            of C-z */
 #endif /* VSWTCH */
 
-#if defined (__mips__) || defined (HAVE_TCATTR)
 #ifdef VSUSP
-  tty.main.c_cc[VSUSP] = CDISABLE;      /* Turn off mips handling of C-z.  */
+  tty.main.c_cc[VSUSP] = CDISABLE;      /* Turn off handling of C-z.  */
 #endif /* VSUSP */
 #ifdef V_DSUSP
-  tty.main.c_cc[V_DSUSP] = CDISABLE; /* Turn off mips handling of C-y.  */
+  tty.main.c_cc[V_DSUSP] = CDISABLE; /* Turn off handling of C-y.  */
 #endif /* V_DSUSP */
 #ifdef VDSUSP /* Some systems have VDSUSP, some have V_DSUSP.  */
   tty.main.c_cc[VDSUSP] = CDISABLE;
@@ -1129,7 +1008,6 @@ init_sys_modes (struct tty_display_info *tty_out)
       tty.main.c_cc[VSTOP] = CDISABLE;
 #endif /* VSTOP */
     }
-#endif /* mips or HAVE_TCATTR */
 
 #ifdef AIX
   tty.main.c_cc[VSTRT] = CDISABLE;
@@ -1152,41 +1030,8 @@ init_sys_modes (struct tty_display_info *tty_out)
   tty.main.c_iflag &= ~IGNBRK;
   tty.main.c_iflag &= ~BRKINT;
 #endif
-#else /* if not HAVE_TERMIO */
-#ifndef DOS_NT
-  XSETINT (Vtty_erase_char, tty.main.sg_erase);
-  tty.main.sg_flags &= ~(ECHO | CRMOD | XTABS);
-  if (meta_key)
-    tty.main.sg_flags |= ANYP;
-  tty.main.sg_flags |= interrupt_input ? RAW : CBREAK;
 #endif /* not DOS_NT */
-#endif /* not HAVE_TERMIO */
-
-  /* If going to use CBREAK mode, we must request C-g to interrupt
-     and turn off start and stop chars, etc.  If not going to use
-     CBREAK mode, do this anyway so as to turn off local flow
-     control for user coming over network on 4.2; in this case,
-     only t_stopc and t_startc really matter.  */
-#ifndef HAVE_TERMIO
-#ifdef HAVE_TCHARS
-  /* Note: if not using CBREAK mode, it makes no difference how we
-     set this */
-  tty.tchars = new_tchars;
-  tty.tchars.t_intrc = quit_char;
-  if (tty_out->flow_control)
-    {
-      tty.tchars.t_startc = '\021';
-      tty.tchars.t_stopc = '\023';
-    }
 
-  tty.lmode = LDECCTQ | LLITOUT | LPASS8 | LNOFLSH | tty_out->old_tty.lmode;
-
-#endif /* HAVE_TCHARS */
-#endif /* not HAVE_TERMIO */
-
-#ifdef HAVE_LTCHARS
-  tty.ltchars = new_ltchars;
-#endif /* HAVE_LTCHARS */
 #ifdef MSDOS    /* Demacs 1.1.2 91/10/20 Manabu Higashida, MW Aug 1993 */
   if (!tty_out->term_initted)
     internal_terminal_init ();
@@ -1205,7 +1050,7 @@ init_sys_modes (struct tty_display_info *tty_out)
   if (!tty_out->flow_control) ioctl (fileno (tty_out->input), TIOCSTART, 0);
 #endif
 
-#if defined (HAVE_TERMIOS) || defined (HPUX)
+#if !defined (DOS_NT)
 #ifdef TCOON
   if (!tty_out->flow_control) tcflow (fileno (tty_out->input), TCOON);
 #endif
@@ -2688,7 +2533,7 @@ strsignal (int code)
 }
 #endif /* HAVE_STRSIGNAL */
 
-#ifdef HAVE_TERMIOS
+#ifndef DOS_NT
 /* For make-serial-process  */
 int
 serial_open (char *port)
@@ -2717,9 +2562,6 @@ serial_open (char *port)
 
   return fd;
 }
-#endif /* TERMIOS  */
-
-#ifdef HAVE_TERMIOS
 
 #if !defined (HAVE_CFMAKERAW)
 /* Workaround for targets which are missing cfmakeraw.  */
@@ -2906,7 +2748,7 @@ serial_configure (struct Lisp_Process *p,
   p->childp = childp2;
 
 }
-#endif /* TERMIOS  */
+#endif /* not DOS_NT  */
 
 /* System depended enumeration of and access to system processes a-la ps(1).  */
 
diff --git a/src/sysselect.h b/src/sysselect.h
index ddb3e91f2e3..0c90814390c 100644
--- a/src/sysselect.h
+++ b/src/sysselect.h
@@ -27,6 +27,10 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #endif
 #endif
 
+/* The w32 build defines select stuff in w32.h, which is included
+   where w32 needs it, but not where sysselect.h is included.  The w32
+   definitions in w32.h are incompatible with the below.  */
+#ifndef WINDOWSNT
 #ifdef FD_SET
 #ifdef FD_SETSIZE
 #define MAXDESC FD_SETSIZE
@@ -44,6 +48,7 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #define FD_ISSET(n, p) (*(p) & (1 << (n)))
 #define FD_ZERO(p) (*(p) = 0)
 #endif /* no FD_SET */
+#endif /* not WINDOWSNT */
 
 #if !defined (HAVE_SELECT)
 #define select sys_select
diff --git a/src/systty.h b/src/systty.h
index 39feef9c3d0..8c46411cedb 100644
--- a/src/systty.h
+++ b/src/systty.h
@@ -17,34 +17,17 @@ 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/>.  */
 
-#ifdef HAVE_TERMIOS
-#define HAVE_TCATTR
-#endif
-
-
 /* Include the proper files.  */
-#ifdef HAVE_TERMIO
+#ifndef DOS_NT
 #ifndef NO_TERMIO
 #include <termio.h>
 #endif /* not NO_TERMIO */
-#include <fcntl.h>
-#else /* not HAVE_TERMIO */
-#ifdef HAVE_TERMIOS
-#ifndef NO_TERMIO
-#include <termio.h>
-#endif
 #include <termios.h>
 #include <fcntl.h>
-#else /* neither HAVE_TERMIO nor HAVE_TERMIOS */
-#ifndef DOS_NT
-#include <sgtty.h>
 #endif /* not DOS_NT */
-#endif /* not HAVE_TERMIOS */
-#endif /* not HAVE_TERMIO */
 
-#ifdef __GNU_LIBRARY__
+#ifdef HAVE_SYS_IOCTL_H
 #include <sys/ioctl.h>
-#include <termios.h>
 #endif
 
 #ifdef HPUX
@@ -74,17 +57,6 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #undef SIGIO
 #endif
 
-/* On TERMIOS systems, the tcmumbleattr calls take care of these
-   parameters, and it's a bad idea to use them (on AIX, it makes the
-   tty hang for a long time).  */
-#if defined (TIOCGLTC) && !defined (HAVE_TERMIOS)
-#define HAVE_LTCHARS
-#endif
-
-#if defined (TIOCGETC) && !defined (HAVE_TERMIOS)
-#define HAVE_TCHARS
-#endif
-
 
 /* Try to establish the correct character to disable terminal functions
    in a system-independent manner.  Note that USG (at least) define
@@ -111,60 +83,19 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #define EMACS_OUTQSIZE(fd, size) (ioctl ((fd), TIOCOUTQ, (size)))
 #endif
 
-#ifdef HAVE_TERMIO
-#ifdef TCOUTQ
-#undef EMACS_OUTQSIZE
-#define EMACS_OUTQSIZE(fd, size) (ioctl ((fd), TCOUTQ, (size)))
-#endif
-#endif
-
 
 /* Manipulate a terminal's current process group.  */
 
-/* EMACS_HAVE_TTY_PGRP is true if we can get and set the tty's current
-   controlling process group.
-
-   EMACS_GET_TTY_PGRP(int FD, int *PGID) sets *PGID the terminal FD's
+/* EMACS_GET_TTY_PGRP(int FD, int *PGID) sets *PGID the terminal FD's
    current process group.  Return -1 if there is an error.
 
    EMACS_SET_TTY_PGRP(int FD, int *PGID) sets the terminal FD's
    current process group to *PGID.  Return -1 if there is an error.  */
 
-/* HPUX tty process group stuff doesn't work, says the anonymous voice
-   from the past.  */
-#ifndef HPUX
-#ifdef TIOCGPGRP
-#define EMACS_HAVE_TTY_PGRP
-#else
-#ifdef HAVE_TERMIOS
-#define EMACS_HAVE_TTY_PGRP
-#endif /* HAVE_TERMIOS */
-#endif /* TIOCGPGRP */
-#endif /* not HPUX */
-
-#ifdef EMACS_HAVE_TTY_PGRP
-
-#if defined (HAVE_TERMIOS)
-
+#ifndef DOS_NT
 #define EMACS_GET_TTY_PGRP(fd, pgid) (*(pgid) = tcgetpgrp ((fd)))
 #define EMACS_SET_TTY_PGRP(fd, pgid) (tcsetpgrp ((fd), *(pgid)))
-
-#else /* not HAVE_TERMIOS */
-#ifdef TIOCSPGRP
-
-#define EMACS_GET_TTY_PGRP(fd, pgid) (ioctl ((fd), TIOCGPGRP, (pgid)))
-#define EMACS_SET_TTY_PGRP(fd, pgid) (ioctl ((fd), TIOCSPGRP, (pgid)))
-
-#endif /* TIOCSPGRP */
-#endif /* HAVE_TERMIOS */
-
-#else /* not EMACS_SET_TTY_PGRP */
-
-/* Just ignore this for now and hope for the best */
-#define EMACS_GET_TTY_PGRP(fd, pgid) 0
-#define EMACS_SET_TTY_PGRP(fd, pgif) 0
-
-#endif /* not EMACS_SET_TTY_PGRP */
+#endif /* not DOS_NT */
 
 /* EMACS_GETPGRP (arg) returns the process group of the process.  */
 
@@ -207,32 +138,11 @@ struct emacs_tty {
 
 /* There is always one of the following elements, so there is no need
    for dummy get and set definitions.  */
-#ifdef HAVE_TCATTR
+#ifndef DOS_NT
   struct termios main;
-#else /* not HAVE_TCATTR */
-#ifdef HAVE_TERMIO
-  struct termio main;
-#else /* not HAVE_TERMIO */
-#ifdef DOS_NT
+#else /* DOS_NT */
   int main;
-#else  /* not DOS_NT */
-  struct sgttyb main;
-#endif /* not DOS_NT */
-#endif /* not HAVE_TERMIO */
-#endif /* not HAVE_TCATTR */
-
-/* If we have TERMIOS, we don't need to do this - they're taken care of
-   by the tc*attr calls.  */
-#ifndef HAVE_TERMIOS
-#ifdef HAVE_LTCHARS
-  struct ltchars ltchars;
-#endif /* HAVE_LTCHARS */
-
-#ifdef HAVE_TCHARS
-  struct tchars tchars;
-  int lmode;
-#endif /* HAVE_TCHARS */
-#endif /* not defined HAVE_TERMIOS */
+#endif /* DOS_NT */
 };
 
 /* Define EMACS_GET_TTY and EMACS_SET_TTY,
@@ -249,7 +159,7 @@ extern int emacs_set_tty (int, struct emacs_tty *, int);
 
 /* Define EMACS_TTY_TABS_OK.  */
 
-#ifdef HAVE_TERMIOS
+#ifndef DOS_NT
 
 #ifdef TABDLY
 #define EMACS_TTY_TABS_OK(p) (((p)->main.c_oflag & TABDLY) != TAB3)
@@ -257,21 +167,9 @@ extern int emacs_set_tty (int, struct emacs_tty *, int);
 #define EMACS_TTY_TABS_OK(p) 1
 #endif /* not TABDLY */
 
-#else /* not def HAVE_TERMIOS */
-#ifdef HAVE_TERMIO
-
-#define EMACS_TTY_TABS_OK(p) (((p)->main.c_oflag & TABDLY) != TAB3)
-
-#else /* neither HAVE_TERMIO nor HAVE_TERMIOS */
-
-#ifdef DOS_NT
+#else /* DOS_NT */
 #define EMACS_TTY_TABS_OK(p) 0
-#else /* not DOS_NT */
-#define EMACS_TTY_TABS_OK(p) (((p)->main.sg_flags & XTABS) != XTABS)
-#endif /* not DOS_NT */
-
-#endif /* not def HAVE_TERMIO */
-#endif /* not def HAVE_TERMIOS */
+#endif /* DOS_NT */
 
 /* arch-tag: cf4b90bc-be41-401c-be98-40619178a712
    (do not change this comment) */
diff --git a/src/term.c b/src/term.c
index 4f326234956..f090cdd2792 100644
--- a/src/term.c
+++ b/src/term.c
@@ -31,9 +31,6 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include <unistd.h>
 #endif
 
-#if HAVE_TERMIOS_H
-#include <termios.h>            /* For TIOCNOTTY. */
-#endif
 #ifdef HAVE_SYS_IOCTL_H
 #include <sys/ioctl.h>
 #endif
@@ -692,7 +689,8 @@ encode_terminal_code (struct glyph *src, int src_len, struct coding_system *codi
                                                   encode_terminal_src_size);
                   buf = encode_terminal_src + nbytes;
                 }
-              if (char_charset (c, charset_list, NULL))
+              if (CHAR_BYTE8_P (c)
+                  || char_charset (c, charset_list, NULL))
                 {
                   /* Store the multibyte form of C at BUF.  */
                   buf += CHAR_STRING (c, buf);
@@ -1617,18 +1615,15 @@ produce_glyphs (struct it *it)
       goto done;
     }
 
-  /* Maybe translate single-byte characters to multibyte.  */
-  it->char_to_display = it->c;
-
-  if (it->c >= 040 && it->c < 0177)
+  if (it->char_to_display >= 040 && it->char_to_display < 0177)
     {
       it->pixel_width = it->nglyphs = 1;
       if (it->glyph_row)
         append_glyph (it);
     }
-  else if (it->c == '\n')
+  else if (it->char_to_display == '\n')
     it->pixel_width = it->nglyphs = 0;
-  else if (it->c == '\t')
+  else if (it->char_to_display == '\t')
     {
       int absolute_x = (it->current_x
                         + it->continuation_lines_width);
@@ -1659,32 +1654,19 @@ produce_glyphs (struct it *it)
       it->pixel_width = nspaces;
       it->nglyphs = nspaces;
     }
-  else if (CHAR_BYTE8_P (it->c))
+  else if (CHAR_BYTE8_P (it->char_to_display))
     {
-      if (unibyte_display_via_language_environment
-          && (it->c >= 0240))
-        {
-          it->char_to_display = BYTE8_TO_CHAR (it->c);
-          it->pixel_width = CHAR_WIDTH (it->char_to_display);
-          it->nglyphs = it->pixel_width;
-          if (it->glyph_row)
-            append_glyph (it);
-        }
-      else
-        {
-          /* Coming here means that it->c is from display table, thus
-             we must send the raw 8-bit byte as is to the terminal.
-             Although there's no way to know how many columns it
-             occupies on a screen, it is a good assumption that a
-             single byte code has 1-column width.  */
-          it->pixel_width = it->nglyphs = 1;
-          if (it->glyph_row)
-            append_glyph (it);
-        }
+      /* Coming here means that we must send the raw 8-bit byte as is
+         to the terminal.  Although there's no way to know how many
+         columns it occupies on a screen, it is a good assumption that
+         a single byte code has 1-column width.  */
+      it->pixel_width = it->nglyphs = 1;
+      if (it->glyph_row)
+        append_glyph (it);
     }
   else
     {
-      it->pixel_width = CHAR_WIDTH (it->c);
+      it->pixel_width = CHAR_WIDTH (it->char_to_display);
       it->nglyphs = it->pixel_width;
 
       if (it->glyph_row)
@@ -1920,7 +1902,7 @@ produce_special_glyphs (struct it *it, enum display_element_type what)
   else
     abort ();
 
-  temp_it.c = GLYPH_CHAR (glyph);
+  temp_it.c = temp_it.char_to_display = GLYPH_CHAR (glyph);
   temp_it.face_id = GLYPH_FACE (glyph);
   temp_it.len = CHAR_BYTES (temp_it.c);
 
diff --git a/src/unexcoff.c b/src/unexcoff.c
index ed319ec8e7f..cb4b8d603b5 100644
--- a/src/unexcoff.c
+++ b/src/unexcoff.c
@@ -74,12 +74,8 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
  * of Dell Computer Corporation.  james@bigtex.cactus.org.
  */
 
-#ifndef emacs
-#define PERROR(arg) perror (arg); return -1
-#else
 #include <config.h>
 #define PERROR(file) report_error (file, new)
-#endif
 
 #ifndef CANNOT_DUMP  /* all rest of file!  */
 
@@ -88,6 +84,7 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #ifdef MSDOS
 #include <fcntl.h>  /* for O_RDONLY, O_RDWR */
 #include <crt0.h>   /* for _crt0_startup_flags and its bits */
+#include <sys/exceptn.h>
 static int save_djgpp_startup_flags;
 #define filehdr external_filehdr
 #define scnhdr external_scnhdr
@@ -132,8 +129,7 @@ struct aouthdr
 #endif
 
 
-extern char *start_of_text ();          /* Start of text */
-extern char *start_of_data ();          /* Start of initialized data */
+extern char *start_of_data (void);              /* Start of initialized data */
 
 static long block_copy_start;           /* Old executable start point */
 static struct filehdr f_hdr;            /* File header */
@@ -155,45 +151,33 @@ static int pagemask;
 
 #define ADDR_CORRECT(x) ((char *)(x) - (char*)0)
 
-#ifdef emacs
-
 #include <setjmp.h>
 #include "lisp.h"
 
-static
-report_error (file, fd)
-     char *file;
-     int fd;
+static void
+report_error (const char *file, int fd)
 {
   if (fd)
     close (fd);
   report_file_error ("Cannot unexec", Fcons (build_string (file), Qnil));
 }
-#endif /* emacs */
 
 #define ERROR0(msg) report_error_1 (new, msg, 0, 0); return -1
 #define ERROR1(msg,x) report_error_1 (new, msg, x, 0); return -1
 #define ERROR2(msg,x,y) report_error_1 (new, msg, x, y); return -1
 
-static
-report_error_1 (fd, msg, a1, a2)
-     int fd;
-     char *msg;
-     int a1, a2;
+static void
+report_error_1 (int fd, const char *msg, int a1, int a2)
 {
   close (fd);
-#ifdef emacs
   error (msg, a1, a2);
-#else
-  fprintf (stderr, msg, a1, a2);
-  fprintf (stderr, "\n");
-#endif
 }
 
-static int make_hdr ();
-static int copy_text_and_data ();
-static int copy_sym ();
-static void mark_x ();
+static int make_hdr (int, int, unsigned, unsigned, unsigned,
+                     const char *, const char *);
+static int copy_text_and_data (int, int);
+static int copy_sym (int, int, const char *, const char *);
+static void mark_x (const char *);
 
 /* ****************************************************************
  * make_hdr
@@ -202,13 +186,9 @@ static void mark_x ();
  * Modify the text and data sizes.
  */
 static int
-make_hdr (new, a_out, data_start, bss_start, entry_address, a_name, new_name)
-     int new, a_out;
-     unsigned data_start, bss_start, entry_address;
-     char *a_name;
-     char *new_name;
+make_hdr (int new, int a_out, unsigned data_start, unsigned bss_start,
+          unsigned entry_address, const char *a_name, const char *new_name)
 {
-  int tem;
   auto struct scnhdr f_thdr;            /* Text section header */
   auto struct scnhdr f_dhdr;            /* Data section header */
   auto struct scnhdr f_bhdr;            /* Bss section header */
@@ -319,9 +299,6 @@ make_hdr (new, a_out, data_start, bss_start, entry_address, a_name, new_name)
      to correspond to what we want to dump.  */
 
   f_hdr.f_flags |= (F_RELFLG | F_EXEC);
-  f_ohdr.text_start = (long) start_of_text ();
-  f_ohdr.tsize = data_start - f_ohdr.text_start;
-  f_ohdr.data_start = data_start;
   f_ohdr.dsize = bss_start - f_ohdr.data_start;
   f_ohdr.bsize = bss_end - bss_start;
   f_thdr.s_size = f_ohdr.tsize;
@@ -379,12 +356,10 @@ make_hdr (new, a_out, data_start, bss_start, entry_address, a_name, new_name)
 
 }
 
-write_segment (new, ptr, end)
-     int new;
-     register char *ptr, *end;
+void
+write_segment (int new, const char *ptr, const char *end)
 {
   register int i, nwrite, ret;
-  char buf[80];
   /* This is the normal amount to write at once.
      It is the size of block that NFS uses.  */
   int writesize = 1 << 13;
@@ -417,16 +392,6 @@ write_segment (new, ptr, end)
             nwrite = pagesize;
           write (new, zeros, nwrite);
         }
-#if 0 /* Now that we have can ask `write' to write more than a page,
-         it is legit for write do less than the whole amount specified.  */
-      else if (nwrite != ret)
-        {
-          sprintf (buf,
-                   "unexec write failure: addr 0x%x, fileno %d, size 0x%x, wrote 0x%x, errno %d",
-                   ptr, new, nwrite, ret, errno);
-          PERROR (buf);
-        }
-#endif
       i += nwrite;
       ptr += nwrite;
     }
@@ -437,8 +402,7 @@ write_segment (new, ptr, end)
  * Copy the text and data segments from memory to the new a.out
  */
 static int
-copy_text_and_data (new, a_out)
-     int new, a_out;
+copy_text_and_data (int new, int a_out)
 {
   register char *end;
   register char *ptr;
@@ -482,9 +446,7 @@ copy_text_and_data (new, a_out)
  * Copy the relocation information and symbol table from the a.out to the new
  */
 static int
-copy_sym (new, a_out, a_name, new_name)
-     int new, a_out;
-     char *a_name, *new_name;
+copy_sym (int new, int a_out, const char *a_name, const char *new_name)
 {
   char page[1024];
   int n;
@@ -520,8 +482,7 @@ copy_sym (new, a_out, a_name, new_name)
  * After successfully building the new a.out, mark it executable
  */
 static void
-mark_x (name)
-     char *name;
+mark_x (const char *name)
 {
   struct stat sbuf;
   int um;
@@ -561,10 +522,8 @@ mark_x (name)
    a reasonable size buffer.  But I don't have time to work on such
    things, so I am installing it as submitted to me.  -- RMS.  */
 
-adjust_lnnoptrs (writedesc, readdesc, new_name)
-     int writedesc;
-     int readdesc;
-     char *new_name;
+int
+adjust_lnnoptrs (int writedesc, int readdesc, const char *new_name)
 {
   register int nsyms;
   register int new;
@@ -606,31 +565,16 @@ adjust_lnnoptrs (writedesc, readdesc, new_name)
   return 0;
 }
 
-extern unsigned start __asm__ ("start");
-
-/*
- *      Return the address of the start of the text segment prior to
- *      doing an unexec.  After unexec the return value is undefined.
- *      See crt0.c for further explanation and _start.
- *
- */
-
-char *
-start_of_text (void)
-{
-  return ((char *) &start);
-}
-
 /* ****************************************************************
  * unexec
  *
  * driving logic.
  */
-unexec (new_name, a_name, data_start, bss_start, entry_address)
-     char *new_name, *a_name;
-     unsigned data_start, bss_start, entry_address;
+int
+unexec (const char *new_name, const char *a_name,
+        unsigned data_start, unsigned bss_start, unsigned entry_address)
 {
-  int new, a_out = -1;
+  int new = -1, a_out = -1;
 
   if (a_name && (a_out = open (a_name, O_RDONLY)) < 0)
     {
@@ -648,7 +592,6 @@ unexec (new_name, a_name, data_start, bss_start, entry_address)
       )
     {
       close (new);
-      /* unlink (new_name);             /* Failed, unlink new a.out */
       return -1;
     }
 
diff --git a/src/unexmacosx.c b/src/unexmacosx.c
index ef43e9bef12..5c450e062c6 100644
--- a/src/unexmacosx.c
+++ b/src/unexmacosx.c
@@ -267,7 +267,7 @@ unexec_copy (off_t dest, off_t src, ssize_t count)
 /* Debugging and informational messages routines.  */
 
 static void
-unexec_error (char *format, ...)
+unexec_error (const char *format, ...)
 {
   va_list ap;
 
diff --git a/src/w16select.c b/src/w16select.c
index 384b82ceff1..ef1b974752b 100644
--- a/src/w16select.c
+++ b/src/w16select.c
@@ -456,7 +456,7 @@ DEFUN ("w16-set-clipboard-data", Fw16_set_clipboard_data, Sw16_set_clipboard_dat
   (Lisp_Object string, Lisp_Object frame)
 {
   unsigned ok = 1, put_status = 0;
-  int nbytes, charset_info, no_crlf_conversion;
+  int nbytes, no_crlf_conversion;
   unsigned char *src, *dst = NULL;
 
   CHECK_STRING (string);
@@ -494,9 +494,7 @@ DEFUN ("w16-set-clipboard-data", Fw16_set_clipboard_data, Sw16_set_clipboard_dat
     {
       /* We must encode contents of STRING according to what
          clipboard-coding-system specifies.  */
-      int bufsize;
       struct coding_system coding;
-      unsigned char *htext2;
       Lisp_Object coding_system =
         NILP (Vnext_selection_coding_system) ?
         Vselection_coding_system : Vnext_selection_coding_system;
@@ -567,7 +565,7 @@ DEFUN ("w16-get-clipboard-data", Fw16_get_clipboard_data, Sw16_get_clipboard_dat
   unsigned data_size, truelen;
   unsigned char *htext = NULL;
   Lisp_Object ret = Qnil;
-  int no_crlf_conversion, require_decoding = 0;
+  int require_decoding = 0;
 
   if (NILP (frame))
     frame = Fselected_frame ();
@@ -608,8 +606,6 @@ DEFUN ("w16-get-clipboard-data", Fw16_get_clipboard_data, Sw16_get_clipboard_dat
   }
   if (require_decoding)
     {
-      int bufsize;
-      unsigned char *buf;
       struct coding_system coding;
       Lisp_Object coding_system = Vnext_selection_coding_system;
 
diff --git a/src/w32fns.c b/src/w32fns.c
index d1f21e8acdd..f91ad948828 100644
--- a/src/w32fns.c
+++ b/src/w32fns.c
@@ -3109,9 +3109,6 @@ w32_wnd_proc (HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
           HIMC context;
           struct window *w;
 
-          if (!context)
-            break;
-
           f = x_window_to_frame (dpyinfo, hwnd);
           w = XWINDOW (FRAME_SELECTED_WINDOW (f));
 
@@ -3129,6 +3126,10 @@ w32_wnd_proc (HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
                                 - WINDOW_MODE_LINE_HEIGHT (w));
 
           context = get_ime_context_fn (hwnd);
+
+          if (!context)
+            break;
+
           set_ime_composition_window_fn (context, &form);
           release_ime_context_fn (hwnd, context);
         }
@@ -6812,6 +6813,7 @@ frame_parm_handler w32_frame_parm_handlers[] =
   x_set_font_backend,
   x_set_alpha,
   0, /* x_set_sticky */
+  0, /* x_set_tool_bar_position */
 };
 
 void
diff --git a/src/w32menu.c b/src/w32menu.c
index 919f8505da8..0ed9bffe70c 100644
--- a/src/w32menu.c
+++ b/src/w32menu.c
@@ -72,10 +72,16 @@ typedef BOOL (WINAPI * SetMenuItemInfoA_Proc) (
     IN UINT,
     IN BOOL,
     IN LPCMENUITEMINFOA);
+typedef int (WINAPI * MessageBoxW_Proc) (
+    IN HWND window,
+    IN WCHAR *text,
+    IN WCHAR *caption,
+    IN UINT type);
 
 GetMenuItemInfoA_Proc get_menu_item_info = NULL;
 SetMenuItemInfoA_Proc set_menu_item_info = NULL;
 AppendMenuW_Proc unicode_append_menu = NULL;
+MessageBoxW_Proc unicode_message_box = NULL;
 
 Lisp_Object Qdebug_on_next_call;
 
@@ -99,6 +105,8 @@ static int is_simple_dialog (Lisp_Object);
 static Lisp_Object simple_dialog_show (FRAME_PTR, Lisp_Object, Lisp_Object);
 #endif
 
+static void utf8to16 (unsigned char *, int, WCHAR *);
+
 void w32_free_menu_strings (HWND);
 
 
@@ -412,12 +420,8 @@ set_frame_menubar (FRAME_PTR f, int first_time, int deep_p)
 
       set_buffer_internal_1 (XBUFFER (buffer));
 
-      /* Run the Lucid hook.  */
+      /* Run the hooks.  */
       safe_run_hooks (Qactivate_menubar_hook);
-      /* If it has changed current-menubar from previous value,
-         really recompute the menubar from the value.  */
-      if (! NILP (Vlucid_menu_bar_dirty_flag))
-        call0 (Qrecompute_lucid_menubar);
       safe_run_hooks (Qmenu_bar_update_hook);
       FRAME_MENU_BAR_ITEMS (f) = menu_bar_items (FRAME_MENU_BAR_ITEMS (f));
 
@@ -662,7 +666,7 @@ free_frame_menubar (FRAME_PTR f)
 
 Lisp_Object
 w32_menu_show (FRAME_PTR f, int x, int y, int for_click, int keymaps,
-               Lisp_Object title, char **error)
+               Lisp_Object title, const char **error)
 {
   int i;
   int menu_item_selection;
@@ -1220,30 +1224,73 @@ simple_dialog_show (FRAME_PTR f, Lisp_Object contents, Lisp_Object header)
 {
   int answer;
   UINT type;
-  char *text, *title;
   Lisp_Object lispy_answer = Qnil, temp = XCAR (contents);
 
-  if (STRINGP (temp))
-    text = SDATA (temp);
-  else
-    text = "";
+  type = MB_YESNO;
+
+  /* Since we only handle Yes/No dialogs, and we already checked
+     is_simple_dialog, we don't need to worry about checking contents
+     to see what type of dialog to use.  */
 
-  if (NILP (header))
+  /* Use unicode if possible, so any language can be displayed.  */
+  if (unicode_message_box)
     {
-      title = "Question";
-      type = MB_ICONQUESTION;
+      WCHAR *text, *title;
+
+      if (STRINGP (temp))
+        {
+          char *utf8_text = SDATA (ENCODE_UTF_8 (temp));
+          /* Be pessimistic about the number of characters needed.
+             Remember characters outside the BMP will take more than
+             one utf16 word, so we cannot simply use the character
+             length of temp.  */
+          int utf8_len = strlen (utf8_text);
+          text = alloca ((utf8_len + 1) * sizeof (WCHAR));
+          utf8to16 (utf8_text, utf8_len, text);
+        }
+      else
+        {
+          text = L"";
+        }
+
+      if (NILP (header))
+        {
+          title = L"Question";
+          type |= MB_ICONQUESTION;
+        }
+      else
+        {
+          title = L"Information";
+          type |= MB_ICONINFORMATION;
+        }
+
+      answer = unicode_message_box (FRAME_W32_WINDOW (f), text, title, type);
     }
   else
     {
-      title = "Information";
-      type = MB_ICONINFORMATION;
-    }
-  type |= MB_YESNO;
+      char *text, *title;
 
-  /* Since we only handle Yes/No dialogs, and we already checked
-     is_simple_dialog, we don't need to worry about checking contents
-     to see what type of dialog to use.  */
-  answer = MessageBox (FRAME_W32_WINDOW (f), text, title, type);
+      /* Fall back on ANSI message box, but at least use system
+         encoding so questions representable by the system codepage
+         are encoded properly.  */
+      if (STRINGP (temp))
+        text = SDATA (ENCODE_SYSTEM (temp));
+      else
+        text = "";
+
+      if (NILP (header))
+        {
+          title = "Question";
+          type |= MB_ICONQUESTION;
+        }
+      else
+        {
+          title = "Information";
+          type |= MB_ICONINFORMATION;
+        }
+
+      answer = MessageBox (FRAME_W32_WINDOW (f), text, title, type);
+    }
 
   if (answer == IDYES)
     lispy_answer = build_string ("Yes");
@@ -1280,9 +1327,9 @@ simple_dialog_show (FRAME_PTR f, Lisp_Object contents, Lisp_Object header)
 
 /* Is this item a separator? */
 static int
-name_is_separator (char *name)
+name_is_separator (const char *name)
 {
-  char *start = name;
+  const char *start = name;
 
   /* Check if name string consists of only dashes ('-').  */
   while (*name == '-') name++;
@@ -1360,7 +1407,7 @@ add_menu_item (HMENU menu, widget_value *wv, HMENU item)
           strcat (out_string, wv->key);
         }
       else
-        out_string = wv->name;
+        out_string = (char *)wv->name;
 
       /* Quote any special characters within the menu item's text and
          key binding.  */
@@ -1697,6 +1744,7 @@ globals_of_w32menu (void)
   get_menu_item_info = (GetMenuItemInfoA_Proc) GetProcAddress (user32, "GetMenuItemInfoA");
   set_menu_item_info = (SetMenuItemInfoA_Proc) GetProcAddress (user32, "SetMenuItemInfoA");
   unicode_append_menu = (AppendMenuW_Proc) GetProcAddress (user32, "AppendMenuW");
+  unicode_message_box = (MessageBoxW_Proc) GetProcAddress (user32, "MessageBoxW");
 }
 
 /* arch-tag: 0eaed431-bb4e-4aac-a527-95a1b4f1fed0
diff --git a/src/w32term.c b/src/w32term.c
index fc03034b14b..992538e0e88 100644
--- a/src/w32term.c
+++ b/src/w32term.c
@@ -2106,17 +2106,34 @@ x_draw_stretch_glyph_string (struct glyph_string *s)
   if (s->hl == DRAW_CURSOR
       && !x_stretch_cursor_p)
     {
-      /* If `x-stretch-block-cursor' is nil, don't draw a block cursor
-         as wide as the stretch glyph.  */
+      /* If `x-stretch-cursor' is nil, don't draw a block cursor as
+         wide as the stretch glyph.  */
       int width, background_width = s->background_width;
-      int x = s->x, left_x = window_box_left_offset (s->w, TEXT_AREA);
+      int x = s->x;
 
-      if (x < left_x)
+      if (!s->row->reversed_p)
         {
-          background_width -= left_x - x;
-          x = left_x;
+          int left_x = window_box_left_offset (s->w, TEXT_AREA);
+
+          if (x < left_x)
+            {
+              background_width -= left_x - x;
+              x = left_x;
+            }
+        }
+      else
+        {
+          /* In R2L rows, draw the cursor on the right edge of the
+             stretch glyph.  */
+          int right_x = window_box_right_offset (s->w, TEXT_AREA);
+
+          if (x + background_width > right_x)
+            background_width -= x - right_x;
+          x += background_width;
         }
       width = min (FRAME_COLUMN_WIDTH (s->f), background_width);
+      if (s->row->reversed_p)
+        x -= width;
 
       /* Draw cursor.  */
       x_draw_glyph_string_bg_rect (s, x, s->y, width, s->height);
@@ -2130,7 +2147,10 @@ x_draw_stretch_glyph_string (struct glyph_string *s)
           RECT r;
           HDC hdc = s->hdc;
 
-          x += width;
+          if (!s->row->reversed_p)
+            x += width;
+          else
+            x = s->x;
           if (s->row->mouse_face_p
               && cursor_in_mouse_face_p (s->w))
             {
@@ -4877,6 +4897,11 @@ x_draw_bar_cursor (struct window *w, struct glyph_row *row,
 
           w->phys_cursor_width = width;
 
+          /* If the character under cursor is R2L, draw the bar cursor
+             on the right of its glyph, rather than on the left.  */
+          if ((cursor_glyph->resolved_level & 1) != 0)
+            x += cursor_glyph->pixel_width - width;
+
           w32_fill_area (f, hdc, cursor_color, x,
                          WINDOW_TO_FRAME_PIXEL_Y (w, w->phys_cursor.y),
                          width, row->height);
diff --git a/src/w32uniscribe.c b/src/w32uniscribe.c
index 9edd6353ba3..05cc8346a50 100644
--- a/src/w32uniscribe.c
+++ b/src/w32uniscribe.c
@@ -180,17 +180,18 @@ uniscribe_otf_capability (struct font *font)
 
 /* Uniscribe implementation of shape for font backend.
 
-   Shape text in LGSTRING.  See the docstring of `font-make-gstring'
-   for the format of LGSTRING.  If the (N+1)th element of LGSTRING
-   is nil, input of shaping is from the 1st to (N)th elements.  In
-   each input glyph, FROM, TO, CHAR, and CODE are already set.
+   Shape text in LGSTRING.  See the docstring of
+   `composition-get-gstring' for the format of LGSTRING.  If the
+   (N+1)th element of LGSTRING is nil, input of shaping is from the
+   1st to (N)th elements.  In each input glyph, FROM, TO, CHAR, and
+   CODE are already set.
 
    This function updates all fields of the input glyphs.  If the
    output glyphs (M) are more than the input glyphs (N), (N+1)th
    through (M)th elements of LGSTRING are updated possibly by making
    a new glyph object and storing it in LGSTRING.  If (M) is greater
-   than the length of LGSTRING, nil should be return.  In that case,
-   this function is called again with the larger LGSTRING.  */
+   than the length of LGSTRING, nil should be returned.  In that case,
+   this function is called again with a larger LGSTRING.  */
 static Lisp_Object
 uniscribe_shape (Lisp_Object lgstring)
 {
@@ -217,6 +218,9 @@ uniscribe_shape (Lisp_Object lgstring)
   max_glyphs = nchars = LGSTRING_GLYPH_LEN (lgstring);
   done_glyphs = 0;
   chars = (wchar_t *) alloca (nchars * sizeof (wchar_t));
+  /* FIXME: This loop assumes that characters in the input LGSTRING
+     are all inside the BMP.  Need to encode characters beyond the BMP
+     as UTF-16.  */
   for (i = 0; i < nchars; i++)
     {
       /* lgstring can be bigger than the number of characters in it, in
@@ -248,9 +252,6 @@ uniscribe_shape (Lisp_Object lgstring)
       return Qnil;
     }
 
-  /* TODO: When we get BIDI support, we need to call ScriptLayout here.
-     Requires that we know the surrounding context.  */
-
   glyphs = alloca (max_glyphs * sizeof (WORD));
   clusters = alloca (nchars * sizeof (WORD));
   attributes = alloca (max_glyphs * sizeof (SCRIPT_VISATTR));
@@ -259,8 +260,12 @@ uniscribe_shape (Lisp_Object lgstring)
 
   for (i = 0; i < nitems; i++)
     {
-      int nglyphs, nchars_in_run, rtl = items[i].a.fRTL ? -1 : 1;
+      int nglyphs, nchars_in_run;
       nchars_in_run = items[i+1].iCharPos - items[i].iCharPos;
+      /* Force ScriptShape to generate glyphs in the same order as
+         they are in the input LGSTRING, which is in the logical
+         order.  */
+      items[i].a.fLogicalOrder = 1;
 
       /* Context may be NULL here, in which case the cache should be
          used without needing to select the font.  */
@@ -321,7 +326,7 @@ uniscribe_shape (Lisp_Object lgstring)
             {
               int j, nclusters, from, to;
 
-              from = rtl > 0 ? 0 : nchars_in_run - 1;
+              from = 0;
               to = from;
 
               for (j = 0; j < nglyphs; j++)
@@ -342,22 +347,19 @@ uniscribe_shape (Lisp_Object lgstring)
                   gl = glyphs[j];
                   LGLYPH_SET_CODE (lglyph, gl);
 
-                  /* Detect clusters, for linking codes back to characters.  */
+                  /* Detect clusters, for linking codes back to
+                     characters.  */
                   if (attributes[j].fClusterStart)
                     {
-                      while (from >= 0 && from < nchars_in_run
-                             && clusters[from] < j)
-                        from += rtl;
-                      if (from < 0)
-                        from = to = 0;
-                      else if (from >= nchars_in_run)
+                      while (from < nchars_in_run && clusters[from] < j)
+                        from++;
+                      if (from >= nchars_in_run)
                         from = to = nchars_in_run - 1;
                       else
                         {
                           int k;
-                          to = rtl > 0 ? nchars_in_run - 1 : 0;
-                          for (k = from + rtl; k >= 0 && k < nchars_in_run;
-                               k += rtl)
+                          to = nchars_in_run - 1;
+                          for (k = from + 1; k < nchars_in_run; k++)
                             {
                               if (clusters[k] > j)
                                 {
@@ -486,6 +488,10 @@ uniscribe_encode_char (struct font *font, int c)
           SCRIPT_VISATTR attrs[2];
           int nglyphs;
 
+          /* Force ScriptShape to generate glyphs in the logical
+             order.  */
+          items[0].a.fLogicalOrder = 1;
+
           result = ScriptShape (context, &(uniscribe_font->cache),
                                 ch, len, 2, &(items[0].a),
                                 glyphs, clusters, attrs, &nglyphs);
diff --git a/src/xdisp.c b/src/xdisp.c
index 80df99fee48..2ec271cdb6b 100644
--- a/src/xdisp.c
+++ b/src/xdisp.c
@@ -217,7 +217,26 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
    glyph with suitably computed width.  Both the blanks and the
    stretch glyph are given the face of the background of the line.
    This way, the terminal-specific back-end can still draw the glyphs
-   left to right, even for R2L lines.  */
+   left to right, even for R2L lines.
+
+   Note one important detail mentioned above: that the bidi reordering
+   engine, driven by the iterator, produces characters in R2L rows
+   starting at the character that will be the rightmost on display.
+   As far as the iterator is concerned, the geometry of such rows is
+   still left to right, i.e. the iterator "thinks" the first character
+   is at the leftmost pixel position.  The iterator does not know that
+   PRODUCE_GLYPHS reverses the order of the glyphs that the iterator
+   delivers.  This is important when functions from the the move_it_*
+   family are used to get to certain screen position or to match
+   screen coordinates with buffer coordinates: these functions use the
+   iterator geometry, which is left to right even in R2L paragraphs.
+   This works well with most callers of move_it_*, because they need
+   to get to a specific column, and columns are still numbered in the
+   reading order, i.e. the rightmost character in a R2L paragraph is
+   still column zero.  But some callers do not get well with this; a
+   notable example is mouse clicks that need to find the character
+   that corresponds to certain pixel coordinates.  See
+   buffer_posn_from_coords in dispnew.c for how this is handled.  */
 
 #include <config.h>
 #include <stdio.h>
@@ -1208,7 +1227,7 @@ window_box_left_offset (struct window *w, int area)
 
 
 /* Return the window-relative coordinate of the right edge of display
-   area AREA of window W.  AREA < 0 means return the left edge of the
+   area AREA of window W.  AREA < 0 means return the right edge of the
    whole window, to the left of the right fringe of W.  */
 
 INLINE int
@@ -1238,7 +1257,7 @@ window_box_left (struct window *w, int area)
 
 
 /* Return the frame-relative coordinate of the right edge of display
-   area AREA of window W.  AREA < 0 means return the left edge of the
+   area AREA of window W.  AREA < 0 means return the right edge of the
    whole window, to the left of the right fringe of W.  */
 
 INLINE int
@@ -3158,7 +3177,7 @@ compute_stop_pos (struct it *it)
 {
   register INTERVAL iv, next_iv;
   Lisp_Object object, limit, position;
-  EMACS_INT charpos, bytepos;
+  EMACS_INT charpos, bytepos, stoppos;
 
   /* If nowhere else, stop at the end.  */
   it->stop_charpos = it->end_charpos;
@@ -3248,8 +3267,12 @@ compute_stop_pos (struct it *it)
         }
     }
 
+  if (it->bidi_p && it->bidi_it.scan_dir < 0)
+    stoppos = -1;
+  else
+    stoppos = it->stop_charpos;
   composition_compute_stop_pos (&it->cmp_it, charpos, bytepos,
-                                it->stop_charpos, it->string);
+                                stoppos, it->string);
 
   xassert (STRINGP (it->string)
            || (it->stop_charpos >= BEGV
@@ -5739,10 +5762,23 @@ get_next_display_element (struct it *it)
           struct charset *unibyte = CHARSET_FROM_ID (charset_unibyte);
           enum { char_is_other = 0, char_is_nbsp, char_is_soft_hyphen }
           nbsp_or_shy = char_is_other;
-          int decoded = it->c;
+          int c = it->c;        /* This is the character to display.  */
+
+          if (! it->multibyte_p && ! ASCII_CHAR_P (c))
+            {
+              xassert (SINGLE_BYTE_CHAR_P (c));
+              if (unibyte_display_via_language_environment)
+                {
+                  c = DECODE_CHAR (unibyte, c);
+                  if (c < 0)
+                    c = BYTE8_TO_CHAR (it->c);
+                }
+              else
+                c = BYTE8_TO_CHAR (it->c);
+            }
 
           if (it->dp
-              && (dv = DISP_CHAR_VECTOR (it->dp, it->c),
+              && (dv = DISP_CHAR_VECTOR (it->dp, c),
                   VECTORP (dv)))
             {
               struct Lisp_Vector *v = XVECTOR (dv);
@@ -5768,21 +5804,10 @@ get_next_display_element (struct it *it)
               goto get_next;
             }
 
-          if (unibyte_display_via_language_environment
-              && !ASCII_CHAR_P (it->c))
-            decoded = DECODE_CHAR (unibyte, it->c);
-
-          if (it->c >= 0x80 && ! NILP (Vnobreak_char_display))
-            {
-              if (it->multibyte_p)
-                nbsp_or_shy = (it->c == 0xA0   ? char_is_nbsp
-                               : it->c == 0xAD ? char_is_soft_hyphen
-                               :                 char_is_other);
-              else if (unibyte_display_via_language_environment)
-                nbsp_or_shy = (decoded == 0xA0   ? char_is_nbsp
-                               : decoded == 0xAD ? char_is_soft_hyphen
-                               :                   char_is_other);
-            }
+          if (! ASCII_CHAR_P (c) && ! NILP (Vnobreak_char_display))
+            nbsp_or_shy = (c == 0xA0   ? char_is_nbsp
+                           : c == 0xAD ? char_is_soft_hyphen
+                           :             char_is_other);
 
           /* Translate control characters into `\003' or `^C' form.
              Control characters coming from a display table entry are
@@ -5790,27 +5815,23 @@ get_next_display_element (struct it *it)
              the translation.  This could easily be changed but I
              don't believe that it is worth doing.
 
-             If it->multibyte_p is nonzero, non-printable non-ASCII
-             characters are also translated to octal form.
+             NBSP and SOFT-HYPEN are property translated too.
 
-             If it->multibyte_p is zero, eight-bit characters that
-             don't have corresponding multibyte char code are also
+             Non-printable characters and raw-byte characters are also
              translated to octal form.  */
-          if ((it->c < ' '
+          if (((c < ' ' || c == 127) /* ASCII control chars */
                ? (it->area != TEXT_AREA
                   /* In mode line, treat \n, \t like other crl chars.  */
-                  || (it->c != '\t'
+                  || (c != '\t'
                       && it->glyph_row
                       && (it->glyph_row->mode_line_p || it->avoid_cursor_p))
-                  || (it->c != '\n' && it->c != '\t'))
+                  || (c != '\n' && c != '\t'))
                : (nbsp_or_shy
-                  || (it->multibyte_p
-                      ? ! CHAR_PRINTABLE_P (it->c)
-                      : (! unibyte_display_via_language_environment
-                         ? it->c >= 0x80
-                         : (decoded >= 0x80 && decoded < 0xA0))))))
+                  || CHAR_BYTE8_P (c)
+                  || ! CHAR_PRINTABLE_P (c))))
             {
-              /* IT->c is a control character which must be displayed
+              /* C is a control character, NBSP, SOFT-HYPEN, raw-byte,
+                 or a non-printable character which must be displayed
                  either as '\003' or as `^C' where the '\\' and '^'
                  can be defined in the display table.  Fill
                  IT->ctl_chars with glyphs for what we have to
@@ -5822,7 +5843,7 @@ get_next_display_element (struct it *it)
 
               /* Handle control characters with ^.  */
 
-              if (it->c < 128 && it->ctl_arrow_p)
+              if (ASCII_CHAR_P (c) && it->ctl_arrow_p)
                 {
                   int g;
 
@@ -5855,7 +5876,7 @@ get_next_display_element (struct it *it)
                     }
 
                   XSETINT (it->ctl_chars[0], g);
-                  XSETINT (it->ctl_chars[1], it->c ^ 0100);
+                  XSETINT (it->ctl_chars[1], c ^ 0100);
                   ctl_len = 2;
                   goto display_control;
                 }
@@ -5870,7 +5891,7 @@ get_next_display_element (struct it *it)
                   face_id = merge_faces (it->f, Qnobreak_space, 0,
                                          it->face_id);
 
-                  it->c = ' ';
+                  c = ' ';
                   XSETINT (it->ctl_chars[0], ' ');
                   ctl_len = 1;
                   goto display_control;
@@ -5916,7 +5937,6 @@ get_next_display_element (struct it *it)
               if (EQ (Vnobreak_char_display, Qt)
                   && nbsp_or_shy == char_is_soft_hyphen)
                 {
-                  it->c = '-';
                   XSETINT (it->ctl_chars[0], '-');
                   ctl_len = 1;
                   goto display_control;
@@ -5928,55 +5948,25 @@ get_next_display_element (struct it *it)
               if (nbsp_or_shy)
                 {
                   XSETINT (it->ctl_chars[0], escape_glyph);
-                  it->c = (nbsp_or_shy == char_is_nbsp ? ' ' : '-');
-                  XSETINT (it->ctl_chars[1], it->c);
+                  c = (nbsp_or_shy == char_is_nbsp ? ' ' : '-');
+                  XSETINT (it->ctl_chars[1], c);
                   ctl_len = 2;
                   goto display_control;
                 }
 
               {
-                unsigned char str[MAX_MULTIBYTE_LENGTH];
-                int len;
-                int i;
+                char str[10];
+                int len, i;
 
-                /* Set IT->ctl_chars[0] to the glyph for `\\'.  */
-                if (CHAR_BYTE8_P (it->c))
-                  {
-                    str[0] = CHAR_TO_BYTE8 (it->c);
-                    len = 1;
-                  }
-                else if (it->c < 256)
-                  {
-                    str[0] = it->c;
-                    len = 1;
-                  }
-                else
-                  {
-                    /* It's an invalid character, which shouldn't
-                       happen actually, but due to bugs it may
-                       happen.  Let's print the char as is, there's
-                       not much meaningful we can do with it.  */
-                    str[0] = it->c;
-                    str[1] = it->c >> 8;
-                    str[2] = it->c >> 16;
-                    str[3] = it->c >> 24;
-                    len = 4;
-                  }
+                if (CHAR_BYTE8_P (c))
+                  /* Display \200 instead of \17777600.  */
+                  c = CHAR_TO_BYTE8 (c);
+                len = sprintf (str, "%03o", c);
 
+                XSETINT (it->ctl_chars[0], escape_glyph);
                 for (i = 0; i < len; i++)
-                  {
-                    int g;
-                    XSETINT (it->ctl_chars[i * 4], escape_glyph);
-                    /* Insert three more glyphs into IT->ctl_chars for
-                       the octal display of the character.  */
-                    g = ((str[i] >> 6) & 7) + '0';
-                    XSETINT (it->ctl_chars[i * 4 + 1], g);
-                    g = ((str[i] >> 3) & 7) + '0';
-                    XSETINT (it->ctl_chars[i * 4 + 2], g);
-                    g = (str[i] & 7) + '0';
-                    XSETINT (it->ctl_chars[i * 4 + 3], g);
-                  }
-                ctl_len = len * 4;
+                  XSETINT (it->ctl_chars[i + 1], str[i]);
+                ctl_len = len + 1;
               }
 
             display_control:
@@ -5991,6 +5981,11 @@ get_next_display_element (struct it *it)
               it->ellipsis_p = 0;
               goto get_next;
             }
+          it->char_to_display = c;
+        }
+      else if (success_p)
+        {
+          it->char_to_display = it->c;
         }
     }
 
@@ -6017,7 +6012,8 @@ get_next_display_element (struct it *it)
                      : STRINGP (it->string) ? IT_STRING_CHARPOS (*it)
                      : IT_CHARPOS (*it));
 
-          it->face_id = FACE_FOR_CHAR (it->f, face, it->c, pos, it->string);
+          it->face_id = FACE_FOR_CHAR (it->f, face, it->char_to_display, pos,
+                                       it->string);
         }
     }
 #endif
@@ -10839,7 +10835,7 @@ note_tool_bar_highlight (struct frame *f, int x, int y)
   enum draw_glyphs_face draw = DRAW_IMAGE_RAISED;
   int mouse_down_p, rc;
 
-  /* Function note_mouse_highlight is called with negative x(y
+  /* Function note_mouse_highlight is called with negative X/Y
      values when mouse moves outside of the frame.  */
   if (x <= 0 || y <= 0)
     {
@@ -16458,15 +16454,19 @@ get_overlay_arrow_glyph_row (struct window *w, Lisp_Object overlay_arrow_string)
 
       /* Get the next character.  */
       if (multibyte_p)
-        it.c = string_char_and_length (p, &it.len);
+        it.c = it.char_to_display = string_char_and_length (p, &it.len);
       else
-        it.c = *p, it.len = 1;
+        {
+          it.c = it.char_to_display = *p, it.len = 1;
+          if (! ASCII_CHAR_P (it.c))
+            it.char_to_display = BYTE8_TO_CHAR (it.c);
+        }
       p += it.len;
 
       /* Get its face.  */
       ilisp = make_number (p - arrow_string);
       face = Fget_text_property (ilisp, Qface, overlay_arrow_string);
-      it.face_id = compute_char_face (f, it.c, face);
+      it.face_id = compute_char_face (f, it.char_to_display, face);
 
       /* Compute its width, get its glyphs.  */
       n_glyphs_before = it.glyph_row->used[TEXT_AREA];
@@ -16698,6 +16698,7 @@ append_space_for_newline (struct it *it, int default_face_p)
              append_space_for_newline has been called.  */
           enum display_element_type saved_what = it->what;
           int saved_c = it->c, saved_len = it->len;
+          int saved_char_to_display = it->char_to_display;
           int saved_x = it->current_x;
           int saved_face_id = it->face_id;
           struct text_pos saved_pos;
@@ -16710,7 +16711,7 @@ append_space_for_newline (struct it *it, int default_face_p)
           it->what = IT_CHARACTER;
           memset (&it->position, 0, sizeof it->position);
           it->object = make_number (0);
-          it->c = ' ';
+          it->c = it->char_to_display = ' ';
           it->len = 1;
 
           if (default_face_p)
@@ -16731,6 +16732,7 @@ append_space_for_newline (struct it *it, int default_face_p)
           it->face_id = saved_face_id;
           it->len = saved_len;
           it->c = saved_c;
+          it->char_to_display = saved_char_to_display;
           return 1;
         }
     }
@@ -16863,7 +16865,7 @@ extend_face_to_end_of_line (struct it *it)
       it->what = IT_CHARACTER;
       memset (&it->position, 0, sizeof it->position);
       it->object = make_number (0);
-      it->c = ' ';
+      it->c = it->char_to_display = ' ';
       it->len = 1;
       /* The last row's blank glyphs should get the default face, to
          avoid painting the rest of the window with the region face,
@@ -17962,16 +17964,22 @@ See also `bidi-paragraph-direction'.  */)
       struct bidi_it itb;
       EMACS_INT pos = BUF_PT (buf);
       EMACS_INT bytepos = BUF_PT_BYTE (buf);
+      int c;
 
       if (buf != current_buffer)
         set_buffer_temp (buf);
-      /* Find previous non-empty line.  */
+      /* bidi_paragraph_init finds the base direction of the paragraph
+         by searching forward from paragraph start.  We need the base
+         direction of the current or _previous_ paragraph, so we need
+         to make sure we are within that paragraph.  To that end, find
+         the previous non-empty line.  */
       if (pos >= ZV && pos > BEGV)
         {
           pos--;
           bytepos = CHAR_TO_BYTE (pos);
         }
-      while (FETCH_BYTE (bytepos) == '\n')
+      while ((c = FETCH_BYTE (bytepos)) == '\n'
+             || c == ' ' || c == '\t' || c == '\f')
         {
           if (bytepos <= BEGV_BYTE)
             break;
@@ -17983,6 +17991,7 @@ See also `bidi-paragraph-direction'.  */)
       itb.charpos = pos;
       itb.bytepos = bytepos;
       itb.first_elt = 1;
+      itb.separator_limit = -1;
 
       bidi_paragraph_init (NEUTRAL_DIR, &itb);
       if (buf != current_buffer)
@@ -20460,7 +20469,12 @@ get_glyph_face_and_encoding (struct frame *f, struct glyph *glyph,
 
   if (face->font)
     {
-      unsigned code = face->font->driver->encode_char (face->font, glyph->u.ch);
+      unsigned code;
+
+      if (CHAR_BYTE8_P (glyph->u.ch))
+        code = CHAR_TO_BYTE8 (glyph->u.ch);
+      else
+        code = face->font->driver->encode_char (face->font, glyph->u.ch);
 
       if (code != FONT_INVALID_CODE)
         STORE_XCHAR2B (char2b, (code >> 8), (code & 0xFF));
@@ -20475,6 +20489,26 @@ get_glyph_face_and_encoding (struct frame *f, struct glyph *glyph,
 }
 
 
+/* Get glyph code of character C in FONT in the two-byte form CHAR2B.
+   Retunr 1 if FONT has a glyph for C, otherwise return 0.  */
+
+static INLINE int
+get_char_glyph_code (int c, struct font *font, XChar2b *char2b)
+{
+  unsigned code;
+
+  if (CHAR_BYTE8_P (c))
+    code = CHAR_TO_BYTE8 (c);
+  else
+    code = font->driver->encode_char (font, c);
+
+  if (code == FONT_INVALID_CODE)
+    return 0;
+  STORE_XCHAR2B (char2b, (code >> 8), (code & 0xFF));
+  return 1;
+}
+
+
 /* Fill glyph string S with composition components specified by S->cmp.
 
    BASE_FACE is the base face of the composition.
@@ -21879,10 +21913,14 @@ produce_stretch_glyph (struct it *it)
         {
           int maxlen = ((IT_BYTEPOS (*it) >= GPT ? ZV : GPT)
                         - IT_BYTEPOS (*it));
-          it2.c = STRING_CHAR_AND_LENGTH (p, it2.len);
+          it2.c = it2.char_to_display = STRING_CHAR_AND_LENGTH (p, it2.len);
         }
       else
-        it2.c = *p, it2.len = 1;
+        {
+          it2.c = it2.char_to_display = *p, it2.len = 1;
+          if (! ASCII_CHAR_P (it2.c))
+            it2.char_to_display = BYTE8_TO_CHAR (it2.c);
+        }
 
       it2.glyph_row = NULL;
       it2.what = IT_CHARACTER;
@@ -22052,49 +22090,12 @@ x_produce_glyphs (struct it *it)
   if (it->what == IT_CHARACTER)
     {
       XChar2b char2b;
-      struct font *font;
       struct face *face = FACE_FROM_ID (it->f, it->face_id);
-      struct font_metrics *pcm;
-      int font_not_found_p;
+      struct font *font = face->font;
+      int font_not_found_p = font == NULL;
+      struct font_metrics *pcm = NULL;
       int boff;                 /* baseline offset */
-      /* We may change it->multibyte_p upon unibyte<->multibyte
-         conversion.  So, save the current value now and restore it
-         later.
-
-         Note: It seems that we don't have to record multibyte_p in
-         struct glyph because the character code itself tells whether
-         or not the character is multibyte.  Thus, in the future, we
-         must consider eliminating the field `multibyte_p' in the
-         struct glyph.  */
-      int saved_multibyte_p = it->multibyte_p;
-
-      /* Maybe translate single-byte characters to multibyte, or the
-         other way.  */
-      it->char_to_display = it->c;
-      if (!ASCII_BYTE_P (it->c)
-          && ! it->multibyte_p)
-        {
-          if (SINGLE_BYTE_CHAR_P (it->c)
-              && unibyte_display_via_language_environment)
-            {
-              struct charset *unibyte = CHARSET_FROM_ID (charset_unibyte);
-
-              /* get_next_display_element assures that this decoding
-                 never fails.  */
-              it->char_to_display = DECODE_CHAR (unibyte, it->c);
-              it->multibyte_p = 1;
-              it->face_id = FACE_FOR_CHAR (it->f, face, it->char_to_display,
-                                           -1, Qnil);
-              face = FACE_FROM_ID (it->f, it->face_id);
-            }
-        }
-
-      /* Get font to use.  Encode IT->char_to_display.  */
-      get_char_face_and_encoding (it->f, it->char_to_display, it->face_id,
-                                  &char2b, it->multibyte_p, 0);
-      font = face->font;
 
-      font_not_found_p = font == NULL;
       if (font_not_found_p)
         {
           /* When no suitable font found, display an empty box based
@@ -22114,16 +22115,12 @@ x_produce_glyphs (struct it *it)
             boff = VCENTER_BASELINE_OFFSET (font, it->f) - boff;
         }
 
-      if (it->char_to_display >= ' '
-          && (!it->multibyte_p || it->char_to_display < 128))
+      if (it->char_to_display != '\n' && it->char_to_display != '\t')
         {
-          /* Either unibyte or ASCII.  */
           int stretched_p;
 
           it->nglyphs = 1;
 
-          pcm = get_per_char_metric (it->f, font, &char2b);
-
           if (it->override_ascent >= 0)
             {
               it->ascent = it->override_ascent;
@@ -22136,6 +22133,15 @@ x_produce_glyphs (struct it *it)
               it->descent = FONT_DESCENT (font) - boff;
             }
 
+          if (! font_not_found_p
+              && get_char_glyph_code (it->char_to_display, font, &char2b))
+            {
+              pcm = get_per_char_metric (it->f, font, &char2b);
+              if (pcm->width == 0
+                  && pcm->rbearing == 0 && pcm->lbearing == 0)
+                pcm = NULL;
+            }
+
           if (pcm)
             {
               it->phys_ascent = pcm->ascent + boff;
@@ -22147,7 +22153,7 @@ x_produce_glyphs (struct it *it)
               it->glyph_not_available_p = 1;
               it->phys_ascent = it->ascent;
               it->phys_descent = it->descent;
-              it->pixel_width = FONT_WIDTH (font);
+              it->pixel_width = font->space_width;
             }
 
           if (it->constrain_row_ascent_descent_p)
@@ -22321,7 +22327,7 @@ x_produce_glyphs (struct it *it)
                 }
             }
         }
-      else if (it->char_to_display == '\t')
+      else                    /* i.e. (it->char_to_display == '\t') */
         {
           if (font->space_width > 0)
             {
@@ -22352,85 +22358,6 @@ x_produce_glyphs (struct it *it)
               it->nglyphs = 1;
             }
         }
-      else
-        {
-          /* A multi-byte character.  Assume that the display width of the
-             character is the width of the character multiplied by the
-             width of the font.  */
-
-          /* If we found a font, this font should give us the right
-             metrics.  If we didn't find a font, use the frame's
-             default font and calculate the width of the character by
-             multiplying the width of font by the width of the
-             character.  */
-
-          pcm = get_per_char_metric (it->f, font, &char2b);
-
-          if (font_not_found_p || !pcm)
-            {
-              int char_width = CHAR_WIDTH (it->char_to_display);
-
-              if (char_width == 0)
-                /* This is a non spacing character.  But, as we are
-                   going to display an empty box, the box must occupy
-                   at least one column.  */
-                char_width = 1;
-              it->glyph_not_available_p = 1;
-              it->pixel_width = font->space_width * char_width;
-              it->phys_ascent = FONT_BASE (font) + boff;
-              it->phys_descent = FONT_DESCENT (font) - boff;
-            }
-          else
-            {
-              it->pixel_width = pcm->width;
-              it->phys_ascent = pcm->ascent + boff;
-              it->phys_descent = pcm->descent - boff;
-              if (it->glyph_row
-                  && (pcm->lbearing < 0
-                      || pcm->rbearing > pcm->width))
-                it->glyph_row->contains_overlapping_glyphs_p = 1;
-            }
-          it->nglyphs = 1;
-          it->ascent = FONT_BASE (font) + boff;
-          it->descent = FONT_DESCENT (font) - boff;
-          if (face->box != FACE_NO_BOX)
-            {
-              int thick = face->box_line_width;
-
-              if (thick > 0)
-                {
-                  it->ascent += thick;
-                  it->descent += thick;
-                }
-              else
-                thick = - thick;
-
-              if (it->start_of_box_run_p)
-                it->pixel_width += thick;
-              if (it->end_of_box_run_p)
-                it->pixel_width += thick;
-            }
-
-          /* If face has an overline, add the height of the overline
-             (1 pixel) and a 1 pixel margin to the character height.  */
-          if (face->overline_p)
-            it->ascent += overline_margin;
-
-          take_vertical_position_into_account (it);
-
-          if (it->ascent < 0)
-            it->ascent = 0;
-          if (it->descent < 0)
-            it->descent = 0;
-
-          if (it->glyph_row)
-            append_glyph (it);
-          if (it->pixel_width == 0)
-            /* We assure that all visible glyphs have at least 1-pixel
-               width.  */
-            it->pixel_width = 1;
-        }
-      it->multibyte_p = saved_multibyte_p;
     }
   else if (it->what == IT_COMPOSITION && it->cmp_it.ch < 0)
     {
@@ -22526,7 +22453,7 @@ x_produce_glyphs (struct it *it)
             }
           else
             {
-              width = FONT_WIDTH (font);
+              width = font->space_width;
               ascent = FONT_BASE (font);
               descent = FONT_DESCENT (font);
               lbearing = 0;
diff --git a/src/xfns.c b/src/xfns.c
index bc28ccd3a63..cb6733e8fa1 100644
--- a/src/xfns.c
+++ b/src/xfns.c
@@ -648,12 +648,16 @@ int
 x_defined_color (struct frame *f, const char *color_name,
                  XColor *color, int alloc_p)
 {
-  int success_p;
+  int success_p = 0;
   Display *dpy = FRAME_X_DISPLAY (f);
   Colormap cmap = FRAME_X_COLORMAP (f);
 
   BLOCK_INPUT;
-  success_p = XParseColor (dpy, cmap, color_name, color);
+#ifdef USE_GTK
+  success_p = xg_check_special_colors (f, color_name, color);
+#endif
+  if (!success_p)
+    success_p = XParseColor (dpy, cmap, color_name, color);
   if (success_p && alloc_p)
     success_p = x_alloc_nearest_color (f, cmap, color);
   UNBLOCK_INPUT;
@@ -3388,6 +3392,8 @@ This function is an internal primitive--use `make-frame' instead.  */)
                        "waitForWM", "WaitForWM", RES_TYPE_BOOLEAN);
   x_default_parameter (f, parms, Qfullscreen, Qnil,
                        "fullscreen", "Fullscreen", RES_TYPE_SYMBOL);
+  x_default_parameter (f, parms, Qtool_bar_position,
+                       f->tool_bar_position, 0, 0, RES_TYPE_SYMBOL);
 
   /* Compute the size of the X window.  */
   window_prompting = x_figure_window_size (f, parms, 1);
@@ -5233,7 +5239,7 @@ Value is t if tooltip was open, nil otherwise.  */)
   /* When using system tooltip, tip_frame is the Emacs frame on which
      the tip is shown.  */
   f = XFRAME (frame);
-  if (xg_hide_tooltip (f))
+  if (FRAME_LIVE_P (f) && xg_hide_tooltip (f))
     frame = Qnil;
 #endif
 
diff --git a/src/xmenu.c b/src/xmenu.c
index 0b24a8f2bd6..68b442388a5 100644
--- a/src/xmenu.c
+++ b/src/xmenu.c
@@ -111,7 +111,7 @@ Lisp_Object Qdebug_on_next_call;
 
 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
 static Lisp_Object xdialog_show (FRAME_PTR, int, Lisp_Object, Lisp_Object,
-                                 char **);
+                                 const char **);
 #endif
 
 static int update_frame_menubar (struct frame *);
@@ -312,7 +312,7 @@ for instance using the window manager, then this produces a quit and
 #else
   {
     Lisp_Object title;
-    char *error_name;
+    const char *error_name;
     Lisp_Object selection;
     int specpdl_count = SPECPDL_INDEX ();
 
@@ -1600,7 +1600,7 @@ create_and_show_popup_menu (FRAME_PTR f, widget_value *first_wv,
 
 Lisp_Object
 xmenu_show (FRAME_PTR f, int x, int y, int for_click, int keymaps,
-            Lisp_Object title, char **error, EMACS_UINT timestamp)
+            Lisp_Object title, const char **error, EMACS_UINT timestamp)
 {
   int i;
   widget_value *wv, *save_wv = 0, *first_wv = 0, *prev_wv = 0;
@@ -1664,7 +1664,7 @@ xmenu_show (FRAME_PTR f, int x, int y, int for_click, int keymaps,
         {
           /* Create a new pane.  */
           Lisp_Object pane_name, prefix;
-          char *pane_string;
+          const char *pane_string;
 
           pane_name = AREF (menu_items, i + MENU_ITEMS_PANE_NAME);
           prefix = AREF (menu_items, i + MENU_ITEMS_PANE_PREFIX);
@@ -1976,12 +1976,16 @@ create_and_show_dialog (FRAME_PTR f, widget_value *first_wv)
 
 #endif /* not USE_GTK */
 
-static char * button_names [] = {
+static const char * button_names [] = {
   "button1", "button2", "button3", "button4", "button5",
   "button6", "button7", "button8", "button9", "button10" };
 
 static Lisp_Object
-xdialog_show (FRAME_PTR f, int keymaps, Lisp_Object title, Lisp_Object header, char **error_name)
+xdialog_show (FRAME_PTR f,
+              int keymaps,
+              Lisp_Object title,
+              Lisp_Object header,
+              const char **error_name)
 {
   int i, nb_buttons=0;
   char dialog_name[6];
@@ -2008,7 +2012,7 @@ xdialog_show (FRAME_PTR f, int keymaps, Lisp_Object title, Lisp_Object header, c
      representing the text label and buttons.  */
   {
     Lisp_Object pane_name, prefix;
-    char *pane_string;
+    const char *pane_string;
     pane_name = XVECTOR (menu_items)->contents[MENU_ITEMS_PANE_NAME];
     prefix = XVECTOR (menu_items)->contents[MENU_ITEMS_PANE_PREFIX];
     pane_string = (NILP (pane_name)
@@ -2239,7 +2243,7 @@ pop_down_menu (Lisp_Object arg)
 
 Lisp_Object
 xmenu_show (FRAME_PTR f, int x, int y, int for_click, int keymaps,
-            Lisp_Object title, char **error, EMACS_UINT timestamp)
+            Lisp_Object title, const char **error, EMACS_UINT timestamp)
 {
   Window root;
   XMenu *menu;
diff --git a/src/xml.c b/src/xml.c
new file mode 100644
index 00000000000..c1098b15a20
--- /dev/null
+++ b/src/xml.c
@@ -0,0 +1,141 @@
+/* Interface to libxml2.
+   Copyright (C) 2010 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/>.  */
+
+#include <config.h>
+
+#ifdef HAVE_LIBXML2
+
+#include <setjmp.h>
+#include <libxml/tree.h>
+#include <libxml/parser.h>
+#include <libxml/HTMLparser.h>
+
+#include "lisp.h"
+#include "buffer.h"
+
+Lisp_Object make_dom (xmlNode *node)
+{
+  if (node->type == XML_ELEMENT_NODE) {
+    Lisp_Object result = Fcons (intern (node->name), Qnil);
+    xmlNode *child;
+    xmlAttr *property;
+
+    /* First add the attributes. */
+    property = node->properties;
+    while (property != NULL) {
+      if (property->children &&
+          property->children->content) {
+        char *pname = xmalloc (strlen (property->name) + 2);
+        *pname = ':';
+        strcpy(pname + 1, property->name);
+        result = Fcons (Fcons (intern (pname),
+                               build_string(property->children->content)),
+                        result);
+        xfree (pname);
+      }
+      property = property->next;
+    }
+    /* Then add the children of the node. */
+    child = node->children;
+    while (child != NULL) {
+      result = Fcons (make_dom (child), result);
+      child = child->next;
+    }
+    return Fnreverse (result);
+  } else if (node->type == XML_TEXT_NODE) {
+    Lisp_Object content = Qnil;
+
+    if (node->content)
+      content = build_string (node->content);
+
+    return Fcons (intern (node->name), content);
+  } else
+    return Qnil;
+}
+
+static Lisp_Object
+parse_buffer (Lisp_Object string, Lisp_Object base_url, int htmlp)
+{
+  xmlDoc *doc;
+  xmlNode *node;
+  Lisp_Object result;
+  int ibeg, iend;
+  char *burl = "";
+
+  LIBXML_TEST_VERSION;
+
+  CHECK_STRING (string);
+
+  if (! NILP (base_url)) {
+    CHECK_STRING (base_url);
+    burl = SDATA (base_url);
+  }
+
+  if (htmlp)
+    doc = htmlReadMemory (SDATA (string), SBYTES (string), burl, "utf-8",
+                          HTML_PARSE_RECOVER|HTML_PARSE_NONET|
+                          HTML_PARSE_NOWARNING|HTML_PARSE_NOERROR);
+  else
+    doc = xmlReadMemory (SDATA (string), SBYTES (string), burl, "utf-8",
+                         XML_PARSE_NONET|XML_PARSE_NOWARNING|
+                         XML_PARSE_NOERROR);
+
+  if (doc != NULL) {
+    node = xmlDocGetRootElement (doc);
+    if (node != NULL)
+      result = make_dom (node);
+
+    xmlFreeDoc (doc);
+    xmlCleanupParser ();
+  }
+
+  return result;
+}
+
+DEFUN ("html-parse-string", Fhtml_parse_string, Shtml_parse_string,
+       0, 2, 0,
+       doc: /* Parse the string as an HTML document and return the parse tree.
+If BASE-URL is non-nil, it will be used to expand relative URLs in
+the HTML document.*/)
+  (Lisp_Object string, Lisp_Object base_url)
+{
+  return parse_buffer (string, base_url, 1);
+}
+
+DEFUN ("xml-parse-string", Fxml_parse_string, Sxml_parse_string,
+       0, 2, 0,
+       doc: /* Parse the string as an XML document and return the parse tree.
+If BASE-URL is non-nil, it will be used to expand relative URLs in
+the XML document.*/)
+  (Lisp_Object string, Lisp_Object base_url)
+{
+  return parse_buffer (string, base_url, 0);
+}
+
+
+/***********************************************************************
+                            Initialization
+ ***********************************************************************/
+void
+syms_of_xml (void)
+{
+  defsubr (&Shtml_parse_string);
+  defsubr (&Sxml_parse_string);
+}
+
+#endif /* HAVE_LIBXML2 */
diff --git a/src/xrdb.c b/src/xrdb.c
index e0d948fd3a6..d81f08747ac 100644
--- a/src/xrdb.c
+++ b/src/xrdb.c
@@ -334,16 +334,17 @@ static XrmDatabase
 get_system_app (const char *class)
 {
   XrmDatabase db = NULL;
-  char *path;
+  const char *path;
+  char *p;
 
   path = getenv ("XFILESEARCHPATH");
   if (! path) path = PATH_X_DEFAULTS;
 
-  path = search_magic_path (path, class, 0, 0);
-  if (path)
+  p = search_magic_path (path, class, 0, 0);
+  if (p)
     {
-      db = XrmGetFileDatabase (path);
-      xfree (path);
+      db = XrmGetFileDatabase (p);
+      xfree (p);
     }
 
   return db;
@@ -360,7 +361,7 @@ get_fallback (Display *display)
 static XrmDatabase
 get_user_app (const char *class)
 {
-  char *path;
+  const char *path;
   char *file = 0;
   char *free_it = 0;
 
diff --git a/src/xselect.c b/src/xselect.c
index 9f15c7c2d99..7479f245a77 100644
--- a/src/xselect.c
+++ b/src/xselect.c
@@ -83,8 +83,6 @@ static void lisp_data_to_selection_data (Display *, Lisp_Object,
                                          unsigned char **, Atom *,
                                          unsigned *, int *, int *);
 static Lisp_Object clean_local_selection_data (Lisp_Object);
-static void initialize_cut_buffers (Display *, Window);
-
 
 /* Printing traces to stderr.  */
 
@@ -105,9 +103,7 @@ static void initialize_cut_buffers (Display *, Window);
 #endif
 
 
-#define CUT_BUFFER_SUPPORT
-
-Lisp_Object QPRIMARY, QSECONDARY, QSTRING, QINTEGER, QCLIPBOARD, QTIMESTAMP,
+Lisp_Object QSECONDARY, QSTRING, QINTEGER, QCLIPBOARD, QTIMESTAMP,
   QTEXT, QDELETE, QMULTIPLE, QINCR, QEMACS_TMP, QTARGETS, QATOM, QNULL,
   QATOM_PAIR;
 
@@ -116,11 +112,6 @@ Lisp_Object QUTF8_STRING;	/* This is a type of selection.  */
 
 Lisp_Object Qcompound_text_with_extensions;
 
-#ifdef CUT_BUFFER_SUPPORT
-Lisp_Object QCUT_BUFFER0, QCUT_BUFFER1, QCUT_BUFFER2, QCUT_BUFFER3,
-  QCUT_BUFFER4, QCUT_BUFFER5, QCUT_BUFFER6, QCUT_BUFFER7;
-#endif
-
 static Lisp_Object Vx_lost_selection_functions;
 static Lisp_Object Vx_sent_selection_functions;
 static Lisp_Object Qforeign_selection;
@@ -270,16 +261,6 @@ symbol_to_x_atom (struct x_display_info *dpyinfo, Display *display, Lisp_Object
   if (EQ (sym, QEMACS_TMP)) return dpyinfo->Xatom_EMACS_TMP;
   if (EQ (sym, QTARGETS))   return dpyinfo->Xatom_TARGETS;
   if (EQ (sym, QNULL))      return dpyinfo->Xatom_NULL;
-#ifdef CUT_BUFFER_SUPPORT
-  if (EQ (sym, QCUT_BUFFER0)) return XA_CUT_BUFFER0;
-  if (EQ (sym, QCUT_BUFFER1)) return XA_CUT_BUFFER1;
-  if (EQ (sym, QCUT_BUFFER2)) return XA_CUT_BUFFER2;
-  if (EQ (sym, QCUT_BUFFER3)) return XA_CUT_BUFFER3;
-  if (EQ (sym, QCUT_BUFFER4)) return XA_CUT_BUFFER4;
-  if (EQ (sym, QCUT_BUFFER5)) return XA_CUT_BUFFER5;
-  if (EQ (sym, QCUT_BUFFER6)) return XA_CUT_BUFFER6;
-  if (EQ (sym, QCUT_BUFFER7)) return XA_CUT_BUFFER7;
-#endif
   if (!SYMBOLP (sym)) abort ();
 
   TRACE1 (" XInternAtom %s", (char *) SDATA (SYMBOL_NAME (sym)));
@@ -315,24 +296,6 @@ x_atom_to_symbol (Display *dpy, Atom atom)
       return QINTEGER;
     case XA_ATOM:
       return QATOM;
-#ifdef CUT_BUFFER_SUPPORT
-    case XA_CUT_BUFFER0:
-      return QCUT_BUFFER0;
-    case XA_CUT_BUFFER1:
-      return QCUT_BUFFER1;
-    case XA_CUT_BUFFER2:
-      return QCUT_BUFFER2;
-    case XA_CUT_BUFFER3:
-      return QCUT_BUFFER3;
-    case XA_CUT_BUFFER4:
-      return QCUT_BUFFER4;
-    case XA_CUT_BUFFER5:
-      return QCUT_BUFFER5;
-    case XA_CUT_BUFFER6:
-      return QCUT_BUFFER6;
-    case XA_CUT_BUFFER7:
-      return QCUT_BUFFER7;
-#endif
     }
 
   dpyinfo = x_display_info_for_display (dpy);
@@ -2258,195 +2221,6 @@ and t is the same as `SECONDARY'.  */)
 }
 
 
-#ifdef CUT_BUFFER_SUPPORT
-
-/* Ensure that all 8 cut buffers exist.  ICCCM says we gotta...  */
-static void
-initialize_cut_buffers (Display *display, Window window)
-{
-  unsigned char *data = (unsigned char *) "";
-  BLOCK_INPUT;
-#define FROB(atom) XChangeProperty (display, window, atom, XA_STRING, 8, \
-                                    PropModeAppend, data, 0)
-  FROB (XA_CUT_BUFFER0);
-  FROB (XA_CUT_BUFFER1);
-  FROB (XA_CUT_BUFFER2);
-  FROB (XA_CUT_BUFFER3);
-  FROB (XA_CUT_BUFFER4);
-  FROB (XA_CUT_BUFFER5);
-  FROB (XA_CUT_BUFFER6);
-  FROB (XA_CUT_BUFFER7);
-#undef FROB
-  UNBLOCK_INPUT;
-}
-
-
-#define CHECK_CUT_BUFFER(symbol)                                        \
-  do { CHECK_SYMBOL ((symbol));                                 \
-    if (!EQ((symbol), QCUT_BUFFER0) && !EQ((symbol), QCUT_BUFFER1)      \
-        && !EQ((symbol), QCUT_BUFFER2) && !EQ((symbol), QCUT_BUFFER3)   \
-        && !EQ((symbol), QCUT_BUFFER4) && !EQ((symbol), QCUT_BUFFER5)   \
-        && !EQ((symbol), QCUT_BUFFER6) && !EQ((symbol), QCUT_BUFFER7))  \
-      signal_error ("Doesn't name a cut buffer", (symbol));             \
-  } while (0)
-
-DEFUN ("x-get-cut-buffer-internal", Fx_get_cut_buffer_internal,
-       Sx_get_cut_buffer_internal, 1, 1, 0,
-       doc: /* Returns the value of the named cut buffer (typically CUT_BUFFER0).  */)
-  (Lisp_Object buffer)
-{
-  Window window;
-  Atom buffer_atom;
-  unsigned char *data = NULL;
-  int bytes;
-  Atom type;
-  int format;
-  unsigned long size;
-  Lisp_Object ret;
-  Display *display;
-  struct x_display_info *dpyinfo;
-  struct frame *sf = SELECTED_FRAME ();
-
-  check_x ();
-
-  if (! FRAME_X_P (sf))
-    return Qnil;
-
-  display = FRAME_X_DISPLAY (sf);
-  dpyinfo = FRAME_X_DISPLAY_INFO (sf);
-  window = RootWindow (display, 0); /* Cut buffers are on screen 0 */
-  CHECK_CUT_BUFFER (buffer);
-  buffer_atom = symbol_to_x_atom (dpyinfo, display, buffer);
-
-  x_get_window_property (display, window, buffer_atom, &data, &bytes,
-                         &type, &format, &size, 0);
-
-  if (!data || !format)
-    {
-      xfree (data);
-      return Qnil;
-    }
-
-  if (format != 8 || type != XA_STRING)
-    signal_error ("Cut buffer doesn't contain 8-bit data",
-                  list2 (x_atom_to_symbol (display, type),
-                         make_number (format)));
-
-  ret = (bytes ? make_unibyte_string ((char *) data, bytes) : Qnil);
-  /* Use xfree, not XFree, because x_get_window_property
-     calls xmalloc itself.  */
-  xfree (data);
-  return ret;
-}
-
-
-DEFUN ("x-store-cut-buffer-internal", Fx_store_cut_buffer_internal,
-       Sx_store_cut_buffer_internal, 2, 2, 0,
-       doc: /* Sets the value of the named cut buffer (typically CUT_BUFFER0).  */)
-  (Lisp_Object buffer, Lisp_Object string)
-{
-  Window window;
-  Atom buffer_atom;
-  unsigned char *data;
-  int bytes;
-  int bytes_remaining;
-  int max_bytes;
-  Display *display;
-  struct frame *sf = SELECTED_FRAME ();
-
-  check_x ();
-
-  if (! FRAME_X_P (sf))
-    return Qnil;
-
-  display = FRAME_X_DISPLAY (sf);
-  window = RootWindow (display, 0); /* Cut buffers are on screen 0 */
-
-  max_bytes = SELECTION_QUANTUM (display);
-  if (max_bytes > MAX_SELECTION_QUANTUM)
-    max_bytes = MAX_SELECTION_QUANTUM;
-
-  CHECK_CUT_BUFFER (buffer);
-  CHECK_STRING (string);
-  buffer_atom = symbol_to_x_atom (FRAME_X_DISPLAY_INFO (sf),
-                                  display, buffer);
-  data = (unsigned char *) SDATA (string);
-  bytes = SBYTES (string);
-  bytes_remaining = bytes;
-
-  if (! FRAME_X_DISPLAY_INFO (sf)->cut_buffers_initialized)
-    {
-      initialize_cut_buffers (display, window);
-      FRAME_X_DISPLAY_INFO (sf)->cut_buffers_initialized = 1;
-    }
-
-  BLOCK_INPUT;
-
-  /* Don't mess up with an empty value.  */
-  if (!bytes_remaining)
-    XChangeProperty (display, window, buffer_atom, XA_STRING, 8,
-                     PropModeReplace, data, 0);
-
-  while (bytes_remaining)
-    {
-      int chunk = (bytes_remaining < max_bytes
-                   ? bytes_remaining : max_bytes);
-      XChangeProperty (display, window, buffer_atom, XA_STRING, 8,
-                       (bytes_remaining == bytes
-                        ? PropModeReplace
-                        : PropModeAppend),
-                       data, chunk);
-      data += chunk;
-      bytes_remaining -= chunk;
-    }
-  UNBLOCK_INPUT;
-  return string;
-}
-
-
-DEFUN ("x-rotate-cut-buffers-internal", Fx_rotate_cut_buffers_internal,
-       Sx_rotate_cut_buffers_internal, 1, 1, 0,
-       doc: /* Rotate the values of the cut buffers by N steps.
-Positive N means shift the values forward, negative means backward.  */)
-  (Lisp_Object n)
-{
-  Window window;
-  Atom props[8];
-  Display *display;
-  struct frame *sf = SELECTED_FRAME ();
-
-  check_x ();
-
-  if (! FRAME_X_P (sf))
-    return Qnil;
-
-  display = FRAME_X_DISPLAY (sf);
-  window = RootWindow (display, 0); /* Cut buffers are on screen 0 */
-  CHECK_NUMBER (n);
-  if (XINT (n) == 0)
-    return n;
-  if (! FRAME_X_DISPLAY_INFO (sf)->cut_buffers_initialized)
-    {
-      initialize_cut_buffers (display, window);
-      FRAME_X_DISPLAY_INFO (sf)->cut_buffers_initialized = 1;
-    }
-
-  props[0] = XA_CUT_BUFFER0;
-  props[1] = XA_CUT_BUFFER1;
-  props[2] = XA_CUT_BUFFER2;
-  props[3] = XA_CUT_BUFFER3;
-  props[4] = XA_CUT_BUFFER4;
-  props[5] = XA_CUT_BUFFER5;
-  props[6] = XA_CUT_BUFFER6;
-  props[7] = XA_CUT_BUFFER7;
-  BLOCK_INPUT;
-  XRotateWindowProperties (display, window, props, 8, XINT (n));
-  UNBLOCK_INPUT;
-  return n;
-}
-
-#endif
-
 /***********************************************************************
                       Drag and drop support
 ***********************************************************************/
@@ -2596,6 +2370,7 @@ If the value is 0 or the atom is not known, return the empty string.  */)
 {
   struct frame *f = check_x_frame (frame);
   char *name = 0;
+  char empty[] = "";
   Lisp_Object ret = Qnil;
   Display *dpy = FRAME_X_DISPLAY (f);
   Atom atom;
@@ -2612,7 +2387,7 @@ If the value is 0 or the atom is not known, return the empty string.  */)
 
   BLOCK_INPUT;
   x_catch_errors (dpy);
-  name = atom ? XGetAtomName (dpy, atom) : "";
+  name = atom ? XGetAtomName (dpy, atom) : empty;
   had_errors = x_had_errors_p (dpy);
   x_uncatch_errors ();
 
@@ -2849,12 +2624,6 @@ syms_of_xselect (void)
   defsubr (&Sx_selection_owner_p);
   defsubr (&Sx_selection_exists_p);
 
-#ifdef CUT_BUFFER_SUPPORT
-  defsubr (&Sx_get_cut_buffer_internal);
-  defsubr (&Sx_store_cut_buffer_internal);
-  defsubr (&Sx_rotate_cut_buffers_internal);
-#endif
-
   defsubr (&Sx_get_atom_name);
   defsubr (&Sx_send_client_message);
   defsubr (&Sx_register_dnd_atom);
@@ -2936,17 +2705,6 @@ A value of 0 means wait as long as necessary.  This is initialized from the
   Qcompound_text_with_extensions = intern_c_string ("compound-text-with-extensions");
   staticpro (&Qcompound_text_with_extensions);
 
-#ifdef CUT_BUFFER_SUPPORT
-  QCUT_BUFFER0 = intern_c_string ("CUT_BUFFER0"); staticpro (&QCUT_BUFFER0);
-  QCUT_BUFFER1 = intern_c_string ("CUT_BUFFER1"); staticpro (&QCUT_BUFFER1);
-  QCUT_BUFFER2 = intern_c_string ("CUT_BUFFER2"); staticpro (&QCUT_BUFFER2);
-  QCUT_BUFFER3 = intern_c_string ("CUT_BUFFER3"); staticpro (&QCUT_BUFFER3);
-  QCUT_BUFFER4 = intern_c_string ("CUT_BUFFER4"); staticpro (&QCUT_BUFFER4);
-  QCUT_BUFFER5 = intern_c_string ("CUT_BUFFER5"); staticpro (&QCUT_BUFFER5);
-  QCUT_BUFFER6 = intern_c_string ("CUT_BUFFER6"); staticpro (&QCUT_BUFFER6);
-  QCUT_BUFFER7 = intern_c_string ("CUT_BUFFER7"); staticpro (&QCUT_BUFFER7);
-#endif
-
   Qforeign_selection = intern_c_string ("foreign-selection");
   staticpro (&Qforeign_selection);
 }
diff --git a/src/xsmfns.c b/src/xsmfns.c
index 0096110bd46..79dccfa55e1 100644
--- a/src/xsmfns.c
+++ b/src/xsmfns.c
@@ -87,7 +87,7 @@ Lisp_Object Vx_session_previous_id;
 /* The option to start Emacs without the splash screen when
    restarting Emacs.  */
 
-#define NOSPLASH_OPT "--no-splash"
+static char NOSPLASH_OPT[] = "--no-splash";
 
 /* The option to make Emacs start in the given directory.  */
 
@@ -198,14 +198,14 @@ smc_save_yourself_CB (SmcConn smcConn,
   SmPropValue values[20];
   int val_idx = 0;
   int props_idx = 0;
-
+  int i;
   char *cwd = NULL;
   char *smid_opt, *chdir_opt = NULL;
 
   /* How to start a new instance of Emacs.  */
   props[props_idx] = &prop_ptr[props_idx];
-  props[props_idx]->name = SmCloneCommand;
-  props[props_idx]->type = SmLISTofARRAY8;
+  props[props_idx]->name = xstrdup (SmCloneCommand);
+  props[props_idx]->type = xstrdup (SmLISTofARRAY8);
   props[props_idx]->num_vals = 1;
   props[props_idx]->vals = &values[val_idx++];
   props[props_idx]->vals[0].length = strlen (emacs_program);
@@ -214,8 +214,8 @@ smc_save_yourself_CB (SmcConn smcConn,
 
   /* The name of the program.  */
   props[props_idx] = &prop_ptr[props_idx];
-  props[props_idx]->name = SmProgram;
-  props[props_idx]->type = SmARRAY8;
+  props[props_idx]->name = xstrdup (SmProgram);
+  props[props_idx]->type = xstrdup (SmARRAY8);
   props[props_idx]->num_vals = 1;
   props[props_idx]->vals = &values[val_idx++];
   props[props_idx]->vals[0].length = strlen (SSDATA (Vinvocation_name));
@@ -224,8 +224,8 @@ smc_save_yourself_CB (SmcConn smcConn,
 
   /* How to restart Emacs.  */
   props[props_idx] = &prop_ptr[props_idx];
-  props[props_idx]->name = SmRestartCommand;
-  props[props_idx]->type = SmLISTofARRAY8;
+  props[props_idx]->name = xstrdup (SmRestartCommand);
+  props[props_idx]->type = xstrdup (SmLISTofARRAY8);
   /* /path/to/emacs, --smid=xxx --no-splash --chdir=dir */
   props[props_idx]->num_vals = 4;
   props[props_idx]->vals = &values[val_idx];
@@ -258,8 +258,8 @@ smc_save_yourself_CB (SmcConn smcConn,
 
   /* User id.  */
   props[props_idx] = &prop_ptr[props_idx];
-  props[props_idx]->name = SmUserID;
-  props[props_idx]->type = SmARRAY8;
+  props[props_idx]->name = xstrdup (SmUserID);
+  props[props_idx]->type = xstrdup (SmARRAY8);
   props[props_idx]->num_vals = 1;
   props[props_idx]->vals = &values[val_idx++];
   props[props_idx]->vals[0].length = strlen (SSDATA (Vuser_login_name));
@@ -270,8 +270,8 @@ smc_save_yourself_CB (SmcConn smcConn,
   if (cwd)
     {
       props[props_idx] = &prop_ptr[props_idx];
-      props[props_idx]->name = SmCurrentDirectory;
-      props[props_idx]->type = SmARRAY8;
+      props[props_idx]->name = xstrdup (SmCurrentDirectory);
+      props[props_idx]->type = xstrdup (SmARRAY8);
       props[props_idx]->num_vals = 1;
       props[props_idx]->vals = &values[val_idx++];
       props[props_idx]->vals[0].length = strlen (cwd);
@@ -286,6 +286,11 @@ smc_save_yourself_CB (SmcConn smcConn,
   xfree (chdir_opt);
 
   free (cwd);
+  for (i = 0; i < props_idx; ++i)
+    {
+      xfree (props[i]->type);
+      xfree (props[i]->name);
+    }
 
   /* See if we maybe shall interact with the user.  */
   if (interactStyle != SmInteractStyleAny
diff --git a/src/xterm.c b/src/xterm.c
index e6bf82ab5a5..2ebe8a80378 100644
--- a/src/xterm.c
+++ b/src/xterm.c
@@ -301,6 +301,9 @@ static Lisp_Object xg_default_icon_file;
 Lisp_Object Qx_gtk_map_stock;
 #endif
 
+/* Some functions take this as char *, not const char *.  */
+static char emacs_class[] = EMACS_CLASS;
+
 /* Used in x_flush.  */
 
 extern XrmDatabase x_load_resources (Display *, const char *, const char *,
@@ -2432,17 +2435,34 @@ x_draw_stretch_glyph_string (struct glyph_string *s)
   if (s->hl == DRAW_CURSOR
       && !x_stretch_cursor_p)
     {
-      /* If `x-stretch-block-cursor' is nil, don't draw a block cursor
-         as wide as the stretch glyph.  */
+      /* If `x-stretch-cursor' is nil, don't draw a block cursor as
+         wide as the stretch glyph.  */
       int width, background_width = s->background_width;
-      int x = s->x, left_x = window_box_left_offset (s->w, TEXT_AREA);
+      int x = s->x;
 
-      if (x < left_x)
+      if (!s->row->reversed_p)
         {
-          background_width -= left_x - x;
-          x = left_x;
+          int left_x = window_box_left_offset (s->w, TEXT_AREA);
+
+          if (x < left_x)
+            {
+              background_width -= left_x - x;
+              x = left_x;
+            }
+        }
+      else
+        {
+          /* In R2L rows, draw the cursor on the right edge of the
+             stretch glyph.  */
+          int right_x = window_box_right_offset (s->w, TEXT_AREA);
+
+          if (x + background_width > right_x)
+            background_width -= x - right_x;
+          x += background_width;
         }
       width = min (FRAME_COLUMN_WIDTH (s->f), background_width);
+      if (s->row->reversed_p)
+        x -= width;
 
       /* Draw cursor.  */
       x_draw_glyph_string_bg_rect (s, x, s->y, width, s->height);
@@ -2455,7 +2475,10 @@ x_draw_stretch_glyph_string (struct glyph_string *s)
           XRectangle r;
           GC gc;
 
-          x += width;
+          if (!s->row->reversed_p)
+            x += width;
+          else
+            x = s->x;
           if (s->row->mouse_face_p
               && cursor_in_mouse_face_p (s->w))
             {
@@ -7129,14 +7152,20 @@ x_draw_bar_cursor (struct window *w, struct glyph_row *row, int width, enum text
 
       if (kind == BAR_CURSOR)
         {
+          int x = WINDOW_TEXT_TO_FRAME_PIXEL_X (w, w->phys_cursor.x);
+
           if (width < 0)
             width = FRAME_CURSOR_WIDTH (f);
           width = min (cursor_glyph->pixel_width, width);
 
           w->phys_cursor_width = width;
 
-          XFillRectangle (dpy, window, gc,
-                          WINDOW_TEXT_TO_FRAME_PIXEL_X (w, w->phys_cursor.x),
+          /* If the character under cursor is R2L, draw the bar cursor
+             on the right of its glyph, rather than on the left.  */
+          if ((cursor_glyph->resolved_level & 1) != 0)
+            x += cursor_glyph->pixel_width - width;
+
+          XFillRectangle (dpy, window, gc, x,
                           WINDOW_TO_FRAME_PIXEL_Y (w, w->phys_cursor.y),
                           width, row->height);
         }
@@ -7872,7 +7901,7 @@ xim_open_dpy (struct x_display_info *dpyinfo, char *resource_name)
       if (dpyinfo->xim)
         XCloseIM (dpyinfo->xim);
       xim = XOpenIM (dpyinfo->display, dpyinfo->xrdb, resource_name,
-                     EMACS_CLASS);
+                     emacs_class);
       dpyinfo->xim = xim;
 
       if (xim)
@@ -7973,7 +8002,7 @@ xim_initialize (struct x_display_info *dpyinfo, char *resource_name)
       xim_inst->resource_name = (char *) xmalloc (len + 1);
       memcpy (xim_inst->resource_name, resource_name, len + 1);
       XRegisterIMInstantiateCallback (dpyinfo->display, dpyinfo->xrdb,
-                                      resource_name, EMACS_CLASS,
+                                      resource_name, emacs_class,
                                       xim_instantiate_callback,
                                       /* This is XPointer in XFree86
                                          but (XPointer *) on Tru64, at
@@ -7998,7 +8027,7 @@ xim_close_dpy (struct x_display_info *dpyinfo)
 #ifdef HAVE_X11R6_XIM
       if (dpyinfo->display)
         XUnregisterIMInstantiateCallback (dpyinfo->display, dpyinfo->xrdb,
-                                          NULL, EMACS_CLASS,
+                                          NULL, emacs_class,
                                           xim_instantiate_callback, NULL);
       xfree (dpyinfo->xim_callback_data->resource_name);
       xfree (dpyinfo->xim_callback_data);
@@ -9709,6 +9738,9 @@ x_term_init (Lisp_Object display_name, char *xrm_option, char *resource_name)
       }
     else
       {
+        static char display_opt[] = "--display";
+        static char name_opt[] = "--name";
+        
         for (argc = 0; argc < NUM_ARGV; ++argc)
           argv[argc] = 0;
 
@@ -9717,11 +9749,11 @@ x_term_init (Lisp_Object display_name, char *xrm_option, char *resource_name)
 
         if (! NILP (display_name))
           {
-            argv[argc++] = "--display";
+            argv[argc++] = display_opt;
             argv[argc++] = SDATA (display_name);
           }
 
-        argv[argc++] = "--name";
+        argv[argc++] = name_opt;
         argv[argc++] = resource_name;
 
         XSetLocaleModifiers ("");
@@ -9744,7 +9776,7 @@ x_term_init (Lisp_Object display_name, char *xrm_option, char *resource_name)
 
         /* Load our own gtkrc if it exists.  */
         {
-          char *file = "~/.emacs.d/gtkrc";
+          const char *file = "~/.emacs.d/gtkrc";
           Lisp_Object s, abs_file;
 
           s = make_string (file, strlen (file));
@@ -10092,8 +10124,6 @@ x_term_init (Lisp_Object display_name, char *xrm_option, char *resource_name)
   dpyinfo->Xatom_net_wm_name
     = XInternAtom (dpyinfo->display, "_NET_WM_NAME", False);
 
-  dpyinfo->cut_buffers_initialized = 0;
-
   dpyinfo->x_dnd_atoms_size = 8;
   dpyinfo->x_dnd_atoms_length = 0;
   dpyinfo->x_dnd_atoms = xmalloc (sizeof (*dpyinfo->x_dnd_atoms)
diff --git a/src/xterm.h b/src/xterm.h
index 972bfb50dc3..d884945f985 100644
--- a/src/xterm.h
+++ b/src/xterm.h
@@ -299,8 +299,6 @@ struct x_display_info
   /* Atom used in XEmbed client messages.  */
   Atom Xatom_XEMBED;
  
-  int cut_buffers_initialized; /* Whether we're sure they all exist */
-
   /* The frame (if any) which has the X window that has keyboard focus.
      Zero if none.  This is examined by Ffocus_frame in xfns.c.  Note
      that a mere EnterNotify event can set this; if you need to know the