Merge from trunk

82 files changed, 3526 insertions, 1808 deletions

diff --git a/src/ChangeLog.10 b/src/ChangeLog.10
index dd847f8a64e..393c7bdf8dc 100644
--- a/src/ChangeLog.10
+++ b/src/ChangeLog.10
@@ -6914,7 +6914,7 @@
 
         * search.c (search_buffer): Give up BM search on case-fold-search
         if one of a target character has a case-equivalence of different
-        charset even if that target charcter is an ASCII.
+        charset even if that target character is an ASCII.
 
         * casefiddle.c (casify_object): Fix for the case that case
         conversion change the byte length.
@@ -21089,7 +21089,7 @@
 
         * w32.c (g_b_init_is_windows_9x, g_b_init_open_process_token)
         (g_b_init_get_token_information, g_b_init_lookup_account_sid)
-        (g_b_init_get_sid_identifier_authority ): Add several static
+        (g_b_init_get_sid_identifier_authority): Add several static
         global variables.
 
         * w32.c (globals_of_w32): New function.  Used to initialize those
diff --git a/src/ChangeLog.5 b/src/ChangeLog.5
index 9be45e2fc54..cc3fcdd88f2 100644
--- a/src/ChangeLog.5
+++ b/src/ChangeLog.5
@@ -4093,7 +4093,7 @@
 
         * xterm.h: Delete X10 code.
 
-        * xfns.c (Fx_create_frame): Don't increment refernce_count
+        * xfns.c (Fx_create_frame): Don't increment reference_count
         until the frame is put on the frame list.
 
         * xterm.c (x_initialize): Init x_noop_count, x_focus_frame
diff --git a/src/ChangeLog.7 b/src/ChangeLog.7
index 6cc3d0f9e3e..7421aba4403 100644
--- a/src/ChangeLog.7
+++ b/src/ChangeLog.7
@@ -1040,7 +1040,7 @@
 
         * lread.c: Remember the last TWO strings skipped with #@.
         (prev_saved_doc_string*): New variables.
-        (Fload): Initalize prev_saved_doc_string.
+        (Fload): Initialize prev_saved_doc_string.
         (read1): Copy saved_doc_string to prev_saved_doc_string
         before storing a new string in saved_doc_string.
         (read_list): Look in prev_saved_doc_string as well as
diff --git a/src/ChangeLog.8 b/src/ChangeLog.8
index 4dd3d0dd071..5033a055576 100644
--- a/src/ChangeLog.8
+++ b/src/ChangeLog.8
@@ -10392,7 +10392,7 @@
         * term.c (get_char_info): Use WHAT field of CHAR_INFO.
         Use tabs as multiples of spaces.
 
-        * dispextern.h (struct char_info ): WHAT field.
+        * dispextern.h (struct char_info): WHAT field.
 
         * term.c (encode_terminal_code): Don't use GLYPH_CHAR, use
         FAST_GLYPH_CHAR instead because GLYPH_CHAR won't remove faces.
@@ -10407,8 +10407,7 @@
 
         * xterm.c (XTget_char_info): Check WANT_ELLIPSIS_P.
 
-        * dispextern.h (struct char_info ): GLYPH_ROW for intermediate
-        glyphs.
+        * dispextern.h (struct char_info): GLYPH_ROW for intermediate glyphs.
 
         * dispnew.c (init_char_info): Init GLYPH_ROW to NULL.  CHAR_CURSOR
         moved to xdisp.c.
@@ -10436,7 +10435,7 @@
 
         * term.c (get_char_info): Set MAX_PIXEL_WIDTH in CHAR_INFO.
 
-        * dispextern.h (struct char_info ): Use LISP_CHAR_TABLE for DP.
+        * dispextern.h (struct char_info): Use LISP_CHAR_TABLE for DP.
         New member MAX_PIXEL_HEIGHT.
 
         * xterm.c (x_per_char_metric): Get per character metrics.
@@ -13869,10 +13868,10 @@
 1998-08-31  Kenichi Handa  <handa@etl.go.jp>
 
         * charset.c (unibyte_char_to_multibyte):
-        Vnonacii_translation_table will convert a 7-bit charcater.
+        Vnonacii_translation_table will convert a 7-bit character.
         (multibyte_char_to_unibyte): Handle the case that
-        Vnonacii_translation_table converts a multibyte charcater to a
-        unibyte charcter of less than 128.
+        Vnonacii_translation_table converts a multibyte character to a
+        unibyte character of less than 128.
         (init_charset_once): Initialize nonascii_insert_offset and
         Vnonacii_translation_table.
 
diff --git a/src/ChangeLog.trunk b/src/ChangeLog.trunk
index 87b54529f2e..de4ba68bdc0 100644
--- a/src/ChangeLog.trunk
+++ b/src/ChangeLog.trunk
@@ -1,3 +1,827 @@
+2010-09-29  Lars Magne Ingebrigtsen  <larsi@gnus.org>
+
+        * gnutls.c (emacs_gnutls_handshake): Made into internal function.
+        (Fgnutls_boot): Start the handshake.
+        (emacs_gnutls_read): Perform the handshake from the reader loop.
+        (Fgnutls_boot): Remove some debugging messages.
+        Change indentation throughout to use the Emacs style.
+        (emacs_gnutls_handshake): Cast the fds to something that's
+        possibly the expected length.
+        (emacs_gnutls_write): Return -1 if we try to write before handshake.
+
+        * process.h (Lisp_Process): Add a gnutls_p field to Lisp_Process.
+
+        * process.c (make_process): Set the gnutls_p field to zero by
+        default.
+        (read_process_output): Always call the gnutls_read function if the
+        stream is a gnutls stream.
+        (send_process): Ditto for writes.
+
+        * gnutls.c (emacs_gnutls_write, emacs_gnutls_read): Refuse to read
+        or write anything until the state is GNUTLS_STAGE_READY.
+        (Fgnutls_boot): Mark the stream as being a gnutls stream.
+
+2010-09-29  Eli Zaretskii  <eliz@gnu.org>
+
+        * xdisp.c (reseat_1): Initialize bidi_it.paragraph_dir to
+        NEUTRAL_DIR.
+        (handle_invisible_prop, iterate_out_of_display_property)
+        (next_element_from_buffer): If bidi_it.first_elt is set, call
+        bidi_paragraph_init with NO_DEFAULT_P argument non-zero.
+        (Bug#7128)
+
+        * print.c (print_object): Fix format string and argument types for
+        printing a Lisp_Misc_Marker.
+
+        * xdisp.c (pos_visible_p, c_string_pos, number_of_chars)
+        (load_overlay_strings, get_overlay_strings_1)
+        (get_overlay_strings, forward_to_next_line_start)
+        (back_to_previous_visible_line_start, reseat, reseat_to_string)
+        (get_next_display_element, next_element_from_string)
+        (next_element_from_c_string, next_element_from_buffer)
+        (move_it_vertically_backward, move_it_by_lines, add_to_log)
+        (message_dolog, message_log_check_duplicate, message2_nolog)
+        (message3, message3_nolog, vmessage, set_message, set_message_1)
+        (hscroll_window_tree, text_outside_line_unchanged_p)
+        (set_cursor_from_row, set_vertical_scroll_bar, redisplay_window)
+        (find_last_unchanged_at_beg_row)
+        (find_first_unchanged_at_end_row, row_containing_pos)
+        (trailing_whitespace_p, display_mode_element, decode_mode_spec)
+        (display_count_lines, x_produce_glyphs, note_mouse_highlight): Use
+        EMACS_INT for buffer and string positions.
+
+        * dispextern.h (struct it) <string_nchars>: Declare EMACS_INT.
+        (row_containing_pos): Adjust prototype.
+
+        * lisp.h (pos_visible_p, message2, message2_nolog, message3)
+        (message2_nolog, set_message): Adjust prototypes.
+
+2010-09-28  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * gnutls.c (Fgnutls_boot): Remove unused vars `data' and `srp_cred'.
+        (Fgnutls_boot): Use SDATA.
+        (Fgnutls_handshake): Remove unused var `max_log_level'.
+
+2010-09-27  Michael Albinus  <michael.albinus@gmx.de>
+
+        * dbusbind.c (syms_of_dbusbind): Set $DBUS_FATAL_WARNINGS to "0".
+        (Bug#7113)
+
+2010-09-27  Jan Djärv  <jan.h.d@swipnet.se>
+
+        * xgselect.c (xg_select): Clear file descriptors not set from
+        rfds and wfds.
+
+        * process.c (wait_reading_process_output): Add missing FD_CLR
+        for write_mask (must mirror connect_wait_mask).
+
+2010-09-27  Teodor Zlatanov  <tzz@lifelogs.com>
+
+        * gnutls.c (gnutls_log_function): Show level and "gnutls.c"
+        prefix.
+        (Fgnutls_boot): Use changed process members.  Use log level with a
+        function parameter to set it.  Bring back Emacs-level debugging
+        messages at log level 1 and 2.
+
+        * process.c (make_process): Initialize gnutls_log_level.
+
+        * process.h: Add gnutls_log_level and rename x509_cred and
+        anon_cred to have the gnutls_ prefix for consistency.
+
+        * gnutls.h (GNUTLS_LOG): Add convenience macro.
+
+2010-09-27  Juanma Barranquero  <lekktu@gmail.com>
+
+        * w32.c (g_b_init_get_sid_identifier_authority)
+        (GetSidIdentifierAuthority_Proc, get_sid_identifier_authority):
+        Remove, not used.
+        (globals_of_w32): Don't set g_b_init_get_sid_identifier_authority.
+        (init_winsock): Remove useless assignment.
+        (open_process_token, get_token_information, lookup_account_sid)
+        (get_sid_sub_authority, get_sid_sub_authority_count, get_file_security)
+        (get_security_descriptor_owner, get_security_descriptor_group)
+        (is_valid_sid, equal_sid, get_length_sid, copy_sid)
+        (get_native_system_info, get_system_times, init_user_info, crlf_to_lf)
+        (is_unc_volume, GetCachedVolumeInformation, get_volume_info)
+        (is_fat_volume, open_unc_volume, read_unc_volume, close_unc_volume)
+        (unc_volume_file_attributes, convert_from_time_t)
+        (create_toolhelp32_snapshot, process32_first, process32_next)
+        (open_thread_token, impersonate_self, revert_to_self)
+        (get_process_memory_info, get_process_working_set_size)
+        (global_memory_status, global_memory_status_ex, socket_to_fd)
+        (shutdown_handler): Make static.
+
+2010-09-27  Michael Albinus  <michael.albinus@gmx.de>
+
+        * dbusbind.c (dbus_fd_cb, xd_get_dispatch_status)
+        (xd_pending_messages): Functions removed.
+        (xd_read_queued_messages): Add parameters fd, *data, for_read in
+        order to be compatible with add_read_fd.  Determine bus from data,
+        and call xd_read_message just for this bus.
+        (xd_add_watch): Use xd_read_queued_messages as callback function.
+        Add data.
+
+        * lisp.h (xd_pending_messages, xd_read_queued_messages): Remove.
+
+2010-09-27  Lars Magne Ingebrigtsen  <larsi@gnus.org>
+
+        * gnutls.c (gnutls_log_function): Added more debugging.
+        (emacs_gnutls_read): Don't infloop while reading.
+
+2010-09-27  Kenichi Handa  <handa@m17n.org>
+
+        These changes are to remove restriction on the number of glyphs in
+        one composition.
+
+        * dispextern.h (struct glyph): Change the member "slice" to union.
+        Remove u.cmp.from and u.cmp.to.  Give more bits to u.cmp.id.
+        (GLYPH_SLICE_EQUAL_P): Adjusted for the above change.
+
+        * dispnew.c (buffer_posn_from_coords): Use glyph->slice.img
+        instead of glyph->slice.
+        (marginal_area_string): Likewise.
+
+        * term.c (encode_terminal_code): Use glyph->slice.cmp instead of
+        glyph->u.cmp.
+        (append_composite_glyph): Likewise.
+
+        * xdisp.c (dump_glyph): Use glyph->slice.cmp instead of
+        glyph->u.cmp.
+        (fill_gstring_glyph_string, x_get_glyph_overhangs)
+        (append_composite_glyph): Likewise.
+        (fill_image_glyph_string): Use glyph->slice.img instead of
+        glyph->slice.
+        (append_glyph, produce_image_glyph, append_stretch_glyph)
+        (note_mouse_highlight): Likewise.
+
+2010-09-26  Jan Djärv  <jan.h.d@swipnet.se>
+
+        * process.c (add_keyboard_wait_descriptor)
+        (delete_keyboard_wait_descriptor): Reinstate ifdef subprocesses.
+        (wait_reading_process_output): Don't pass write_mask to select
+        if SELECT_CANT_DO_WRITE_MASK is defined.
+        (SELECT_CANT_DO_WRITE_MASK): Define if SELECT_CANT_DO_WRITE_MASK.
+
+        * process.h (add_read_fd, delete_read_fd, add_write_fd)
+        (delete_write_fd): Declare.
+
+        * process.c (gpm_wait_mask, max_gpm_desc): Remove.
+        (write_mask): New variable.
+        (max_input_desc): Renamed from max_keyboard_desc.
+        (fd_callback_info): New variable.
+        (add_read_fd, delete_read_fd, add_write_fd, delete_write_fd):
+        New functions.
+        (Fmake_network_process): FD_SET write_mask.
+        (deactivate_process): FD_CLR write_mask.
+        (wait_reading_process_output): Connecting renamed to Writeok.
+        check_connect removed.  check_write is new.  Remove references to gpm.
+        Use Writeok/check_write unconditionally (i.e. no #ifdef
+        NON_BLOCKING_CONNECT) instead of Connecting.
+        Loop over file descriptors and call callbacks in fd_callback_info
+        if file descriptor is ready for I/O.
+        (add_gpm_wait_descriptor): Just call add_keyboard_wait_descriptor.
+        (delete_gpm_wait_descriptor): Just call delete_keyboard_wait_descriptor.
+        (keyboard_bit_set): Use max_input_desc.
+        (add_keyboard_wait_descriptor, delete_keyboard_wait_descriptor):
+        Remove #ifdef subprocesses.  Use max_input_desc.
+        (init_process): Initialize write_mask and fd_callback_info.
+
+        * keyboard.c (readable_events, gobble_input): Remove DBUS code.
+
+        * dbusbind.c: Include process.h.
+        (dbus_fd_cb, xd_find_watch_fd, xd_toggle_watch)
+        (xd_read_message_1): New functions.
+        (xd_add_watch, xd_remove_watch): Call xd_find_watch_fd.
+        Handle watch for both read and write.
+        (Fdbus_init_bus): Also register xd_toggle_watch.
+        (Fdbus_call_method_asynchronously, Fdbus_method_return_internal)
+        (Fdbus_method_error_internal, Fdbus_send_signal): Remove call
+        to dbus_connection_flush.
+        (xd_read_message): Move most of the code to xd_read_message_1.
+        Call xd_read_message_1 until status is COMPLETE.
+
+2010-09-26  Dan Nicolaescu  <dann@ics.uci.edu>
+
+        * term.c: Do not include sys/ioctl.h, not needed.
+        (init_tty): Reorder code to reduce the number of #ifdefs.
+        No code changes.
+
+2010-09-26  Teodor Zlatanov  <tzz@lifelogs.com>
+
+        * process.h: Set up GnuTLS support.
+
+        * process.c (make_process, Fstart_process)
+        (read_process_output, send_process): Set up GnuTLS support for
+        process input/output file descriptors.
+
+        * gnutls.h: The GnuTLS glue for Emacs, macros and enums.
+
+        * gnutls.c: The source code for GnuTLS support in Emacs.
+
+        * emacs.c: Set up GnuTLS support and call syms_of_gnutls.
+
+        * config.in: Set up GnuTLS support.
+
+        * Makefile.in (LIBGNUTLS_LIBS, LIBGNUTLS_CFLAGS, ALL_CFLAGS)
+        (obj, LIBES): Set up GnuTLS support.
+
+2010-09-26  Juanma Barranquero  <lekktu@gmail.com>
+
+        * w32.c (get_emacs_configuration_options): Fix previous change.
+
+2010-09-25  Chong Yidong  <cyd@stupidchicken.com>
+
+        * insdel.c (prepare_to_modify_buffer): Ensure the mark marker is
+        alive before using it (Bug#6977).
+
+2010-09-25  Lars Magne Ingebrigtsen  <larsi@gnus.org>
+
+        * xdisp.c (face_before_or_after_it_pos): EMACS_INT/int fixup.
+
+        * dispextern.h: EMACS_INT/int fixup.
+
+        * xdisp.c (string_pos_nchars_ahead, init_iterator): EMACS_INT/int
+        fixup.
+
+        * xrdb.c (magic_file_p): EMACS_INT/int fixup.
+
+2010-09-25  Eli Zaretskii  <eliz@gnu.org>
+
+        * window.c (Fpos_visible_in_window_p, Fdelete_other_windows)
+        (Fselect_window, window_scroll_pixel_based)
+        (window_scroll_line_based, Frecenter, Fset_window_configuration):
+        Use EMACS_INT for buffer positions.
+
+        * textprop.c (validate_interval_range, interval_of)
+        (property_change_between_p, Fadd_text_properties)
+        (set_text_properties_1, Fremove_text_properties)
+        (Fremove_list_of_text_properties, Ftext_property_any)
+        (Ftext_property_not_all, copy_text_properties)
+        (text_property_list, extend_property_ranges)
+        (verify_interval_modification): Use EMACS_INT for buffer
+        positions.
+
+        * term.c (fast_find_position, term_mouse_highlight): Use EMACS_INT
+        for buffer positions.
+
+        * process.c (read_process_output, send_process)
+        (Fprocess_send_region, status_notify): Use EMACS_INT for buffer
+        and string positions and size.
+
+        * print.c (print_object, print_string, strout): Use EMACS_INT for
+        string indices.
+
+        * minibuf.c (string_to_object): Use EMACS_INT for string position
+        and size.
+
+        * marker.c (verify_bytepos): Use EMACS_INT for buffer positions.
+
+        * lread.c <read_from_string_index, read_from_string_index_byte>
+        <read_from_string_limit, readchar_count>: Define EMACS_INT.
+        (readchar, unreadchar, read_internal_start): Use EMACS_INT for
+        buffer positions and string length.
+
+        * keyboard.c <last_point_position, last_non_minibuf_size>: Declare
+        EMACS_INT.
+        (echo_truncate, adjust_point_for_property, read_char)
+        (gen_help_event, make_lispy_event, modify_event_symbol)
+        (Fexecute_extended_command, stuff_buffered_input): Use EMACS_INT
+        for buffer positions and string length.
+
+        * keyboard.h (gen_help_event): Adjust prototype.
+
+        * termhooks.h <struct input_event>: Make `code' member EMACS_INT.
+
+        * commands.h <last_point_position>: Declare EMACS_INT.
+
+        * xdisp.c <help_echo_pos>: Define as EMACS_INT.
+        (truncate_echo_area): Accept EMACS_INT argument.
+
+        * dispextern.h <help_echo_pos>: Declare EMACS_INT.
+
+        * lisp.h (truncate_echo_area): Adjust prototype.
+
+        * composite.c (composition_adjust_point): Return EMACS_INT.
+
+        * composite.h (composition_adjust_point): Adjust prototype.
+
+2010-09-25  Juanma Barranquero  <lekktu@gmail.com>
+
+        * process.c (Fmake_network_process): When arg :host is 'local,
+        use address 127.0.0.1, not name "localhost".  (Bug#6781)
+
+2010-09-24  Eli Zaretskii  <eliz@gnu.org>
+
+        * indent.c (Fcurrent_indentation, indented_beyond_p)
+        (compute_motion): Use EMACS_INT for buffer position variables.
+
+        * lisp.h (indented_beyond_p): Adjust prototype.
+
+        * buffer.c (overlay_strings): Return EMACS_INT.
+
+        * buffer.h (overlay_strings): Adjust prototype.
+
+        * region-cache.c (pp_cache): Adjust format to arguments.
+
+        * eval.c <specpdl_size, lisp_eval_depth>: Declare EMACS_INT.
+        (call_debugger): Use EMACS_INT for specpdl_size related variables.
+        (verror): Use EMACS_INT for size of allocated buffer.
+
+        * keyboard.c (make_lispy_position): Use EMACS_INT for buffer
+        positions.
+
+        * xdisp.c (redisplay_internal, try_window_id)
+        (set_cursor_from_row, find_first_unchanged_at_end_row): Use
+        EMACS_INT for buffer positions.
+
+        * dispextern.h (set_cursor_from_row): Adjust prototype.
+
+        * dispnew.c (increment_matrix_positions)
+        (increment_row_positions, copy_glyph_row_contents)
+        (mode_line_string, marginal_area_string): Use EMACS_INT for buffer
+        positions.
+
+        * dispextern.h (mode_line_string, marginal_area_string)
+        (increment_matrix_positions, increment_row_positions): Adjust
+        prototypes.
+
+        * data.c (Faref, Faset): Use EMACS_INT for string length and
+        positions.
+
+        * cmds.c (internal_self_insert): Use EMACS_INT for the count of
+        characters to insert.
+
+        * ccl.c (Fccl_execute_on_string): Use EMACS_INT for string
+        position and size.
+
+        * syntax.c (scan_words, update_syntax_table)
+        (prev_char_comend_first, back_comment, skip_chars)
+        (skip_syntaxes, Fforward_comment, Fbackward_prefix_chars): Use
+        EMACS_INT for buffer and string positions.
+
+        * syntax.h (scan_words, update_syntax_table): Adjust prototypes.
+
+        * casefiddle.c (operate_on_word): Use EMACS_INT for buffer
+        positions.
+
+2010-09-24  Lars Magne Ingebrigtsen  <larsi@gnus.org>
+
+        * scroll.c (calculate_scrolling, line_ins_del)
+        (calculate_direct_scrolling, scroll_cost): Fix EMACS_INT/int
+        conversion.
+
+        * region-cache.c (move_cache_gap, set_cache_region, pp_cache)
+        (region_cache_backward, region_cache_forward)
+        (revalidate_region_cache, set_cache_region): FIX EMACS_INT/int
+        conversion.
+
+        * xdisp.c (message_dolog): Fix EMACS_INT/int conversion.
+
+        * eval.c (verror): Fix EMACS_INT/int conversion.
+
+        * print.c (PRINTDECLARE, PRINTPREPARE, strout, print_string)
+        (print_preprocess, print_check_string_charset_prop)
+        (print_object): Fix EMACS_INT/int conversion.
+
+        * xdisp.c (message_dolog): Fix EMACS_INT/int conversion.
+
+2010-09-24  Eli Zaretskii  <eliz@gnu.org>
+
+        * callproc.c (Fcall_process): Use EMACS_INT for count of
+        characters read from the subprocess.
+
+        * bidi.c (struct bidi_paragraph_info): Use EMACS_INT for buffer
+        positions.
+        (bidi_cache_search, bidi_cache_find): Use EMACS_INT for buffer
+        positions.
+
+        * buffer.c (struct sortvec): Use EMACS_INT for buffer positions.
+        (struct sortstrlist, overlay_str_len): Use EMACS_INT for string
+        length.
+        (advance_to_char_boundary, Fset_buffer_multibyte)
+        (overlays_at, overlays_in, mouse_face_overlay_overlaps)
+        (overlay_touches_p, record_overlay_string, overlay_strings)
+        (recenter_overlay_lists, fix_start_end_in_overlays)
+        (modify_overlay, Fmove_overlay, report_overlay_modification)
+        (evaporate_overlays): Use EMACS_INT for buffer positions.
+
+        * lisp.h (fix_start_end_in_overlays, overlay_touches_p): Adjust
+        prototypes.
+
+        * dispextern.h (struct bidi_saved_info): Use EMACS_INT for buffer
+        positions.
+
+        * fns.c (Fcompare_strings, Fstring_lessp, concat)
+        (string_make_unibyte, Fstring_as_unibyte, Fsubstring)
+        (Fsubstring_no_properties, substring_both, Ffillarray)
+        (Fclear_string, mapcar1, Fmapconcat, Fmapcar, Fmapc)
+        (Fbase64_encode_region, Fbase64_encode_string, base64_encode_1)
+        (Fbase64_decode_region, Fbase64_decode_string, base64_decode_1)
+        (Fmd5): Use EMACS_INT for buffer and string positions and length
+        variables and arguments.
+
+        * lisp.h (substring_both): Adjust prototype.
+
+2010-09-24  Juanma Barranquero  <lekktu@gmail.com>
+
+        Remove W32 API function pointer unused since 2005-02-15 (revno 2005-02-15T23:19:26Z!jasonr@gnu.org).
+        * w32fns.c (clipboard_sequence_fn): Don't declare.
+        (globals_of_w32fns): Don't initialize it.
+
+2010-09-23  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * syntax.c (back_comment): Detect the case where a 1-char comment
+        starter is also the 2nd char of a 2-char comment ender.
+
+2010-09-23  Jan Djärv  <jan.h.d@swipnet.se>
+
+        * gtkutil.c (xg_tool_bar_menu_proxy): Set gtk-menu-items to TRUE.
+
+2010-09-23  Lars Magne Ingebrigtsen  <larsi@gnus.org>
+
+        * eval.c (verror): EMACS_INT/int cleanup.
+
+        * lisp.h (SPECPDL_INDEX): Cast to int, since we're not going to
+        unwind_protect more than 2GB worth of functions.
+
+        * editfns.c (Finsert_char): EMACS_INT/int cleanup.
+
+        * lisp.h: Have oblookup take EMACS_INT to allow interning big
+        string and avoid compiler warnings.
+        (USE_SAFE_ALLOCA): Cast to int to avoid compilation warnings in
+        all users.
+
+        * lread.c (oblookup): EMACS_INT/int cleanup.
+
+        * cmds.c (Fforward_line, Fdelete_char): EMACS_INT/int cleanup.
+
+2010-09-23  Eli Zaretskii  <eliz@gnu.org>
+
+        * editfns.c (clip_to_bounds): Return an EMACS_INT value.
+
+        * lisp.h (clip_to_bounds): Adjust prototype.
+
+        * intervals.c (adjust_for_invis_intang): Return EMACS_INT value.
+
+2010-09-23  Lars Magne Ingebrigtsen  <larsi@gnus.org>
+
+        * lisp.h: doprnt.c EMACS_INT/int cleanup.
+
+        * doprnt.c (doprnt): EMACS_INT/int cleanup.
+
+        * doc.c (Fsnarf_documentation, get_doc_string): EMACS_INT/int
+        cleanup.
+
+        * lisp.h: Change the definition of all marker.c functions that
+        take and return buffer stuff to be EMACS_INT instead of int.
+
+        * marker.c (buf_charpos_to_bytepos, CONSIDER, set_marker_both)
+        (buf_charpos_to_bytepos, bytepos_to_charpos)
+        (buf_bytepos_to_charpos, Fbuffer_has_markers_at)
+        (set_marker_restricted, set_marker_both): Convert int to EMACS_INT
+        for all buffer positions.
+
+2010-09-23  Chong Yidong  <cyd@stupidchicken.com>
+
+        * intervals.c (traverse_intervals, rotate_right, rotate_left)
+        (split_interval_right, find_interval, next_interval)
+        (delete_node, delete_interval, interval_deletion_adjustment)
+        (adjust_intervals_for_deletion, merge_interval_right)
+        (merge_interval_left, graft_intervals_into_buffer)
+        (copy_intervals): Convert EMACS_UINTs to EMACS_INT.
+
+        * intervals.h (traverse_intervals): Update prototype.
+
+2010-09-23  Eli Zaretskii  <eliz@gnu.org>
+
+        * indent.c (compute_motion): Use EMACS_INT for arguments to
+        region_cache_forward.
+
+        * region-cache.c (struct boundary, struct region_cache): Use
+        EMACS_INT for positions.
+        (find_cache_boundary, move_cache_gap, insert_cache_boundary)
+        (delete_cache_boundaries, set_cache_region)
+        (invalidate_region_cache, know_region_cache)
+        (region_cache_forward, region_cache_backward, pp_cache): Use
+        EMACS_INT for buffer positions.
+
+        * region-cache.h (know_region_cache, invalidate_region_cache)
+        (region_cache_forward, region_cache_backward): Adjust prototypes.
+
+        * search.c (string_match_1, fast_c_string_match_ignore_case)
+        (looking_at_1, scan_buffer, scan_newline)
+        (find_next_newline_no_quit, find_before_next_newline)
+        (search_command, trivial_regexp_p, search_buffer, simple_search)
+        (boyer_moore, wordify, Freplace_match): Use EMACS_INT for buffer
+        and string positions and length.
+
+        * lisp.h (scan_buffer, scan_newline, find_next_newline_no_quit)
+        (find_before_next_newline): Adjust prototypes.
+
+        * editfns.c (transpose_markers, update_buffer_properties)
+        (buildmark, clip_to_bounds, Fgoto_char, overlays_around)
+        (get_pos_property, Fconstrain_to_field)
+        (Fline_beginning_position, Fline_end_position, Fprevious_char)
+        (Fchar_after, Fchar_before, Finsert_char)
+        (Finsert_buffer_substring, Fcompare_buffer_substrings)
+        (Fsubst_char_in_region, Fformat, Ftranspose_regions): Use
+        EMACS_INT for buffer and string position variables.
+        (Finsert_char): Protect against too large insertions.
+
+        * lisp.h (clip_to_bounds): Adjust prototype.
+
+        * intervals.c (traverse_intervals, rotate_right, rotate_left)
+        (balance_an_interval, split_interval_right, split_interval_left)
+        (find_interval, next_interval, update_interval)
+        (adjust_intervals_for_insertion, delete_node, delete_interval)
+        (interval_deletion_adjustment, adjust_intervals_for_deletion)
+        (offset_intervals, merge_interval_right, merge_interval_left)
+        (graft_intervals_into_buffer, adjust_for_invis_intang)
+        (move_if_not_intangible, get_local_map, copy_intervals)
+        (copy_intervals_to_string, compare_string_intervals)
+        (set_intervals_multibyte_1): Use EMACS_INT for buffer positions
+        and for interval tree size.
+
+        * intervals.h (traverse_intervals, split_interval_right)
+        (split_interval_left, find_interval, offset_intervals)
+        (graft_intervals_into_buffer, copy_intervals)
+        (copy_intervals_to_string, move_if_not_intangible, get_local_map)
+        (update_interval): Adjust prototypes.
+
+        * xdisp.c (check_point_in_composition, reconsider_clip_changes):
+        Use EMACS_INT for buffer position variables and arguments.
+
+        * composite.c (get_composition_id, find_composition)
+        (run_composition_function, compose_text)
+        (composition_gstring_width, autocmp_chars)
+        (composition_update_it, Ffind_composition_internal): Use EMACS_INT
+        for buffer positions and string length variables and arguments.
+
+        * composite.h (get_composition_id, find_composition, compose_text)
+        (composition_gstring_width): Adjust prototypes.
+
+        * editfns.c (Fformat): Use EMACS_INT for string size variables.
+
+        * xdisp.c (store_mode_line_noprop, display_mode_element): Use
+        EMACS_INT for string positions.
+
+        * intervals.c (get_property_and_range): Use EMACS_INT for buffer
+        position arguments.
+
+        * intervals.h (get_property_and_range): Adjust prototype.
+
+        * character.c (parse_str_as_multibyte, str_as_multibyte)
+        (parse_str_to_multibyte, str_to_multibyte, str_as_unibyte)
+        (string_count_byte8, string_escape_byte8, c_string_width)
+        (strwidth, lisp_string_width, multibyte_chars_in_text): Use
+        EMACS_INT for string length variables and arguments.
+
+        * character.h (parse_str_as_multibyte, str_as_multibyte)
+        (parse_str_to_multibyte, str_to_multibyte, str_as_unibyte)
+        (c_string_width, strwidth, lisp_string_width): Adjust
+        prototypes.
+
+        * font.c (font_intern_prop): Use EMACS_INT for string length
+        variables.
+
+        * font.c (font_intern_prop): Use EMACS_INT for string length
+        variables.
+
+        * fns.c (Fstring_as_multibyte): Use EMACS_INT for string length
+        variables.
+
+        * alloc.c <total_string_size>: Declare as EMACS_INT, not int.
+        (Fmake_string): Protect against too large strings.
+        (live_string_p, live_cons_p, live_symbol_p, live_float_p)
+        (live_misc_p): Use ptrdiff_t instead of int for pointer
+        differences.
+        (string_bytes, check_sblock, check_string_free_list)
+        (allocate_string_data, compact_small_strings, Fmake_string)
+        (Fmake_bool_vector, make_string, make_unibyte_string)
+        (make_multibyte_string, make_string_from_bytes)
+        (make_specified_string_string, Fmake_list, Fmake_vector): Use
+        EMACS_INT for string length variables and arguments.
+        (find_string_data_in_pure, make_pure_string, make_pure_c_string)
+        (Fpurecopy): Use EMACS_INT for string size.
+        (mark_vectorlike, mark_char_table, mark_object): Use EMACS_UINT
+        for vector size.
+
+        * lisp.h (make_string, make_unibyte_string, make_multibyte_string)
+        (make_string_from_bytes, make_specified_string_string)
+        (make_pure_string, string_bytes, check_point_in_composition):
+        Adjust prototypes.
+
+2010-09-22  Eli Zaretskii  <eliz@gnu.org>
+
+        * editfns.c (Fsubst_char_in_region, Ftranslate_region_internal)
+        (check_translation): Use EMACS_INT for buffer positions and
+        length.
+
+        * undo.c (record_marker_adjustment, record_delete)
+        (record_change, record_point, record_insert)
+        (record_property_change, Fprimitive_undo): Use EMACS_INT for
+        buffer positions.
+
+        * lisp.h (record_marker_adjustment, record_delete)
+        (record_change, record_point, record_insert)
+        (record_property_change, Fprimitive_undo): Adjust prototypes.
+
+2010-09-22  Juanma Barranquero  <lekktu@gmail.com>
+            Eli Zaretskii  <eliz@gnu.org>
+
+        * w32.c (get_emacs_configuration_options): Fix buffer overrun.
+
+2010-09-22  Eli Zaretskii  <eliz@gnu.org>
+
+        * minibuf.c (Fminibuffer_contents)
+        (Fminibuffer_contents_no_properties)
+        (Fminibuffer_completion_contents): Use EMACS_INT for minibuffer
+        positions.
+
+        * keyboard.c (command_loop_1): Use EMACS_INT to compare point with
+        mark.
+
+        * alloc.c (make_uninit_string, make_uninit_multibyte_string)
+        (allocate_string_data): Accept EMACS_INT for string length.
+
+        * editfns.c (Ffield_string, Ffield_string_no_properties)
+        (make_buffer_string, make_buffer_string_both, Fbuffer_substring)
+        (Fbuffer_substring_no_properties, find_field, Fdelete_field)
+        (Ffield_string, Ffield_string_no_properties, Ffield_beginning)
+        (Ffield_end): Use EMACS_INT for buffer positions.
+
+        * insdel.c (prepare_to_modify_buffer): Use EMACS_INT to compare
+        point with mark.
+
+        * lisp.h (allocate_string_data, make_uninit_string)
+        (make_uninit_multibyte_string, make_buffer_string)
+        (make_buffer_string_both): Adjust prototypes.
+
+2010-09-22  Chong Yidong  <cyd@stupidchicken.com>
+
+        * xml.c: Switch to GNU indentation.
+        (make_dom): Change parse tree format to match xml.el.
+        (Fxml_parse_html_string_internal): Rename from html-parse-string.
+        (Fxml_parse_string_internal): Rename from xml-parse-string.
+
+2010-09-22  Kenichi Handa  <handa@m17n.org>
+
+        * xdisp.c (compute_stop_pos): Call composition_compute_stop_pos
+        only if we are not at a composition.
+        (set_iterator_to_next): Give it->end_charpos to
+        composition_compute_stop_pos.
+        (set_iterator_to_next, next_element_from_buffer): Likewise.
+
+        * dispnew.c (buffer_posn_from_coords): Fix position when the
+        current display element is a grapheme cluster in bidi-reordered
+        region.
+
+2010-09-21  Ari Roponen  <ari.roponen@gmail.com>  (tiny change)
+
+        * doc.c (Fsnarf_documentation): Use memmove instead of memcpy as
+        the regions may overlap.
+
+2010-09-21  Juanma Barranquero  <lekktu@gmail.com>
+
+        * makefile.w32-in ($(BLD)/sysdep.$(O)): Update dependencies.
+
+2010-09-21  Dan Nicolaescu  <dann@ics.uci.edu>
+
+        * emacs.c: Do not include sys/ioctl.h, not needed.
+
+        * doprnt.c: Do not include stdlib.h, config.h does it.
+        Move #include before macro definition.
+
+2010-09-20  Dan Nicolaescu  <dann@ics.uci.edu>
+
+        * Makefile.in (temacs): Link using $(CC) not $(LD).
+        (LD_FIRSTFLAG): Define using autoconf.
+        (LD): Remove.
+
+        Remove HAVE_TERMIOS definitions.
+        * s/usg5-4-common.h (HAVE_TERMIOS):
+        * s/template.h (HAVE_TERMIOS):
+        * s/gnu-linux.h (HAVE_TERMIOS):
+        * s/darwin.h (HAVE_TERMIOS):
+        * s/cygwin.h (HAVE_TERMIOS):
+        * s/bsd-common.h (HAVE_TERMIOS):
+        * s/aix4-2.h (HAVE_TERMIOS):
+        * s/hpux10-20.h (HAVE_TERMIOS): Do not define, it is assumed
+        defined on all non-MS platforms.
+        (HAVE_PSTAT_GETDYNAMIC): Do not define, autoconf does it.
+
+        * xterm.c (xt_action_hook): Use const.
+
+2010-09-20  Juanma Barranquero  <lekktu@gmail.com>
+
+        Don't make W32 code conditional on HAVE_SOCKETS, it's always defined.
+        * w32.c: Remove top-level uses of #ifdef HAVE_SOCKETS.
+        (gethostname) [!HAVE_SOCKETS]: Remove.
+        (SOCK_REPLACE_HANDLE): Remove macro.
+        (socket_to_fd, sys_close, _sys_read_ahead, sys_read, sys_write)
+        (term_ntproc, init_ntproc): Don't conditionalize on HAVE_SOCKETS.
+        * w32proc.c: Remove top-level uses of #ifdef HAVE_SOCKETS.
+        (syms_of_ntproc): Don't conditionalize on HAVE_SOCKETS.
+
+2010-09-18  Eli Zaretskii  <eliz@gnu.org>
+
+        * deps.mk (xml.o): Add dependencies.
+
+        * xdisp.c (Fcurrent_bidi_paragraph_direction):
+        Call bidi_paragraph_init with NO_DEFAULT_P non-zero.  (Bug#7038)
+
+        * bidi.c (bidi_paragraph_init): Accept an additional argument
+        NO_DEFAULT_P; all callers changed.  If NO_DEFAULT_P is non-zero,
+        search back until a paragraph with a strong directional character
+        is found, and use that to determine paragraph's base direction.
+
+        * dispextern.h (bidi_paragraph_init): Update prototype.
+
+2010-09-17  Eli Zaretskii  <eliz@gnu.org>
+
+        * w32.c (_PROCESS_MEMORY_COUNTERS_EX): Don't define with versions
+        of w32api >= 3.15.  (Bug#6989)
+
+2010-09-17  Lars Magne Ingebrigtsen  <larsi@gnus.org>
+
+        * process.c (wait_reading_process_output): Don't message about
+        accept-process-output unless the time limit really is zero.
+
+2010-09-17  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * frame.c (Ftool_bar_pixel_width): YAILOM (Yet another
+        int/Lisp_Object mixup).
+
+2010-09-17  Jan Djärv  <jan.h.d@swipnet.se>
+
+        * keyboard.c (parse_tool_bar_item): For QClabel, set TOOL_BAR_ITEM_LABEL
+        not HELP.
+
+2010-09-17  Stephen Berman  <stephen.berman@gmx.net>
+
+        * frame.c (Ftool_bar_pixel_width): New function to expose tool
+        bar's pixel width to Lisp (Bug#7048).
+
+2010-09-14  Juanma Barranquero  <lekktu@gmail.com>
+
+        * cmds.c (syms_of_cmds) <post-self-insert-hook>: Fix typos in docstring.
+
+2010-09-17  Jan Djärv  <jan.h.d@swipnet.se>
+
+        * gtkutil.c (xg_pack_tool_bar): Call gtk_handle_box_set_handle_position
+        with argument top/left if tool bar is vertical/horizontal (Bug#7051).
+
+2010-09-17  Kenichi Handa  <handa@m17n.org>
+
+        * ftfont.c (ftfont_check_otf): Fix previous change.
+
+2010-09-14  Kenichi Handa  <handa@m17n.org>
+
+        * ftfont.c (ftfont_check_otf): Fix the case of checking just
+        existence of GSUB or GPOS.
+
+2010-09-14  Juanma Barranquero  <lekktu@gmail.com>
+
+        * cmds.c (syms_of_cmds) <post-self-insert-hook>: Fix typos in docstring.
+
+2010-09-14  Lars Magne Ingebrigtsen  <larsi@gnus.org>
+
+        * xml.c (parse_buffer): Renamed to parse_string(), since that's
+        what it does.
+        (parse_string): Return nil when the document can't be parsed.
+
+2010-09-14  Jan Djärv  <jan.h.d@swipnet.se>
+
+        * xterm.c (get_current_vm_state): New function.
+        (do_ewmh_fullscreen): Call get_current_vm_state and compare with
+        want_fullscreen so set_wm_state calls are few (Bug#7013).
+        (x_handle_net_wm_state): Move code to get_current_vm_state and
+        call that function.
+
+2010-09-14  Courtney Bane  <emacs-bugs-7626@cbane.org>  (tiny change)
+
+        * term.c (tty_set_terminal_modes): Don't initialize twice (bug#7002).
+
+2010-09-14  Kenichi Handa  <handa@m17n.org>
+
+        * coding.c (encode_coding_iso_2022): Don't optimize for ASCII if
+        we may use designation or locking-shift.
+
+2010-09-14  Kenichi Handa  <handa@m17n.org>
+
+        * coding.c (detect_coding_emacs_mule): Fix checking of multibyte
+        sequence when the source is multibyte.
+
+2010-09-14  Andreas Schwab  <schwab@linux-m68k.org>
+
+        * xml.c (Fxml_parse_string, Fxml_parse_string): Revert last change.
+        Don't make first argument optional.  Doc fix.
+
+2010-09-14  Leo  <sdl.web@gmail.com>  (tiny change)
+
+        * xml.c (Fxml_parse_string, Fhtml_parse_string): Fix up the
+        parameters for the doc string.
+
 2010-09-12  Lars Magne Ingebrigtsen  <larsi@gnus.org>
 
         * xml.c (Fhtml_parse_string, Fxml_parse_string): Mention BASE-URL.
@@ -101,9 +925,9 @@
         (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.
+        non-ASCII characters.  Don't set it->char_to_display here.
+        Don't handle unibyte-display-via-language-environment here.  For a
+        character of no glyph, use font->space_width instead of FONT_WIDTH.
 
 2010-08-31  Stefan Monnier  <monnier@iro.umontreal.ca>
 
@@ -344,7 +1168,7 @@
 
 2010-08-18  Jan Djärv  <jan.h.d@swipnet.se>
 
-        * gtkutil.c (update_frame_tool_bar): Literal stings are const char*.
+        * gtkutil.c (update_frame_tool_bar): Literal strings are const char*.
 
 2010-08-18  David De La Harpe Golden  <david@harpegolden.net>
 
@@ -534,7 +1358,7 @@
         * 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*.
+        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
@@ -546,7 +1370,7 @@
         non-const char.
 
         * xmenu.c (Fx_popup_dialog): error_name is const char*.
-        (xmenu_show): error parameter is const char **. pane_string is const
+        (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.
@@ -2303,7 +3127,7 @@
         (smc_save_yourself_CB, x_session_initialize): Use SSDATA for strings
         passed to strlen/strcpy/strcat.
         (create_client_leader_window): Surround with #ifndef USE_GTK.  Cast
-        7:th arg to XChangeProperty to (unsigned char *)
+        7:th arg to XChangeProperty to (unsigned char *).
 
         * xsettings.c (something_changedCB, parse_settings)
         (apply_xft_settings): Reformat prototype.
@@ -18625,7 +19449,7 @@
         (Ffont_shape_text): New function.
         (Fopen_font): If the font size is not given, use 12-pixel.
         (Ffont_at): New arg STRING.
-        (syms_of_font): Initalize font_charset_alist.
+        (syms_of_font): Initialize font_charset_alist.
         Declare Ffont_shape_text as a Lisp function.  Call syms_of_XXfont
         conditionally.
 
@@ -19622,7 +20446,7 @@
 
         * font.c (font_unparse_fcname): Fix typo (swidth->width).
         (font_list_entities): Check driver_list->on.
-        (register_font_driver): Initalize `on' member to 0.
+        (register_font_driver): Initialize `on' member to 0.
         (font_update_drivers): New function.
         (Fclear_font_cache): Check driver_list->on.
 
@@ -20265,7 +21089,7 @@
 
         * search.c (search_buffer): Give up BM search on case-fold-search
         if one of a target character has a case-equivalence of different
-        byte length even if that target charcter is an ASCII.
+        byte length even if that target character is an ASCII.
         (simple_search): Fix calculation of byte length of matched text.
         (boyer_moore): Fix handling of case-equivalent multibyte characters.
 
diff --git a/src/Makefile.in b/src/Makefile.in
index d91b95d86e3..00706460d25 100644
--- a/src/Makefile.in
+++ b/src/Makefile.in
@@ -35,6 +35,7 @@ CC = @CC@
 CFLAGS = @CFLAGS@
 CPPFLAGS = @CPPFLAGS@
 LDFLAGS = @LDFLAGS@
+LD_FIRSTFLAG=@LD_FIRSTFLAG@
 EXEEXT = @EXEEXT@
 version = @version@
 # Substitute an assignment for the MAKE variable, because
@@ -124,8 +125,6 @@ LIBS_SYSTEM=@LIBS_SYSTEM@
 ## Where to find libgcc.a, if using gcc and necessary.
 LIB_GCC=@LIB_GCC@
 
-LD=@LINKER@
-
 ## May use $CRT_DIR.
 LIB_STANDARD=@LIB_STANDARD@
 
@@ -287,6 +286,9 @@ LIBRESOLV = @LIBRESOLV@
 
 LIBSELINUX_LIBS = @LIBSELINUX_LIBS@
 
+LIBGNUTLS_LIBS = @LIBGNUTLS_LIBS@
+LIBGNUTLS_CFLAGS = @LIBGNUTLS_CFLAGS@
+
 INTERVALS_H = dispextern.h intervals.h composite.h
 
 GETLOADAVG_LIBS = @GETLOADAVG_LIBS@
@@ -326,6 +328,7 @@ ALL_CFLAGS=-Demacs -DHAVE_CONFIG_H $(MYCPPFLAGS) -I. -I${srcdir} \
   ${LIBXML2_CFLAGS} ${DBUS_CFLAGS} \
   ${GCONF_CFLAGS} ${FREETYPE_CFLAGS} ${FONTCONFIG_CFLAGS} \
   ${LIBOTF_CFLAGS} ${M17N_FLT_CFLAGS} ${DEPFLAGS} ${PROFILING_CFLAGS} \
+  $(LIBGNUTLS_CFLAGS) \
   ${C_WARNINGS_SWITCH} ${CFLAGS}
 ALL_OBJC_CFLAGS=$(ALL_CFLAGS) $(GNU_OBJC_CFLAGS)
 
@@ -350,7 +353,7 @@ obj=    dispnew.o frame.o scroll.o xdisp.o menu.o $(XMENU_OBJ) window.o \
         alloc.o data.o doc.o editfns.o callint.o \
         eval.o floatfns.o fns.o font.o print.o lread.o \
         syntax.o $(UNEXEC_OBJ) bytecode.o \
-        process.o callproc.o \
+        process.o gnutls.o callproc.o \
         region-cache.o sound.o atimer.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)
@@ -602,6 +605,7 @@ LIBES = $(LIBS) $(LIBX_BASE) $(LIBX_OTHER) $(LIBSOUND) \
    ${LIBXML2_LIBS} $(LIBGPM) $(LIBRESOLV) $(LIBS_SYSTEM) \
    $(LIBS_TERMCAP) $(GETLOADAVG_LIBS) ${GCONF_LIBS} ${LIBSELINUX_LIBS} \
    $(FREETYPE_LIBS) $(FONTCONFIG_LIBS) $(LIBOTF_LIBS) $(M17N_FLT_LIBS) \
+   $(LIBGNUTLS_LIBS) \
    $(LIB_GCC) $(LIB_MATH) $(LIB_STANDARD) $(LIB_GCC)
 
 all: emacs${EXEEXT} $(OTHER_FILES)
@@ -646,7 +650,7 @@ buildobj.h: Makefile
 
 
 temacs${EXEEXT}: $(START_FILES) stamp-oldxmenu ${obj} ${otherobj}
-        $(LD) ${TEMACS_LDFLAGS} ${TEMACS_LDFLAGS2} \
+        $(CC) $(LD_FIRSTFLAG) ${TEMACS_LDFLAGS} ${TEMACS_LDFLAGS2} \
           -o temacs ${START_FILES} ${obj} ${otherobj} ${LIBES}
 
 ## The following oldxmenu-related rules are only (possibly) used if
diff --git a/src/alloc.c b/src/alloc.c
index d83d8937722..f2bb28e2d96 100644
--- a/src/alloc.c
+++ b/src/alloc.c
@@ -1643,7 +1643,7 @@ static int total_strings, total_free_strings;
 
 /* Number of bytes used by live strings.  */
 
-static int total_string_size;
+static EMACS_INT total_string_size;
 
 /* Given a pointer to a Lisp_String S which is on the free-list
    string_free_list, return a pointer to its successor in the
@@ -1738,11 +1738,12 @@ static void check_sblock (struct sblock *);
 
 /* Like GC_STRING_BYTES, but with debugging check.  */
 
-int
-string_bytes (s)
-     struct Lisp_String *s;
+EMACS_INT
+string_bytes (struct Lisp_String *s)
 {
-  int nbytes = (s->size_byte < 0 ? s->size & ~ARRAY_MARK_FLAG : s->size_byte);
+  EMACS_INT nbytes =
+    (s->size_byte < 0 ? s->size & ~ARRAY_MARK_FLAG : s->size_byte);
+
   if (!PURE_POINTER_P (s)
       && s->data
       && nbytes != SDATA_NBYTES (SDATA_OF_STRING (s)))
@@ -1764,7 +1765,7 @@ check_sblock (b)
     {
       /* Compute the next FROM here because copying below may
          overwrite data we need to compute it.  */
-      int nbytes;
+      EMACS_INT nbytes;
 
       /* Check that the string size recorded in the string is the
          same as the one recorded in the sdata structure. */
@@ -1824,7 +1825,7 @@ check_string_free_list ()
   s = string_free_list;
   while (s != NULL)
     {
-      if ((unsigned)s < 1024)
+      if ((unsigned long)s < 1024)
         abort();
       s = NEXT_FREE_LISP_STRING (s);
     }
@@ -1907,11 +1908,12 @@ allocate_string (void)
    S->data if it was initially non-null.  */
 
 void
-allocate_string_data (struct Lisp_String *s, int nchars, int nbytes)
+allocate_string_data (struct Lisp_String *s,
+                      EMACS_INT nchars, EMACS_INT nbytes)
 {
   struct sdata *data, *old_data;
   struct sblock *b;
-  int needed, old_nbytes;
+  EMACS_INT needed, old_nbytes;
 
   /* Determine the number of bytes needed to store NBYTES bytes
      of string data.  */
@@ -2153,7 +2155,7 @@ compact_small_strings (void)
         {
           /* Compute the next FROM here because copying below may
              overwrite data we need to compute it.  */
-          int nbytes;
+          EMACS_INT nbytes;
 
 #ifdef GC_CHECK_STRING_BYTES
           /* Check that the string size recorded in the string is the
@@ -2231,7 +2233,8 @@ INIT must be an integer that represents a character.  */)
 {
   register Lisp_Object val;
   register unsigned char *p, *end;
-  int c, nbytes;
+  int c;
+  EMACS_INT nbytes;
 
   CHECK_NATNUM (length);
   CHECK_NUMBER (init);
@@ -2250,9 +2253,12 @@ INIT must be an integer that represents a character.  */)
     {
       unsigned char str[MAX_MULTIBYTE_LENGTH];
       int len = CHAR_STRING (c, str);
+      EMACS_INT string_len = XINT (length);
 
-      nbytes = len * XINT (length);
-      val = make_uninit_multibyte_string (XINT (length), nbytes);
+      if (string_len > MOST_POSITIVE_FIXNUM / len)
+        error ("Maximum string size exceeded");
+      nbytes = len * string_len;
+      val = make_uninit_multibyte_string (string_len, nbytes);
       p = SDATA (val);
       end = p + nbytes;
       while (p != end)
@@ -2275,7 +2281,8 @@ LENGTH must be a number.  INIT matters only in whether it is t or nil.  */)
   register Lisp_Object val;
   struct Lisp_Bool_Vector *p;
   int real_init, i;
-  int length_in_chars, length_in_elts, bits_per_value;
+  EMACS_INT length_in_chars, length_in_elts;
+  int bits_per_value;
 
   CHECK_NATNUM (length);
 
@@ -2315,10 +2322,10 @@ LENGTH must be a number.  INIT matters only in whether it is t or nil.  */)
    multibyte, depending on the contents.  */
 
 Lisp_Object
-make_string (const char *contents, int nbytes)
+make_string (const char *contents, EMACS_INT nbytes)
 {
   register Lisp_Object val;
-  int nchars, multibyte_nbytes;
+  EMACS_INT nchars, multibyte_nbytes;
 
   parse_str_as_multibyte (contents, nbytes, &nchars, &multibyte_nbytes);
   if (nbytes == nchars || nbytes != multibyte_nbytes)
@@ -2334,7 +2341,7 @@ make_string (const char *contents, int nbytes)
 /* Make an unibyte string from LENGTH bytes at CONTENTS.  */
 
 Lisp_Object
-make_unibyte_string (const char *contents, int length)
+make_unibyte_string (const char *contents, EMACS_INT length)
 {
   register Lisp_Object val;
   val = make_uninit_string (length);
@@ -2348,7 +2355,8 @@ make_unibyte_string (const char *contents, int length)
    bytes at CONTENTS.  */
 
 Lisp_Object
-make_multibyte_string (const char *contents, int nchars, int nbytes)
+make_multibyte_string (const char *contents,
+                       EMACS_INT nchars, EMACS_INT nbytes)
 {
   register Lisp_Object val;
   val = make_uninit_multibyte_string (nchars, nbytes);
@@ -2361,7 +2369,8 @@ make_multibyte_string (const char *contents, int nchars, int nbytes)
    CONTENTS.  It is a multibyte string if NBYTES != NCHARS.  */
 
 Lisp_Object
-make_string_from_bytes (const char *contents, int nchars, int nbytes)
+make_string_from_bytes (const char *contents,
+                        EMACS_INT nchars, EMACS_INT nbytes)
 {
   register Lisp_Object val;
   val = make_uninit_multibyte_string (nchars, nbytes);
@@ -2378,7 +2387,8 @@ make_string_from_bytes (const char *contents, int nchars, int nbytes)
    characters by itself.  */
 
 Lisp_Object
-make_specified_string (const char *contents, int nchars, int nbytes, int multibyte)
+make_specified_string (const char *contents,
+                       EMACS_INT nchars, EMACS_INT nbytes, int multibyte)
 {
   register Lisp_Object val;
 
@@ -2411,7 +2421,7 @@ build_string (const char *str)
    occupying LENGTH bytes.  */
 
 Lisp_Object
-make_uninit_string (int length)
+make_uninit_string (EMACS_INT length)
 {
   Lisp_Object val;
 
@@ -2427,7 +2437,7 @@ make_uninit_string (int length)
    which occupy NBYTES bytes.  */
 
 Lisp_Object
-make_uninit_multibyte_string (int nchars, int nbytes)
+make_uninit_multibyte_string (EMACS_INT nchars, EMACS_INT nbytes)
 {
   Lisp_Object string;
   struct Lisp_String *s;
@@ -2766,7 +2776,7 @@ DEFUN ("make-list", Fmake_list, Smake_list, 2, 2, 0,
   (register Lisp_Object length, Lisp_Object init)
 {
   register Lisp_Object val;
-  register int size;
+  register EMACS_INT size;
 
   CHECK_NATNUM (length);
   size = XFASTINT (length);
@@ -2944,7 +2954,7 @@ See also the function `vector'.  */)
 {
   Lisp_Object vector;
   register EMACS_INT sizei;
-  register int index;
+  register EMACS_INT index;
   register struct Lisp_Vector *p;
 
   CHECK_NATNUM (length);
@@ -3841,7 +3851,7 @@ live_string_p (struct mem_node *m, void *p)
   if (m->type == MEM_TYPE_STRING)
     {
       struct string_block *b = (struct string_block *) m->start;
-      int offset = (char *) p - (char *) &b->strings[0];
+      ptrdiff_t offset = (char *) p - (char *) &b->strings[0];
 
       /* P must point to the start of a Lisp_String structure, and it
          must not be on the free-list.  */
@@ -3864,7 +3874,7 @@ live_cons_p (struct mem_node *m, void *p)
   if (m->type == MEM_TYPE_CONS)
     {
       struct cons_block *b = (struct cons_block *) m->start;
-      int offset = (char *) p - (char *) &b->conses[0];
+      ptrdiff_t offset = (char *) p - (char *) &b->conses[0];
 
       /* P must point to the start of a Lisp_Cons, not be
          one of the unused cells in the current cons block,
@@ -3890,7 +3900,7 @@ live_symbol_p (struct mem_node *m, void *p)
   if (m->type == MEM_TYPE_SYMBOL)
     {
       struct symbol_block *b = (struct symbol_block *) m->start;
-      int offset = (char *) p - (char *) &b->symbols[0];
+      ptrdiff_t offset = (char *) p - (char *) &b->symbols[0];
 
       /* P must point to the start of a Lisp_Symbol, not be
          one of the unused cells in the current symbol block,
@@ -3916,7 +3926,7 @@ live_float_p (struct mem_node *m, void *p)
   if (m->type == MEM_TYPE_FLOAT)
     {
       struct float_block *b = (struct float_block *) m->start;
-      int offset = (char *) p - (char *) &b->floats[0];
+      ptrdiff_t offset = (char *) p - (char *) &b->floats[0];
 
       /* P must point to the start of a Lisp_Float and not be
          one of the unused cells in the current float block.  */
@@ -3940,7 +3950,7 @@ live_misc_p (struct mem_node *m, void *p)
   if (m->type == MEM_TYPE_MISC)
     {
       struct marker_block *b = (struct marker_block *) m->start;
-      int offset = (char *) p - (char *) &b->markers[0];
+      ptrdiff_t offset = (char *) p - (char *) &b->markers[0];
 
       /* P must point to the start of a Lisp_Misc, not be
          one of the unused cells in the current misc block,
@@ -4647,9 +4657,10 @@ check_pure_size (void)
    address.  Return NULL if not found.  */
 
 static char *
-find_string_data_in_pure (const char *data, int nbytes)
+find_string_data_in_pure (const char *data, EMACS_INT nbytes)
 {
-  int i, skip, bm_skip[256], last_char_skip, infinity, start, start_max;
+  int i;
+  EMACS_INT skip, bm_skip[256], last_char_skip, infinity, start, start_max;
   const unsigned char *p;
   char *non_lisp_beg;
 
@@ -4716,7 +4727,8 @@ find_string_data_in_pure (const char *data, int nbytes)
    string; then the string is not protected from gc.  */
 
 Lisp_Object
-make_pure_string (const char *data, int nchars, int nbytes, int multibyte)
+make_pure_string (const char *data,
+                  EMACS_INT nchars, EMACS_INT nbytes, int multibyte)
 {
   Lisp_Object string;
   struct Lisp_String *s;
@@ -4744,7 +4756,7 @@ make_pure_c_string (const char *data)
 {
   Lisp_Object string;
   struct Lisp_String *s;
-  int nchars = strlen (data);
+  EMACS_INT nchars = strlen (data);
 
   s = (struct Lisp_String *) pure_alloc (sizeof *s, Lisp_String);
   s->size = nchars;
@@ -4834,7 +4846,7 @@ Does not copy symbols.  Copies strings without text properties.  */)
   else if (FUNVECP (obj) || VECTORP (obj))
     {
       register struct Lisp_Vector *vec;
-      register int i;
+      register EMACS_INT i;
       EMACS_INT size;
 
       size = XVECTOR (obj)->size;
@@ -5283,8 +5295,8 @@ static int mark_object_loop_halt;
 static void
 mark_vectorlike (struct Lisp_Vector *ptr)
 {
-  register EMACS_INT size = ptr->size;
-  register int i;
+  register EMACS_UINT size = ptr->size;
+  register EMACS_UINT i;
 
   eassert (!VECTOR_MARKED_P (ptr));
   VECTOR_MARK (ptr);            /* Else mark it */
@@ -5306,8 +5318,8 @@ mark_vectorlike (struct Lisp_Vector *ptr)
 static void
 mark_char_table (struct Lisp_Vector *ptr)
 {
-  register EMACS_INT size = ptr->size & PSEUDOVECTOR_SIZE_MASK;
-  register int i;
+  register EMACS_UINT size = ptr->size & PSEUDOVECTOR_SIZE_MASK;
+  register EMACS_UINT i;
 
   eassert (!VECTOR_MARKED_P (ptr));
   VECTOR_MARK (ptr);
@@ -5436,8 +5448,8 @@ mark_object (Lisp_Object arg)
            recursion there.  */
         {
           register struct Lisp_Vector *ptr = XVECTOR (obj);
-          register EMACS_INT size = ptr->size;
-          register int i;
+          register EMACS_UINT size = ptr->size;
+          register EMACS_UINT i;
 
           CHECK_LIVE (live_vector_p);
           VECTOR_MARK (ptr);    /* Else mark it */
diff --git a/src/bidi.c b/src/bidi.c
index a6d4d1b2506..b7c6fdc2ddd 100644
--- a/src/bidi.c
+++ b/src/bidi.c
@@ -79,10 +79,10 @@ static Lisp_Object bidi_type_table, bidi_mirror_table;
 
 /* What we need to know about the current paragraph.  */
 struct bidi_paragraph_info {
-  int start_bytepos;    /* byte position where it begins */
-  int end_bytepos;      /* byte position where it ends */
-  int embedding_level;  /* its basic embedding level */
-  bidi_dir_t base_dir;  /* its base direction */
+  EMACS_INT start_bytepos;      /* byte position where it begins */
+  EMACS_INT end_bytepos;        /* byte position where it ends */
+  int       embedding_level;    /* its basic embedding level */
+  bidi_dir_t base_dir;          /* its base direction */
 };
 
 /* Data type for describing the bidirectional character categories.  */
@@ -313,7 +313,7 @@ bidi_cache_fetch_state (int idx, struct bidi_it *bidi_it)
    resolved levels in cached states.  DIR, if non-zero, means search
    in that direction from the last cache hit.  */
 static INLINE int
-bidi_cache_search (int charpos, int level, int dir)
+bidi_cache_search (EMACS_INT charpos, int level, int dir)
 {
   int i, i_start;
 
@@ -462,7 +462,7 @@ bidi_cache_iterator_state (struct bidi_it *bidi_it, int resolved)
 }
 
 static INLINE bidi_type_t
-bidi_cache_find (int charpos, int level, struct bidi_it *bidi_it)
+bidi_cache_find (EMACS_INT charpos, int level, struct bidi_it *bidi_it)
 {
   int i = bidi_cache_search (charpos, level, bidi_it->scan_dir);
 
@@ -583,18 +583,26 @@ bidi_find_paragraph_start (EMACS_INT pos, EMACS_INT pos_byte)
   return pos_byte;
 }
 
-/* Determine the direction, a.k.a. base embedding level, of the
+/* Determine the base direction, a.k.a. base embedding level, of the
    paragraph we are about to iterate through.  If DIR is either L2R or
    R2L, just use that.  Otherwise, determine the paragraph direction
-   from the first strong character of the paragraph.
-
-   Note that this gives the paragraph separator the same direction as
-   the preceding paragraph, even though Emacs generally views the
-   separartor as not belonging to any paragraph.  */
+   from the first strong directional character of the paragraph.
+
+   NO_DEFAULT_P non-nil means don't default to L2R if the paragraph
+   has no strong directional characters and both DIR and
+   bidi_it->paragraph_dir are NEUTRAL_DIR.  In that case, search back
+   in the buffer until a paragraph is found with a strong character,
+   or until hitting BEGV.  In the latter case, fall back to L2R.  This
+   flag is used in current-bidi-paragraph-direction.
+
+   Note that this function gives the paragraph separator the same
+   direction as the preceding paragraph, even though Emacs generally
+   views the separartor as not belonging to any paragraph.  */
 void
-bidi_paragraph_init (bidi_dir_t dir, struct bidi_it *bidi_it)
+bidi_paragraph_init (bidi_dir_t dir, struct bidi_it *bidi_it, int no_default_p)
 {
   EMACS_INT bytepos = bidi_it->bytepos;
+  EMACS_INT pstartbyte;
 
   /* Special case for an empty buffer. */
   if (bytepos == BEGV_BYTE && bytepos == ZV_BYTE)
@@ -643,49 +651,75 @@ bidi_paragraph_init (bidi_dir_t dir, struct bidi_it *bidi_it)
 
       /* We are either at the beginning of a paragraph or in the
          middle of it.  Find where this paragraph starts.  */
-      bytepos = bidi_find_paragraph_start (pos, bytepos);
-
+      pstartbyte = bidi_find_paragraph_start (pos, bytepos);
       bidi_it->separator_limit = -1;
       bidi_it->new_paragraph = 0;
-      ch = FETCH_CHAR (bytepos);
-      ch_len = CHAR_BYTES (ch);
-      pos = BYTE_TO_CHAR (bytepos);
-      type = bidi_get_type (ch, NEUTRAL_DIR);
-
-      for (pos++, bytepos += ch_len;
-           /* NOTE: UAX#9 says to search only for L, AL, or R types of
-              characters, and ignore RLE, RLO, LRE, and LRO.  However,
-              I'm not sure it makes sense to omit those 4; should try
-              with and without that to see the effect.  */
-           (bidi_get_category (type) != STRONG)
-             || (bidi_ignore_explicit_marks_for_paragraph_level
-                 && (type == RLE || type == RLO
-                     || type == LRE || type == LRO));
-           type = bidi_get_type (ch, NEUTRAL_DIR))
-        {
-          if (type == NEUTRAL_B && bidi_at_paragraph_end (pos, bytepos) >= -1)
-            break;
-          if (bytepos >= ZV_BYTE)
-            {
-              /* Pretend there's a paragraph separator at end of buffer.  */
-              type = NEUTRAL_B;
+
+      /* The following loop is run more than once only if NO_DEFAULT_P
+         is non-zero.  */
+      do {
+        bytepos = pstartbyte;
+        ch = FETCH_CHAR (bytepos);
+        ch_len = CHAR_BYTES (ch);
+        pos = BYTE_TO_CHAR (bytepos);
+        type = bidi_get_type (ch, NEUTRAL_DIR);
+
+        for (pos++, bytepos += ch_len;
+             /* NOTE: UAX#9 says to search only for L, AL, or R types
+                of characters, and ignore RLE, RLO, LRE, and LRO.
+                However, I'm not sure it makes sense to omit those 4;
+                should try with and without that to see the effect.  */
+             (bidi_get_category (type) != STRONG)
+               || (bidi_ignore_explicit_marks_for_paragraph_level
+                   && (type == RLE || type == RLO
+                       || type == LRE || type == LRO));
+             type = bidi_get_type (ch, NEUTRAL_DIR))
+          {
+            if (type == NEUTRAL_B && bidi_at_paragraph_end (pos, bytepos) >= -1)
               break;
-            }
-          FETCH_CHAR_ADVANCE (ch, pos, bytepos);
-        }
-      if (type == STRONG_R || type == STRONG_AL) /* P3 */
-        bidi_it->paragraph_dir = R2L;
-      else if (type == STRONG_L)
-        bidi_it->paragraph_dir = L2R;
+            if (bytepos >= ZV_BYTE)
+              {
+                /* Pretend there's a paragraph separator at end of
+                   buffer.  */
+                type = NEUTRAL_B;
+                break;
+              }
+            FETCH_CHAR_ADVANCE (ch, pos, bytepos);
+          }
+        if (type == STRONG_R || type == STRONG_AL) /* P3 */
+          bidi_it->paragraph_dir = R2L;
+        else if (type == STRONG_L)
+          bidi_it->paragraph_dir = L2R;
+        if (no_default_p && bidi_it->paragraph_dir == NEUTRAL_DIR)
+          {
+            /* If this paragraph is at BEGV, default to L2R.  */
+            if (pstartbyte == BEGV_BYTE)
+              bidi_it->paragraph_dir = L2R; /* P3 and HL1 */
+            else
+              {
+                EMACS_INT prevpbyte = pstartbyte;
+                EMACS_INT p = BYTE_TO_CHAR (pstartbyte), pbyte = pstartbyte;
+
+                /* Find the beginning of the previous paragraph, if any.  */
+                while (pbyte > BEGV_BYTE && prevpbyte >= pstartbyte)
+                  {
+                    p--;
+                    pbyte = CHAR_TO_BYTE (p);
+                    prevpbyte = bidi_find_paragraph_start (p, pbyte);
+                  }
+                pstartbyte = prevpbyte;
+              }
+          }
+      } while (no_default_p && bidi_it->paragraph_dir == NEUTRAL_DIR);
     }
   else
     abort ();
 
   /* Contrary to UAX#9 clause P3, we only default the paragraph
      direction to L2R if we have no previous usable paragraph
-     direction.  */
+     direction.  This is allowed by the HL1 clause.  */
   if (bidi_it->paragraph_dir != L2R && bidi_it->paragraph_dir != R2L)
-    bidi_it->paragraph_dir = L2R; /* P3 and ``higher protocols'' */
+    bidi_it->paragraph_dir = L2R; /* P3 and HL1 ``higher-level protocols'' */
   if (bidi_it->paragraph_dir == R2L)
     bidi_it->level_stack[0].level = 1;
   else
diff --git a/src/buffer.c b/src/buffer.c
index 86a638eb230..6b6b6efc633 100644
--- a/src/buffer.c
+++ b/src/buffer.c
@@ -2092,7 +2092,7 @@ validate_region (register Lisp_Object *b, register Lisp_Object *e)
    and return the adjusted position.  */
 
 static int
-advance_to_char_boundary (int byte_pos)
+advance_to_char_boundary (EMACS_INT byte_pos)
 {
   int c;
 
@@ -2105,7 +2105,7 @@ advance_to_char_boundary (int byte_pos)
     {
       /* We should advance BYTE_POS only when C is a constituent of a
          multibyte sequence.  */
-      int orig_byte_pos = byte_pos;
+      EMACS_INT orig_byte_pos = byte_pos;
 
       do
         {
@@ -2273,7 +2273,7 @@ current buffer is cleared.  */)
 {
   struct Lisp_Marker *tail, *markers;
   struct buffer *other;
-  int begv, zv;
+  EMACS_INT begv, zv;
   int narrowed = (BEG != BEGV || Z != ZV);
   int modified_p = !NILP (Fbuffer_modified_p (Qnil));
   Lisp_Object old_undo = current_buffer->undo_list;
@@ -2305,7 +2305,7 @@ current buffer is cleared.  */)
 
   if (NILP (flag))
     {
-      int pos, stop;
+      EMACS_INT pos, stop;
       unsigned char *p;
 
       /* Do this first, so it can use CHAR_TO_BYTE
@@ -2345,7 +2345,7 @@ current buffer is cleared.  */)
             {
               c = STRING_CHAR_AND_LENGTH (p, bytes);
               /* Delete all bytes for this 8-bit character but the
-                 last one, and change the last one to the charcter
+                 last one, and change the last one to the character
                  code.  */
               bytes--;
               del_range_2 (pos, pos, pos + bytes, pos + bytes, 0);
@@ -2369,8 +2369,8 @@ current buffer is cleared.  */)
     }
   else
     {
-      int pt = PT;
-      int pos, stop;
+      EMACS_INT pt = PT;
+      EMACS_INT pos, stop;
       unsigned char *p, *pend;
 
       /* Be sure not to have a multibyte sequence striding over the GAP.
@@ -2386,7 +2386,7 @@ current buffer is cleared.  */)
           while (! CHAR_HEAD_P (*p) && p > BEG_ADDR) p--;
           if (LEADING_CODE_P (*p))
             {
-              int new_gpt = GPT_BYTE - (GPT_ADDR - p);
+              EMACS_INT new_gpt = GPT_BYTE - (GPT_ADDR - p);
 
               move_gap_both (new_gpt, new_gpt);
             }
@@ -2470,8 +2470,8 @@ current buffer is cleared.  */)
         ZV = chars_in_text (BEG_ADDR, ZV_BYTE - BEG_BYTE) + BEG;
 
       {
-        int pt_byte = advance_to_char_boundary (PT_BYTE);
-        int pt;
+        EMACS_INT pt_byte = advance_to_char_boundary (PT_BYTE);
+        EMACS_INT pt;
 
         if (pt_byte > GPT_BYTE)
           pt = chars_in_text (GAP_END_ADDR, pt_byte - GPT_BYTE) + GPT;
@@ -2642,13 +2642,13 @@ overlays_at (EMACS_INT pos, int extend, Lisp_Object **vec_ptr, int *len_ptr,
   int idx = 0;
   int len = *len_ptr;
   Lisp_Object *vec = *vec_ptr;
-  int next = ZV;
-  int prev = BEGV;
+  EMACS_INT next = ZV;
+  EMACS_INT prev = BEGV;
   int inhibit_storing = 0;
 
   for (tail = current_buffer->overlays_before; tail; tail = tail->next)
     {
-      int startpos, endpos;
+      EMACS_INT startpos, endpos;
 
       XSETMISC (overlay, tail);
 
@@ -2699,7 +2699,7 @@ overlays_at (EMACS_INT pos, int extend, Lisp_Object **vec_ptr, int *len_ptr,
 
   for (tail = current_buffer->overlays_after; tail; tail = tail->next)
     {
-      int startpos, endpos;
+      EMACS_INT startpos, endpos;
 
       XSETMISC (overlay, tail);
 
@@ -2773,22 +2773,23 @@ overlays_at (EMACS_INT pos, int extend, Lisp_Object **vec_ptr, int *len_ptr,
    But we still return the total number of overlays.  */
 
 static int
-overlays_in (int beg, int end, int extend, Lisp_Object **vec_ptr, int *len_ptr,
-             int *next_ptr, int *prev_ptr)
+overlays_in (EMACS_INT beg, EMACS_INT end, int extend,
+             Lisp_Object **vec_ptr, int *len_ptr,
+             EMACS_INT *next_ptr, EMACS_INT *prev_ptr)
 {
   Lisp_Object overlay, ostart, oend;
   struct Lisp_Overlay *tail;
   int idx = 0;
   int len = *len_ptr;
   Lisp_Object *vec = *vec_ptr;
-  int next = ZV;
-  int prev = BEGV;
+  EMACS_INT next = ZV;
+  EMACS_INT prev = BEGV;
   int inhibit_storing = 0;
   int end_is_Z = end == Z;
 
   for (tail = current_buffer->overlays_before; tail; tail = tail->next)
     {
-      int startpos, endpos;
+      EMACS_INT startpos, endpos;
 
       XSETMISC (overlay, tail);
 
@@ -2838,7 +2839,7 @@ overlays_in (int beg, int end, int extend, Lisp_Object **vec_ptr, int *len_ptr,
 
   for (tail = current_buffer->overlays_after; tail; tail = tail->next)
     {
-      int startpos, endpos;
+      EMACS_INT startpos, endpos;
 
       XSETMISC (overlay, tail);
 
@@ -2897,8 +2898,8 @@ overlays_in (int beg, int end, int extend, Lisp_Object **vec_ptr, int *len_ptr,
 int
 mouse_face_overlay_overlaps (Lisp_Object overlay)
 {
-  int start = OVERLAY_POSITION (OVERLAY_START (overlay));
-  int end = OVERLAY_POSITION (OVERLAY_END (overlay));
+  EMACS_INT start = OVERLAY_POSITION (OVERLAY_START (overlay));
+  EMACS_INT end = OVERLAY_POSITION (OVERLAY_END (overlay));
   int n, i, size;
   Lisp_Object *v, tem;
 
@@ -2924,14 +2925,14 @@ mouse_face_overlay_overlaps (Lisp_Object overlay)
 
 /* Fast function to just test if we're at an overlay boundary.  */
 int
-overlay_touches_p (int pos)
+overlay_touches_p (EMACS_INT pos)
 {
   Lisp_Object overlay;
   struct Lisp_Overlay *tail;
 
   for (tail = current_buffer->overlays_before; tail; tail = tail->next)
     {
-      int endpos;
+      EMACS_INT endpos;
 
       XSETMISC (overlay ,tail);
       if (!OVERLAYP (overlay))
@@ -2946,7 +2947,7 @@ overlay_touches_p (int pos)
 
   for (tail = current_buffer->overlays_after; tail; tail = tail->next)
     {
-      int startpos;
+      EMACS_INT startpos;
 
       XSETMISC (overlay, tail);
       if (!OVERLAYP (overlay))
@@ -2964,7 +2965,7 @@ overlay_touches_p (int pos)
 struct sortvec
 {
   Lisp_Object overlay;
-  int beg, end;
+  EMACS_INT beg, end;
   int priority;
 };
 
@@ -3051,7 +3052,7 @@ struct sortstrlist
   struct sortstr *buf;  /* An array that expands as needed; never freed.  */
   int size;             /* Allocated length of that array.  */
   int used;             /* How much of the array is currently in use.  */
-  int bytes;            /* Total length of the strings in buf.  */
+  EMACS_INT bytes;              /* Total length of the strings in buf.  */
 };
 
 /* Buffers for storing information about the overlays touching a given
@@ -3062,7 +3063,7 @@ static struct sortstrlist overlay_heads, overlay_tails;
 static unsigned char *overlay_str_buf;
 
 /* Allocated length of overlay_str_buf.  */
-static int overlay_str_len;
+static EMACS_INT overlay_str_len;
 
 /* A comparison function suitable for passing to qsort.  */
 static int
@@ -3080,7 +3081,7 @@ cmp_for_strings (const void *as1, const void *as2)
 static void
 record_overlay_string (struct sortstrlist *ssl, Lisp_Object str, Lisp_Object str2, Lisp_Object pri, int size)
 {
-  int nbytes;
+  EMACS_INT nbytes;
 
   if (ssl->used == ssl->size)
     {
@@ -3133,12 +3134,12 @@ record_overlay_string (struct sortstrlist *ssl, Lisp_Object str, Lisp_Object str
    PSTR, if that variable is non-null.  The string may be overwritten by
    subsequent calls.  */
 
-int
+EMACS_INT
 overlay_strings (EMACS_INT pos, struct window *w, unsigned char **pstr)
 {
   Lisp_Object overlay, window, str;
   struct Lisp_Overlay *ov;
-  int startpos, endpos;
+  EMACS_INT startpos, endpos;
   int multibyte = ! NILP (current_buffer->enable_multibyte_characters);
 
   overlay_heads.used = overlay_heads.bytes = 0;
@@ -3208,9 +3209,9 @@ overlay_strings (EMACS_INT pos, struct window *w, unsigned char **pstr)
   if (overlay_heads.bytes || overlay_tails.bytes)
     {
       Lisp_Object tem;
-      int i;
+      EMACS_INT i;
       unsigned char *p;
-      int total = overlay_heads.bytes + overlay_tails.bytes;
+      EMACS_INT total = overlay_heads.bytes + overlay_tails.bytes;
 
       if (total > overlay_str_len)
         {
@@ -3221,7 +3222,7 @@ overlay_strings (EMACS_INT pos, struct window *w, unsigned char **pstr)
       p = overlay_str_buf;
       for (i = overlay_tails.used; --i >= 0;)
         {
-          int nbytes;
+          EMACS_INT nbytes;
           tem = overlay_tails.buf[i].string;
           nbytes = copy_text (SDATA (tem), p,
                               SBYTES (tem),
@@ -3230,7 +3231,7 @@ overlay_strings (EMACS_INT pos, struct window *w, unsigned char **pstr)
         }
       for (i = 0; i < overlay_heads.used; ++i)
         {
-          int nbytes;
+          EMACS_INT nbytes;
           tem = overlay_heads.buf[i].string;
           nbytes = copy_text (SDATA (tem), p,
                               SBYTES (tem),
@@ -3295,7 +3296,7 @@ recenter_overlay_lists (struct buffer *buf, EMACS_INT pos)
       if (OVERLAY_POSITION (end) > pos)
         {
           /* OVERLAY needs to be moved.  */
-          int where = OVERLAY_POSITION (beg);
+          EMACS_INT where = OVERLAY_POSITION (beg);
           struct Lisp_Overlay *other, *other_prev;
 
           /* Splice the cons cell TAIL out of overlays_before.  */
@@ -3368,7 +3369,7 @@ recenter_overlay_lists (struct buffer *buf, EMACS_INT pos)
       if (OVERLAY_POSITION (end) <= pos)
         {
           /* OVERLAY needs to be moved.  */
-          int where = OVERLAY_POSITION (end);
+          EMACS_INT where = OVERLAY_POSITION (end);
           struct Lisp_Overlay *other, *other_prev;
 
           /* Splice the cons cell TAIL out of overlays_after.  */
@@ -3440,7 +3441,7 @@ adjust_overlays_for_delete (EMACS_INT pos, EMACS_INT length)
    Such an overlay might even have negative size at this point.
    If so, we'll make the overlay empty. */
 void
-fix_start_end_in_overlays (register int start, register int end)
+fix_start_end_in_overlays (register EMACS_INT start, register EMACS_INT end)
 {
   Lisp_Object overlay;
   struct Lisp_Overlay *before_list, *after_list;
@@ -3452,7 +3453,7 @@ fix_start_end_in_overlays (register int start, register int end)
      current_buffer->overlays_before or overlays_after, depending
      which loop we're in.  */
   struct Lisp_Overlay *tail, *parent;
-  int startpos, endpos;
+  EMACS_INT startpos, endpos;
 
   /* This algorithm shifts links around instead of consing and GCing.
      The loop invariant is that before_list (resp. after_list) is a
@@ -3753,7 +3754,7 @@ modify_overlay (struct buffer *buf, EMACS_INT start, EMACS_INT end)
 {
   if (start > end)
     {
-      int temp = start;
+      EMACS_INT temp = start;
       start = end;
       end = temp;
     }
@@ -3844,8 +3845,8 @@ buffer.  */)
       /* Redisplay where the overlay was.  */
       if (!NILP (obuffer))
         {
-          int o_beg;
-          int o_end;
+          EMACS_INT o_beg;
+          EMACS_INT o_end;
 
           o_beg = OVERLAY_POSITION (OVERLAY_START (overlay));
           o_end = OVERLAY_POSITION (OVERLAY_END (overlay));
@@ -3859,7 +3860,7 @@ buffer.  */)
   else
     /* Redisplay the area the overlay has just left, or just enclosed.  */
     {
-      int o_beg, o_end;
+      EMACS_INT o_beg, o_end;
 
       o_beg = OVERLAY_POSITION (OVERLAY_START (overlay));
       o_end = OVERLAY_POSITION (OVERLAY_END (overlay));
@@ -4037,7 +4038,7 @@ end of the buffer.  */)
   /* Put all the overlays we want in a vector in overlay_vec.
      Store the length in len.  */
   noverlays = overlays_in (XINT (beg), XINT (end), 1, &overlay_vec, &len,
-                           (int *) 0, (int *) 0);
+                           NULL, NULL);
 
   /* Make a list of them all.  */
   result = Flist (noverlays, overlay_vec);
@@ -4280,7 +4281,7 @@ report_overlay_modification (Lisp_Object start, Lisp_Object end, int after,
       last_overlay_modification_hooks_used = 0;
       for (tail = current_buffer->overlays_before; tail; tail = tail->next)
         {
-          int startpos, endpos;
+          EMACS_INT startpos, endpos;
           Lisp_Object ostart, oend;
 
           XSETMISC (overlay, tail);
@@ -4317,7 +4318,7 @@ report_overlay_modification (Lisp_Object start, Lisp_Object end, int after,
 
       for (tail = current_buffer->overlays_after; tail; tail = tail->next)
         {
-          int startpos, endpos;
+          EMACS_INT startpos, endpos;
           Lisp_Object ostart, oend;
 
           XSETMISC (overlay, tail);
@@ -4409,7 +4410,7 @@ evaporate_overlays (EMACS_INT pos)
   if (pos <= current_buffer->overlay_center)
     for (tail = current_buffer->overlays_before; tail; tail = tail->next)
       {
-        int endpos;
+        EMACS_INT endpos;
         XSETMISC (overlay, tail);
         endpos = OVERLAY_POSITION (OVERLAY_END (overlay));
         if (endpos < pos)
@@ -4421,7 +4422,7 @@ evaporate_overlays (EMACS_INT pos)
   else
     for (tail = current_buffer->overlays_after; tail; tail = tail->next)
       {
-        int startpos;
+        EMACS_INT startpos;
         XSETMISC (overlay, tail);
         startpos = OVERLAY_POSITION (OVERLAY_START (overlay));
         if (startpos > pos)
diff --git a/src/buffer.h b/src/buffer.h
index 339e7d9bb6d..3a4dd106360 100644
--- a/src/buffer.h
+++ b/src/buffer.h
@@ -865,7 +865,7 @@ extern int overlays_at (EMACS_INT pos, int extend, Lisp_Object **vec_ptr,
                         EMACS_INT *prev_ptr, int change_req);
 extern int sort_overlays (Lisp_Object *, int, struct window *);
 extern void recenter_overlay_lists (struct buffer *, EMACS_INT);
-extern int overlay_strings (EMACS_INT, struct window *, unsigned char **);
+extern EMACS_INT overlay_strings (EMACS_INT, struct window *, unsigned char **);
 extern void validate_region (Lisp_Object *, Lisp_Object *);
 extern void set_buffer_internal (struct buffer *);
 extern void set_buffer_internal_1 (struct buffer *);
diff --git a/src/callproc.c b/src/callproc.c
index 8c1384df6a1..6f70631a484 100644
--- a/src/callproc.c
+++ b/src/callproc.c
@@ -678,9 +678,9 @@ usage: (call-process PROGRAM &optional INFILE BUFFER DISPLAY &rest ARGS)  */)
   QUIT;
 
   {
-    register int nread;
+    register EMACS_INT nread;
     int first = 1;
-    int total_read = 0;
+    EMACS_INT total_read = 0;
     int carryover = 0;
     int display_on_the_fly = display_p;
     struct coding_system saved_coding;
diff --git a/src/casefiddle.c b/src/casefiddle.c
index b6551618b2f..a9169f79951 100644
--- a/src/casefiddle.c
+++ b/src/casefiddle.c
@@ -352,8 +352,8 @@ static Lisp_Object
 operate_on_word (Lisp_Object arg, EMACS_INT *newpoint)
 {
   Lisp_Object val;
-  int farend;
-  int iarg;
+  EMACS_INT farend;
+  EMACS_INT iarg;
 
   CHECK_NUMBER (arg);
   iarg = XINT (arg);
diff --git a/src/ccl.c b/src/ccl.c
index f418c65b01e..f98897b51fa 100644
--- a/src/ccl.c
+++ b/src/ccl.c
@@ -2061,10 +2061,10 @@ usage: (ccl-execute-on-string CCL-PROGRAM STATUS STRING &optional CONTINUE UNIBY
   int i;
   int outbufsize;
   unsigned char *outbuf, *outp;
-  int str_chars, str_bytes;
+  EMACS_INT str_chars, str_bytes;
 #define CCL_EXECUTE_BUF_SIZE 1024
   int source[CCL_EXECUTE_BUF_SIZE], destination[CCL_EXECUTE_BUF_SIZE];
-  int consumed_chars, consumed_bytes, produced_chars;
+  EMACS_INT consumed_chars, consumed_bytes, produced_chars;
 
   if (setup_ccl_program (&ccl, ccl_prog) < 0)
     error ("Invalid CCL program");
@@ -2128,7 +2128,7 @@ usage: (ccl-execute-on-string CCL-PROGRAM STATUS STRING &optional CONTINUE UNIBY
               if (outp - outbuf + MAX_MULTIBYTE_LENGTH * ccl.produced
                   > outbufsize)
                 {
-                  int offset = outp - outbuf;
+                  EMACS_INT offset = outp - outbuf;
                   outbufsize += MAX_MULTIBYTE_LENGTH * ccl.produced;
                   outbuf = (unsigned char *) xrealloc (outbuf, outbufsize);
                   outp = outbuf + offset;
@@ -2140,7 +2140,7 @@ usage: (ccl-execute-on-string CCL-PROGRAM STATUS STRING &optional CONTINUE UNIBY
             {
               if (outp - outbuf + ccl.produced > outbufsize)
                 {
-                  int offset = outp - outbuf;
+                  EMACS_INT offset = outp - outbuf;
                   outbufsize += ccl.produced;
                   outbuf = (unsigned char *) xrealloc (outbuf, outbufsize);
                   outp = outbuf + offset;
diff --git a/src/character.c b/src/character.c
index c4a3a008bcd..d80f8139486 100644
--- a/src/character.c
+++ b/src/character.c
@@ -378,11 +378,12 @@ usage: (char-width CHAR)  */)
    characters and bytes of the substring in *NCHARS and *NBYTES
    respectively.  */
 
-int
-c_string_width (const unsigned char *str, int len, int precision, int *nchars, int *nbytes)
+EMACS_INT
+c_string_width (const unsigned char *str, EMACS_INT len, int precision,
+                EMACS_INT *nchars, EMACS_INT *nbytes)
 {
-  int i = 0, i_byte = 0;
-  int width = 0;
+  EMACS_INT i = 0, i_byte = 0;
+  EMACS_INT width = 0;
   struct Lisp_Char_Table *dp = buffer_display_table ();
 
   while (i_byte < len)
@@ -429,8 +430,8 @@ c_string_width (const unsigned char *str, int len, int precision, int *nchars, i
    current buffer.  The width is measured by how many columns it
    occupies on the screen.  */
 
-int
-strwidth (const unsigned char *str, int len)
+EMACS_INT
+strwidth (const unsigned char *str, EMACS_INT len)
 {
   return c_string_width (str, len, -1, NULL, NULL);
 }
@@ -442,17 +443,18 @@ strwidth (const unsigned char *str, int len)
    PRECISION, and set number of characters and bytes of the substring
    in *NCHARS and *NBYTES respectively.  */
 
-int
-lisp_string_width (Lisp_Object string, int precision, int *nchars, int *nbytes)
+EMACS_INT
+lisp_string_width (Lisp_Object string, int precision,
+                   EMACS_INT *nchars, EMACS_INT *nbytes)
 {
-  int len = SCHARS (string);
+  EMACS_INT len = SCHARS (string);
   /* This set multibyte to 0 even if STRING is multibyte when it
      contains only ascii and eight-bit-graphic, but that's
      intentional.  */
   int multibyte = len < SBYTES (string);
   unsigned char *str = SDATA (string);
-  int i = 0, i_byte = 0;
-  int width = 0;
+  EMACS_INT i = 0, i_byte = 0;
+  EMACS_INT width = 0;
   struct Lisp_Char_Table *dp = buffer_display_table ();
 
   while (i < len)
@@ -570,11 +572,11 @@ EMACS_INT
 multibyte_chars_in_text (const unsigned char *ptr, EMACS_INT nbytes)
 {
   const unsigned char *endp = ptr + nbytes;
-  int chars = 0;
+  EMACS_INT chars = 0;
 
   while (ptr < endp)
     {
-      int len = MULTIBYTE_LENGTH (ptr, endp);
+      EMACS_INT len = MULTIBYTE_LENGTH (ptr, endp);
 
       if (len == 0)
         abort ();
@@ -592,10 +594,11 @@ multibyte_chars_in_text (const unsigned char *ptr, EMACS_INT nbytes)
    represented by 2-byte in a multibyte text.  */
 
 void
-parse_str_as_multibyte (const unsigned char *str, int len, int *nchars, int *nbytes)
+parse_str_as_multibyte (const unsigned char *str, EMACS_INT len,
+                        EMACS_INT *nchars, EMACS_INT *nbytes)
 {
   const unsigned char *endp = str + len;
-  int n, chars = 0, bytes = 0;
+  EMACS_INT n, chars = 0, bytes = 0;
 
   if (len >= MAX_MULTIBYTE_LENGTH)
     {
@@ -633,12 +636,13 @@ parse_str_as_multibyte (const unsigned char *str, int len, int *nchars, int *nby
    area and that is enough.  Return the number of bytes of the
    resulting text.  */
 
-int
-str_as_multibyte (unsigned char *str, int len, int nbytes, int *nchars)
+EMACS_INT
+str_as_multibyte (unsigned char *str, EMACS_INT len, EMACS_INT nbytes,
+                  EMACS_INT *nchars)
 {
   unsigned char *p = str, *endp = str + nbytes;
   unsigned char *to;
-  int chars = 0;
+  EMACS_INT chars = 0;
   int n;
 
   if (nbytes >= MAX_MULTIBYTE_LENGTH)
@@ -709,11 +713,11 @@ str_as_multibyte (unsigned char *str, int len, int nbytes, int *nchars)
    bytes it may ocupy when converted to multibyte string by
    `str_to_multibyte'.  */
 
-int
-parse_str_to_multibyte (const unsigned char *str, int len)
+EMACS_INT
+parse_str_to_multibyte (const unsigned char *str, EMACS_INT len)
 {
   const unsigned char *endp = str + len;
-  int bytes;
+  EMACS_INT bytes;
 
   for (bytes = 0; str < endp; str++)
     bytes += (*str < 0x80) ? 1 : 2;
@@ -727,8 +731,8 @@ parse_str_to_multibyte (const unsigned char *str, int len)
    that we can use LEN bytes at STR as a work area and that is
    enough.  */
 
-int
-str_to_multibyte (unsigned char *str, int len, int bytes)
+EMACS_INT
+str_to_multibyte (unsigned char *str, EMACS_INT len, EMACS_INT bytes)
 {
   unsigned char *p = str, *endp = str + bytes;
   unsigned char *to;
@@ -756,8 +760,8 @@ str_to_multibyte (unsigned char *str, int len, int bytes)
    actually converts characters in the range 0x80..0xFF to
    unibyte.  */
 
-int
-str_as_unibyte (unsigned char *str, int bytes)
+EMACS_INT
+str_as_unibyte (unsigned char *str, EMACS_INT bytes)
 {
   const unsigned char *p = str, *endp = str + bytes;
   unsigned char *to;
@@ -818,14 +822,14 @@ str_to_unibyte (const unsigned char *src, unsigned char *dst, EMACS_INT chars, i
 }
 
 
-int
+EMACS_INT
 string_count_byte8 (Lisp_Object string)
 {
   int multibyte = STRING_MULTIBYTE (string);
-  int nbytes = SBYTES (string);
+  EMACS_INT nbytes = SBYTES (string);
   unsigned char *p = SDATA (string);
   unsigned char *pend = p + nbytes;
-  int count = 0;
+  EMACS_INT count = 0;
   int c, len;
 
   if (multibyte)
@@ -851,10 +855,10 @@ string_count_byte8 (Lisp_Object string)
 Lisp_Object
 string_escape_byte8 (Lisp_Object string)
 {
-  int nchars = SCHARS (string);
-  int nbytes = SBYTES (string);
+  EMACS_INT nchars = SCHARS (string);
+  EMACS_INT nbytes = SBYTES (string);
   int multibyte = STRING_MULTIBYTE (string);
-  int byte8_count;
+  EMACS_INT byte8_count;
   const unsigned char *src, *src_end;
   unsigned char *dst;
   Lisp_Object val;
@@ -869,12 +873,22 @@ string_escape_byte8 (Lisp_Object string)
     return string;
 
   if (multibyte)
-    /* Convert 2-byte sequence of byte8 chars to 4-byte octal.  */
-    val = make_uninit_multibyte_string (nchars + byte8_count * 3,
-                                        nbytes + byte8_count * 2);
+    {
+      if ((MOST_POSITIVE_FIXNUM - nchars) / 3 < byte8_count
+          || (MOST_POSITIVE_FIXNUM - nbytes) / 2 < byte8_count)
+        error ("Maximum string size exceeded");
+
+      /* Convert 2-byte sequence of byte8 chars to 4-byte octal.  */
+      val = make_uninit_multibyte_string (nchars + byte8_count * 3,
+                                          nbytes + byte8_count * 2);
+    }
   else
-    /* Convert 1-byte sequence of byte8 chars to 4-byte octal.  */
-    val = make_uninit_string (nbytes + byte8_count * 3);
+    {
+      if ((MOST_POSITIVE_FIXNUM - nchars) / 3 < byte8_count)
+        error ("Maximum string size exceeded");
+      /* Convert 1-byte sequence of byte8 chars to 4-byte octal.  */
+      val = make_uninit_string (nbytes + byte8_count * 3);
+    }
 
   src = SDATA (string);
   src_end = src + nbytes;
diff --git a/src/character.h b/src/character.h
index 8726b2ae1d6..aea1a47a1f6 100644
--- a/src/character.h
+++ b/src/character.h
@@ -603,17 +603,20 @@ extern int string_char (const unsigned char *,
 
 extern int translate_char (Lisp_Object, int c);
 extern int char_printable_p (int c);
-extern void parse_str_as_multibyte (const unsigned char *, int, int *,
-                                    int *);
-extern int parse_str_to_multibyte (const unsigned char *, int);
-extern int str_as_multibyte (unsigned char *, int, int, int *);
-extern int str_to_multibyte (unsigned char *, int, int);
-extern int str_as_unibyte (unsigned char *, int);
+extern void parse_str_as_multibyte (const unsigned char *,
+                                    EMACS_INT, EMACS_INT *, EMACS_INT *);
+extern EMACS_INT parse_str_to_multibyte (const unsigned char *, EMACS_INT);
+extern EMACS_INT str_as_multibyte (unsigned char *, EMACS_INT, EMACS_INT,
+                             EMACS_INT *);
+extern EMACS_INT str_to_multibyte (unsigned char *, EMACS_INT, EMACS_INT);
+extern EMACS_INT str_as_unibyte (unsigned char *, EMACS_INT);
 extern EMACS_INT str_to_unibyte (const unsigned char *, unsigned char *,
                                  EMACS_INT, int);
-extern int strwidth (const unsigned char *, int);
-extern int c_string_width (const unsigned char *, int, int, int *, int *);
-extern int lisp_string_width (Lisp_Object, int, int *, int *);
+extern EMACS_INT strwidth (const unsigned char *, EMACS_INT);
+extern EMACS_INT c_string_width (const unsigned char *, EMACS_INT, int,
+                                 EMACS_INT *, EMACS_INT *);
+extern EMACS_INT lisp_string_width (Lisp_Object, int,
+                                    EMACS_INT *, EMACS_INT *);
 
 extern Lisp_Object Vprintable_chars;
 
diff --git a/src/charset.c b/src/charset.c
index 036d7146db6..8051b11330e 100644
--- a/src/charset.c
+++ b/src/charset.c
@@ -427,7 +427,7 @@ load_charset_map (struct charset *charset, struct charset_map_entries *entries,
 
 
 /* Read a hexadecimal number (preceded by "0x") from the file FP while
-   paying attention to comment charcter '#'.  */
+   paying attention to comment character '#'.  */
 
 static INLINE unsigned
 read_hex (FILE *fp, int *eof)
diff --git a/src/cmds.c b/src/cmds.c
index f12e759b7a6..e12d7c370d9 100644
--- a/src/cmds.c
+++ b/src/cmds.c
@@ -37,7 +37,7 @@ Lisp_Object Qkill_forward_chars, Qkill_backward_chars;
 /* A possible value for a buffer's overwrite-mode variable.  */
 Lisp_Object Qoverwrite_mode_binary;
 
-static int internal_self_insert (int, int);
+static int internal_self_insert (int, EMACS_INT);
 
 DEFUN ("forward-point", Fforward_point, Sforward_point, 1, 1, 0,
        doc: /* Return buffer position N characters after (before if N negative) point.  */)
@@ -68,7 +68,7 @@ right or to the left on the screen.  This is in contrast with
      hooks, etcetera), that's not a good approach.  So we validate the
      proposed position, then set point.  */
   {
-    int new_point = PT + XINT (n);
+    EMACS_INT new_point = PT + XINT (n);
 
     if (new_point < BEGV)
       {
@@ -116,9 +116,9 @@ With positive N, a non-empty line at the end counts as one line
 successfully moved (for the return value).  */)
   (Lisp_Object n)
 {
-  int opoint = PT, opoint_byte = PT_BYTE;
-  int pos, pos_byte;
-  int count, shortage;
+  EMACS_INT opoint = PT, opoint_byte = PT_BYTE;
+  EMACS_INT pos, pos_byte;
+  EMACS_INT count, shortage;
 
   if (NILP (n))
     count = 1;
@@ -188,7 +188,7 @@ not move.  To ignore field boundaries bind `inhibit-field-text-motion'
 to t.  */)
   (Lisp_Object n)
 {
-  int newpos;
+  EMACS_INT newpos;
 
   if (NILP (n))
     XSETFASTINT (n, 1);
@@ -233,7 +233,7 @@ N was explicitly specified.
 The command `delete-forward' is preferable for interactive use.  */)
   (Lisp_Object n, Lisp_Object killflag)
 {
-  int pos;
+  EMACS_INT pos;
 
   CHECK_NUMBER (n);
 
@@ -303,7 +303,7 @@ After insertion, the value of `auto-fill-function' is called if the
     bitch_at_user ();
   {
     int character = translate_char (Vtranslation_table_for_input,
-                                    XINT (last_command_event));
+                                    (int) XINT (last_command_event));
     int val = internal_self_insert (character, XFASTINT (n));
     if (val == 2)
       nonundocount = 0;
@@ -323,7 +323,7 @@ static Lisp_Object Qexpand_abbrev;
 static Lisp_Object Qpost_self_insert_hook, Vpost_self_insert_hook;
 
 static int
-internal_self_insert (int c, int n)
+internal_self_insert (int c, EMACS_INT n)
 {
   int hairy = 0;
   Lisp_Object tem;
@@ -333,8 +333,8 @@ internal_self_insert (int c, int n)
   int len;
   /* Working buffer and pointer for multi-byte form of C.  */
   unsigned char str[MAX_MULTIBYTE_LENGTH];
-  int chars_to_delete = 0;
-  int spaces_to_insert = 0;
+  EMACS_INT chars_to_delete = 0;
+  EMACS_INT spaces_to_insert = 0;
 
   overwrite = current_buffer->overwrite_mode;
   if (!NILP (Vbefore_change_functions) || !NILP (Vafter_change_functions))
@@ -380,12 +380,12 @@ internal_self_insert (int c, int n)
         chars_to_delete = n;
       else if (c != '\n' && c2 != '\n')
         {
-          int pos = PT;
-          int pos_byte = PT_BYTE;
+          EMACS_INT pos = PT;
+          EMACS_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))));
+                            + n * (int) XINT (Fchar_width (make_number (c))));
 
               /* The actual cursor position after the trial of moving
                  to column TARGET_CLM.  It is greater than TARGET_CLM
@@ -393,7 +393,8 @@ internal_self_insert (int c, int n)
                  character.  In that case, the new point is set after
                  that character.  */
               int actual_clm
-                = XFASTINT (Fmove_to_column (make_number (target_clm), Qnil));
+                = (int) XFASTINT (Fmove_to_column (make_number (target_clm),
+                                                   Qnil));
 
               chars_to_delete = PT - pos;
 
@@ -524,7 +525,7 @@ syms_of_cmds (void)
 
   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.  */);
+This is run after inserting the character.  */);
   Vpost_self_insert_hook = Qnil;
 
   defsubr (&Sforward_point);
diff --git a/src/coding.c b/src/coding.c
index 6012978b60a..d6285ed9245 100644
--- a/src/coding.c
+++ b/src/coding.c
@@ -2008,7 +2008,7 @@ detect_coding_emacs_mule (struct coding_system *coding,
         }
       else
         {
-          int more_bytes = emacs_mule_bytes[*src_base] - 1;
+          int more_bytes = emacs_mule_bytes[c] - 1;
 
           while (more_bytes > 0)
             {
@@ -4490,7 +4490,10 @@ encode_coding_iso_2022 (struct coding_system *coding)
   charset_list = CODING_ATTR_CHARSET_LIST (attrs);
   coding->safe_charsets = SDATA (CODING_ATTR_SAFE_CHARSETS (attrs));
 
-  ascii_compatible = ! NILP (CODING_ATTR_ASCII_COMPAT (attrs));
+  ascii_compatible
+    = (! NILP (CODING_ATTR_ASCII_COMPAT (attrs))
+       && ! (CODING_ISO_FLAGS (coding) & (CODING_ISO_FLAG_DESIGNATION
+                                          | CODING_ISO_FLAG_LOCKING_SHIFT)));
 
   while (charbuf < charbuf_end)
     {
diff --git a/src/commands.h b/src/commands.h
index 52136428eee..6b22da8ba15 100644
--- a/src/commands.h
+++ b/src/commands.h
@@ -74,7 +74,7 @@ extern Lisp_Object Vthis_command;
 extern Lisp_Object unread_switch_frame;
 
 /* The value of point when the last command was started.  */
-extern int last_point_position;
+extern EMACS_INT last_point_position;
 
 /* The buffer that was current when the last command was started.  */
 extern Lisp_Object last_point_position_buffer;
diff --git a/src/composite.c b/src/composite.c
index bc5a67ef6e2..be9aafbeacc 100644
--- a/src/composite.c
+++ b/src/composite.c
@@ -180,7 +180,8 @@ Lisp_Object composition_temp;
    If the composition is invalid, return -1.  */
 
 int
-get_composition_id (int charpos, int bytepos, int nchars, Lisp_Object prop, Lisp_Object string)
+get_composition_id (EMACS_INT charpos, EMACS_INT bytepos, EMACS_INT nchars,
+                    Lisp_Object prop, Lisp_Object string)
 {
   Lisp_Object id, length, components, key, *key_contents;
   int glyph_len;
@@ -188,7 +189,8 @@ get_composition_id (int charpos, int bytepos, int nchars, Lisp_Object prop, Lisp
   int hash_index;
   unsigned hash_code;
   struct composition *cmp;
-  int i, ch;
+  EMACS_INT i;
+  int ch;
 
   /* PROP should be
         Form-A: ((LENGTH . COMPONENTS) . MODIFICATION-FUNC)
@@ -290,7 +292,7 @@ get_composition_id (int charpos, int bytepos, int nchars, Lisp_Object prop, Lisp
       && VECTORP (AREF (components, 0)))
     {
       /* COMPONENTS is a glyph-string.  */
-      int len = ASIZE (key);
+      EMACS_UINT len = ASIZE (key);
 
       for (i = 1; i < len; i++)
         if (! VECTORP (AREF (key, i)))
@@ -298,7 +300,7 @@ get_composition_id (int charpos, int bytepos, int nchars, Lisp_Object prop, Lisp
     }
   else if (VECTORP (components) || CONSP (components))
     {
-      int len = XVECTOR (key)->size;
+      EMACS_UINT len = XVECTOR (key)->size;
 
       /* The number of elements should be odd.  */
       if ((len % 2) == 0)
@@ -427,7 +429,9 @@ get_composition_id (int charpos, int bytepos, int nchars, Lisp_Object prop, Lisp
    This doesn't check the validity of composition.  */
 
 int
-find_composition (int pos, int limit, EMACS_INT *start, EMACS_INT *end, Lisp_Object *prop, Lisp_Object object)
+find_composition (EMACS_INT pos, EMACS_INT limit,
+                  EMACS_INT *start, EMACS_INT *end,
+                  Lisp_Object *prop, Lisp_Object object)
 {
   Lisp_Object val;
 
@@ -465,7 +469,7 @@ find_composition (int pos, int limit, EMACS_INT *start, EMACS_INT *end, Lisp_Obj
    FROM and TO with property PROP.  */
 
 static void
-run_composition_function (int from, int to, Lisp_Object prop)
+run_composition_function (EMACS_INT from, EMACS_INT to, Lisp_Object prop)
 {
   Lisp_Object func;
   EMACS_INT start, end;
@@ -628,7 +632,8 @@ make_composition_value_copy (Lisp_Object list)
    indices START and END in STRING.  */
 
 void
-compose_text (int start, int end, Lisp_Object components, Lisp_Object modification_func, Lisp_Object string)
+compose_text (EMACS_INT start, EMACS_INT end, Lisp_Object components,
+              Lisp_Object modification_func, Lisp_Object string)
 {
   Lisp_Object prop;
 
@@ -735,7 +740,8 @@ composition_gstring_p (Lisp_Object gstring)
 }
 
 int
-composition_gstring_width (Lisp_Object gstring, int from, int to, struct font_metrics *metrics)
+composition_gstring_width (Lisp_Object gstring, EMACS_INT from, EMACS_INT to,
+                           struct font_metrics *metrics)
 {
   Lisp_Object *glyph;
   int width = 0;
@@ -907,7 +913,7 @@ autocmp_chars (Lisp_Object rule, EMACS_INT charpos, EMACS_INT bytepos, EMACS_INT
   EMACS_INT to;
   EMACS_INT pt = PT, pt_byte = PT_BYTE;
   Lisp_Object re, font_object, lgstring;
-  int len;
+  EMACS_INT len;
 
   record_unwind_save_match_data ();
   re = AREF (rule, 0);
@@ -1397,7 +1403,7 @@ composition_update_it (struct composition_it *cmp_it, EMACS_INT charpos, EMACS_I
       /* automatic composition */
       Lisp_Object gstring = composition_gstring_from_id (cmp_it->id);
       Lisp_Object glyph;
-      int from, to;
+      EMACS_INT from;
 
       if (cmp_it->nglyphs == 0)
         {
@@ -1656,7 +1662,7 @@ find_automatic_composition (EMACS_INT pos, EMACS_INT limit, EMACS_INT *start, EM
 /* Return the adjusted point provided that point is moved from LAST_PT
    to NEW_PT.  */
 
-int
+EMACS_INT
 composition_adjust_point (EMACS_INT last_pt, EMACS_INT new_pt)
 {
   EMACS_INT charpos, bytepos, startpos, beg, end, pos;
@@ -1879,9 +1885,9 @@ See `find-composition' for more details.  */)
     id = COMPOSITION_ID (prop);
   else
     {
-      int start_byte = (NILP (string)
-                        ? CHAR_TO_BYTE (start)
-                        : string_char_to_byte (string, start));
+      EMACS_INT start_byte = (NILP (string)
+                              ? CHAR_TO_BYTE (start)
+                              : string_char_to_byte (string, start));
       id = get_composition_id (start, start_byte, end - start, prop, string);
     }
 
diff --git a/src/composite.h b/src/composite.h
index 554ab554115..5c8ade39596 100644
--- a/src/composite.h
+++ b/src/composite.h
@@ -212,15 +212,16 @@ extern Lisp_Object Vauto_composition_function;
 extern Lisp_Object Qauto_composition_function;
 extern Lisp_Object Vcomposition_function_table;
 
-extern int get_composition_id (int, int, int, Lisp_Object, Lisp_Object);
-extern int find_composition (int, int, EMACS_INT *, EMACS_INT *, Lisp_Object *,
-                             Lisp_Object);
+extern int get_composition_id (EMACS_INT, EMACS_INT, EMACS_INT,
+                               Lisp_Object, Lisp_Object);
+extern int find_composition (EMACS_INT, EMACS_INT, EMACS_INT *, EMACS_INT *,
+                             Lisp_Object *, Lisp_Object);
 extern void update_compositions (EMACS_INT, EMACS_INT, int);
 extern void make_composition_value_copy (Lisp_Object);
 extern void compose_region (int, int, Lisp_Object, Lisp_Object,
                             Lisp_Object);
 extern void syms_of_composite (void);
-extern void compose_text (int, int, Lisp_Object, Lisp_Object,
+extern void compose_text (EMACS_INT, EMACS_INT, Lisp_Object, Lisp_Object,
                           Lisp_Object);
 
 /* Macros for lispy glyph-string.  This is completely different from
@@ -306,7 +307,7 @@ struct font_metrics;
 extern Lisp_Object composition_gstring_put_cache (Lisp_Object, int);
 extern Lisp_Object composition_gstring_from_id (int);
 extern int composition_gstring_p (Lisp_Object);
-extern int composition_gstring_width (Lisp_Object, int, int,
+extern int composition_gstring_width (Lisp_Object, EMACS_INT, EMACS_INT,
                                       struct font_metrics *);
 
 extern void composition_compute_stop_pos (struct composition_it *,
@@ -319,7 +320,7 @@ extern int composition_reseat_it (struct composition_it *,
 extern int composition_update_it (struct composition_it *,
                                   EMACS_INT, EMACS_INT, Lisp_Object);
 
-extern int composition_adjust_point (EMACS_INT, EMACS_INT);
+extern EMACS_INT composition_adjust_point (EMACS_INT, EMACS_INT);
 
 EXFUN (Fcompose_region_internal, 4);
 EXFUN (Fcompose_string_internal, 5);
diff --git a/src/config.in b/src/config.in
index 199afbd78ba..43ebb756215 100644
--- a/src/config.in
+++ b/src/config.in
@@ -255,6 +255,9 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 /* Define to 1 if you have a gif (or ungif) library. */
 #undef HAVE_GIF
 
+/* Define if we have the GNU TLS library.  */
+#undef HAVE_GNUTLS
+
 /* Define to 1 if you have the gpm library (-lgpm). */
 #undef HAVE_GPM
 
@@ -1094,6 +1097,12 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include config_opsysfile
 #include config_machfile
 
+#if HAVE_GNUTLS
+#define LIBGNUTLS $(LIBGNUTLS_LIBS)
+#else /* not HAVE_GNUTLS */
+#define LIBGNUTLS
+#endif /* not HAVE_GNUTLS */
+
 /* Set up some defines, C and LD flags for NeXTstep interface on GNUstep.
   (There is probably a better place to do this, but right now the Cocoa
    side does this in s/darwin.h and we cannot
diff --git a/src/data.c b/src/data.c
index 9490b7ac79a..78ccb75ca89 100644
--- a/src/data.c
+++ b/src/data.c
@@ -2092,13 +2092,14 @@ ARRAY may be a vector, a string, a char-table, a bool-vector,
 or a byte-code object.  IDX starts at 0.  */)
   (register Lisp_Object array, Lisp_Object idx)
 {
-  register int idxval;
+  register EMACS_INT idxval;
 
   CHECK_NUMBER (idx);
   idxval = XINT (idx);
   if (STRINGP (array))
     {
-      int c, idxval_byte;
+      int c;
+      EMACS_INT idxval_byte;
 
       if (idxval < 0 || idxval >= SCHARS (array))
         args_out_of_range (array, idx);
@@ -2146,7 +2147,7 @@ Return NEWELT.  ARRAY may be a vector, a string, a char-table or a
 bool-vector.  IDX starts at 0.  */)
   (register Lisp_Object array, Lisp_Object idx, Lisp_Object newelt)
 {
-  register int idxval;
+  register EMACS_INT idxval;
 
   CHECK_NUMBER (idx);
   idxval = XINT (idx);
@@ -2181,7 +2182,7 @@ bool-vector.  IDX starts at 0.  */)
     }
   else if (STRING_MULTIBYTE (array))
     {
-      int idxval_byte, prev_bytes, new_bytes, nbytes;
+      EMACS_INT idxval_byte, prev_bytes, new_bytes, nbytes;
       unsigned char workbuf[MAX_MULTIBYTE_LENGTH], *p0 = workbuf, *p1;
 
       if (idxval < 0 || idxval >= SCHARS (array))
@@ -2197,7 +2198,7 @@ bool-vector.  IDX starts at 0.  */)
       if (prev_bytes != new_bytes)
         {
           /* We must relocate the string data.  */
-          int nchars = SCHARS (array);
+          EMACS_INT nchars = SCHARS (array);
           unsigned char *str;
           USE_SAFE_ALLOCA;
 
diff --git a/src/dbusbind.c b/src/dbusbind.c
index 3b6f0e543bb..ffa02e8e9c9 100644
--- a/src/dbusbind.c
+++ b/src/dbusbind.c
@@ -27,6 +27,7 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include "frame.h"
 #include "termhooks.h"
 #include "keyboard.h"
+#include "process.h"
 
 
 /* Subroutines.  */
@@ -799,71 +800,84 @@ xd_initialize (Lisp_Object bus, int raise_error)
   return connection;
 }
 
-
-/* Add connection file descriptor to input_wait_mask, in order to
-   let select() detect, whether a new message has been arrived.  */
-dbus_bool_t
-xd_add_watch (DBusWatch *watch, void *data)
+/* Return the file descriptor for WATCH, -1 if not found.  */
+static int
+xd_find_watch_fd (DBusWatch *watch)
 {
-  /* We check only for incoming data.  */
-  if (dbus_watch_get_flags (watch) & DBUS_WATCH_READABLE)
-    {
 #if HAVE_DBUS_WATCH_GET_UNIX_FD
-      /* TODO: Reverse these on Win32, which prefers the opposite.  */
-      int fd = dbus_watch_get_unix_fd(watch);
-      if (fd == -1)
-        fd = dbus_watch_get_socket(watch);
+  /* TODO: Reverse these on Win32, which prefers the opposite.  */
+  int fd = dbus_watch_get_unix_fd (watch);
+  if (fd == -1)
+    fd = dbus_watch_get_socket (watch);
 #else
-      int fd = dbus_watch_get_fd(watch);
+  int fd = dbus_watch_get_fd (watch);
 #endif
-      XD_DEBUG_MESSAGE ("fd %d", fd);
+  return fd;
+}
 
-      if (fd == -1)
-        return FALSE;
+/* Prototype.  */
+static void
+xd_read_queued_messages (int fd, void *data, int for_read);
 
-      /* Add the file descriptor to input_wait_mask.  */
-      add_keyboard_wait_descriptor (fd);
-    }
+/* Start monitoring WATCH for possible I/O.  */
+static dbus_bool_t
+xd_add_watch (DBusWatch *watch, void *data)
+{
+  unsigned int flags = dbus_watch_get_flags (watch);
+  int fd = xd_find_watch_fd (watch);
 
-  /* Return.  */
+  XD_DEBUG_MESSAGE ("fd %d, write %d, enabled %d",
+                    fd, flags & DBUS_WATCH_WRITABLE,
+                    dbus_watch_get_enabled (watch));
+
+  if (fd == -1)
+    return FALSE;
+
+  if (dbus_watch_get_enabled (watch))
+    {
+      if (flags & DBUS_WATCH_WRITABLE)
+        add_write_fd (fd, xd_read_queued_messages, data);
+      if (flags & DBUS_WATCH_READABLE)
+        add_read_fd (fd, xd_read_queued_messages, data);
+    }
   return TRUE;
 }
 
-/* Remove connection file descriptor from input_wait_mask.  DATA is
-   the used bus, either a string or QCdbus_system_bus or
+/* Stop monitoring WATCH for possible I/O.
+   DATA is the used bus, either a string or QCdbus_system_bus or
    QCdbus_session_bus.  */
-void
+static void
 xd_remove_watch (DBusWatch *watch, void *data)
 {
-  /* We check only for incoming data.  */
-  if (dbus_watch_get_flags (watch) & DBUS_WATCH_READABLE)
-    {
-#if HAVE_DBUS_WATCH_GET_UNIX_FD
-      /* TODO: Reverse these on Win32, which prefers the opposite.  */
-      int fd = dbus_watch_get_unix_fd(watch);
-      if (fd == -1)
-        fd = dbus_watch_get_socket(watch);
-#else
-      int fd = dbus_watch_get_fd(watch);
-#endif
-      XD_DEBUG_MESSAGE ("fd %d", fd);
+  unsigned int flags = dbus_watch_get_flags (watch);
+  int fd = xd_find_watch_fd (watch);
 
-      if (fd == -1)
-        return;
+  XD_DEBUG_MESSAGE ("fd %d", fd);
 
-      /* Unset session environment.  */
-      if ((data != NULL) && (data == (void*) XHASH (QCdbus_session_bus)))
-        {
-          XD_DEBUG_MESSAGE ("unsetenv DBUS_SESSION_BUS_ADDRESS");
-          unsetenv ("DBUS_SESSION_BUS_ADDRESS");
-        }
+  if (fd == -1)
+    return;
 
-      /* Remove the file descriptor from input_wait_mask.  */
-      delete_keyboard_wait_descriptor (fd);
+  /* Unset session environment.  */
+  if (data != NULL && data == (void*) XHASH (QCdbus_session_bus))
+    {
+      XD_DEBUG_MESSAGE ("unsetenv DBUS_SESSION_BUS_ADDRESS");
+      unsetenv ("DBUS_SESSION_BUS_ADDRESS");
     }
 
-  /* Return.  */
-  return;
+  if (flags & DBUS_WATCH_WRITABLE)
+    delete_write_fd (fd);
+  if (flags & DBUS_WATCH_READABLE)
+    delete_read_fd (fd);
+}
+
+/* Toggle monitoring WATCH for possible I/O.  */
+static void
+xd_toggle_watch (DBusWatch *watch, void *data)
+{
+  if (dbus_watch_get_enabled (watch))
+    xd_add_watch (watch, data);
+  else
+    xd_remove_watch (watch, data);
 }
 
 DEFUN ("dbus-init-bus", Fdbus_init_bus, Sdbus_init_bus, 1, 1, 0,
@@ -880,7 +894,8 @@ DEFUN ("dbus-init-bus", Fdbus_init_bus, Sdbus_init_bus, 1, 1, 0,
   if (!dbus_connection_set_watch_functions (connection,
                                             xd_add_watch,
                                             xd_remove_watch,
-                                            NULL, (void*) XHASH (bus), NULL))
+                                            xd_toggle_watch,
+                                            (void*) XHASH (bus), NULL))
     XD_SIGNAL1 (build_string ("Cannot add watch functions"));
 
   /* Add bus to list of registered buses.  */
@@ -1288,9 +1303,6 @@ usage: (dbus-call-method-asynchronously BUS SERVICE PATH INTERFACE METHOD HANDLE
       result = Qnil;
     }
 
-  /* Flush connection to ensure the message is handled.  */
-  dbus_connection_flush (connection);
-
   XD_DEBUG_MESSAGE ("Message sent");
 
   /* Cleanup.  */
@@ -1379,9 +1391,6 @@ usage: (dbus-method-return-internal BUS SERIAL SERVICE &rest ARGS)  */)
   if (!dbus_connection_send (connection, dmessage, NULL))
     XD_SIGNAL1 (build_string ("Cannot send message"));
 
-  /* Flush connection to ensure the message is handled.  */
-  dbus_connection_flush (connection);
-
   XD_DEBUG_MESSAGE ("Message sent");
 
   /* Cleanup.  */
@@ -1471,9 +1480,6 @@ usage: (dbus-method-error-internal BUS SERIAL SERVICE &rest ARGS)  */)
   if (!dbus_connection_send (connection, dmessage, NULL))
     XD_SIGNAL1 (build_string ("Cannot send message"));
 
-  /* Flush connection to ensure the message is handled.  */
-  dbus_connection_flush (connection);
-
   XD_DEBUG_MESSAGE ("Message sent");
 
   /* Cleanup.  */
@@ -1589,9 +1595,6 @@ usage: (dbus-send-signal BUS SERVICE PATH INTERFACE SIGNAL &rest ARGS)  */)
   if (!dbus_connection_send (connection, dmessage, NULL))
     XD_SIGNAL1 (build_string ("Cannot send message"));
 
-  /* Flush connection to ensure the message is handled.  */
-  dbus_connection_flush (connection);
-
   XD_DEBUG_MESSAGE ("Signal sent");
 
   /* Cleanup.  */
@@ -1601,76 +1604,26 @@ usage: (dbus-send-signal BUS SERVICE PATH INTERFACE SIGNAL &rest ARGS)  */)
   return Qt;
 }
 
-/* Check, whether there is pending input in the message queue of the
-   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)
-{
-  DBusConnection *connection;
-
-  /* Open a connection to the bus.  */
-  connection = xd_initialize (bus, FALSE);
-  if (connection == NULL) return FALSE;
-
-  /* Non blocking read of the next available message.  */
-  dbus_connection_read_write (connection, 0);
-
-  /* Return.  */
-  return
-    (dbus_connection_get_dispatch_status (connection)
-     == DBUS_DISPATCH_DATA_REMAINS)
-    ? TRUE : FALSE;
-}
-
-/* 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;
-
-      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 either a
-   Lisp symbol, :system or :session, or a string denoting the bus
-   address.  */
-static Lisp_Object
-xd_read_message (Lisp_Object bus)
+/* Read one 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 void
+xd_read_message_1 (DBusConnection *connection, Lisp_Object bus)
 {
   Lisp_Object args, key, value;
   struct gcpro gcpro1;
   struct input_event event;
-  DBusConnection *connection;
   DBusMessage *dmessage;
   DBusMessageIter iter;
   unsigned int dtype;
   int mtype, serial;
   const char *uname, *path, *interface, *member;
 
-  /* Open a connection to the bus.  */
-  connection = xd_initialize (bus, TRUE);
-
-  /* Non blocking read of the next available message.  */
-  dbus_connection_read_write (connection, 0);
   dmessage = dbus_connection_pop_message (connection);
 
   /* Return if there is no queued message.  */
   if (dmessage == NULL)
-    return Qnil;
+    return;
 
   /* Collect the parameters.  */
   args = Qnil;
@@ -1801,22 +1754,49 @@ xd_read_message (Lisp_Object bus)
  cleanup:
   dbus_message_unref (dmessage);
 
-  RETURN_UNGCPRO (Qnil);
+  UNGCPRO;
 }
 
-/* Read queued incoming messages from all buses.  */
-void
-xd_read_queued_messages (void)
+/* Read queued incoming messages 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)
+{
+  /* Open a connection to the bus.  */
+  DBusConnection *connection = xd_initialize (bus, TRUE);
+
+  /* Non blocking read of the next available message.  */
+  dbus_connection_read_write (connection, 0);
+
+  while (dbus_connection_get_dispatch_status (connection)
+         != DBUS_DISPATCH_COMPLETE)
+    xd_read_message_1 (connection, bus);
+  return Qnil;
+}
+
+/* Callback called when something is ready to read or write.  */
+static void
+xd_read_queued_messages (int fd, void *data, int for_read)
 {
   Lisp_Object busp = Vdbus_registered_buses;
+  Lisp_Object bus = Qnil;
+
+  /* Find bus related to fd.  */
+  if (data != NULL)
+    while (!NILP (busp))
+      {
+        if (data == (void*) XHASH (CAR_SAFE (busp)))
+          bus = CAR_SAFE (busp);
+        busp = CDR_SAFE (busp);
+      }
+
+  if (NILP(bus))
+    return;
 
+  /* We ignore all Lisp errors during the call.  */
   xd_in_read_queued_messages = 1;
-  while (!NILP (busp))
-    {
-      /* We ignore all Lisp errors during the call.  */
-      internal_catch (Qdbus_error, xd_read_message, CAR_SAFE (busp));
-      busp = CDR_SAFE (busp);
-    }
+  internal_catch (Qdbus_error, xd_read_message, bus);
   xd_in_read_queued_messages = 0;
 }
 
@@ -2181,8 +2161,12 @@ be called when the D-Bus reply message arrives.  */);
     doc: /* If non-nil, debug messages of D-Bus bindings are raised.  */);
 #ifdef DBUS_DEBUG
   Vdbus_debug = Qt;
+  /* We can also set environment DBUS_VERBOSE=1 in order to see more
+     traces.  */
 #else
   Vdbus_debug = Qnil;
+  /* We do not want to abort.  */
+  setenv ("DBUS_FATAL_WARNINGS", "0", 1);
 #endif
 
   Fprovide (intern_c_string ("dbusbind"), Qnil);
diff --git a/src/deps.mk b/src/deps.mk
index d00be96744b..eebf98ec003 100644
--- a/src/deps.mk
+++ b/src/deps.mk
@@ -230,6 +230,7 @@ xmenu.o: xmenu.c xterm.h termhooks.h window.h dispextern.h frame.h buffer.h \
    charset.h keyboard.h $(srcdir)/../lwlib/lwlib.h blockinput.h atimer.h \
    systime.h gtkutil.h msdos.h coding.h menu.h lisp.h $(config_h) composite.h \
    keymap.h sysselect.h
+xml.o: xml.c buffer.h lisp.h $(config_h)
 xterm.o: xterm.c xterm.h termhooks.h termopts.h termchar.h window.h buffer.h \
    dispextern.h frame.h disptab.h blockinput.h atimer.h systime.h syssignal.h \
    keyboard.h emacs-icon.h character.h charset.h ccl.h fontset.h composite.h \
diff --git a/src/dispextern.h b/src/dispextern.h
index 5138958b6db..20e074d2393 100644
--- a/src/dispextern.h
+++ b/src/dispextern.h
@@ -394,7 +394,15 @@ struct glyph
      w32_char_font_type.  Otherwise it equals FONT_TYPE_UNKNOWN.  */
   unsigned font_type : 3;
 
-  struct glyph_slice slice;
+  /* A union of sub-structures for different glyph types.  */
+  union
+  {
+    /* Metrics of a partial glyph of an image (type == IMAGE_GLYPH).  */
+    struct glyph_slice img;
+    /* Start and end indices of glyphs of a graphme cluster of a
+       composition (type == COMPOSITE_GLYPH).  */
+    struct { int from, to; } cmp;
+  } slice;
 
   /* A union of sub-structures for different glyph types.  */
   union
@@ -402,16 +410,13 @@ struct glyph
     /* Character code for character glyphs (type == CHAR_GLYPH).  */
     unsigned ch;
 
-    /* Sub-structures for type == COMPOSITION_GLYPH.  */
+    /* Sub-structures for type == COMPOSITE_GLYPH.  */
     struct
     {
       /* Flag to tell if the composition is automatic or not.  */
       unsigned automatic : 1;
       /* ID of the composition.  */
-      unsigned id    : 23;
-      /* Start and end indices of glyphs of the composition.  */
-      unsigned from : 4;
-      unsigned to : 4;
+      unsigned id    : 31;
     } cmp;
 
     /* Image ID for image glyphs (type == IMAGE_GLYPH).  */
@@ -443,13 +448,21 @@ struct glyph
 #define CHAR_GLYPH_SPACE_P(GLYPH) \
   ((GLYPH).u.ch == SPACEGLYPH && (GLYPH).face_id == DEFAULT_FACE_ID)
 
-/* Are glyph slices of glyphs *X and *Y equal */
+/* Are glyph slices of glyphs *X and *Y equal?  It assumes that both
+   glyphs have the same type.
+
+   Note: for composition glyphs, we don't have to compare slice.cmp.to
+   because they should be the same if and only if slice.cmp.from are
+   the same.  */
 
-#define GLYPH_SLICE_EQUAL_P(X, Y)               \
-  ((X)->slice.x == (Y)->slice.x                 \
-   && (X)->slice.y == (Y)->slice.y              \
-   && (X)->slice.width == (Y)->slice.width      \
-   && (X)->slice.height == (Y)->slice.height)
+#define GLYPH_SLICE_EQUAL_P(X, Y)                               \
+  ((X)->type == IMAGE_GLYPH                                     \
+   ? ((X)->slice.img.x == (Y)->slice.img.x                      \
+      && (X)->slice.img.y == (Y)->slice.img.y                   \
+      && (X)->slice.img.width == (Y)->slice.img.width           \
+      && (X)->slice.img.height == (Y)->slice.img.height)        \
+   : ((X)->type != COMPOSITE_GLYPH                              \
+      || (X)->slice.cmp.from == (Y)->slice.cmp.from))
 
 /* Are glyphs *X and *Y displayed equal?  */
 
@@ -1770,7 +1783,7 @@ typedef enum { NEUTRAL_DIR, L2R, R2L } bidi_dir_t;
 /* Data type for storing information about characters we need to
    remember.  */
 struct bidi_saved_info {
-  int bytepos, charpos;         /* character's buffer position */
+  EMACS_INT bytepos, charpos;   /* character's buffer position */
   bidi_type_t type;             /* character's resolved bidi type */
   bidi_type_t type_after_w1;    /* original type of the character, after W1 */
   bidi_type_t orig_type;        /* type as we found it in the buffer */
@@ -2054,7 +2067,7 @@ struct it
 
   /* Number of characters in the string (s, or it->string) we iterate
      over.  */
-  int string_nchars;
+  EMACS_INT string_nchars;
 
   /* Start and end of a visible region; -1 if the region is not
      visible in the window.  */
@@ -2896,12 +2909,12 @@ extern EMACS_INT tool_bar_button_relief;
 
 extern void bidi_init_it (EMACS_INT, EMACS_INT, struct bidi_it *);
 extern void bidi_move_to_visually_next (struct bidi_it *);
-extern void bidi_paragraph_init (bidi_dir_t, struct bidi_it *);
+extern void bidi_paragraph_init (bidi_dir_t, struct bidi_it *, int);
 extern int  bidi_mirror_char (int);
 
 /* Defined in xdisp.c */
 
-struct glyph_row *row_containing_pos (struct window *, int,
+struct glyph_row *row_containing_pos (struct window *, EMACS_INT,
                                       struct glyph_row *,
                                       struct glyph_row *, int);
 EMACS_INT string_buffer_position (struct window *, Lisp_Object,
@@ -2929,7 +2942,8 @@ void remember_mouse_glyph (struct frame *, int, int, NativeRectangle *);
 void mark_window_display_accurate (Lisp_Object, int);
 void redisplay_preserve_echo_area (int);
 int set_cursor_from_row (struct window *, struct glyph_row *,
-                         struct glyph_matrix *, int, int, int, int);
+                         struct glyph_matrix *, EMACS_INT, EMACS_INT,
+                         int, int);
 void init_iterator (struct it *, struct window *, EMACS_INT,
                     EMACS_INT, struct glyph_row *, enum face_id);
 void init_iterator_to_row_start (struct it *, struct window *,
@@ -2937,7 +2951,7 @@ void init_iterator_to_row_start (struct it *, struct window *,
 int get_next_display_element (struct it *);
 void set_iterator_to_next (struct it *, int);
 void start_display (struct it *, struct window *, struct text_pos);
-void move_it_to (struct it *, int, int, int, int, int);
+void move_it_to (struct it *, EMACS_INT, int, int, int, int);
 void move_it_vertically (struct it *, int);
 void move_it_vertically_backward (struct it *, int);
 void move_it_by_lines (struct it *, int, int);
@@ -2956,7 +2970,7 @@ extern int help_echo_showing_p;
 extern int current_mode_line_height, current_header_line_height;
 extern Lisp_Object help_echo_string, help_echo_window;
 extern Lisp_Object help_echo_object, previous_help_echo_string;
-extern int help_echo_pos;
+extern EMACS_INT help_echo_pos;
 extern struct frame *last_mouse_frame;
 extern int last_tool_bar_item;
 extern Lisp_Object Vmouse_autoselect_window;
@@ -3209,11 +3223,11 @@ extern Lisp_Object buffer_posn_from_coords (struct window *,
                                             Lisp_Object *,
                                             int *, int *, int *, int *);
 extern Lisp_Object mode_line_string (struct window *, enum window_part,
-                                     int *, int *, int *,
+                                     int *, int *, EMACS_INT *,
                                      Lisp_Object *,
                                      int *, int *, int *, int *);
 extern Lisp_Object marginal_area_string (struct window *, enum window_part,
-                                         int *, int *, int *,
+                                         int *, int *, EMACS_INT *,
                                          Lisp_Object *,
                                          int *, int *, int *, int *);
 extern void redraw_frame (struct frame *);
@@ -3236,9 +3250,9 @@ void shift_glyph_matrix (struct window *, struct glyph_matrix *,
                          int, int, int);
 void rotate_matrix (struct glyph_matrix *, int, int, int);
 void increment_matrix_positions (struct glyph_matrix *,
-                                 int, int, int, int);
+                                 int, int, EMACS_INT, EMACS_INT);
 void blank_row (struct window *, struct glyph_row *, int);
-void increment_row_positions (struct glyph_row *, int, int);
+void increment_row_positions (struct glyph_row *, EMACS_INT, EMACS_INT);
 void enable_glyph_matrix_rows (struct glyph_matrix *, int, int, int);
 void clear_glyph_row (struct glyph_row *);
 void prepare_desired_row (struct glyph_row *);
diff --git a/src/dispnew.c b/src/dispnew.c
index 9344d792f3d..f9729fc28cb 100644
--- a/src/dispnew.c
+++ b/src/dispnew.c
@@ -849,7 +849,8 @@ rotate_matrix (struct glyph_matrix *matrix, int first, int last, int by)
    DELTA_BYTES.  */
 
 void
-increment_matrix_positions (struct glyph_matrix *matrix, int start, int end, int delta, int delta_bytes)
+increment_matrix_positions (struct glyph_matrix *matrix, int start, int end,
+                            EMACS_INT delta, EMACS_INT delta_bytes)
 {
   /* Check that START and END are reasonable values.  */
   xassert (start >= 0 && start <= matrix->nrows);
@@ -1088,7 +1089,8 @@ blank_row (struct window *w, struct glyph_row *row, int y)
    ends.  */
 
 void
-increment_row_positions (struct glyph_row *row, int delta, int delta_bytes)
+increment_row_positions (struct glyph_row *row,
+                         EMACS_INT delta, EMACS_INT delta_bytes)
 {
   int area, i;
 
@@ -1200,7 +1202,8 @@ copy_row_except_pointers (struct glyph_row *to, struct glyph_row *from)
    positions in row TO by DELTA/ DELTA_BYTES.  */
 
 void
-copy_glyph_row_contents (struct glyph_row *to, struct glyph_row *from, int delta, int delta_bytes)
+copy_glyph_row_contents (struct glyph_row *to, struct glyph_row *from,
+                         EMACS_INT delta, EMACS_INT delta_bytes)
 {
   int area;
 
@@ -5420,6 +5423,22 @@ buffer_posn_from_coords (struct window *w, int *x, int *y, struct display_pos *p
   if (STRINGP (it.string))
     string = it.string;
   *pos = it.current;
+  if (it.what == IT_COMPOSITION
+      && it.cmp_it.nchars > 1
+      && it.cmp_it.reversed_p)
+    {
+      /* The current display element is a grapheme cluster in a
+         composition.  In that case, we need the position of the first
+         character of the cluster.  But, as it.cmp_it.reversed_p is 1,
+         it.current points to the last character of the cluster, thus
+         we must move back to the first character of the same
+         cluster.  */
+      CHARPOS (pos->pos) -= it.cmp_it.nchars - 1;
+      if (STRINGP (it.string))
+        BYTEPOS (pos->pos) = string_char_to_byte (string, CHARPOS (pos->pos));
+      else
+        BYTEPOS (pos->pos) = CHAR_TO_BYTE (CHARPOS (pos->pos));
+    }
 
 #ifdef HAVE_WINDOW_SYSTEM
   if (it.what == IT_IMAGE)
@@ -5441,8 +5460,8 @@ buffer_posn_from_coords (struct window *w, int *x, int *y, struct display_pos *p
           if (img)
             {
               *dy -= row->ascent - glyph->ascent;
-              *dx += glyph->slice.x;
-              *dy += glyph->slice.y;
+              *dx += glyph->slice.img.x;
+              *dy += glyph->slice.img.y;
               /* Image slices positions are still relative to the entire image */
               *width = img->width;
               *height = img->height;
@@ -5482,7 +5501,9 @@ buffer_posn_from_coords (struct window *w, int *x, int *y, struct display_pos *p
    *CHARPOS is set to the position in the string returned.  */
 
 Lisp_Object
-mode_line_string (struct window *w, enum window_part part, int *x, int *y, int *charpos, Lisp_Object *object, int *dx, int *dy, int *width, int *height)
+mode_line_string (struct window *w, enum window_part part,
+                  int *x, int *y, EMACS_INT *charpos, Lisp_Object *object,
+                  int *dx, int *dy, int *width, int *height)
 {
   struct glyph_row *row;
   struct glyph *glyph, *end;
@@ -5549,7 +5570,9 @@ mode_line_string (struct window *w, enum window_part part, int *x, int *y, int *
    the string returned.  */
 
 Lisp_Object
-marginal_area_string (struct window *w, enum window_part part, int *x, int *y, int *charpos, Lisp_Object *object, int *dx, int *dy, int *width, int *height)
+marginal_area_string (struct window *w, enum window_part part,
+                      int *x, int *y, EMACS_INT *charpos, Lisp_Object *object,
+                      int *dx, int *dy, int *width, int *height)
 {
   struct glyph_row *row = w->current_matrix->rows;
   struct glyph *glyph, *end;
@@ -5604,8 +5627,8 @@ marginal_area_string (struct window *w, enum window_part part, int *x, int *y, i
               if (img != NULL)
                 *object = img->spec;
               y0 -= row->ascent - glyph->ascent;
-              x0 += glyph->slice.x;
-              y0 += glyph->slice.y;
+              x0 += glyph->slice.img.x;
+              y0 += glyph->slice.img.y;
             }
 #endif
         }
diff --git a/src/doc.c b/src/doc.c
index 86d29a5a5ef..8ec94f9836c 100644
--- a/src/doc.c
+++ b/src/doc.c
@@ -100,8 +100,8 @@ get_doc_string (Lisp_Object filepos, int unibyte, int definition)
   register int fd;
   register char *name;
   register char *p, *p1;
-  int minsize;
-  int offset, position;
+  EMACS_INT minsize;
+  EMACS_INT offset, position;
   Lisp_Object file, tem;
 
   if (INTEGERP (filepos))
@@ -180,14 +180,14 @@ get_doc_string (Lisp_Object filepos, int unibyte, int definition)
   p = get_doc_string_buffer;
   while (1)
     {
-      int space_left = (get_doc_string_buffer_size
-                        - (p - get_doc_string_buffer));
+      EMACS_INT space_left = (get_doc_string_buffer_size
+                              - (p - get_doc_string_buffer));
       int nread;
 
       /* Allocate or grow the buffer if we need to.  */
       if (space_left == 0)
         {
-          int in_buffer = p - get_doc_string_buffer;
+          EMACS_INT in_buffer = p - get_doc_string_buffer;
           get_doc_string_buffer_size += 16 * 1024;
           get_doc_string_buffer
             = (char *) xrealloc (get_doc_string_buffer,
@@ -287,8 +287,8 @@ get_doc_string (Lisp_Object filepos, int unibyte, int definition)
   else
     {
       /* 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));
+      EMACS_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,
                                      nchars,
                                      to - (get_doc_string_buffer + offset));
@@ -561,8 +561,8 @@ the same file name is found in the `doc-directory'.  */)
 {
   int fd;
   char buf[1024 + 1];
-  register int filled;
-  register int pos;
+  register EMACS_INT filled;
+  register EMACS_INT pos;
   register char *p, *end;
   Lisp_Object sym;
   char *name;
@@ -596,7 +596,7 @@ the same file name is found in the `doc-directory'.  */)
 
     for (beg = buildobj; *beg; beg = end)
       {
-        int len;
+        EMACS_INT len;
 
         while (*beg && isspace (*beg)) ++beg;
 
@@ -643,7 +643,7 @@ the same file name is found in the `doc-directory'.  */)
               if (end - p > 4 && end[-2] == '.'
                   && (end[-1] == 'o' || end[-1] == 'c'))
                 {
-                  int len = end - p - 2;
+                  EMACS_INT len = end - p - 2;
                   char *fromfile = alloca (len + 1);
                   strncpy (fromfile, &p[2], len);
                   fromfile[len] = 0;
@@ -688,7 +688,7 @@ the same file name is found in the `doc-directory'.  */)
         }
       pos += end - buf;
       filled -= end - buf;
-      memcpy (buf, end, filled);
+      memmove (buf, end, filled);
     }
   emacs_close (fd);
   return Qnil;
@@ -715,16 +715,16 @@ a new string, without any text properties, is returned.  */)
   int changed = 0;
   register unsigned char *strp;
   register unsigned char *bufp;
-  int idx;
-  int bsize;
+  EMACS_INT idx;
+  EMACS_INT bsize;
   Lisp_Object tem;
   Lisp_Object keymap;
   unsigned char *start;
-  int length, length_byte;
+  EMACS_INT length, length_byte;
   Lisp_Object name;
   struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
   int multibyte;
-  int nchars;
+  EMACS_INT nchars;
 
   if (NILP (string))
     return Qnil;
@@ -776,7 +776,7 @@ a new string, without any text properties, is returned.  */)
         }
       else if (strp[0] == '\\' && strp[1] == '[')
         {
-          int start_idx;
+          EMACS_INT start_idx;
           int follow_remap = 1;
 
           changed = 1;
@@ -815,7 +815,7 @@ a new string, without any text properties, is returned.  */)
 
           if (NILP (tem))       /* but not on any keys */
             {
-              int offset = bufp - buf;
+              EMACS_INT offset = bufp - buf;
               buf = (unsigned char *) xrealloc (buf, bsize += 4);
               bufp = buf + offset;
               memcpy (bufp, "M-x ", 4);
@@ -838,7 +838,7 @@ a new string, without any text properties, is returned.  */)
       else if (strp[0] == '\\' && (strp[1] == '{' || strp[1] == '<'))
         {
           struct buffer *oldbuf;
-          int start_idx;
+          EMACS_INT start_idx;
           /* This is for computing the SHADOWS arg for describe_map_tree.  */
           Lisp_Object active_maps = Fcurrent_active_maps (Qnil, Qnil);
           Lisp_Object earlier_maps;
@@ -909,7 +909,7 @@ a new string, without any text properties, is returned.  */)
           length_byte = SBYTES (tem);
         subst:
           {
-            int offset = bufp - buf;
+            EMACS_INT offset = bufp - buf;
             buf = (unsigned char *) xrealloc (buf, bsize += length_byte);
             bufp = buf + offset;
             memcpy (bufp, start, length_byte);
diff --git a/src/doprnt.c b/src/doprnt.c
index 1b45b21e36b..02adc51f1e5 100644
--- a/src/doprnt.c
+++ b/src/doprnt.c
@@ -33,21 +33,17 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include <unistd.h>
 #endif
 
-#ifdef HAVE_STDLIB_H
-#include <stdlib.h>
-#endif
-
 #include "lisp.h"
 
-#ifndef DBL_MAX_10_EXP
-#define DBL_MAX_10_EXP 308 /* IEEE double */
-#endif
-
 /* Since we use the macro CHAR_HEAD_P, we have to include this, but
    don't have to include others because CHAR_HEAD_P does not contains
    another macro.  */
 #include "character.h"
 
+#ifndef DBL_MAX_10_EXP
+#define DBL_MAX_10_EXP 308 /* IEEE double */
+#endif
+
 /* Generate output from a format-spec FORMAT,
    terminated at position FORMAT_END.
    Output goes in BUFFER, which has room for BUFSIZE chars.
@@ -58,7 +54,7 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
    String arguments are passed as C strings.
    Integers are passed as C integers.  */
 
-int
+EMACS_INT
 doprnt (char *buffer, register int bufsize, const char *format,
         const char *format_end, va_list ap)
 {
@@ -100,7 +96,7 @@ doprnt (char *buffer, register int bufsize, const char *format,
       if (*fmt == '%')  /* Check for a '%' character */
         {
           unsigned size_bound = 0;
-          int width;            /* Columns occupied by STRING.  */
+          EMACS_INT width;  /* Columns occupied by STRING.  */
 
           fmt++;
           /* Copy this one %-spec into fmtcpy.  */
diff --git a/src/editfns.c b/src/editfns.c
index 1bd6682c3b6..f76beb5e678 100644
--- a/src/editfns.c
+++ b/src/editfns.c
@@ -94,8 +94,9 @@ extern Lisp_Object w32_get_internal_run_time (void);
 #endif
 
 static int tm_diff (struct tm *, struct tm *);
-static void find_field (Lisp_Object, Lisp_Object, Lisp_Object, int *, Lisp_Object, int *);
-static void update_buffer_properties (int, int);
+static void find_field (Lisp_Object, Lisp_Object, Lisp_Object,
+                        EMACS_INT *, Lisp_Object, EMACS_INT *);
+static void update_buffer_properties (EMACS_INT, EMACS_INT);
 static Lisp_Object region_limit (int);
 static size_t emacs_memftimeu (char *, size_t, const char *,
                                size_t, const struct tm *, int);
@@ -106,7 +107,8 @@ static void general_insert_function (void (*) (const unsigned char *, EMACS_INT)
                                      int, int, Lisp_Object *);
 static Lisp_Object subst_char_in_region_unwind (Lisp_Object);
 static Lisp_Object subst_char_in_region_unwind_1 (Lisp_Object);
-static void transpose_markers (int, int, int, int, int, int, int, int);
+static void transpose_markers (EMACS_INT, EMACS_INT, EMACS_INT, EMACS_INT,
+                               EMACS_INT, EMACS_INT, EMACS_INT, EMACS_INT);
 
 Lisp_Object Vbuffer_access_fontify_functions;
 Lisp_Object Qbuffer_access_fontify_functions;
@@ -245,7 +247,7 @@ A multibyte character is handled correctly.  */)
 }
 
 static Lisp_Object
-buildmark (int charpos, int bytepos)
+buildmark (EMACS_INT charpos, EMACS_INT bytepos)
 {
   register Lisp_Object mark;
   mark = Fmake_marker ();
@@ -270,8 +272,8 @@ DEFUN ("point-marker", Fpoint_marker, Spoint_marker, 0, 0, 0,
   return buildmark (PT, PT_BYTE);
 }
 
-int
-clip_to_bounds (int lower, int num, int upper)
+EMACS_INT
+clip_to_bounds (EMACS_INT lower, EMACS_INT num, EMACS_INT upper)
 {
   if (num < lower)
     return lower;
@@ -288,7 +290,7 @@ Beginning of buffer is position (point-min), end is (point-max).
 The return value is POSITION.  */)
   (register Lisp_Object position)
 {
-  int pos;
+  EMACS_INT pos;
 
   if (MARKERP (position)
       && current_buffer == XMARKER (position)->buffer)
@@ -364,11 +366,11 @@ If you set the marker not to point anywhere, the buffer will have no mark.  */)
    of length LEN.  */
 
 static int
-overlays_around (int pos, Lisp_Object *vec, int len)
+overlays_around (EMACS_INT pos, Lisp_Object *vec, int len)
 {
   Lisp_Object overlay, start, end;
   struct Lisp_Overlay *tail;
-  int startpos, endpos;
+  EMACS_INT startpos, endpos;
   int idx = 0;
 
   for (tail = current_buffer->overlays_before; tail; tail = tail->next)
@@ -436,7 +438,7 @@ get_pos_property (Lisp_Object position, register Lisp_Object prop, Lisp_Object o
     return Fget_text_property (position, prop, object);
   else
     {
-      int posn = XINT (position);
+      EMACS_INT posn = XINT (position);
       int noverlays;
       Lisp_Object *overlay_vec, tem;
       struct buffer *obuf = current_buffer;
@@ -515,7 +517,9 @@ get_pos_property (Lisp_Object position, register Lisp_Object prop, Lisp_Object o
    is not stored.  */
 
 static void
-find_field (Lisp_Object pos, Lisp_Object merge_at_boundary, Lisp_Object beg_limit, int *beg, Lisp_Object end_limit, int *end)
+find_field (Lisp_Object pos, Lisp_Object merge_at_boundary,
+            Lisp_Object beg_limit,
+            EMACS_INT *beg, Lisp_Object end_limit, EMACS_INT *end)
 {
   /* Fields right before and after the point.  */
   Lisp_Object before_field, after_field;
@@ -631,7 +635,7 @@ A field is a region of text with the same `field' property.
 If POS is nil, the value of point is used for POS.  */)
   (Lisp_Object pos)
 {
-  int beg, end;
+  EMACS_INT beg, end;
   find_field (pos, Qnil, Qnil, &beg, Qnil, &end);
   if (beg != end)
     del_range (beg, end);
@@ -644,7 +648,7 @@ A field is a region of text with the same `field' property.
 If POS is nil, the value of point is used for POS.  */)
   (Lisp_Object pos)
 {
-  int beg, end;
+  EMACS_INT beg, end;
   find_field (pos, Qnil, Qnil, &beg, Qnil, &end);
   return make_buffer_string (beg, end, 1);
 }
@@ -655,7 +659,7 @@ A field is a region of text with the same `field' property.
 If POS is nil, the value of point is used for POS.  */)
   (Lisp_Object pos)
 {
-  int beg, end;
+  EMACS_INT beg, end;
   find_field (pos, Qnil, Qnil, &beg, Qnil, &end);
   return make_buffer_string (beg, end, 0);
 }
@@ -670,7 +674,7 @@ If LIMIT is non-nil, it is a buffer position; if the beginning of the field
 is before LIMIT, then LIMIT will be returned instead.  */)
   (Lisp_Object pos, Lisp_Object escape_from_edge, Lisp_Object limit)
 {
-  int beg;
+  EMACS_INT beg;
   find_field (pos, escape_from_edge, limit, &beg, Qnil, 0);
   return make_number (beg);
 }
@@ -685,7 +689,7 @@ If LIMIT is non-nil, it is a buffer position; if the end of the field
 is after LIMIT, then LIMIT will be returned instead.  */)
   (Lisp_Object pos, Lisp_Object escape_from_edge, Lisp_Object limit)
 {
-  int end;
+  EMACS_INT end;
   find_field (pos, escape_from_edge, Qnil, 0, limit, &end);
   return make_number (end);
 }
@@ -720,7 +724,7 @@ Field boundaries are not noticed if `inhibit-field-text-motion' is non-nil.  */)
   (Lisp_Object new_pos, Lisp_Object old_pos, Lisp_Object escape_from_edge, Lisp_Object only_in_line, Lisp_Object inhibit_capture_property)
 {
   /* If non-zero, then the original point, before re-positioning.  */
-  int orig_point = 0;
+  EMACS_INT orig_point = 0;
   int fwd;
   Lisp_Object prev_old, prev_new;
 
@@ -817,7 +821,7 @@ boundaries bind `inhibit-field-text-motion' to t.
 This function does not move point.  */)
   (Lisp_Object n)
 {
-  int orig, orig_byte, end;
+  EMACS_INT orig, orig_byte, end;
   int count = SPECPDL_INDEX ();
   specbind (Qinhibit_point_motion_hooks, Qt);
 
@@ -858,8 +862,8 @@ boundaries bind `inhibit-field-text-motion' to t.
 This function does not move point.  */)
   (Lisp_Object n)
 {
-  int end_pos;
-  int orig = PT;
+  EMACS_INT end_pos;
+  EMACS_INT orig = PT;
 
   if (NILP (n))
     XSETFASTINT (n, 1);
@@ -1131,7 +1135,7 @@ At the beginning of the buffer or accessible region, return 0.  */)
     XSETFASTINT (temp, 0);
   else if (!NILP (current_buffer->enable_multibyte_characters))
     {
-      int pos = PT_BYTE;
+      EMACS_INT pos = PT_BYTE;
       DEC_POS (pos);
       XSETFASTINT (temp, FETCH_CHAR (pos));
     }
@@ -1185,7 +1189,7 @@ POS is an integer or a marker and defaults to point.
 If POS is out of range, the value is nil.  */)
   (Lisp_Object pos)
 {
-  register int pos_byte;
+  register EMACS_INT pos_byte;
 
   if (NILP (pos))
     {
@@ -1218,7 +1222,7 @@ If POS is out of range, the value is nil.  */)
   (Lisp_Object pos)
 {
   register Lisp_Object val;
-  register int pos_byte;
+  register EMACS_INT pos_byte;
 
   if (NILP (pos))
     {
@@ -2266,8 +2270,9 @@ from adjoining text, if those properties are sticky.  */)
   (Lisp_Object character, Lisp_Object count, Lisp_Object inherit)
 {
   register unsigned char *string;
-  register int strlen;
-  register int i, n;
+  register EMACS_INT strlen;
+  register int i;
+  register EMACS_INT n;
   int len;
   unsigned char str[MAX_MULTIBYTE_LENGTH];
 
@@ -2278,6 +2283,8 @@ from adjoining text, if those properties are sticky.  */)
     len = CHAR_STRING (XFASTINT (character), str);
   else
     str[0] = XFASTINT (character), len = 1;
+  if (MOST_POSITIVE_FIXNUM / len < XINT (count))
+    error ("Maximum buffer size would be exceeded");
   n = XINT (count) * len;
   if (n <= 0)
     return Qnil;
@@ -2343,10 +2350,10 @@ from adjoining text, if those properties are sticky.  */)
    buffer substrings.  */
 
 Lisp_Object
-make_buffer_string (int start, int end, int props)
+make_buffer_string (EMACS_INT start, EMACS_INT end, int props)
 {
-  int start_byte = CHAR_TO_BYTE (start);
-  int end_byte = CHAR_TO_BYTE (end);
+  EMACS_INT start_byte = CHAR_TO_BYTE (start);
+  EMACS_INT end_byte = CHAR_TO_BYTE (end);
 
   return make_buffer_string_both (start, start_byte, end, end_byte, props);
 }
@@ -2367,7 +2374,8 @@ make_buffer_string (int start, int end, int props)
    buffer substrings.  */
 
 Lisp_Object
-make_buffer_string_both (int start, int start_byte, int end, int end_byte, int props)
+make_buffer_string_both (EMACS_INT start, EMACS_INT start_byte,
+                         EMACS_INT end, EMACS_INT end_byte, int props)
 {
   Lisp_Object result, tem, tem1;
 
@@ -2400,7 +2408,7 @@ make_buffer_string_both (int start, int start_byte, int end, int end_byte, int p
    in the current buffer, if necessary.  */
 
 static void
-update_buffer_properties (int start, int end)
+update_buffer_properties (EMACS_INT start, EMACS_INT end)
 {
   /* If this buffer has some access functions,
      call them, specifying the range of the buffer being accessed.  */
@@ -2439,7 +2447,7 @@ into the result string; if you don't want the text properties,
 use `buffer-substring-no-properties' instead.  */)
   (Lisp_Object start, Lisp_Object end)
 {
-  register int b, e;
+  register EMACS_INT b, e;
 
   validate_region (&start, &end);
   b = XINT (start);
@@ -2455,7 +2463,7 @@ The two arguments START and END are character positions;
 they can be in either order.  */)
   (Lisp_Object start, Lisp_Object end)
 {
-  register int b, e;
+  register EMACS_INT b, e;
 
   validate_region (&start, &end);
   b = XINT (start);
@@ -2481,7 +2489,7 @@ Arguments START and END are character positions specifying the substring.
 They default to the values of (point-min) and (point-max) in BUFFER.  */)
   (Lisp_Object buffer, Lisp_Object start, Lisp_Object end)
 {
-  register int b, e, temp;
+  register EMACS_INT b, e, temp;
   register struct buffer *bp, *obuf;
   Lisp_Object buf;
 
@@ -2534,13 +2542,13 @@ The value of `case-fold-search' in the current buffer
 determines whether case is significant or ignored.  */)
   (Lisp_Object buffer1, Lisp_Object start1, Lisp_Object end1, Lisp_Object buffer2, Lisp_Object start2, Lisp_Object end2)
 {
-  register int begp1, endp1, begp2, endp2, temp;
+  register EMACS_INT begp1, endp1, begp2, endp2, temp;
   register struct buffer *bp1, *bp2;
   register Lisp_Object trt
     = (!NILP (current_buffer->case_fold_search)
        ? current_buffer->case_canon_table : Qnil);
-  int chars = 0;
-  int i1, i2, i1_byte, i2_byte;
+  EMACS_INT chars = 0;
+  EMACS_INT i1, i2, i1_byte, i2_byte;
 
   /* Find the first buffer and its substring.  */
 
@@ -2701,12 +2709,12 @@ and don't mark the buffer as really changed.
 Both characters must have the same length of multi-byte form.  */)
   (Lisp_Object start, Lisp_Object end, Lisp_Object fromchar, Lisp_Object tochar, Lisp_Object noundo)
 {
-  register int pos, pos_byte, stop, i, len, end_byte;
+  register EMACS_INT pos, pos_byte, stop, i, len, end_byte;
   /* Keep track of the first change in the buffer:
      if 0 we haven't found it yet.
      if < 0 we've found it and we've run the before-change-function.
      if > 0 we've actually performed it and the value is its position.  */
-  int changed = 0;
+  EMACS_INT changed = 0;
   unsigned char fromstr[MAX_MULTIBYTE_LENGTH], tostr[MAX_MULTIBYTE_LENGTH];
   unsigned char *p;
   int count = SPECPDL_INDEX ();
@@ -2715,7 +2723,7 @@ Both characters must have the same length of multi-byte form.  */)
 #define COMBINING_AFTER  2
 #define COMBINING_BOTH (COMBINING_BEFORE | COMBINING_AFTER)
   int maybe_byte_combining = COMBINING_NO;
-  int last_changed = 0;
+  EMACS_INT last_changed = 0;
   int multibyte_p = !NILP (current_buffer->enable_multibyte_characters);
 
  restart:
@@ -2772,7 +2780,7 @@ Both characters must have the same length of multi-byte form.  */)
     stop = min (stop, GPT_BYTE);
   while (1)
     {
-      int pos_byte_next = pos_byte;
+      EMACS_INT pos_byte_next = pos_byte;
 
       if (pos_byte >= stop)
         {
@@ -2875,7 +2883,8 @@ Both characters must have the same length of multi-byte form.  */)
 }
 
 
-static Lisp_Object check_translation (int, int, int, Lisp_Object);
+static Lisp_Object check_translation (EMACS_INT, EMACS_INT, EMACS_INT,
+                                      Lisp_Object);
 
 /* Helper function for Ftranslate_region_internal.
 
@@ -2884,7 +2893,8 @@ static Lisp_Object check_translation (int, int, int, Lisp_Object);
    element is found, return it.  Otherwise return Qnil.  */
 
 static Lisp_Object
-check_translation (int pos, int pos_byte, int end, Lisp_Object val)
+check_translation (EMACS_INT pos, EMACS_INT pos_byte, EMACS_INT end,
+                   Lisp_Object val)
 {
   int buf_size = 16, buf_used = 0;
   int *buf = alloca (sizeof (int) * buf_size);
@@ -2892,7 +2902,7 @@ check_translation (int pos, int pos_byte, int end, Lisp_Object val)
   for (; CONSP (val); val = XCDR (val))
     {
       Lisp_Object elt;
-      int len, i;
+      EMACS_INT len, i;
 
       elt = XCAR (val);
       if (! CONSP (elt))
@@ -2908,7 +2918,7 @@ check_translation (int pos, int pos_byte, int end, Lisp_Object val)
               if (buf_used <= i)
                 {
                   unsigned char *p = BYTE_POS_ADDR (pos_byte);
-                  int len;
+                  int len1;
 
                   if (buf_used == buf_size)
                     {
@@ -2919,8 +2929,8 @@ check_translation (int pos, int pos_byte, int end, Lisp_Object val)
                       memcpy (newbuf, buf, sizeof (int) * buf_used);
                       buf = newbuf;
                     }
-                  buf[buf_used++] = STRING_CHAR_AND_LENGTH (p, len);
-                  pos_byte += len;
+                  buf[buf_used++] = STRING_CHAR_AND_LENGTH (p, len1);
+                  pos_byte += len1;
                 }
               if (XINT (AREF (elt, i)) != buf[i])
                 break;
@@ -2945,8 +2955,8 @@ It returns the number of characters changed.  */)
   register unsigned char *tt;   /* Trans table. */
   register int nc;              /* New character. */
   int cnt;                      /* Number of changes made. */
-  int size;                     /* Size of translate table. */
-  int pos, pos_byte, end_pos;
+  EMACS_INT size;               /* Size of translate table. */
+  EMACS_INT pos, pos_byte, end_pos;
   int multibyte = !NILP (current_buffer->enable_multibyte_characters);
   int string_multibyte;
   Lisp_Object val;
@@ -3016,7 +3026,7 @@ It returns the number of characters changed.  */)
             }
           else
             {
-              int c;
+              EMACS_INT c;
 
               nc = oc;
               val = CHAR_TABLE_REF (table, oc);
@@ -3229,7 +3239,7 @@ save_restriction_restore (Lisp_Object data)
         /* The restriction has changed from the saved one, so restore
            the saved restriction.  */
         {
-          int pt = BUF_PT (buf);
+          EMACS_INT pt = BUF_PT (buf);
 
           SET_BUF_BEGV_BOTH (buf, beg->charpos, beg->bytepos);
           SET_BUF_ZV_BOTH (buf, end->charpos, end->bytepos);
@@ -3508,7 +3518,7 @@ usage: (format STRING &rest OBJECTS)  */)
   (int nargs, register Lisp_Object *args)
 {
   register int n;               /* The number of the next arg to substitute */
-  register int total;           /* An estimate of the final length */
+  register EMACS_INT total;     /* An estimate of the final length */
   char *buf, *p;
   register unsigned char *format, *end, *format_start;
   int nchars;
@@ -3517,7 +3527,7 @@ usage: (format STRING &rest OBJECTS)  */)
   int multibyte = 0;
   /* When we make a multibyte string, we must pay attention to the
      byte combining problem, i.e., a byte may be combined with a
-     multibyte charcter of the previous string.  This flag tells if we
+     multibyte character of the previous string.  This flag tells if we
      must consider such a situation or not.  */
   int maybe_combine_byte;
   unsigned char *this_format;
@@ -3602,8 +3612,8 @@ usage: (format STRING &rest OBJECTS)  */)
   while (format != end)
     if (*format++ == '%')
       {
-        int thissize = 0;
-        int actual_width = 0;
+        EMACS_INT thissize = 0;
+        EMACS_INT actual_width = 0;
         unsigned char *this_format_start = format - 1;
         int field_width = 0;
 
@@ -3845,8 +3855,8 @@ usage: (format STRING &rest OBJECTS)  */)
               /* handle case (precision[n] >= 0) */
 
               int width, padding;
-              int nbytes, start, end;
-              int nchars_string;
+              EMACS_INT nbytes, start, end;
+              EMACS_INT nchars_string;
 
               /* lisp_string_width ignores a precision of 0, but GNU
                  libc functions print 0 characters when the precision
@@ -3857,7 +3867,8 @@ usage: (format STRING &rest OBJECTS)  */)
               if (precision[n] == 0)
                 width = nchars_string = nbytes = 0;
               else if (precision[n] > 0)
-                width = lisp_string_width (args[n], precision[n], &nchars_string, &nbytes);
+                width = lisp_string_width (args[n], precision[n],
+                                           &nchars_string, &nbytes);
               else
                 {               /* no precision spec given for this argument */
                   width = lisp_string_width (args[n], -1, NULL, NULL);
@@ -4016,7 +4027,8 @@ usage: (format STRING &rest OBJECTS)  */)
 
       if (CONSP (props))
         {
-          int bytepos = 0, position = 0, translated = 0, argn = 1;
+          EMACS_INT bytepos = 0, position = 0, translated = 0;
+          int argn = 1;
           Lisp_Object list;
 
           /* Adjust the bounds of each text property
@@ -4034,7 +4046,7 @@ usage: (format STRING &rest OBJECTS)  */)
           for (list = props; CONSP (list); list = XCDR (list))
             {
               Lisp_Object item;
-              int pos;
+              EMACS_INT pos;
 
               item = XCAR (list);
 
@@ -4170,11 +4182,12 @@ Case is ignored if `case-fold-search' is non-nil in the current buffer.  */)
    It's the caller's job to ensure that START1 <= END1 <= START2 <= END2.  */
 
 static void
-transpose_markers (int start1, int end1, int start2, int end2,
-                   int start1_byte, int end1_byte,
-                   int start2_byte, int end2_byte)
+transpose_markers (EMACS_INT start1, EMACS_INT end1,
+                   EMACS_INT start2, EMACS_INT end2,
+                   EMACS_INT start1_byte, EMACS_INT end1_byte,
+                   EMACS_INT start2_byte, EMACS_INT end2_byte)
 {
-  register int amt1, amt1_byte, amt2, amt2_byte, diff, diff_byte, mpos;
+  register EMACS_INT amt1, amt1_byte, amt2, amt2_byte, diff, diff_byte, mpos;
   register struct Lisp_Marker *marker;
 
   /* Update point as if it were a marker.  */
@@ -4271,7 +4284,7 @@ Transposing beyond buffer boundaries is an error.  */)
   /* Swap the regions if they're reversed.  */
   if (start2 < end1)
     {
-      register int glumph = start1;
+      register EMACS_INT glumph = start1;
       start1 = start2;
       start2 = glumph;
       glumph = end1;
diff --git a/src/emacs.c b/src/emacs.c
index 33e0d60630b..397b6d1ce88 100644
--- a/src/emacs.c
+++ b/src/emacs.c
@@ -32,10 +32,6 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include <unistd.h>
 #endif
 
-#ifdef HAVE_SYS_IOCTL_H
-#include <sys/ioctl.h>
-#endif
-
 #ifdef WINDOWSNT
 #include <fcntl.h>
 #include <windows.h> /* just for w32.h */
@@ -63,6 +59,10 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include "keyboard.h"
 #include "keymap.h"
 
+#ifdef HAVE_GNUTLS
+#include "gnutls.h"
+#endif
+
 #ifdef HAVE_NS
 #include "nsterm.h"
 #endif
@@ -1573,6 +1573,10 @@ main (int argc, char **argv)
       syms_of_fontset ();
 #endif /* HAVE_NS */
 
+#ifdef HAVE_GNUTLS
+      syms_of_gnutls ();
+#endif
+
 #ifdef HAVE_DBUS
       syms_of_dbusbind ();
 #endif /* HAVE_DBUS */
diff --git a/src/eval.c b/src/eval.c
index a16d6c59809..6383a672ae3 100644
--- a/src/eval.c
+++ b/src/eval.c
@@ -89,7 +89,7 @@ Lisp_Object Vinternal_interpreter_environment;
 
 /* Current number of specbindings allocated in specpdl.  */
 
-int specpdl_size;
+EMACS_INT specpdl_size;
 
 /* Pointer to beginning of specpdl.  */
 
@@ -105,7 +105,7 @@ EMACS_INT max_specpdl_size;
 
 /* Depth in Lisp evaluations and function calls.  */
 
-int lisp_eval_depth;
+EMACS_INT lisp_eval_depth;
 
 /* Maximum allowed depth in Lisp evaluations and function calls.  */
 
@@ -227,7 +227,7 @@ call_debugger (Lisp_Object arg)
   int debug_while_redisplaying;
   int count = SPECPDL_INDEX ();
   Lisp_Object val;
-  int old_max = max_specpdl_size;
+  EMACS_INT old_max = max_specpdl_size;
 
   /* Temporarily bump up the stack limits,
      so the debugger won't run out of stack.  */
@@ -2065,7 +2065,7 @@ void
 verror (const char *m, va_list ap)
 {
   char buf[200];
-  int size = 200;
+  EMACS_INT size = 200;
   int mlen;
   char *buffer = buf;
   char *args[3];
@@ -2076,7 +2076,7 @@ verror (const char *m, va_list ap)
 
   while (1)
     {
-      int used;
+      EMACS_INT used;
       used = doprnt (buffer, size, m, m + mlen, ap);
       if (used < size)
         break;
diff --git a/src/fns.c b/src/fns.c
index be4b99d50e6..7bae3bb0fae 100644
--- a/src/fns.c
+++ b/src/fns.c
@@ -241,8 +241,8 @@ If string STR1 is greater, the value is a positive number N;
   N - 1 is the number of characters that match at the beginning.  */)
   (Lisp_Object str1, Lisp_Object start1, Lisp_Object end1, Lisp_Object str2, Lisp_Object start2, Lisp_Object end2, Lisp_Object ignore_case)
 {
-  register int end1_char, end2_char;
-  register int i1, i1_byte, i2, i2_byte;
+  register EMACS_INT end1_char, end2_char;
+  register EMACS_INT i1, i1_byte, i2, i2_byte;
 
   CHECK_STRING (str1);
   CHECK_STRING (str2);
@@ -332,8 +332,8 @@ Case is significant.
 Symbols are also allowed; their print names are used instead.  */)
   (register Lisp_Object s1, Lisp_Object s2)
 {
-  register int end;
-  register int i1, i1_byte, i2, i2_byte;
+  register EMACS_INT end;
+  register EMACS_INT i1, i1_byte, i2, i2_byte;
 
   if (SYMBOLP (s1))
     s1 = SYMBOL_NAME (s1);
@@ -456,8 +456,8 @@ with the original.  */)
 struct textprop_rec
 {
   int argnum;                   /* refer to ARGS (arguments of `concat') */
-  int from;                     /* refer to ARGS[argnum] (argument string) */
-  int to;                       /* refer to VAL (the target string) */
+  EMACS_INT from;               /* refer to ARGS[argnum] (argument string) */
+  EMACS_INT to;                 /* refer to VAL (the target string) */
 };
 
 static Lisp_Object
@@ -466,10 +466,10 @@ concat (int nargs, Lisp_Object *args, enum Lisp_Type target_type, int last_speci
   Lisp_Object val;
   register Lisp_Object tail;
   register Lisp_Object this;
-  int toindex;
-  int toindex_byte = 0;
-  register int result_len;
-  register int result_len_byte;
+  EMACS_INT toindex;
+  EMACS_INT toindex_byte = 0;
+  register EMACS_INT result_len;
+  register EMACS_INT result_len_byte;
   register int argnum;
   Lisp_Object last_tail;
   Lisp_Object prev;
@@ -513,16 +513,16 @@ concat (int nargs, Lisp_Object *args, enum Lisp_Type target_type, int last_speci
   some_multibyte = 0;
   for (argnum = 0; argnum < nargs; argnum++)
     {
-      int len;
+      EMACS_INT len;
       this = args[argnum];
       len = XFASTINT (Flength (this));
       if (target_type == Lisp_String)
         {
           /* We must count the number of bytes needed in the string
              as well as the number of characters.  */
-          int i;
+          EMACS_INT i;
           Lisp_Object ch;
-          int this_len_byte;
+          EMACS_INT this_len_byte;
 
           if (VECTORP (this) || FUNVECP (this))
             for (i = 0; i < len; i++)
@@ -594,9 +594,9 @@ concat (int nargs, Lisp_Object *args, enum Lisp_Type target_type, int last_speci
   for (argnum = 0; argnum < nargs; argnum++)
     {
       Lisp_Object thislen;
-      int thisleni = 0;
-      register unsigned int thisindex = 0;
-      register unsigned int thisindex_byte = 0;
+      EMACS_INT thisleni = 0;
+      register EMACS_INT thisindex = 0;
+      register EMACS_INT thisindex_byte = 0;
 
       this = args[argnum];
       if (!CONSP (this))
@@ -606,7 +606,7 @@ concat (int nargs, Lisp_Object *args, enum Lisp_Type target_type, int last_speci
       if (STRINGP (this) && STRINGP (val)
           && STRING_MULTIBYTE (this) == some_multibyte)
         {
-          int thislen_byte = SBYTES (this);
+          EMACS_INT thislen_byte = SBYTES (this);
 
           memcpy (SDATA (val) + toindex_byte, SDATA (this), SBYTES (this));
           if (! NULL_INTERVAL_P (STRING_INTERVALS (this)))
@@ -713,7 +713,7 @@ concat (int nargs, Lisp_Object *args, enum Lisp_Type target_type, int last_speci
   if (num_textprops > 0)
     {
       Lisp_Object props;
-      int last_to_end = -1;
+      EMACS_INT last_to_end = -1;
 
       for (argnum = 0; argnum < num_textprops; argnum++)
         {
@@ -938,7 +938,7 @@ string_to_multibyte (Lisp_Object string)
 Lisp_Object
 string_make_unibyte (Lisp_Object string)
 {
-  int nchars;
+  EMACS_INT nchars;
   unsigned char *buf;
   Lisp_Object ret;
   USE_SAFE_ALLOCA;
@@ -1003,7 +1003,7 @@ If STRING is multibyte and contains a character of charset
 
   if (STRING_MULTIBYTE (string))
     {
-      int bytes = SBYTES (string);
+      EMACS_INT bytes = SBYTES (string);
       unsigned char *str = (unsigned char *) xmalloc (bytes);
 
       memcpy (str, SDATA (string), bytes);
@@ -1036,7 +1036,7 @@ If you're not sure, whether to use `string-as-multibyte' or
   if (! STRING_MULTIBYTE (string))
     {
       Lisp_Object new_string;
-      int nchars, nbytes;
+      EMACS_INT nchars, nbytes;
 
       parse_str_as_multibyte (SDATA (string),
                               SBYTES (string),
@@ -1138,10 +1138,10 @@ value is a new vector that contains the elements between index FROM
   (Lisp_Object string, register Lisp_Object from, Lisp_Object to)
 {
   Lisp_Object res;
-  int size;
-  int size_byte = 0;
-  int from_char, to_char;
-  int from_byte = 0, to_byte = 0;
+  EMACS_INT size;
+  EMACS_INT size_byte = 0;
+  EMACS_INT from_char, to_char;
+  EMACS_INT from_byte = 0, to_byte = 0;
 
   CHECK_VECTOR_OR_STRING (string);
   CHECK_NUMBER (from);
@@ -1206,9 +1206,9 @@ If FROM or TO is negative, it counts from the end.
 With one argument, just copy STRING without its properties.  */)
   (Lisp_Object string, register Lisp_Object from, Lisp_Object to)
 {
-  int size, size_byte;
-  int from_char, to_char;
-  int from_byte, to_byte;
+  EMACS_INT size, size_byte;
+  EMACS_INT from_char, to_char;
+  EMACS_INT from_byte, to_byte;
 
   CHECK_STRING (string);
 
@@ -1256,11 +1256,12 @@ With one argument, just copy STRING without its properties.  */)
    both in characters and in bytes.  */
 
 Lisp_Object
-substring_both (Lisp_Object string, int from, int from_byte, int to, int to_byte)
+substring_both (Lisp_Object string, EMACS_INT from, EMACS_INT from_byte,
+                EMACS_INT to, EMACS_INT to_byte)
 {
   Lisp_Object res;
-  int size;
-  int size_byte;
+  EMACS_INT size;
+  EMACS_INT size_byte;
 
   CHECK_VECTOR_OR_STRING (string);
 
@@ -2150,7 +2151,9 @@ DEFUN ("fillarray", Ffillarray, Sfillarray, 2, 2, 0,
 ARRAY is a vector, string, char-table, or bool-vector.  */)
   (Lisp_Object array, Lisp_Object item)
 {
-  register int size, index, charval;
+  register EMACS_INT size, index;
+  int charval;
+
   if (VECTORP (array))
     {
       register Lisp_Object *p = XVECTOR (array)->contents;
@@ -2176,7 +2179,7 @@ ARRAY is a vector, string, char-table, or bool-vector.  */)
         {
           unsigned char str[MAX_MULTIBYTE_LENGTH];
           int len = CHAR_STRING (charval, str);
-          int size_byte = SBYTES (array);
+          EMACS_INT size_byte = SBYTES (array);
           unsigned char *p1 = p, *endp = p + size_byte;
           int i;
 
@@ -2224,7 +2227,7 @@ DEFUN ("clear-string", Fclear_string, Sclear_string,
 This makes STRING unibyte and may change its length.  */)
   (Lisp_Object string)
 {
-  int len;
+  EMACS_INT len;
   CHECK_STRING (string);
   len = SBYTES (string);
   memset (SDATA (string), 0, len);
@@ -2288,11 +2291,11 @@ usage: (nconc &rest LISTS)  */)
  LENI is the length of VALS, which should also be the length of SEQ.  */
 
 static void
-mapcar1 (int leni, Lisp_Object *vals, Lisp_Object fn, Lisp_Object seq)
+mapcar1 (EMACS_INT leni, Lisp_Object *vals, Lisp_Object fn, Lisp_Object seq)
 {
   register Lisp_Object tail;
   Lisp_Object dummy;
-  register int i;
+  register EMACS_INT i;
   struct gcpro gcpro1, gcpro2, gcpro3;
 
   if (vals)
@@ -2334,12 +2337,12 @@ mapcar1 (int leni, Lisp_Object *vals, Lisp_Object fn, Lisp_Object seq)
     }
   else if (STRINGP (seq))
     {
-      int i_byte;
+      EMACS_INT i_byte;
 
       for (i = 0, i_byte = 0; i < leni;)
         {
           int c;
-          int i_before = i;
+          EMACS_INT i_before = i;
 
           FETCH_STRING_CHAR_ADVANCE (c, seq, i, i_byte);
           XSETFASTINT (dummy, c);
@@ -2371,10 +2374,10 @@ SEQUENCE may be a list, a vector, a bool-vector, or a string.  */)
   (Lisp_Object function, Lisp_Object sequence, Lisp_Object separator)
 {
   Lisp_Object len;
-  register int leni;
+  register EMACS_INT leni;
   int nargs;
   register Lisp_Object *args;
-  register int i;
+  register EMACS_INT i;
   struct gcpro gcpro1;
   Lisp_Object ret;
   USE_SAFE_ALLOCA;
@@ -2411,7 +2414,7 @@ SEQUENCE may be a list, a vector, a bool-vector, or a string.  */)
   (Lisp_Object function, Lisp_Object sequence)
 {
   register Lisp_Object len;
-  register int leni;
+  register EMACS_INT leni;
   register Lisp_Object *args;
   Lisp_Object ret;
   USE_SAFE_ALLOCA;
@@ -2437,7 +2440,7 @@ Unlike `mapcar', don't accumulate the results.  Return SEQUENCE.
 SEQUENCE may be a list, a vector, a bool-vector, or a string.  */)
   (Lisp_Object function, Lisp_Object sequence)
 {
-  register int leni;
+  register EMACS_INT leni;
 
   leni = XFASTINT (Flength (sequence));
   if (CHAR_TABLE_P (sequence))
@@ -2961,8 +2964,9 @@ static const short base64_char_to_value[128] =
    base64 characters.  */
 
 
-static int base64_encode_1 (const char *, char *, int, int, int);
-static int base64_decode_1 (const char *, char *, int, int, int *);
+static EMACS_INT base64_encode_1 (const char *, char *, EMACS_INT, int, int);
+static EMACS_INT base64_decode_1 (const char *, char *, EMACS_INT, int,
+                                  EMACS_INT *);
 
 DEFUN ("base64-encode-region", Fbase64_encode_region, Sbase64_encode_region,
        2, 3, "r",
@@ -2973,9 +2977,9 @@ into shorter lines.  */)
   (Lisp_Object beg, Lisp_Object end, Lisp_Object no_line_break)
 {
   char *encoded;
-  int allength, length;
-  int ibeg, iend, encoded_length;
-  int old_pos = PT;
+  EMACS_INT allength, length;
+  EMACS_INT ibeg, iend, encoded_length;
+  EMACS_INT old_pos = PT;
   USE_SAFE_ALLOCA;
 
   validate_region (&beg, &end);
@@ -3031,7 +3035,7 @@ Optional second argument NO-LINE-BREAK means do not break long lines
 into shorter lines.  */)
   (Lisp_Object string, Lisp_Object no_line_break)
 {
-  int allength, length, encoded_length;
+  EMACS_INT allength, length, encoded_length;
   char *encoded;
   Lisp_Object encoded_string;
   USE_SAFE_ALLOCA;
@@ -3067,10 +3071,12 @@ into shorter lines.  */)
   return encoded_string;
 }
 
-static int
-base64_encode_1 (const char *from, char *to, int length, int line_break, int multibyte)
+static EMACS_INT
+base64_encode_1 (const char *from, char *to, EMACS_INT length,
+                 int line_break, int multibyte)
 {
-  int counter = 0, i = 0;
+  int counter = 0;
+  EMACS_INT i = 0;
   char *e = to;
   int c;
   unsigned int value;
@@ -3169,11 +3175,11 @@ Return the length of the decoded text.
 If the region can't be decoded, signal an error and don't modify the buffer.  */)
   (Lisp_Object beg, Lisp_Object end)
 {
-  int ibeg, iend, length, allength;
+  EMACS_INT ibeg, iend, length, allength;
   char *decoded;
-  int old_pos = PT;
-  int decoded_length;
-  int inserted_chars;
+  EMACS_INT old_pos = PT;
+  EMACS_INT decoded_length;
+  EMACS_INT inserted_chars;
   int multibyte = !NILP (current_buffer->enable_multibyte_characters);
   USE_SAFE_ALLOCA;
 
@@ -3230,7 +3236,7 @@ DEFUN ("base64-decode-string", Fbase64_decode_string, Sbase64_decode_string,
   (Lisp_Object string)
 {
   char *decoded;
-  int length, decoded_length;
+  EMACS_INT length, decoded_length;
   Lisp_Object decoded_string;
   USE_SAFE_ALLOCA;
 
@@ -3262,14 +3268,15 @@ DEFUN ("base64-decode-string", Fbase64_decode_string, Sbase64_decode_string,
    form.  If NCHARS_RETRUN is not NULL, store the number of produced
    characters in *NCHARS_RETURN.  */
 
-static int
-base64_decode_1 (const char *from, char *to, int length, int multibyte, int *nchars_return)
+static EMACS_INT
+base64_decode_1 (const char *from, char *to, EMACS_INT length,
+                 int multibyte, EMACS_INT *nchars_return)
 {
-  int i = 0;
+  EMACS_INT i = 0;              /* Used inside READ_QUADRUPLET_BYTE */
   char *e = to;
   unsigned char c;
   unsigned long value;
-  int nchars = 0;
+  EMACS_INT nchars = 0;
 
   while (1)
     {
@@ -4575,13 +4582,13 @@ guesswork fails.  Normally, an error is signaled in such case.  */)
   unsigned char digest[16];
   unsigned char value[33];
   int i;
-  int size;
-  int size_byte = 0;
-  int start_char = 0, end_char = 0;
-  int start_byte = 0, end_byte = 0;
-  register int b, e;
+  EMACS_INT size;
+  EMACS_INT size_byte = 0;
+  EMACS_INT start_char = 0, end_char = 0;
+  EMACS_INT start_byte = 0, end_byte = 0;
+  register EMACS_INT b, e;
   register struct buffer *bp;
-  int temp;
+  EMACS_INT temp;
 
   if (STRINGP (object))
     {
diff --git a/src/font.c b/src/font.c
index ae7211e92fe..dee55d1e976 100644
--- a/src/font.c
+++ b/src/font.c
@@ -237,7 +237,7 @@ font_intern_prop (const char *str, int len, int force_symbol)
   int i;
   Lisp_Object tem;
   Lisp_Object obarray;
-  int nbytes, nchars;
+  EMACS_INT nbytes, nchars;
 
   if (len == 1 && *str == '*')
     return Qnil;
diff --git a/src/frame.c b/src/frame.c
index 93a6e898c9b..04cc1ca07da 100644
--- a/src/frame.c
+++ b/src/frame.c
@@ -2649,6 +2649,28 @@ If FRAME is omitted, the selected frame is used.  */)
 #endif
     return make_number (FRAME_COLS (f));
 }
+
+DEFUN ("tool-bar-pixel-width", Ftool_bar_pixel_width,
+       Stool_bar_pixel_width, 0, 1, 0,
+       doc: /* Return width in pixels of FRAME's tool bar.
+The result is greater than zero only when the tool bar is on the left
+or right side of FRAME.  If FRAME is omitted, the selected frame is
+used.  */)
+  (Lisp_Object frame)
+{
+  struct frame *f;
+
+  if (NILP (frame))
+    frame = selected_frame;
+  CHECK_FRAME (frame);
+  f = XFRAME (frame);
+
+#ifdef FRAME_TOOLBAR_WIDTH
+  if (FRAME_WINDOW_P (f))
+    return make_number (FRAME_TOOLBAR_WIDTH (f));
+#endif
+  return make_number (0);
+}
 
 DEFUN ("set-frame-height", Fset_frame_height, Sset_frame_height, 2, 3, 0,
        doc: /* Specify that the frame FRAME has LINES lines.
@@ -4596,6 +4618,7 @@ automatically.  See also `mouse-autoselect-window'.  */);
   defsubr (&Sframe_char_width);
   defsubr (&Sframe_pixel_height);
   defsubr (&Sframe_pixel_width);
+  defsubr (&Stool_bar_pixel_width);
   defsubr (&Sset_frame_height);
   defsubr (&Sset_frame_width);
   defsubr (&Sset_frame_size);
diff --git a/src/frame.h b/src/frame.h
index 6b307c7c3b1..e66fd9341c7 100644
--- a/src/frame.h
+++ b/src/frame.h
@@ -310,7 +310,7 @@ struct frame
   /* Canonical X unit.  Width of default font, in pixels.  */
   int column_width;
 
-  /* Widht of space glyph of default font, in pixels.  */
+  /* Width of space glyph of default font, in pixels.  */
   int space_width;
 
   /* Canonical Y unit.  Height of a line, in pixels.  */
diff --git a/src/ftfont.c b/src/ftfont.c
index b99e50ca3ff..97bf265a84c 100644
--- a/src/ftfont.c
+++ b/src/ftfont.c
@@ -1632,38 +1632,70 @@ ftfont_get_metrics (MFLTFont *font, MFLTGlyphString *gstring,
 static int
 ftfont_check_otf (MFLTFont *font, MFLTOtfSpec *spec)
 {
+#define FEATURE_NONE(IDX) (! spec->features[IDX])
+
+#define FEATURE_ANY(IDX)        \
+  (spec->features[IDX]          \
+   && spec->features[IDX][0] == 0xFFFFFFFF && spec->features[IDX][1] == 0)
+
   struct MFLTFontFT *flt_font_ft = (struct MFLTFontFT *) font;
   OTF *otf = flt_font_ft->otf;
   OTF_Tag *tags;
   int i, n, negative;
 
+  if (FEATURE_ANY (0) && FEATURE_ANY (1))
+    /* Return 1 iff any of GSUB or GPOS support the script (and language).  */
+    return (otf
+            && (OTF_check_features (otf, 0, spec->script, spec->langsys,
+                                    NULL, 0) > 0
+                || OTF_check_features (otf, 1, spec->script, spec->langsys,
+                                       NULL, 0) > 0));
+
   for (i = 0; i < 2; i++)
-    {
-      if (! spec->features[i])
-        continue;
-      for (n = 0; spec->features[i][n]; n++);
-      tags = alloca (sizeof (OTF_Tag) * n);
-      for (n = 0, negative = 0; spec->features[i][n]; n++)
-        {
-          if (spec->features[i][n] == 0xFFFFFFFF)
-            negative = 1;
-          else if (negative)
-            tags[n - 1] = spec->features[i][n] | 0x80000000;
-          else
-            tags[n] = spec->features[i][n];
-        }
+    if (! FEATURE_ANY (i))
+      {
+        if (FEATURE_NONE (i))
+          {
+            if (otf
+                && OTF_check_features (otf, i == 0, spec->script, spec->langsys,
+                                       NULL, 0) > 0)
+              return 0;
+            continue;
+          }
+        if (spec->features[i][0] == 0xFFFFFFFF)
+          {
+            if (! otf
+                || OTF_check_features (otf, i == 0, spec->script, spec->langsys,
+                                       NULL, 0) <= 0)
+              continue;
+          }
+        else if (! otf)
+          return 0;
+        for (n = 1; spec->features[i][n]; n++);
+        tags = alloca (sizeof (OTF_Tag) * n);
+        for (n = 0, negative = 0; spec->features[i][n]; n++)
+          {
+            if (spec->features[i][n] == 0xFFFFFFFF)
+              negative = 1;
+            else if (negative)
+              tags[n - 1] = spec->features[i][n] | 0x80000000;
+            else
+              tags[n] = spec->features[i][n];
+          }
 #ifdef M17N_FLT_USE_NEW_FEATURE
-      if (OTF_check_features (otf, i == 0, spec->script, spec->langsys,
-                              tags, n - negative) != 1)
-        return 0;
+        if (OTF_check_features (otf, i == 0, spec->script, spec->langsys,
+                                tags, n - negative) != 1)
+          return 0;
 #else  /* not M17N_FLT_USE_NEW_FEATURE */
-      if (n - negative > 0
-          && OTF_check_features (otf, i == 0, spec->script, spec->langsys,
-                                 tags, n - negative) != 1)
-        return 0;
+        if (n - negative > 0
+            && OTF_check_features (otf, i == 0, spec->script, spec->langsys,
+                                   tags, n - negative) != 1)
+          return 0;
 #endif  /* not M17N_FLT_USE_NEW_FEATURE */
-    }
+      }
   return 1;
+#undef FEATURE_NONE
+#undef FEATURE_ANY
 }
 
 #define DEVICE_DELTA(table, size)                               \
diff --git a/src/gnutls.c b/src/gnutls.c
new file mode 100644
index 00000000000..37b4341d184
--- /dev/null
+++ b/src/gnutls.c
@@ -0,0 +1,539 @@
+/* GnuTLS glue for GNU Emacs.
+   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>
+#include <errno.h>
+#include <setjmp.h>
+
+#include "lisp.h"
+#include "process.h"
+
+#ifdef HAVE_GNUTLS
+#include <gnutls/gnutls.h>
+
+Lisp_Object Qgnutls_code;
+Lisp_Object Qgnutls_anon, Qgnutls_x509pki;
+Lisp_Object Qgnutls_e_interrupted, Qgnutls_e_again,
+  Qgnutls_e_invalid_session, Qgnutls_e_not_ready_for_handshake;
+int global_initialized;
+
+void
+emacs_gnutls_handshake (struct Lisp_Process *proc)
+{
+  gnutls_session_t state = proc->gnutls_state;
+  int ret;
+
+  if (proc->gnutls_initstage < GNUTLS_STAGE_HANDSHAKE_CANDO)
+    return;
+
+  if (proc->gnutls_initstage < GNUTLS_STAGE_TRANSPORT_POINTERS_SET)
+    {
+      gnutls_transport_set_ptr2 (state,
+                                 (gnutls_transport_ptr_t) (long) proc->infd,
+                                 (gnutls_transport_ptr_t) (long) proc->outfd);
+
+      proc->gnutls_initstage = GNUTLS_STAGE_TRANSPORT_POINTERS_SET;
+    }
+
+  ret = gnutls_handshake (state);
+  proc->gnutls_initstage = GNUTLS_STAGE_HANDSHAKE_TRIED;
+
+  if (ret == GNUTLS_E_SUCCESS)
+    {
+      /* here we're finally done.  */
+      proc->gnutls_initstage = GNUTLS_STAGE_READY;
+    }
+}
+
+int
+emacs_gnutls_write (int fildes, struct Lisp_Process *proc, char *buf,
+                    unsigned int nbyte)
+{
+  register int rtnval, bytes_written;
+  gnutls_session_t state = proc->gnutls_state;
+
+  if (proc->gnutls_initstage != GNUTLS_STAGE_READY)
+    return -1;
+
+  bytes_written = 0;
+
+  while (nbyte > 0)
+    {
+      rtnval = gnutls_write (state, buf, nbyte);
+
+      if (rtnval == -1)
+        {
+          if (errno == EINTR)
+            continue;
+          else
+            return (bytes_written ? bytes_written : -1);
+        }
+
+      buf += rtnval;
+      nbyte -= rtnval;
+      bytes_written += rtnval;
+    }
+  fsync (STDOUT_FILENO);
+
+  return (bytes_written);
+}
+
+int
+emacs_gnutls_read (int fildes, struct Lisp_Process *proc, char *buf,
+                   unsigned int nbyte)
+{
+  register int rtnval;
+  gnutls_session_t state = proc->gnutls_state;
+
+  if (proc->gnutls_initstage != GNUTLS_STAGE_READY)
+    {
+      emacs_gnutls_handshake (proc);
+      return -1;
+    }
+
+  rtnval = gnutls_read (state, buf, nbyte);
+  if (rtnval >= 0)
+    return rtnval;
+  else
+    return 0;
+}
+
+/* convert an integer error to a Lisp_Object; it will be either a
+   known symbol like `gnutls_e_interrupted' and `gnutls_e_again' or
+   simply the integer value of the error.  GNUTLS_E_SUCCESS is mapped
+   to Qt.  */
+Lisp_Object gnutls_make_error (int error)
+{
+  switch (error)
+    {
+    case GNUTLS_E_SUCCESS:
+      return Qt;
+    case GNUTLS_E_AGAIN:
+      return Qgnutls_e_again;
+    case GNUTLS_E_INTERRUPTED:
+      return Qgnutls_e_interrupted;
+    case GNUTLS_E_INVALID_SESSION:
+      return Qgnutls_e_invalid_session;
+    }
+
+  return make_number (error);
+}
+
+DEFUN ("gnutls-get-initstage", Fgnutls_get_initstage, Sgnutls_get_initstage, 1, 1, 0,
+       doc: /* Return the GnuTLS init stage of PROCESS.
+See also `gnutls-boot'.  */)
+    (Lisp_Object proc)
+{
+  CHECK_PROCESS (proc);
+
+  return make_number (GNUTLS_INITSTAGE (proc));
+}
+
+DEFUN ("gnutls-errorp", Fgnutls_errorp, Sgnutls_errorp, 1, 1, 0,
+       doc: /* Returns t if ERROR (as generated by gnutls_make_error)
+indicates a GnuTLS problem.  */)
+    (Lisp_Object error)
+{
+  if (EQ (error, Qt)) return Qnil;
+
+  return Qt;
+}
+
+DEFUN ("gnutls-error-fatalp", Fgnutls_error_fatalp, Sgnutls_error_fatalp, 1, 1, 0,
+       doc: /* Checks if ERROR is fatal.
+ERROR is an integer or a symbol with an integer `gnutls-code' property.  */)
+    (Lisp_Object err)
+{
+  Lisp_Object code;
+
+  if (EQ (err, Qt)) return Qnil;
+
+  if (SYMBOLP (err))
+    {
+      code = Fget (err, Qgnutls_code);
+      if (NUMBERP (code))
+        {
+          err = code;
+        }
+      else
+        {
+          error ("Symbol has no numeric gnutls-code property");
+        }
+    }
+
+  if (!NUMBERP (err))
+    error ("Not an error symbol or code");
+
+  if (0 == gnutls_error_is_fatal (XINT (err)))
+    return Qnil;
+
+  return Qt;
+}
+
+DEFUN ("gnutls-error-string", Fgnutls_error_string, Sgnutls_error_string, 1, 1, 0,
+       doc: /* Returns a description of ERROR.
+ERROR is an integer or a symbol with an integer `gnutls-code' property.  */)
+    (Lisp_Object err)
+{
+  Lisp_Object code;
+
+  if (EQ (err, Qt)) return build_string ("Not an error");
+
+  if (SYMBOLP (err))
+    {
+      code = Fget (err, Qgnutls_code);
+      if (NUMBERP (code))
+        {
+          err = code;
+        }
+      else
+        {
+          return build_string ("Symbol has no numeric gnutls-code property");
+        }
+    }
+
+  if (!NUMBERP (err))
+    return build_string ("Not an error symbol or code");
+
+  return build_string (gnutls_strerror (XINT (err)));
+}
+
+DEFUN ("gnutls-deinit", Fgnutls_deinit, Sgnutls_deinit, 1, 1, 0,
+       doc: /* Deallocate GNU TLS resources associated with PROCESS.
+See also `gnutls-init'.  */)
+    (Lisp_Object proc)
+{
+  gnutls_session_t state;
+
+  CHECK_PROCESS (proc);
+  state = XPROCESS (proc)->gnutls_state;
+
+  if (GNUTLS_INITSTAGE (proc) >= GNUTLS_STAGE_INIT)
+    {
+      gnutls_deinit (state);
+      GNUTLS_INITSTAGE (proc) = GNUTLS_STAGE_INIT - 1;
+    }
+
+  return Qt;
+}
+
+/* Initializes global GNU TLS state to defaults.
+Call `gnutls-global-deinit' when GNU TLS usage is no longer needed.
+Returns zero on success.  */
+Lisp_Object gnutls_emacs_global_init (void)
+{
+  int ret = GNUTLS_E_SUCCESS;
+
+  if (!global_initialized)
+    ret = gnutls_global_init ();
+
+  global_initialized = 1;
+
+  return gnutls_make_error (ret);
+}
+
+/* Deinitializes global GNU TLS state.
+See also `gnutls-global-init'.  */
+Lisp_Object gnutls_emacs_global_deinit (void)
+{
+  if (global_initialized)
+    gnutls_global_deinit ();
+
+  global_initialized = 0;
+
+  return gnutls_make_error (GNUTLS_E_SUCCESS);
+}
+
+static void gnutls_log_function (int level, const char* string)
+{
+  message("gnutls.c: [%d] %s", level, string);
+}
+
+DEFUN ("gnutls-boot", Fgnutls_boot, Sgnutls_boot, 3, 7, 0,
+       doc: /* Initializes client-mode GnuTLS for process PROC.
+Currently only client mode is supported.  Returns a success/failure
+value you can check with `gnutls-errorp'.
+
+PRIORITY_STRING is a string describing the priority.
+TYPE is either `gnutls-anon' or `gnutls-x509pki'.
+TRUSTFILE is a PEM encoded trust file for `gnutls-x509pki'.
+KEYFILE is ... for `gnutls-x509pki' (TODO).
+CALLBACK is ... for `gnutls-x509pki' (TODO).
+LOGLEVEL is the debug level requested from GnuTLS, try 4.
+
+LOGLEVEL will be set for this process AND globally for GnuTLS.  So if
+you set it higher or lower at any point, it affects global debugging.
+
+Note that the priority is set on the client.  The server does not use
+the protocols's priority except for disabling protocols that were not
+specified.
+
+Processes must be initialized with this function before other GNU TLS
+functions are used.  This function allocates resources which can only
+be deallocated by calling `gnutls-deinit' or by calling it again.
+
+Each authentication type may need additional information in order to
+work.  For X.509 PKI (`gnutls-x509pki'), you need TRUSTFILE and
+KEYFILE and optionally CALLBACK.  */)
+    (Lisp_Object proc, Lisp_Object priority_string, Lisp_Object type,
+     Lisp_Object trustfile, Lisp_Object keyfile, Lisp_Object callback,
+     Lisp_Object loglevel)
+{
+  int ret = GNUTLS_E_SUCCESS;
+
+  int max_log_level = 0;
+
+  /* TODO: GNUTLS_X509_FMT_DER is also an option.  */
+  int file_format = GNUTLS_X509_FMT_PEM;
+
+  gnutls_session_t state;
+  gnutls_certificate_credentials_t x509_cred;
+  gnutls_anon_client_credentials_t anon_cred;
+  Lisp_Object global_init;
+
+  CHECK_PROCESS (proc);
+  CHECK_SYMBOL (type);
+  CHECK_STRING (priority_string);
+
+  state = XPROCESS (proc)->gnutls_state;
+  XPROCESS (proc)->gnutls_p = 1;
+
+  if (NUMBERP (loglevel))
+    {
+      gnutls_global_set_log_function (gnutls_log_function);
+      gnutls_global_set_log_level (XINT (loglevel));
+      max_log_level = XINT (loglevel);
+      XPROCESS (proc)->gnutls_log_level = max_log_level;
+    }
+
+  /* always initialize globals.  */
+  global_init = gnutls_emacs_global_init ();
+  if (! NILP (Fgnutls_errorp (global_init)))
+    return global_init;
+
+  /* deinit and free resources.  */
+  if (GNUTLS_INITSTAGE (proc) >= GNUTLS_STAGE_CRED_ALLOC)
+    {
+      GNUTLS_LOG (1, max_log_level, "deallocating credentials");
+
+      if (EQ (type, Qgnutls_x509pki))
+        {
+          GNUTLS_LOG (2, max_log_level, "deallocating x509 credentials");
+          x509_cred = XPROCESS (proc)->gnutls_x509_cred;
+          gnutls_certificate_free_credentials (x509_cred);
+        }
+      else if (EQ (type, Qgnutls_anon))
+        {
+          GNUTLS_LOG (2, max_log_level, "deallocating anon credentials");
+          anon_cred = XPROCESS (proc)->gnutls_anon_cred;
+          gnutls_anon_free_client_credentials (anon_cred);
+        }
+      else
+        {
+          error ("unknown credential type");
+          ret = GNUTLS_EMACS_ERROR_INVALID_TYPE;
+        }
+
+      if (GNUTLS_INITSTAGE (proc) >= GNUTLS_STAGE_INIT)
+        {
+          GNUTLS_LOG (1, max_log_level, "deallocating x509 credentials");
+          Fgnutls_deinit (proc);
+        }
+    }
+
+  GNUTLS_INITSTAGE (proc) = GNUTLS_STAGE_EMPTY;
+
+  GNUTLS_LOG (1, max_log_level, "allocating credentials");
+
+  if (EQ (type, Qgnutls_x509pki))
+    {
+      GNUTLS_LOG (2, max_log_level, "allocating x509 credentials");
+      x509_cred = XPROCESS (proc)->gnutls_x509_cred;
+      if (gnutls_certificate_allocate_credentials (&x509_cred) < 0)
+        memory_full ();
+    }
+  else if (EQ (type, Qgnutls_anon))
+    {
+      GNUTLS_LOG (2, max_log_level, "allocating anon credentials");
+      anon_cred = XPROCESS (proc)->gnutls_anon_cred;
+      if (gnutls_anon_allocate_client_credentials (&anon_cred) < 0)
+        memory_full ();
+    }
+  else
+    {
+      error ("unknown credential type");
+      ret = GNUTLS_EMACS_ERROR_INVALID_TYPE;
+    }
+
+  if (ret < GNUTLS_E_SUCCESS)
+    return gnutls_make_error (ret);
+
+  GNUTLS_INITSTAGE (proc) = GNUTLS_STAGE_CRED_ALLOC;
+
+  if (EQ (type, Qgnutls_x509pki))
+    {
+      if (STRINGP (trustfile))
+        {
+          GNUTLS_LOG (1, max_log_level, "setting the trustfile");
+          ret = gnutls_certificate_set_x509_trust_file
+            (x509_cred,
+             SDATA (trustfile),
+             file_format);
+
+          if (ret < GNUTLS_E_SUCCESS)
+            return gnutls_make_error (ret);
+        }
+
+      if (STRINGP (keyfile))
+        {
+          GNUTLS_LOG (1, max_log_level, "setting the keyfile");
+          ret = gnutls_certificate_set_x509_crl_file
+            (x509_cred,
+             SDATA (keyfile),
+             file_format);
+
+          if (ret < GNUTLS_E_SUCCESS)
+            return gnutls_make_error (ret);
+        }
+    }
+
+  GNUTLS_INITSTAGE (proc) = GNUTLS_STAGE_FILES;
+
+  GNUTLS_LOG (1, max_log_level, "gnutls_init");
+
+  ret = gnutls_init (&state, GNUTLS_CLIENT);
+
+  if (ret < GNUTLS_E_SUCCESS)
+    return gnutls_make_error (ret);
+
+  XPROCESS (proc)->gnutls_state = state;
+
+  GNUTLS_INITSTAGE (proc) = GNUTLS_STAGE_INIT;
+
+  GNUTLS_LOG (1, max_log_level, "setting the priority string");
+
+  ret = gnutls_priority_set_direct(state,
+                                   (char*) SDATA (priority_string),
+                                   NULL);
+
+  if (ret < GNUTLS_E_SUCCESS)
+    return gnutls_make_error (ret);
+
+  GNUTLS_INITSTAGE (proc) = GNUTLS_STAGE_PRIORITY;
+
+  if (EQ (type, Qgnutls_x509pki))
+    {
+      ret = gnutls_cred_set (state, GNUTLS_CRD_CERTIFICATE, x509_cred);
+    }
+  else if (EQ (type, Qgnutls_anon))
+    {
+      ret = gnutls_cred_set (state, GNUTLS_CRD_ANON, anon_cred);
+    }
+  else
+    {
+      error ("unknown credential type");
+      ret = GNUTLS_EMACS_ERROR_INVALID_TYPE;
+    }
+
+  if (ret < GNUTLS_E_SUCCESS)
+    return gnutls_make_error (ret);
+
+  XPROCESS (proc)->gnutls_anon_cred = anon_cred;
+  XPROCESS (proc)->gnutls_x509_cred = x509_cred;
+  XPROCESS (proc)->gnutls_cred_type = type;
+
+  GNUTLS_INITSTAGE (proc) = GNUTLS_STAGE_CRED_SET;
+
+  emacs_gnutls_handshake (XPROCESS (proc));
+
+  return gnutls_make_error (GNUTLS_E_SUCCESS);
+}
+
+DEFUN ("gnutls-bye", Fgnutls_bye,
+       Sgnutls_bye, 2, 2, 0,
+       doc: /* Terminate current GNU TLS connection for PROCESS.
+The connection should have been initiated using `gnutls-handshake'.
+
+If CONT is not nil the TLS connection gets terminated and further
+receives and sends will be disallowed. If the return value is zero you
+may continue using the connection.  If CONT is nil, GnuTLS actually
+sends an alert containing a close request and waits for the peer to
+reply with the same message.  In order to reuse the connection you
+should wait for an EOF from the peer.
+
+This function may also return `gnutls-e-again', or
+`gnutls-e-interrupted'.  */)
+    (Lisp_Object proc, Lisp_Object cont)
+{
+  gnutls_session_t state;
+  int ret;
+
+  CHECK_PROCESS (proc);
+
+  state = XPROCESS (proc)->gnutls_state;
+
+  ret = gnutls_bye (state,
+                    NILP (cont) ? GNUTLS_SHUT_RDWR : GNUTLS_SHUT_WR);
+
+  return gnutls_make_error (ret);
+}
+
+void
+syms_of_gnutls (void)
+{
+  global_initialized = 0;
+
+  Qgnutls_code = intern_c_string ("gnutls-code");
+  staticpro (&Qgnutls_code);
+
+  Qgnutls_anon = intern_c_string ("gnutls-anon");
+  staticpro (&Qgnutls_anon);
+
+  Qgnutls_x509pki = intern_c_string ("gnutls-x509pki");
+  staticpro (&Qgnutls_x509pki);
+
+  Qgnutls_e_interrupted = intern_c_string ("gnutls-e-interrupted");
+  staticpro (&Qgnutls_e_interrupted);
+  Fput (Qgnutls_e_interrupted, Qgnutls_code,
+        make_number (GNUTLS_E_INTERRUPTED));
+
+  Qgnutls_e_again = intern_c_string ("gnutls-e-again");
+  staticpro (&Qgnutls_e_again);
+  Fput (Qgnutls_e_again, Qgnutls_code,
+        make_number (GNUTLS_E_AGAIN));
+
+  Qgnutls_e_invalid_session = intern_c_string ("gnutls-e-invalid-session");
+  staticpro (&Qgnutls_e_invalid_session);
+  Fput (Qgnutls_e_invalid_session, Qgnutls_code,
+        make_number (GNUTLS_E_INVALID_SESSION));
+
+  Qgnutls_e_not_ready_for_handshake =
+    intern_c_string ("gnutls-e-not-ready-for-handshake");
+  staticpro (&Qgnutls_e_not_ready_for_handshake);
+  Fput (Qgnutls_e_not_ready_for_handshake, Qgnutls_code,
+        make_number (GNUTLS_E_APPLICATION_ERROR_MIN));
+
+  defsubr (&Sgnutls_get_initstage);
+  defsubr (&Sgnutls_errorp);
+  defsubr (&Sgnutls_error_fatalp);
+  defsubr (&Sgnutls_error_string);
+  defsubr (&Sgnutls_boot);
+  defsubr (&Sgnutls_deinit);
+  defsubr (&Sgnutls_bye);
+}
+#endif
diff --git a/src/gnutls.h b/src/gnutls.h
new file mode 100644
index 00000000000..bcf9776963f
--- /dev/null
+++ b/src/gnutls.h
@@ -0,0 +1,62 @@
+/* GnuTLS glue for GNU Emacs.
+   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/>.  */
+
+#ifndef EMACS_GNUTLS_DEFINED
+#define EMACS_GNUTLS_DEFINED
+
+#ifdef HAVE_GNUTLS
+#include <gnutls/gnutls.h>
+
+typedef enum
+{
+  /* Initialization stages.  */
+  GNUTLS_STAGE_EMPTY = 0,
+  GNUTLS_STAGE_CRED_ALLOC,
+  GNUTLS_STAGE_FILES,
+  GNUTLS_STAGE_INIT,
+  GNUTLS_STAGE_PRIORITY,
+  GNUTLS_STAGE_CRED_SET,
+
+  /* Handshake stages.  */
+  GNUTLS_STAGE_HANDSHAKE_CANDO = GNUTLS_STAGE_CRED_SET,
+  GNUTLS_STAGE_TRANSPORT_POINTERS_SET,
+  GNUTLS_STAGE_HANDSHAKE_TRIED,
+
+  GNUTLS_STAGE_READY,
+} gnutls_initstage_t;
+
+#define GNUTLS_EMACS_ERROR_INVALID_TYPE GNUTLS_E_APPLICATION_ERROR_MIN
+
+#define GNUTLS_INITSTAGE(proc) (XPROCESS (proc)->gnutls_initstage)
+
+#define GNUTLS_PROCESS_USABLE(proc) (GNUTLS_INITSTAGE(proc) >= GNUTLS_STAGE_READY)
+
+#define GNUTLS_LOG(level, max, string) if (level <= max) { gnutls_log_function (level, "(Emacs) " string); }
+
+int
+emacs_gnutls_write (int fildes, struct Lisp_Process *proc, char *buf,
+                    unsigned int nbyte);
+int
+emacs_gnutls_read (int fildes, struct Lisp_Process *proc, char *buf,
+                   unsigned int nbyte);
+
+extern void syms_of_gnutls (void);
+
+#endif 
+
+#endif
diff --git a/src/gtkutil.c b/src/gtkutil.c
index dbd48eb5272..f82be62965d 100644
--- a/src/gtkutil.c
+++ b/src/gtkutil.c
@@ -3716,6 +3716,8 @@ xg_tool_bar_menu_proxy (GtkToolItem *toolitem, gpointer user_data)
       GtkSettings *settings = gtk_widget_get_settings (GTK_WIDGET (wbutton));
       GtkImageType store_type = gtk_image_get_storage_type (wimage);
 
+      g_object_set (G_OBJECT (settings), "gtk-menu-images", TRUE, NULL);
+
       if (store_type == GTK_IMAGE_STOCK)
         {
           gchar *stock_id;
@@ -3974,6 +3976,8 @@ xg_pack_tool_bar (FRAME_PTR f, Lisp_Object pos)
 
   if (into_hbox) 
     {
+      gtk_handle_box_set_handle_position (GTK_HANDLE_BOX (x->handlebox_widget),
+                                          GTK_POS_TOP);
       gtk_box_pack_start (GTK_BOX (x->hbox_widget), x->handlebox_widget,
                           FALSE, FALSE, 0);
 
@@ -3986,6 +3990,8 @@ xg_pack_tool_bar (FRAME_PTR f, Lisp_Object pos)
   else
     {
       int vbox_pos = x->menubar_widget ? 1 : 0;
+      gtk_handle_box_set_handle_position (GTK_HANDLE_BOX (x->handlebox_widget),
+                                          GTK_POS_LEFT);
       gtk_box_pack_start (GTK_BOX (x->vbox_widget), x->handlebox_widget,
                           FALSE, FALSE, 0);
 
diff --git a/src/image.c b/src/image.c
index 499cbf298c1..3c74c516d3f 100644
--- a/src/image.c
+++ b/src/image.c
@@ -8626,7 +8626,7 @@ of `image-library-alist', which see).  */)
 #if defined (HAVE_IMAGEMAGICK)
   if (EQ (type, Qimagemagick))
     {
-      /* MagickWandGenesis() initalizes the imagemagick library.  */
+      /* MagickWandGenesis() initializes the imagemagick library.  */
       MagickWandGenesis ();
       return CHECK_LIB_AVAILABLE (&imagemagick_type, init_imagemagick_functions,
                                   libraries);
diff --git a/src/indent.c b/src/indent.c
index 970904cba7b..affcc222f0b 100644
--- a/src/indent.c
+++ b/src/indent.c
@@ -865,7 +865,7 @@ following any initial whitespace.  */)
   (void)
 {
   Lisp_Object val;
-  int opoint = PT, opoint_byte = PT_BYTE;
+  EMACS_INT opoint = PT, opoint_byte = PT_BYTE;
 
   scan_newline (PT, PT_BYTE, BEGV, BEGV_BYTE, -1, 1);
 
@@ -964,10 +964,10 @@ position_indentation (register int pos_byte)
    preceding line.  */
 
 int
-indented_beyond_p (int pos, int pos_byte, double column)
+indented_beyond_p (EMACS_INT pos, EMACS_INT pos_byte, double column)
 {
   double val;
-  int opoint = PT, opoint_byte = PT_BYTE;
+  EMACS_INT opoint = PT, opoint_byte = PT_BYTE;
 
   SET_PT_BOTH (pos, pos_byte);
   while (PT > BEGV && FETCH_BYTE (PT_BYTE) == '\n')
@@ -1254,7 +1254,7 @@ compute_motion (EMACS_INT from, EMACS_INT fromvpos, EMACS_INT fromhpos, int did_
                to be changed here.  */
             {
               unsigned char *ovstr;
-              int ovlen = overlay_strings (pos, win, &ovstr);
+              EMACS_INT ovlen = overlay_strings (pos, win, &ovstr);
               hpos += ((multibyte && ovlen > 0)
                        ? strwidth (ovstr, ovlen) : ovlen);
             }
@@ -1448,7 +1448,7 @@ compute_motion (EMACS_INT from, EMACS_INT fromvpos, EMACS_INT fromhpos, int did_
          the text character-by-character.  */
       if (current_buffer->width_run_cache && pos >= next_width_run)
         {
-          int run_end;
+          EMACS_INT run_end;
           int common_width
             = region_cache_forward (current_buffer,
                                     current_buffer->width_run_cache,
@@ -1459,7 +1459,7 @@ compute_motion (EMACS_INT from, EMACS_INT fromvpos, EMACS_INT fromhpos, int did_
              want to skip over it for some other reason.  */
           if (common_width != 0)
             {
-              int run_end_hpos;
+              EMACS_INT run_end_hpos;
 
               /* Don't go past the final buffer posn the user
                  requested.  */
diff --git a/src/insdel.c b/src/insdel.c
index 2ccc0b8eaac..abe6f350585 100644
--- a/src/insdel.c
+++ b/src/insdel.c
@@ -2051,14 +2051,15 @@ prepare_to_modify_buffer (EMACS_INT start, EMACS_INT end,
 
   /* If `select-active-regions' is non-nil, save the region text.  */
   if (!NILP (current_buffer->mark_active)
+      && XMARKER (current_buffer->mark)->buffer
       && 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));
+      EMACS_INT b = XMARKER (current_buffer->mark)->charpos;
+      EMACS_INT e = PT;
       if (b < e)
         Vsaved_region_selection = make_buffer_string (b, e, 0);
       else if (b > e)
diff --git a/src/intervals.c b/src/intervals.c
index 86cbe1effcc..5e08e13d23b 100644
--- a/src/intervals.c
+++ b/src/intervals.c
@@ -222,7 +222,8 @@ traverse_intervals_noorder (INTERVAL tree, void (*function) (INTERVAL, Lisp_Obje
    Pass FUNCTION two args: an interval, and ARG.  */
 
 void
-traverse_intervals (INTERVAL tree, int position, void (*function) (INTERVAL, Lisp_Object), Lisp_Object arg)
+traverse_intervals (INTERVAL tree, EMACS_INT position,
+                    void (*function) (INTERVAL, Lisp_Object), Lisp_Object arg)
 {
   while (!NULL_INTERVAL_P (tree))
     {
@@ -316,7 +317,7 @@ rotate_right (INTERVAL interval)
 {
   INTERVAL i;
   INTERVAL B = interval->left;
-  int old_total = interval->total_length;
+  EMACS_INT old_total = interval->total_length;
 
   /* Deal with any Parent of A;  make it point to B.  */
   if (! ROOT_INTERVAL_P (interval))
@@ -363,7 +364,7 @@ rotate_left (INTERVAL interval)
 {
   INTERVAL i;
   INTERVAL B = interval->right;
-  int old_total = interval->total_length;
+  EMACS_INT old_total = interval->total_length;
 
   /* Deal with any parent of A;  make it point to B.  */
   if (! ROOT_INTERVAL_P (interval))
@@ -402,7 +403,7 @@ rotate_left (INTERVAL interval)
 static INTERVAL
 balance_an_interval (INTERVAL i)
 {
-  register int old_diff, new_diff;
+  register EMACS_INT old_diff, new_diff;
 
   while (1)
     {
@@ -502,11 +503,11 @@ balance_intervals (INTERVAL tree)
    it is still a root after this operation.  */
 
 INTERVAL
-split_interval_right (INTERVAL interval, int offset)
+split_interval_right (INTERVAL interval, EMACS_INT offset)
 {
   INTERVAL new = make_interval ();
-  int position = interval->position;
-  int new_length = LENGTH (interval) - offset;
+  EMACS_INT position = interval->position;
+  EMACS_INT new_length = LENGTH (interval) - offset;
 
   new->position = position + offset;
   SET_INTERVAL_PARENT (new, interval);
@@ -547,10 +548,10 @@ split_interval_right (INTERVAL interval, int offset)
    it is still a root after this operation.  */
 
 INTERVAL
-split_interval_left (INTERVAL interval, int offset)
+split_interval_left (INTERVAL interval, EMACS_INT offset)
 {
   INTERVAL new = make_interval ();
-  int new_length = offset;
+  EMACS_INT new_length = offset;
 
   new->position = interval->position;
   interval->position = interval->position + offset;
@@ -613,11 +614,11 @@ interval_start_pos (INTERVAL source)
    will update this cache based on the result of find_interval.  */
 
 INTERVAL
-find_interval (register INTERVAL tree, register int position)
+find_interval (register INTERVAL tree, register EMACS_INT position)
 {
   /* The distance from the left edge of the subtree at TREE
                     to POSITION.  */
-  register int relative_position;
+  register EMACS_INT relative_position;
 
   if (NULL_INTERVAL_P (tree))
     return NULL_INTERVAL;
@@ -670,7 +671,7 @@ INTERVAL
 next_interval (register INTERVAL interval)
 {
   register INTERVAL i = interval;
-  register int next_position;
+  register EMACS_INT next_position;
 
   if (NULL_INTERVAL_P (i))
     return NULL_INTERVAL;
@@ -745,7 +746,7 @@ previous_interval (register INTERVAL interval)
    To speed up the process, we assume that the ->position of
    I and all its parents is already uptodate.  */
 INTERVAL
-update_interval (register INTERVAL i, int pos)
+update_interval (register INTERVAL i, EMACS_INT pos)
 {
   if (NULL_INTERVAL_P (i))
     return NULL_INTERVAL;
@@ -864,13 +865,14 @@ adjust_intervals_for_insertion (tree, position, length)
    this text, and make it have the merged properties of both ends.  */
 
 static INTERVAL
-adjust_intervals_for_insertion (INTERVAL tree, int position, int length)
+adjust_intervals_for_insertion (INTERVAL tree,
+                                EMACS_INT position, EMACS_INT length)
 {
   register INTERVAL i;
   register INTERVAL temp;
   int eobp = 0;
   Lisp_Object parent;
-  int offset;
+  EMACS_INT offset;
 
   if (TOTAL_LENGTH (tree) == 0) /* Paranoia */
     abort ();
@@ -1228,7 +1230,7 @@ static INTERVAL
 delete_node (register INTERVAL i)
 {
   register INTERVAL migrate, this;
-  register int migrate_amt;
+  register EMACS_INT migrate_amt;
 
   if (NULL_INTERVAL_P (i->left))
     return i->right;
@@ -1261,7 +1263,7 @@ void
 delete_interval (register INTERVAL i)
 {
   register INTERVAL parent;
-  int amt = LENGTH (i);
+  EMACS_INT amt = LENGTH (i);
 
   if (amt > 0)                  /* Only used on zero-length intervals now.  */
     abort ();
@@ -1311,10 +1313,11 @@ delete_interval (register INTERVAL i)
    Do this by recursing down TREE to the interval in question, and
    deleting the appropriate amount of text.  */
 
-static int
-interval_deletion_adjustment (register INTERVAL tree, register int from, register int amount)
+static EMACS_INT
+interval_deletion_adjustment (register INTERVAL tree, register EMACS_INT from,
+                              register EMACS_INT amount)
 {
-  register int relative_position = from;
+  register EMACS_INT relative_position = from;
 
   if (NULL_INTERVAL_P (tree))
     return 0;
@@ -1322,9 +1325,9 @@ interval_deletion_adjustment (register INTERVAL tree, register int from, registe
   /* Left branch */
   if (relative_position < LEFT_TOTAL_LENGTH (tree))
     {
-      int subtract = interval_deletion_adjustment (tree->left,
-                                                   relative_position,
-                                                   amount);
+      EMACS_INT subtract = interval_deletion_adjustment (tree->left,
+                                                          relative_position,
+                                                          amount);
       tree->total_length -= subtract;
       CHECK_TOTAL_LENGTH (tree);
       return subtract;
@@ -1333,7 +1336,7 @@ interval_deletion_adjustment (register INTERVAL tree, register int from, registe
   else if (relative_position >= (TOTAL_LENGTH (tree)
                                  - RIGHT_TOTAL_LENGTH (tree)))
     {
-      int subtract;
+      EMACS_INT subtract;
 
       relative_position -= (tree->total_length
                             - RIGHT_TOTAL_LENGTH (tree));
@@ -1348,9 +1351,9 @@ interval_deletion_adjustment (register INTERVAL tree, register int from, registe
   else
     {
       /* How much can we delete from this interval?  */
-      int my_amount = ((tree->total_length
-                        - RIGHT_TOTAL_LENGTH (tree))
-                       - relative_position);
+      EMACS_INT my_amount = ((tree->total_length
+                               - RIGHT_TOTAL_LENGTH (tree))
+                              - relative_position);
 
       if (amount > my_amount)
         amount = my_amount;
@@ -1372,12 +1375,13 @@ interval_deletion_adjustment (register INTERVAL tree, register int from, registe
    buffer position, i.e. origin 1).  */
 
 static void
-adjust_intervals_for_deletion (struct buffer *buffer, int start, int length)
+adjust_intervals_for_deletion (struct buffer *buffer,
+                               EMACS_INT start, EMACS_INT length)
 {
-  register int left_to_delete = length;
+  register EMACS_INT left_to_delete = length;
   register INTERVAL tree = BUF_INTERVALS (buffer);
   Lisp_Object parent;
-  int offset;
+  EMACS_INT offset;
 
   GET_INTERVAL_OBJECT (parent, tree);
   offset = (BUFFERP (parent) ? BUF_BEG (XBUFFER (parent)) : 0);
@@ -1423,7 +1427,7 @@ adjust_intervals_for_deletion (struct buffer *buffer, int start, int length)
    of LENGTH.  */
 
 INLINE void
-offset_intervals (struct buffer *buffer, int start, int length)
+offset_intervals (struct buffer *buffer, EMACS_INT start, EMACS_INT length)
 {
   if (NULL_INTERVAL_P (BUF_INTERVALS (buffer)) || length == 0)
     return;
@@ -1446,7 +1450,7 @@ offset_intervals (struct buffer *buffer, int start, int length)
 INTERVAL
 merge_interval_right (register INTERVAL i)
 {
-  register int absorb = LENGTH (i);
+  register EMACS_INT absorb = LENGTH (i);
   register INTERVAL successor;
 
   /* Zero out this interval.  */
@@ -1502,7 +1506,7 @@ merge_interval_right (register INTERVAL i)
 INTERVAL
 merge_interval_left (register INTERVAL i)
 {
-  register int absorb = LENGTH (i);
+  register EMACS_INT absorb = LENGTH (i);
   register INTERVAL predecessor;
 
   /* Zero out this interval.  */
@@ -1598,7 +1602,7 @@ reproduce_tree_obj (INTERVAL source, Lisp_Object parent)
 static INTERVAL
 make_new_interval (intervals, start, length)
      INTERVAL intervals;
-     int start, length;
+     EMACS_INT start, length;
 {
   INTERVAL slot;
 
@@ -1670,11 +1674,13 @@ make_new_interval (intervals, start, length)
    text...  */
 
 void
-graft_intervals_into_buffer (INTERVAL source, int position, int length, struct buffer *buffer, int inherit)
+graft_intervals_into_buffer (INTERVAL source, EMACS_INT position,
+                             EMACS_INT length, struct buffer *buffer,
+                             int inherit)
 {
   register INTERVAL under, over, this, prev;
   register INTERVAL tree;
-  int over_used;
+  EMACS_INT over_used;
 
   tree = BUF_INTERVALS (buffer);
 
@@ -1920,8 +1926,9 @@ set_point (EMACS_INT charpos)
    Note that `stickiness' is determined by overlay marker insertion types,
    if the invisible property comes from an overlay.  */
 
-static int
-adjust_for_invis_intang (int pos, int test_offs, int adj, int test_intang)
+static EMACS_INT
+adjust_for_invis_intang (EMACS_INT pos, EMACS_INT test_offs, EMACS_INT adj,
+                         int test_intang)
 {
   Lisp_Object invis_propval, invis_overlay;
   Lisp_Object test_pos;
@@ -2183,7 +2190,7 @@ set_point_both (EMACS_INT charpos, EMACS_INT bytepos)
    segment that reaches all the way to point.  */
 
 void
-move_if_not_intangible (int position)
+move_if_not_intangible (EMACS_INT position)
 {
   Lisp_Object pos;
   Lisp_Object intangible_propval;
@@ -2246,7 +2253,8 @@ move_if_not_intangible (int position)
    nil means the current buffer. */
 
 int
-get_property_and_range (int pos, Lisp_Object prop, Lisp_Object *val, EMACS_INT *start, EMACS_INT *end, Lisp_Object object)
+get_property_and_range (EMACS_INT pos, Lisp_Object prop, Lisp_Object *val,
+                        EMACS_INT *start, EMACS_INT *end, Lisp_Object object)
 {
   INTERVAL i, prev, next;
 
@@ -2289,10 +2297,11 @@ get_property_and_range (int pos, Lisp_Object prop, Lisp_Object *val, EMACS_INT *
    POSITION must be in the accessible part of BUFFER.  */
 
 Lisp_Object
-get_local_map (register int position, register struct buffer *buffer, Lisp_Object type)
+get_local_map (register EMACS_INT position, register struct buffer *buffer,
+               Lisp_Object type)
 {
   Lisp_Object prop, lispy_position, lispy_buffer;
-  int old_begv, old_zv, old_begv_byte, old_zv_byte;
+  EMACS_INT old_begv, old_zv, old_begv_byte, old_zv_byte;
 
   /* Perhaps we should just change `position' to the limit.  */
   if (position > BUF_ZV (buffer) || position < BUF_BEGV (buffer))
@@ -2342,10 +2351,10 @@ get_local_map (register int position, register struct buffer *buffer, Lisp_Objec
    The new interval tree has no parent and has a starting-position of 0.  */
 
 INTERVAL
-copy_intervals (INTERVAL tree, int start, int length)
+copy_intervals (INTERVAL tree, EMACS_INT start, EMACS_INT length)
 {
   register INTERVAL i, new, t;
-  register int got, prevlen;
+  register EMACS_INT got, prevlen;
 
   if (NULL_INTERVAL_P (tree) || length <= 0)
     return NULL_INTERVAL;
@@ -2383,7 +2392,8 @@ copy_intervals (INTERVAL tree, int start, int length)
 /* Give STRING the properties of BUFFER from POSITION to LENGTH.  */
 
 INLINE void
-copy_intervals_to_string (Lisp_Object string, struct buffer *buffer, int position, int length)
+copy_intervals_to_string (Lisp_Object string, struct buffer *buffer,
+                          EMACS_INT position, EMACS_INT length)
 {
   INTERVAL interval_copy = copy_intervals (BUF_INTERVALS (buffer),
                                            position, length);
@@ -2401,8 +2411,8 @@ int
 compare_string_intervals (Lisp_Object s1, Lisp_Object s2)
 {
   INTERVAL i1, i2;
-  int pos = 0;
-  int end = SCHARS (s1);
+  EMACS_INT pos = 0;
+  EMACS_INT end = SCHARS (s1);
 
   i1 = find_interval (STRING_INTERVALS (s1), 0);
   i2 = find_interval (STRING_INTERVALS (s2), 0);
@@ -2410,9 +2420,9 @@ compare_string_intervals (Lisp_Object s1, Lisp_Object s2)
   while (pos < end)
     {
       /* Determine how far we can go before we reach the end of I1 or I2.  */
-      int len1 = (i1 != 0 ? INTERVAL_LAST_POS (i1) : end) - pos;
-      int len2 = (i2 != 0 ? INTERVAL_LAST_POS (i2) : end) - pos;
-      int distance = min (len1, len2);
+      EMACS_INT len1 = (i1 != 0 ? INTERVAL_LAST_POS (i1) : end) - pos;
+      EMACS_INT len2 = (i2 != 0 ? INTERVAL_LAST_POS (i2) : end) - pos;
+      EMACS_INT distance = min (len1, len2);
 
       /* If we ever find a mismatch between the strings,
          they differ.  */
@@ -2436,7 +2446,9 @@ compare_string_intervals (Lisp_Object s1, Lisp_Object s2)
    START_BYTE ... END_BYTE in bytes.  */
 
 static void
-set_intervals_multibyte_1 (INTERVAL i, int multi_flag, int start, int start_byte, int end, int end_byte)
+set_intervals_multibyte_1 (INTERVAL i, int multi_flag,
+                           EMACS_INT start, EMACS_INT start_byte,
+                           EMACS_INT end, EMACS_INT end_byte)
 {
   /* Fix the length of this interval.  */
   if (multi_flag)
@@ -2454,11 +2466,11 @@ set_intervals_multibyte_1 (INTERVAL i, int multi_flag, int start, int start_byte
   /* Recursively fix the length of the subintervals.  */
   if (i->left)
     {
-      int left_end, left_end_byte;
+      EMACS_INT left_end, left_end_byte;
 
       if (multi_flag)
         {
-          int temp;
+          EMACS_INT temp;
           left_end_byte = start_byte + LEFT_TOTAL_LENGTH (i);
           left_end = BYTE_TO_CHAR (left_end_byte);
 
@@ -2487,11 +2499,11 @@ set_intervals_multibyte_1 (INTERVAL i, int multi_flag, int start, int start_byte
     }
   if (i->right)
     {
-      int right_start_byte, right_start;
+      EMACS_INT right_start_byte, right_start;
 
       if (multi_flag)
         {
-          int temp;
+          EMACS_INT temp;
 
           right_start_byte = end_byte - RIGHT_TOTAL_LENGTH (i);
           right_start = BYTE_TO_CHAR (right_start_byte);
diff --git a/src/intervals.h b/src/intervals.h
index 612c1a99848..b39fbd6899d 100644
--- a/src/intervals.h
+++ b/src/intervals.h
@@ -250,36 +250,36 @@ extern INTERVAL make_interval (void);
 extern INTERVAL create_root_interval (Lisp_Object);
 extern void copy_properties (INTERVAL, INTERVAL);
 extern int intervals_equal (INTERVAL, INTERVAL);
-extern void traverse_intervals (INTERVAL, int,
+extern void traverse_intervals (INTERVAL, EMACS_INT,
                                 void (*) (INTERVAL, Lisp_Object),
                                 Lisp_Object);
 extern void traverse_intervals_noorder (INTERVAL,
                                         void (*) (INTERVAL, Lisp_Object),
                                         Lisp_Object);
-extern INTERVAL split_interval_right (INTERVAL, int);
-extern INTERVAL split_interval_left (INTERVAL, int);
-extern INTERVAL find_interval (INTERVAL, int);
+extern INTERVAL split_interval_right (INTERVAL, EMACS_INT);
+extern INTERVAL split_interval_left (INTERVAL, EMACS_INT);
+extern INTERVAL find_interval (INTERVAL, EMACS_INT);
 extern INTERVAL next_interval (INTERVAL);
 extern INTERVAL previous_interval (INTERVAL);
 extern INTERVAL merge_interval_left (INTERVAL);
 extern INTERVAL merge_interval_right (INTERVAL);
 extern void delete_interval (INTERVAL);
-extern INLINE void offset_intervals (struct buffer *, int, int);
-extern void graft_intervals_into_buffer (INTERVAL, int, int,
+extern INLINE void offset_intervals (struct buffer *, EMACS_INT, EMACS_INT);
+extern void graft_intervals_into_buffer (INTERVAL, EMACS_INT, EMACS_INT,
                                          struct buffer *, int);
 extern void verify_interval_modification (struct buffer *, int, int);
 extern INTERVAL balance_intervals (INTERVAL);
 extern INLINE void copy_intervals_to_string (Lisp_Object, struct buffer *,
-                                             int, int);
-extern INTERVAL copy_intervals (INTERVAL, int, int);
+                                             EMACS_INT, EMACS_INT);
+extern INTERVAL copy_intervals (INTERVAL, EMACS_INT, EMACS_INT);
 extern int compare_string_intervals (Lisp_Object, Lisp_Object);
 extern Lisp_Object textget (Lisp_Object, Lisp_Object);
 extern Lisp_Object lookup_char_property (Lisp_Object, Lisp_Object, int);
-extern void move_if_not_intangible (int);
-extern int get_property_and_range (int, Lisp_Object, Lisp_Object *,
+extern void move_if_not_intangible (EMACS_INT);
+extern int get_property_and_range (EMACS_INT, Lisp_Object, Lisp_Object *,
                                    EMACS_INT *, EMACS_INT *, Lisp_Object);
-extern Lisp_Object get_local_map (int, struct buffer *, Lisp_Object);
-extern INTERVAL update_interval (INTERVAL, int);
+extern Lisp_Object get_local_map (EMACS_INT, struct buffer *, Lisp_Object);
+extern INTERVAL update_interval (INTERVAL, EMACS_INT);
 extern void set_intervals_multibyte (int);
 extern INTERVAL validate_interval_range (Lisp_Object, Lisp_Object *,
                                          Lisp_Object *, int);
diff --git a/src/keyboard.c b/src/keyboard.c
index 95fc275ffe8..b77689bde06 100644
--- a/src/keyboard.c
+++ b/src/keyboard.c
@@ -304,7 +304,7 @@ EMACS_INT extra_keyboard_modifiers;
 Lisp_Object meta_prefix_char;
 
 /* Last size recorded for a current buffer which is not a minibuffer.  */
-static int last_non_minibuf_size;
+static EMACS_INT last_non_minibuf_size;
 
 /* Number of idle seconds before an auto-save and garbage collection.  */
 static Lisp_Object Vauto_save_timeout;
@@ -337,7 +337,7 @@ Lisp_Object real_this_command;
 Lisp_Object Vthis_original_command;
 
 /* The value of point when the last command was started.  */
-int last_point_position;
+EMACS_INT last_point_position;
 
 /* The buffer that was current when the last command was started.  */
 Lisp_Object last_point_position_buffer;
@@ -621,7 +621,7 @@ static Lisp_Object make_lispy_movement (struct frame *, Lisp_Object,
                                         Lisp_Object, Lisp_Object,
                                         unsigned long);
 #endif
-static Lisp_Object modify_event_symbol (int, unsigned, Lisp_Object,
+static Lisp_Object modify_event_symbol (EMACS_INT, unsigned, Lisp_Object,
                                         Lisp_Object, const char **,
                                         Lisp_Object *, unsigned);
 static Lisp_Object make_lispy_switch_frame (Lisp_Object);
@@ -867,7 +867,7 @@ echo_length (void)
    switches frames while entering a key sequence.  */
 
 static void
-echo_truncate (int nchars)
+echo_truncate (EMACS_INT nchars)
 {
   if (STRINGP (current_kboard->echo_string))
     current_kboard->echo_string
@@ -1480,7 +1480,7 @@ some_mouse_moved (void)
 static int read_key_sequence (Lisp_Object *, int, Lisp_Object,
                               int, int, int);
 void safe_run_hooks (Lisp_Object);
-static void adjust_point_for_property (int, int);
+static void adjust_point_for_property (EMACS_INT, int);
 
 /* Cancel hourglass from protect_unwind.
    ARG is not used.  */
@@ -1811,8 +1811,9 @@ command_loop_1 (void)
                          && !NILP (Vtransient_mark_mode)))
                   && !EQ (Vthis_command, Qhandle_switch_frame))
                 {
-                  int beg = XINT (Fmarker_position (current_buffer->mark));
-                  int end = XINT (make_number (PT));
+                  EMACS_INT beg =
+                    XINT (Fmarker_position (current_buffer->mark));
+                  EMACS_INT end = PT;
                   if (beg < end)
                     call2 (Qx_set_selection, QPRIMARY,
                            make_buffer_string (beg, end, 0));
@@ -1869,7 +1870,7 @@ command_loop_1 (void)
    LAST_PT is the last position of point.  */
 
 static void
-adjust_point_for_property (int last_pt, int modified)
+adjust_point_for_property (EMACS_INT last_pt, int modified)
 {
   EMACS_INT beg, end;
   Lisp_Object val, overlay, tmp;
@@ -1878,7 +1879,7 @@ adjust_point_for_property (int last_pt, int modified)
      user can keep inserting another character at point or keep
      deleting characters around point.  */
   int check_composition = ! modified, check_display = 1, check_invisible = 1;
-  int orig_pt = PT;
+  EMACS_INT orig_pt = PT;
 
   /* FIXME: cycling is probably not necessary because these properties
      can't be usefully combined anyway.  */
@@ -2781,7 +2782,8 @@ read_char (int commandflag, int nmaps, Lisp_Object *maps, Lisp_Object prev_event
 
   if (INTERACTIVE && NILP (c))
     {
-      int delay_level, buffer_size;
+      int delay_level;
+      EMACS_INT buffer_size;
 
       /* Slow down auto saves logarithmically in size of current buffer,
          and garbage collect while we're at it.  */
@@ -3520,12 +3522,6 @@ restore_getcjmp (jmp_buf temp)
 static int
 readable_events (int flags)
 {
-#ifdef HAVE_DBUS
-  /* Check whether a D-Bus message has arrived.  */
-  if (xd_pending_messages () > 0)
-    return 1;
-#endif /* HAVE_DBUS */
-
   if (flags & READABLE_EVENTS_DO_TIMERS_NOW)
     timer_check (1);
 
@@ -3795,22 +3791,20 @@ kbd_buffer_unget_event (register struct input_event *event)
 }
 
 
-/* Generate HELP_EVENT input_events in BUFP which has room for
-   SIZE events.  If there's not enough room in BUFP, ignore this
-   event.
+/* Generate a HELP_EVENT input_event and store it in the keyboard
+   buffer.
 
    HELP is the help form.
 
-   FRAME is the frame on which the help is generated.  OBJECT is the
-   Lisp object where the help was found (a buffer, a string, an
-   overlay, or nil if neither from a string nor from a buffer.  POS is
-   the position within OBJECT where the help was found.
-
-   Value is the number of input_events generated.  */
+   FRAME and WINDOW are the frame and window where the help is
+   generated.  OBJECT is the Lisp object where the help was found (a
+   buffer, a string, an overlay, or nil if neither from a string nor
+   from a buffer).  POS is the position within OBJECT where the help
+   was found.  */
 
 void
 gen_help_event (Lisp_Object help, Lisp_Object frame, Lisp_Object window,
-                Lisp_Object object, int pos)
+                Lisp_Object object, EMACS_INT pos)
 {
   struct input_event event;
 
@@ -5280,7 +5274,8 @@ make_lispy_position (struct frame *f, Lisp_Object *x, Lisp_Object *y,
       /* It's a click in window window at frame coordinates (x,y)  */
       struct window *w = XWINDOW (window);
       Lisp_Object string_info = Qnil;
-      int textpos = -1, rx = -1, ry = -1;
+      EMACS_INT textpos = -1;
+      int rx = -1, ry = -1;
       int dx = -1, dy = -1;
       int width = -1, height = -1;
       Lisp_Object object = Qnil;
@@ -5299,7 +5294,7 @@ make_lispy_position (struct frame *f, Lisp_Object *x, Lisp_Object *y,
           /* Mode line or header line.  Look for a string under
              the mouse that may have a `local-map' property.  */
           Lisp_Object string;
-          int charpos;
+          EMACS_INT charpos;
 
           posn = part == ON_MODE_LINE ? Qmode_line : Qheader_line;
           rx = wx, ry = wy;
@@ -5323,7 +5318,7 @@ make_lispy_position (struct frame *f, Lisp_Object *x, Lisp_Object *y,
       else if (part == ON_LEFT_MARGIN || part == ON_RIGHT_MARGIN)
         {
           Lisp_Object string;
-          int charpos;
+          EMACS_INT charpos;
 
           posn = (part == ON_LEFT_MARGIN) ? Qleft_margin : Qright_margin;
           rx = wx, ry = wy;
@@ -5458,7 +5453,7 @@ make_lispy_event (struct input_event *event)
     case MULTIBYTE_CHAR_KEYSTROKE_EVENT:
       {
         Lisp_Object lispy_c;
-        int c = event->code;
+        EMACS_INT c = event->code;
         if (event->kind == ASCII_KEYSTROKE_EVENT)
           {
             c &= 0377;
@@ -6582,7 +6577,7 @@ reorder_modifiers (Lisp_Object symbol)
    in the symbol's name.  */
 
 static Lisp_Object
-modify_event_symbol (int symbol_num, unsigned int modifiers, Lisp_Object symbol_kind,
+modify_event_symbol (EMACS_INT symbol_num, unsigned int modifiers, Lisp_Object symbol_kind,
                      Lisp_Object name_alist_or_stem, const char **name_table,
                      Lisp_Object *symbol_table, unsigned int table_size)
 {
@@ -6646,7 +6641,7 @@ modify_event_symbol (int symbol_num, unsigned int modifiers, Lisp_Object symbol_
       if (NILP (value))
         {
           char buf[20];
-          sprintf (buf, "key-%d", symbol_num);
+          sprintf (buf, "key-%ld", (long)symbol_num);
           value = intern (buf);
         }
 
@@ -6876,11 +6871,6 @@ get_input_pending (int *addr, int flags)
 void
 gobble_input (int expected)
 {
-#ifdef HAVE_DBUS
-  /* Read D-Bus messages.  */
-  xd_read_queued_messages ();
-#endif /* HAVE_DBUS */
-
 #ifdef SIGIO
   if (interrupt_input)
     {
@@ -8305,7 +8295,7 @@ parse_tool_bar_item (Lisp_Object key, Lisp_Object item)
         {
           const char *bad_label = "!!?GARBLED ITEM?!!";
           /* `:label LABEL-STRING'.  */
-          PROP (TOOL_BAR_ITEM_HELP) = STRINGP (value)
+          PROP (TOOL_BAR_ITEM_LABEL) = STRINGP (value)
             ? value
             : make_string (bad_label, strlen (bad_label));
           have_label = 1;
@@ -10352,7 +10342,7 @@ give to the command you invoke, if it asks for an argument.  */)
   (Lisp_Object prefixarg)
 {
   Lisp_Object function;
-  int saved_last_point_position;
+  EMACS_INT saved_last_point_position;
   Lisp_Object saved_keys, saved_last_point_position_buffer;
   Lisp_Object bindings, value;
   struct gcpro gcpro1, gcpro2, gcpro3;
@@ -10820,7 +10810,7 @@ stuff_buffered_input (Lisp_Object stuffstring)
 
   if (STRINGP (stuffstring))
     {
-      register int count;
+      register EMACS_INT count;
 
       p = SDATA (stuffstring);
       count = SBYTES (stuffstring);
diff --git a/src/keyboard.h b/src/keyboard.h
index a3bb46f4454..9fd3b48eba9 100644
--- a/src/keyboard.h
+++ b/src/keyboard.h
@@ -524,7 +524,7 @@ extern void poll_for_input_1 (void);
 extern void show_help_echo (Lisp_Object, Lisp_Object, Lisp_Object,
                             Lisp_Object, int);
 extern void gen_help_event (Lisp_Object, Lisp_Object, Lisp_Object,
-                            Lisp_Object, int);
+                            Lisp_Object, EMACS_INT);
 extern void kbd_buffer_store_help_event (Lisp_Object, Lisp_Object);
 extern Lisp_Object menu_item_eval_property (Lisp_Object);
 extern int  kbd_buffer_events_waiting (int);
diff --git a/src/lisp.h b/src/lisp.h
index d44c05c661f..d942e792957 100644
--- a/src/lisp.h
+++ b/src/lisp.h
@@ -742,7 +742,7 @@ struct Lisp_Cons
 #ifdef GC_CHECK_STRING_BYTES
 
 struct Lisp_String;
-extern int string_bytes (struct Lisp_String *);
+extern EMACS_INT string_bytes (struct Lisp_String *);
 #define STRING_BYTES(S) string_bytes ((S))
 
 #else /* not GC_CHECK_STRING_BYTES */
@@ -1903,11 +1903,11 @@ struct specbinding
 
 extern struct specbinding *specpdl;
 extern struct specbinding *specpdl_ptr;
-extern int specpdl_size;
+extern EMACS_INT specpdl_size;
 
 extern EMACS_INT max_specpdl_size;
 
-#define SPECPDL_INDEX() (specpdl_ptr - specpdl)
+#define SPECPDL_INDEX() ((int) (specpdl_ptr - specpdl))
 
 /* Everything needed to describe an active condition case.  */
 struct handler
@@ -2521,7 +2521,8 @@ EXFUN (Fstring_as_unibyte, 1);
 EXFUN (Fstring_to_multibyte, 1);
 EXFUN (Fstring_to_unibyte, 1);
 EXFUN (Fsubstring, 3);
-extern Lisp_Object substring_both (Lisp_Object, int, int, int, int);
+extern Lisp_Object substring_both (Lisp_Object, EMACS_INT, EMACS_INT,
+                                   EMACS_INT, EMACS_INT);
 EXFUN (Fnth, 2);
 EXFUN (Fnthcdr, 2);
 EXFUN (Fmemq, 2);
@@ -2682,24 +2683,24 @@ extern Lisp_Object restore_message_unwind (Lisp_Object);
 extern void pop_message (void);
 extern void restore_message (void);
 extern Lisp_Object current_message (void);
-extern void set_message (const char *s, Lisp_Object, int, int);
+extern void set_message (const char *s, Lisp_Object, EMACS_INT, int);
 extern void clear_message (int, int);
 extern void message (const char *, ...);
 extern void message_nolog (const char *, ...);
 extern void message1 (const char *);
 extern void message1_nolog (const char *);
-extern void message2 (const char *, int, int);
-extern void message2_nolog (const char *, int, int);
-extern void message3 (Lisp_Object, int, int);
-extern void message3_nolog (Lisp_Object, int, int);
-extern void message_dolog (const char *, int, int, int);
+extern void message2 (const char *, EMACS_INT, int);
+extern void message2_nolog (const char *, EMACS_INT, int);
+extern void message3 (Lisp_Object, EMACS_INT, int);
+extern void message3_nolog (Lisp_Object, EMACS_INT, int);
+extern void message_dolog (const char *, EMACS_INT, int, int);
 extern void message_with_string (const char *, Lisp_Object, int);
 extern void message_log_maybe_newline (void);
 extern void update_echo_area (void);
-extern void truncate_echo_area (int);
+extern void truncate_echo_area (EMACS_INT);
 extern void redisplay (void);
 extern int check_point_in_composition
-        (struct buffer *, int, struct buffer *, int);
+        (struct buffer *, EMACS_INT, struct buffer *, EMACS_INT);
 extern void redisplay_preserve_echo_area (int);
 extern void prepare_menu_bars (void);
 
@@ -2707,7 +2708,7 @@ void set_frame_cursor_types (struct frame *, Lisp_Object);
 extern void syms_of_xdisp (void);
 extern void init_xdisp (void);
 extern Lisp_Object safe_eval (Lisp_Object);
-extern int pos_visible_p (struct window *, int, int *,
+extern int pos_visible_p (struct window *, EMACS_INT, int *,
                           int *, int *, int *, int *, int *);
 
 /* Defined in xsettings.c */
@@ -2718,7 +2719,7 @@ extern void memory_warnings (POINTER_TYPE *, void (*warnfun) (const char *));
 
 /* Defined in alloc.c */
 extern void check_pure_size (void);
-extern void allocate_string_data (struct Lisp_String *, int, int);
+extern void allocate_string_data (struct Lisp_String *, EMACS_INT, EMACS_INT);
 extern void reset_malloc_hooks (void);
 extern void uninterrupt_malloc (void);
 extern void malloc_warning (const char *);
@@ -2745,16 +2746,17 @@ EXFUN (Fmake_symbol, 1);
 EXFUN (Fmake_marker, 0);
 EXFUN (Fmake_string, 2);
 extern Lisp_Object build_string (const char *);
-extern Lisp_Object make_string (const char *, int);
-extern Lisp_Object make_unibyte_string (const char *, int);
-extern Lisp_Object make_multibyte_string (const char *, int, int);
+extern Lisp_Object make_string (const char *, EMACS_INT);
+extern Lisp_Object make_unibyte_string (const char *, EMACS_INT);
+extern Lisp_Object make_multibyte_string (const char *, EMACS_INT, EMACS_INT);
 extern Lisp_Object make_event_array (int, Lisp_Object *);
-extern Lisp_Object make_uninit_string (int);
-extern Lisp_Object make_uninit_multibyte_string (int, int);
-extern Lisp_Object make_string_from_bytes (const char *, int, int);
-extern Lisp_Object make_specified_string (const char *, int, int, int);
+extern Lisp_Object make_uninit_string (EMACS_INT);
+extern Lisp_Object make_uninit_multibyte_string (EMACS_INT, EMACS_INT);
+extern Lisp_Object make_string_from_bytes (const char *, EMACS_INT, EMACS_INT);
+extern Lisp_Object make_specified_string (const char *,
+                                          EMACS_INT, EMACS_INT, int);
 EXFUN (Fpurecopy, 1);
-extern Lisp_Object make_pure_string (const char *, int, int, int);
+extern Lisp_Object make_pure_string (const char *, EMACS_INT, EMACS_INT, int);
 extern Lisp_Object make_pure_c_string (const char *data);
 extern Lisp_Object pure_cons (Lisp_Object, Lisp_Object);
 extern Lisp_Object make_pure_vector (EMACS_INT);
@@ -2843,7 +2845,7 @@ extern void float_to_string (unsigned char *, double);
 extern void syms_of_print (void);
 
 /* Defined in doprnt.c */
-extern int doprnt (char *, int, const char *, const char *, va_list);
+extern EMACS_INT doprnt (char *, int, const char *, const char *, va_list);
 
 /* Defined in lread.c */
 extern Lisp_Object Vafter_load_alist;
@@ -2866,7 +2868,7 @@ extern Lisp_Object check_obarray (Lisp_Object);
 extern Lisp_Object intern (const char *);
 extern Lisp_Object intern_c_string (const char *);
 extern Lisp_Object make_symbol (const char *);
-extern Lisp_Object oblookup (Lisp_Object, const char *, int, int);
+extern Lisp_Object oblookup (Lisp_Object, const char *, EMACS_INT, EMACS_INT);
 #define LOADHIST_ATTACH(x) \
   do {                                                                  \
     if (initialized) Vcurrent_load_list = Fcons (x, Vcurrent_load_list); \
@@ -3018,9 +3020,10 @@ EXFUN (Fwiden, 0);
 EXFUN (Fuser_login_name, 1);
 EXFUN (Fsystem_name, 0);
 EXFUN (Fcurrent_time, 0);
-extern int clip_to_bounds (int, int, int);
-extern Lisp_Object make_buffer_string (int, int, int);
-extern Lisp_Object make_buffer_string_both (int, int, int, int, int);
+extern EMACS_INT clip_to_bounds (EMACS_INT, EMACS_INT, EMACS_INT);
+extern Lisp_Object make_buffer_string (EMACS_INT, EMACS_INT, int);
+extern Lisp_Object make_buffer_string_both (EMACS_INT, EMACS_INT, EMACS_INT,
+                                            EMACS_INT, int);
 extern void init_editfns (void);
 extern void syms_of_editfns (void);
 EXFUN (Fconstrain_to_field, 5);
@@ -3040,10 +3043,10 @@ EXFUN (Foverlay_end, 1);
 EXFUN (Foverlay_buffer, 1);
 extern void adjust_overlays_for_insert (EMACS_INT, EMACS_INT);
 extern void adjust_overlays_for_delete (EMACS_INT, EMACS_INT);
-extern void fix_start_end_in_overlays (int, int);
+extern void fix_start_end_in_overlays (EMACS_INT, EMACS_INT);
 extern void report_overlay_modification (Lisp_Object, Lisp_Object, int,
                                          Lisp_Object, Lisp_Object, Lisp_Object);
-extern int overlay_touches_p (int);
+extern int overlay_touches_p (EMACS_INT);
 extern Lisp_Object Vbuffer_alist, Vinhibit_read_only;
 EXFUN (Fbuffer_list, 1);
 EXFUN (Fget_buffer, 1);
@@ -3080,17 +3083,17 @@ EXFUN (Fmarker_position, 1);
 EXFUN (Fmarker_buffer, 1);
 EXFUN (Fcopy_marker, 2);
 EXFUN (Fset_marker, 3);
-extern int marker_position (Lisp_Object);
-extern int marker_byte_position (Lisp_Object);
+extern EMACS_INT marker_position (Lisp_Object);
+extern EMACS_INT marker_byte_position (Lisp_Object);
 extern void clear_charpos_cache (struct buffer *);
-extern int charpos_to_bytepos (int);
-extern int buf_charpos_to_bytepos (struct buffer *, int);
-extern int buf_bytepos_to_charpos (struct buffer *, int);
+extern EMACS_INT charpos_to_bytepos (EMACS_INT);
+extern EMACS_INT buf_charpos_to_bytepos (struct buffer *, EMACS_INT);
+extern EMACS_INT buf_bytepos_to_charpos (struct buffer *, EMACS_INT);
 extern void unchain_marker (struct Lisp_Marker *marker);
 extern Lisp_Object set_marker_restricted (Lisp_Object, Lisp_Object, Lisp_Object);
-extern Lisp_Object set_marker_both (Lisp_Object, Lisp_Object, int, int);
+extern Lisp_Object set_marker_both (Lisp_Object, Lisp_Object, EMACS_INT, EMACS_INT);
 extern Lisp_Object set_marker_restricted_both (Lisp_Object, Lisp_Object,
-                                               int, int);
+                                               EMACS_INT, EMACS_INT);
 extern void syms_of_marker (void);
 
 /* Defined in fileio.c */
@@ -3148,12 +3151,13 @@ extern int fast_c_string_match_ignore_case (Lisp_Object, const char *);
 extern int fast_string_match_ignore_case (Lisp_Object, Lisp_Object);
 extern EMACS_INT fast_looking_at (Lisp_Object, EMACS_INT, EMACS_INT,
                                   EMACS_INT, EMACS_INT, Lisp_Object);
-extern int scan_buffer (int, EMACS_INT, EMACS_INT, int, int *, int);
-extern int scan_newline (EMACS_INT, EMACS_INT, EMACS_INT, EMACS_INT,
-                         int, int);
-extern int find_next_newline (EMACS_INT, int);
-extern int find_next_newline_no_quit (EMACS_INT, int);
-extern int find_before_next_newline (EMACS_INT, EMACS_INT, int);
+extern EMACS_INT scan_buffer (int, EMACS_INT, EMACS_INT, EMACS_INT,
+                              int *, int);
+extern EMACS_INT scan_newline (EMACS_INT, EMACS_INT, EMACS_INT, EMACS_INT,
+                               EMACS_INT, int);
+extern EMACS_INT find_next_newline (EMACS_INT, int);
+extern EMACS_INT find_next_newline_no_quit (EMACS_INT, EMACS_INT);
+extern EMACS_INT find_before_next_newline (EMACS_INT, EMACS_INT, EMACS_INT);
 extern void syms_of_search (void);
 extern void clear_regexp_cache (void);
 
@@ -3265,7 +3269,7 @@ EXFUN (Fcurrent_column, 0);
 EXFUN (Fmove_to_column, 2);
 extern double current_column (void);
 extern void invalidate_current_column (void);
-extern int indented_beyond_p (int, int, double);
+extern int indented_beyond_p (EMACS_INT, EMACS_INT, double);
 extern void syms_of_indent (void);
 
 /* Defined in frame.c */
@@ -3422,12 +3426,13 @@ extern Lisp_Object Qapply;
 extern Lisp_Object Qinhibit_read_only;
 EXFUN (Fundo_boundary, 0);
 extern void truncate_undo_list (struct buffer *);
-extern void record_marker_adjustment (Lisp_Object, int);
-extern void record_insert (int, int);
-extern void record_delete (int, Lisp_Object);
+extern void record_marker_adjustment (Lisp_Object, EMACS_INT);
+extern void record_insert (EMACS_INT, EMACS_INT);
+extern void record_delete (EMACS_INT, Lisp_Object);
 extern void record_first_change (void);
-extern void record_change (int, int);
-extern void record_property_change (int, int, Lisp_Object, Lisp_Object,
+extern void record_change (EMACS_INT, EMACS_INT);
+extern void record_property_change (EMACS_INT, EMACS_INT,
+                                    Lisp_Object, Lisp_Object,
                                     Lisp_Object);
 extern void syms_of_undo (void);
 extern Lisp_Object Vundo_outer_limit;
@@ -3618,8 +3623,6 @@ extern int have_menus_p (void);
 
 #ifdef HAVE_DBUS
 /* Defined in dbusbind.c */
-int xd_pending_messages (void);
-void xd_read_queued_messages (void);
 void syms_of_dbusbind (void);
 #endif
 
@@ -3752,7 +3755,7 @@ extern void init_system_name (void);
 extern Lisp_Object safe_alloca_unwind (Lisp_Object);
 
 #define USE_SAFE_ALLOCA                 \
-  int sa_count = SPECPDL_INDEX (), sa_must_free = 0
+  int sa_count = (int) SPECPDL_INDEX (), sa_must_free = 0
 
 /* SAFE_ALLOCA allocates a simple buffer.  */
 
diff --git a/src/lread.c b/src/lread.c
index 1a6d7e832f6..64633a6e442 100644
--- a/src/lread.c
+++ b/src/lread.c
@@ -169,13 +169,13 @@ static FILE *instream;
 static int read_pure;
 
 /* For use within read-from-string (this reader is non-reentrant!!)  */
-static int read_from_string_index;
-static int read_from_string_index_byte;
-static int read_from_string_limit;
+static EMACS_INT read_from_string_index;
+static EMACS_INT read_from_string_index_byte;
+static EMACS_INT read_from_string_limit;
 
 /* Number of characters read in the current call to Fread or
    Fread_from_string. */
-static int readchar_count;
+static EMACS_INT readchar_count;
 
 /* This contains the last string skipped with #@.  */
 static char *saved_doc_string;
@@ -282,7 +282,7 @@ readchar (Lisp_Object readcharfun, int *multibyte)
     {
       register struct buffer *inbuffer = XBUFFER (readcharfun);
 
-      int pt_byte = BUF_PT_BYTE (inbuffer);
+      EMACS_INT pt_byte = BUF_PT_BYTE (inbuffer);
 
       if (pt_byte >= BUF_ZV_BYTE (inbuffer))
         return -1;
@@ -311,7 +311,7 @@ readchar (Lisp_Object readcharfun, int *multibyte)
     {
       register struct buffer *inbuffer = XMARKER (readcharfun)->buffer;
 
-      int bytepos = marker_byte_position (readcharfun);
+      EMACS_INT bytepos = marker_byte_position (readcharfun);
 
       if (bytepos >= BUF_ZV_BYTE (inbuffer))
         return -1;
@@ -445,7 +445,7 @@ unreadchar (Lisp_Object readcharfun, int c)
   else if (BUFFERP (readcharfun))
     {
       struct buffer *b = XBUFFER (readcharfun);
-      int bytepos = BUF_PT_BYTE (b);
+      EMACS_INT bytepos = BUF_PT_BYTE (b);
 
       BUF_PT (b)--;
       if (! NILP (b->enable_multibyte_characters))
@@ -458,7 +458,7 @@ unreadchar (Lisp_Object readcharfun, int c)
   else if (MARKERP (readcharfun))
     {
       struct buffer *b = XMARKER (readcharfun)->buffer;
-      int bytepos = XMARKER (readcharfun)->bytepos;
+      EMACS_INT bytepos = XMARKER (readcharfun)->bytepos;
 
       XMARKER (readcharfun)->charpos--;
       if (! NILP (b->enable_multibyte_characters))
@@ -2035,7 +2035,7 @@ read_internal_start (Lisp_Object stream, Lisp_Object start, Lisp_Object end)
   if (STRINGP (stream)
       || ((CONSP (stream) && STRINGP (XCAR (stream)))))
     {
-      int startval, endval;
+      EMACS_INT startval, endval;
       Lisp_Object string;
 
       if (STRINGP (stream))
@@ -3896,7 +3896,7 @@ OBARRAY defaults to the value of the variable `obarray'.  */)
    Also store the bucket number in oblookup_last_bucket_number.  */
 
 Lisp_Object
-oblookup (Lisp_Object obarray, register const char *ptr, int size, int size_byte)
+oblookup (Lisp_Object obarray, register const char *ptr, EMACS_INT size, EMACS_INT size_byte)
 {
   int hash;
   int obsize;
diff --git a/src/makefile.w32-in b/src/makefile.w32-in
index 8d99d6cedfe..752a3c211b3 100644
--- a/src/makefile.w32-in
+++ b/src/makefile.w32-in
@@ -1344,7 +1344,6 @@ $(BLD)/sysdep.$(O) : \
         $(EMACS_ROOT)/nt/inc/pwd.h \
         $(EMACS_ROOT)/nt/inc/unistd.h \
         $(EMACS_ROOT)/nt/inc/sys/file.h \
-        $(EMACS_ROOT)/nt/inc/sys/ioctl.h \
         $(EMACS_ROOT)/nt/inc/sys/socket.h \
         $(EMACS_ROOT)/nt/inc/sys/time.h \
         $(SRC)/lisp.h \
diff --git a/src/marker.c b/src/marker.c
index b5ea80562df..3f8b78e81a8 100644
--- a/src/marker.c
+++ b/src/marker.c
@@ -27,12 +27,12 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 /* Record one cached position found recently by
    buf_charpos_to_bytepos or buf_bytepos_to_charpos.  */
 
-static int cached_charpos;
-static int cached_bytepos;
+static EMACS_INT cached_charpos;
+static EMACS_INT cached_bytepos;
 static struct buffer *cached_buffer;
 static int cached_modiff;
 
-static void byte_char_debug_check (struct buffer *, int, int);
+static void byte_char_debug_check (struct buffer *, EMACS_INT, EMACS_INT);
 
 /* Nonzero means enable debugging checks on byte/char correspondences.  */
 
@@ -60,12 +60,12 @@ clear_charpos_cache (struct buffer *b)
 
 #define CONSIDER(CHARPOS, BYTEPOS)                                      \
 {                                                                       \
-  int this_charpos = (CHARPOS);                                         \
+  EMACS_INT this_charpos = (CHARPOS);                                   \
   int changed = 0;                                                      \
                                                                         \
   if (this_charpos == charpos)                                          \
     {                                                                   \
-      int value = (BYTEPOS);                                            \
+      EMACS_INT value = (BYTEPOS);                                      \
       if (byte_debug_flag)                                              \
         byte_char_debug_check (b, charpos, value);                      \
       return value;                                                     \
@@ -90,7 +90,7 @@ clear_charpos_cache (struct buffer *b)
     {                                                                   \
       if (best_above - best_below == best_above_byte - best_below_byte) \
         {                                                               \
-          int value = best_below_byte + (charpos - best_below);         \
+          EMACS_INT value = best_below_byte + (charpos - best_below);   \
           if (byte_debug_flag)                                          \
             byte_char_debug_check (b, charpos, value);                  \
           return value;                                                 \
@@ -99,9 +99,9 @@ clear_charpos_cache (struct buffer *b)
 }
 
 static void
-byte_char_debug_check (struct buffer *b, int charpos, int bytepos)
+byte_char_debug_check (struct buffer *b, EMACS_INT charpos, EMACS_INT bytepos)
 {
-  int nchars = 0;
+  EMACS_INT nchars = 0;
 
   if (bytepos > BUF_GPT_BYTE (b))
     {
@@ -118,18 +118,18 @@ byte_char_debug_check (struct buffer *b, int charpos, int bytepos)
     abort ();
 }
 
-int
-charpos_to_bytepos (int charpos)
+EMACS_INT
+charpos_to_bytepos (EMACS_INT charpos)
 {
   return buf_charpos_to_bytepos (current_buffer, charpos);
 }
 
-int
-buf_charpos_to_bytepos (struct buffer *b, int charpos)
+EMACS_INT
+buf_charpos_to_bytepos (struct buffer *b, EMACS_INT charpos)
 {
   struct Lisp_Marker *tail;
-  int best_above, best_above_byte;
-  int best_below, best_below_byte;
+  EMACS_INT best_above, best_above_byte;
+  EMACS_INT best_below, best_below_byte;
 
   if (charpos < BUF_BEG (b) || charpos > BUF_Z (b))
     abort ();
@@ -247,11 +247,11 @@ buf_charpos_to_bytepos (struct buffer *b, int charpos)
 /* Used for debugging: recompute the bytepos corresponding to CHARPOS
    in the simplest, most reliable way.  */
 
-int
-verify_bytepos (int charpos)
+EMACS_INT
+verify_bytepos (EMACS_INT charpos)
 {
-  int below = 1;
-  int below_byte = 1;
+  EMACS_INT below = 1;
+  EMACS_INT below_byte = 1;
 
   while (below != charpos)
     {
@@ -269,12 +269,12 @@ verify_bytepos (int charpos)
 
 #define CONSIDER(BYTEPOS, CHARPOS)                                      \
 {                                                                       \
-  int this_bytepos = (BYTEPOS);                                         \
+  EMACS_INT this_bytepos = (BYTEPOS);                                   \
   int changed = 0;                                                      \
                                                                         \
   if (this_bytepos == bytepos)                                          \
     {                                                                   \
-      int value = (CHARPOS);                                            \
+      EMACS_INT value = (CHARPOS);                                      \
       if (byte_debug_flag)                                              \
         byte_char_debug_check (b, value, bytepos);                      \
       return value;                                                     \
@@ -299,7 +299,7 @@ verify_bytepos (int charpos)
     {                                                                   \
       if (best_above - best_below == best_above_byte - best_below_byte) \
         {                                                               \
-          int value = best_below + (bytepos - best_below_byte);         \
+          EMACS_INT value = best_below + (bytepos - best_below_byte);   \
           if (byte_debug_flag)                                          \
             byte_char_debug_check (b, value, bytepos);                  \
           return value;                                                 \
@@ -307,18 +307,18 @@ verify_bytepos (int charpos)
     }                                                                   \
 }
 
-int
-bytepos_to_charpos (int bytepos)
+EMACS_INT
+bytepos_to_charpos (EMACS_INT bytepos)
 {
   return buf_bytepos_to_charpos (current_buffer, bytepos);
 }
 
-int
-buf_bytepos_to_charpos (struct buffer *b, int bytepos)
+EMACS_INT
+buf_bytepos_to_charpos (struct buffer *b, EMACS_INT bytepos)
 {
   struct Lisp_Marker *tail;
-  int best_above, best_above_byte;
-  int best_below, best_below_byte;
+  EMACS_INT best_above, best_above_byte;
+  EMACS_INT best_below, best_below_byte;
 
   if (bytepos < BUF_BEG_BYTE (b) || bytepos > BUF_Z_BYTE (b))
     abort ();
@@ -470,7 +470,7 @@ Then it no longer slows down editing in any buffer.
 Returns MARKER.  */)
   (Lisp_Object marker, Lisp_Object position, Lisp_Object buffer)
 {
-  register int charno, bytepos;
+  register EMACS_INT charno, bytepos;
   register struct buffer *b;
   register struct Lisp_Marker *m;
 
@@ -545,7 +545,7 @@ Returns MARKER.  */)
 Lisp_Object
 set_marker_restricted (Lisp_Object marker, Lisp_Object pos, Lisp_Object buffer)
 {
-  register int charno, bytepos;
+  register EMACS_INT charno, bytepos;
   register struct buffer *b;
   register struct Lisp_Marker *m;
 
@@ -618,7 +618,7 @@ set_marker_restricted (Lisp_Object marker, Lisp_Object pos, Lisp_Object buffer)
    character position and the corresponding byte position.  */
 
 Lisp_Object
-set_marker_both (Lisp_Object marker, Lisp_Object buffer, int charpos, int bytepos)
+set_marker_both (Lisp_Object marker, Lisp_Object buffer, EMACS_INT charpos, EMACS_INT bytepos)
 {
   register struct buffer *b;
   register struct Lisp_Marker *m;
@@ -666,7 +666,7 @@ set_marker_both (Lisp_Object marker, Lisp_Object buffer, int charpos, int bytepo
    be outside the visible part.  */
 
 Lisp_Object
-set_marker_restricted_both (Lisp_Object marker, Lisp_Object buffer, int charpos, int bytepos)
+set_marker_restricted_both (Lisp_Object marker, Lisp_Object buffer, EMACS_INT charpos, EMACS_INT bytepos)
 {
   register struct buffer *b;
   register struct Lisp_Marker *m;
@@ -776,7 +776,7 @@ unchain_marker (register struct Lisp_Marker *marker)
 
 /* Return the char position of marker MARKER, as a C integer.  */
 
-int
+EMACS_INT
 marker_position (Lisp_Object marker)
 {
   register struct Lisp_Marker *m = XMARKER (marker);
@@ -790,12 +790,12 @@ marker_position (Lisp_Object marker)
 
 /* Return the byte position of marker MARKER, as a C integer.  */
 
-int
+EMACS_INT
 marker_byte_position (Lisp_Object marker)
 {
   register struct Lisp_Marker *m = XMARKER (marker);
   register struct buffer *buf = m->buffer;
-  register int i = m->bytepos;
+  register EMACS_INT i = m->bytepos;
 
   if (!buf)
     error ("Marker does not point anywhere");
@@ -856,7 +856,7 @@ DEFUN ("buffer-has-markers-at", Fbuffer_has_markers_at, Sbuffer_has_markers_at,
   (Lisp_Object position)
 {
   register struct Lisp_Marker *tail;
-  register int charno;
+  register EMACS_INT charno;
 
   charno = XINT (position);
 
diff --git a/src/minibuf.c b/src/minibuf.c
index 009d94c36a8..f3a24afc199 100644
--- a/src/minibuf.c
+++ b/src/minibuf.c
@@ -236,7 +236,7 @@ string_to_object (Lisp_Object val, Lisp_Object defalt)
 {
   struct gcpro gcpro1, gcpro2;
   Lisp_Object expr_and_pos;
-  int pos;
+  EMACS_INT pos;
 
   GCPRO2 (val, defalt);
 
@@ -254,7 +254,7 @@ string_to_object (Lisp_Object val, Lisp_Object defalt)
     {
       /* Ignore trailing whitespace; any other trailing junk
          is an error.  */
-      int i;
+      EMACS_INT i;
       pos = string_char_to_byte (val, pos);
       for (i = pos; i < SBYTES (val); i++)
         {
@@ -370,7 +370,7 @@ DEFUN ("minibuffer-contents", Fminibuffer_contents,
 If the current buffer is not a minibuffer, return its entire contents.  */)
   (void)
 {
-  int prompt_end = XINT (Fminibuffer_prompt_end ());
+  EMACS_INT prompt_end = XINT (Fminibuffer_prompt_end ());
   return make_buffer_string (prompt_end, ZV, 1);
 }
 
@@ -380,7 +380,7 @@ DEFUN ("minibuffer-contents-no-properties", Fminibuffer_contents_no_properties,
 If the current buffer is not a minibuffer, return its entire contents.  */)
   (void)
 {
-  int prompt_end = XINT (Fminibuffer_prompt_end ());
+  EMACS_INT prompt_end = XINT (Fminibuffer_prompt_end ());
   return make_buffer_string (prompt_end, ZV, 0);
 }
 
@@ -391,7 +391,7 @@ That is what completion commands operate on.
 If the current buffer is not a minibuffer, return its entire contents.  */)
   (void)
 {
-  int prompt_end = XINT (Fminibuffer_prompt_end ());
+  EMACS_INT prompt_end = XINT (Fminibuffer_prompt_end ());
   if (PT < prompt_end)
     error ("Cannot do completion in the prompt");
   return make_buffer_string (prompt_end, PT, 1);
diff --git a/src/print.c b/src/print.c
index 91ac68c8d30..d4cbc2ac24a 100644
--- a/src/print.c
+++ b/src/print.c
@@ -96,11 +96,11 @@ Lisp_Object being_printed[PRINT_CIRCLE];
 char *print_buffer;
 
 /* Size allocated in print_buffer.  */
-int print_buffer_size;
+EMACS_INT print_buffer_size;
 /* Chars stored in print_buffer.  */
-int print_buffer_pos;
+EMACS_INT print_buffer_pos;
 /* Bytes stored in print_buffer.  */
-int print_buffer_pos_byte;
+EMACS_INT print_buffer_pos_byte;
 
 /* Maximum length of list to print in full; noninteger means
    effectively infinity */
@@ -177,8 +177,8 @@ int print_output_debug_flag = 1;
 
 #define PRINTDECLARE                                                    \
    struct buffer *old = current_buffer;                                 \
-   int old_point = -1, start_point = -1;                                \
-   int old_point_byte = -1, start_point_byte = -1;                      \
+   EMACS_INT old_point = -1, start_point = -1;                          \
+   EMACS_INT old_point_byte = -1, start_point_byte = -1;                \
    int specpdl_count = SPECPDL_INDEX ();                                \
    int free_print_buffer = 0;                                           \
    int multibyte = !NILP (current_buffer->enable_multibyte_characters); \
@@ -342,8 +342,8 @@ printchar (unsigned int ch, Lisp_Object fun)
    to data in a Lisp string.  Otherwise that is not safe.  */
 
 static void
-strout (const char *ptr, int size, int size_byte, Lisp_Object printcharfun,
-        int multibyte)
+strout (const char *ptr, EMACS_INT size, EMACS_INT size_byte,
+        Lisp_Object printcharfun, int multibyte)
 {
   if (size < 0)
     size_byte = size = strlen (ptr);
@@ -395,7 +395,7 @@ strout (const char *ptr, int size, int size_byte, Lisp_Object printcharfun,
   else
     {
       /* PRINTCHARFUN is a Lisp function.  */
-      int i = 0;
+      EMACS_INT i = 0;
 
       if (size == size_byte)
         {
@@ -430,7 +430,7 @@ print_string (Lisp_Object string, Lisp_Object printcharfun)
 {
   if (EQ (printcharfun, Qt) || NILP (printcharfun))
     {
-      int chars;
+      EMACS_INT chars;
 
       if (print_escape_nonascii)
         string = string_escape_byte8 (string);
@@ -446,7 +446,7 @@ print_string (Lisp_Object string, Lisp_Object printcharfun)
              convert STRING to a multibyte string containing the same
              character codes.  */
           Lisp_Object newstr;
-          int bytes;
+          EMACS_INT bytes;
 
           chars = SBYTES (string);
           bytes = parse_str_to_multibyte (SDATA (string), chars);
@@ -464,7 +464,7 @@ print_string (Lisp_Object string, Lisp_Object printcharfun)
       if (EQ (printcharfun, Qt))
         {
           /* Output to echo area.  */
-          int nbytes = SBYTES (string);
+          EMACS_INT nbytes = SBYTES (string);
           char *buffer;
 
           /* Copy the string contents so that relocation of STRING by
@@ -489,9 +489,9 @@ print_string (Lisp_Object string, Lisp_Object printcharfun)
     {
       /* Otherwise, string may be relocated by printing one char.
          So re-fetch the string address for each character.  */
-      int i;
-      int size = SCHARS (string);
-      int size_byte = SBYTES (string);
+      EMACS_INT i;
+      EMACS_INT size = SCHARS (string);
+      EMACS_INT size_byte = SBYTES (string);
       struct gcpro gcpro1;
       GCPRO1 (string);
       if (size == size_byte)
@@ -868,7 +868,7 @@ to make it write to the debugging output.  */)
   (Lisp_Object character)
 {
   CHECK_NUMBER (character);
-  putc (XINT (character), stderr);
+  putc ((int) XINT (character), stderr);
 
 #ifdef WINDOWSNT
   /* Send the output to a debugger (nothing happens if there isn't one).  */
@@ -1430,8 +1430,8 @@ print_check_string_charset_prop (INTERVAL interval, Lisp_Object string)
       || ! (print_check_string_result & PRINT_STRING_UNSAFE_CHARSET_FOUND))
     {
       int i, c;
-      int charpos = interval->position;
-      int bytepos = string_char_to_byte (string, charpos);
+      EMACS_INT charpos = interval->position;
+      EMACS_INT bytepos = string_char_to_byte (string, charpos);
       Lisp_Object charset;
 
       charset = XCAR (XCDR (val));
@@ -1563,10 +1563,10 @@ print_object (Lisp_Object obj, register Lisp_Object printcharfun, int escapeflag
         print_string (obj, printcharfun);
       else
         {
-          register int i, i_byte;
+          register EMACS_INT i, i_byte;
           struct gcpro gcpro1;
           unsigned char *str;
-          int size_byte;
+          EMACS_INT size_byte;
           /* 1 means we must ensure that the next character we output
              cannot be taken as part of a hex character escape.  */
           int need_nonhex = 0;
@@ -1684,7 +1684,8 @@ print_object (Lisp_Object obj, register Lisp_Object printcharfun, int escapeflag
         register unsigned char *p = SDATA (SYMBOL_NAME (obj));
         register unsigned char *end = p + SBYTES (SYMBOL_NAME (obj));
         register int c;
-        int i, i_byte, size_byte;
+        int i, i_byte;
+        EMACS_INT size_byte;
         Lisp_Object name;
 
         name = SYMBOL_NAME (obj);
@@ -1803,7 +1804,8 @@ print_object (Lisp_Object obj, register Lisp_Object printcharfun, int escapeflag
             }
 
           {
-            int print_length, i;
+            EMACS_INT print_length;
+            int i;
             Lisp_Object halftail = obj;
 
             /* Negative values of print-length are invalid in CL.
@@ -1898,7 +1900,7 @@ print_object (Lisp_Object obj, register Lisp_Object printcharfun, int escapeflag
           register int i;
           register unsigned char c;
           struct gcpro gcpro1;
-          int size_in_chars
+          EMACS_INT size_in_chars
             = ((XBOOL_VECTOR (obj)->size + BOOL_VECTOR_BITS_PER_CHAR - 1)
                / BOOL_VECTOR_BITS_PER_CHAR);
 
@@ -1984,7 +1986,8 @@ print_object (Lisp_Object obj, register Lisp_Object printcharfun, int escapeflag
       else if (HASH_TABLE_P (obj))
         {
           struct Lisp_Hash_Table *h = XHASH_TABLE (obj);
-          int i, real_size, size;
+          int i;
+          EMACS_INT real_size, size;
 #if 0
           strout ("#<hash-table", -1, -1, printcharfun, 0);
           if (SYMBOLP (h->test))
@@ -2150,7 +2153,7 @@ print_object (Lisp_Object obj, register Lisp_Object printcharfun, int escapeflag
           {
             register int i;
             register Lisp_Object tem;
-            int real_size = size;
+            EMACS_INT real_size = size;
 
             /* Don't print more elements than the specified maximum.  */
             if (NATNUMP (Vprint_length)
@@ -2182,7 +2185,7 @@ print_object (Lisp_Object obj, register Lisp_Object printcharfun, int escapeflag
             strout ("in no buffer", -1, -1, printcharfun, 0);
           else
             {
-              sprintf (buf, "at %d", marker_position (obj));
+              sprintf (buf, "at %ld", (long)marker_position (obj));
               strout (buf, -1, -1, printcharfun, 0);
               strout (" in ", -1, -1, printcharfun, 0);
               print_string (XMARKER (obj)->buffer->name, printcharfun);
@@ -2196,9 +2199,9 @@ print_object (Lisp_Object obj, register Lisp_Object printcharfun, int escapeflag
             strout ("in no buffer", -1, -1, printcharfun, 0);
           else
             {
-              sprintf (buf, "from %d to %d in ",
-                       marker_position (OVERLAY_START (obj)),
-                       marker_position (OVERLAY_END   (obj)));
+              sprintf (buf, "from %ld to %ld in ",
+                       (long)marker_position (OVERLAY_START (obj)),
+                       (long)marker_position (OVERLAY_END   (obj)));
               strout (buf, -1, -1, printcharfun, 0);
               print_string (XMARKER (OVERLAY_START (obj))->buffer->name,
                             printcharfun);
diff --git a/src/process.c b/src/process.c
index f348dca7d35..a698e56fe39 100644
--- a/src/process.c
+++ b/src/process.c
@@ -105,6 +105,9 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include "sysselect.h"
 #include "syssignal.h"
 #include "syswait.h"
+#ifdef HAVE_GNUTLS
+#include "gnutls.h"
+#endif
 
 #if defined (USE_GTK) || defined (HAVE_GCONF)
 #include "xgselect.h"
@@ -198,8 +201,10 @@ int update_tick;
 
 /* Define NON_BLOCKING_CONNECT if we can support non-blocking connects.  */
 
+/* Only W32 has this, it really means that select can't take write mask.  */
 #ifdef BROKEN_NON_BLOCKING_CONNECT
 #undef NON_BLOCKING_CONNECT
+#define SELECT_CANT_DO_WRITE_MASK
 #else
 #ifndef NON_BLOCKING_CONNECT
 #ifdef HAVE_SELECT
@@ -291,9 +296,9 @@ static SELECT_TYPE non_keyboard_wait_mask;
 
 static SELECT_TYPE non_process_wait_mask;
 
-/* Mask for the gpm mouse input descriptor.  */
+/* Mask for selecting for write.  */
 
-static SELECT_TYPE gpm_wait_mask;
+static SELECT_TYPE write_mask;
 
 #ifdef NON_BLOCKING_CONNECT
 /* Mask of bits indicating the descriptors that we wait for connect to
@@ -313,11 +318,8 @@ static int num_pending_connects;
 /* The largest descriptor currently in use for a process object.  */
 static int max_process_desc;
 
-/* The largest descriptor currently in use for keyboard input.  */
-static int max_keyboard_desc;
-
-/* The largest descriptor currently in use for gpm mouse input.  */
-static int max_gpm_desc;
+/* The largest descriptor currently in use for input.  */
+static int max_input_desc;
 
 /* Indexed by descriptor, gives the process (if any) for that descriptor */
 Lisp_Object chan_process[MAXDESC];
@@ -363,6 +365,90 @@ static int pty_max_bytes;
 static char pty_name[24];
 #endif
 
+
+struct fd_callback_data
+{
+  fd_callback func;
+  void *data;
+#define FOR_READ  1
+#define FOR_WRITE 2
+  int condition; /* mask of the defines above.  */
+} fd_callback_info[MAXDESC];
+
+
+/* Add a file descriptor FD to be monitored for when read is possible.
+   When read is possible, call FUNC with argument DATA.  */
+
+void
+add_read_fd (int fd, fd_callback func, void *data)
+{
+  xassert (fd < MAXDESC);
+  add_keyboard_wait_descriptor (fd);
+
+  fd_callback_info[fd].func = func;
+  fd_callback_info[fd].data = data;
+  fd_callback_info[fd].condition |= FOR_READ;
+}
+
+/* Stop monitoring file descriptor FD for when read is possible.  */
+
+void
+delete_read_fd (int fd)
+{
+  xassert (fd < MAXDESC);
+  delete_keyboard_wait_descriptor (fd);
+
+  fd_callback_info[fd].condition &= ~FOR_READ;
+  if (fd_callback_info[fd].condition == 0)
+    {
+      fd_callback_info[fd].func = 0;
+      fd_callback_info[fd].data = 0;
+    }
+}
+
+/* Add a file descriptor FD to be monitored for when write is possible.
+   When write is possible, call FUNC with argument DATA.  */
+
+void
+add_write_fd (int fd, fd_callback func, void *data)
+{
+  xassert (fd < MAXDESC);
+  FD_SET (fd, &write_mask);
+  if (fd > max_input_desc)
+    max_input_desc = fd;
+
+  fd_callback_info[fd].func = func;
+  fd_callback_info[fd].data = data;
+  fd_callback_info[fd].condition |= FOR_WRITE;
+}
+
+/* Stop monitoring file descriptor FD for when write is possible.  */
+
+void
+delete_write_fd (int fd)
+{
+  int lim = max_input_desc;
+
+  xassert (fd < MAXDESC);
+  FD_CLR (fd, &write_mask);
+  fd_callback_info[fd].condition &= ~FOR_WRITE;
+  if (fd_callback_info[fd].condition == 0)
+    {
+      fd_callback_info[fd].func = 0;
+      fd_callback_info[fd].data = 0;
+
+      if (fd == max_input_desc)
+        for (fd = lim; fd >= 0; fd--)
+          if (FD_ISSET (fd, &input_wait_mask) || FD_ISSET (fd, &write_mask))
+            {
+              max_input_desc = fd;
+              break;
+            }
+      
+    }
+}
+
+
 /* Compute the Lisp form of the process status, p->status, from
    the numeric status that was returned by `wait'.  */
 
@@ -583,6 +669,12 @@ make_process (Lisp_Object name)
   p->read_output_skip = 0;
 #endif
 
+#ifdef HAVE_GNUTLS
+  p->gnutls_initstage = GNUTLS_STAGE_EMPTY;
+  p->gnutls_log_level = 0;
+  p->gnutls_p = 0;
+#endif
+
   /* If name is already in use, modify it until it is unused.  */
 
   name1 = name;
@@ -1526,6 +1618,12 @@ usage: (start-process NAME BUFFER PROGRAM &rest PROGRAM-ARGS)  */)
   XPROCESS (proc)->filter = Qnil;
   XPROCESS (proc)->command = Flist (nargs - 2, args + 2);
 
+#ifdef HAVE_GNUTLS
+  /* AKA GNUTLS_INITSTAGE(proc).  */
+  XPROCESS (proc)->gnutls_initstage = GNUTLS_STAGE_EMPTY;
+  XPROCESS (proc)->gnutls_cred_type = Qnil;
+#endif
+
 #ifdef ADAPTIVE_READ_BUFFERING
   XPROCESS (proc)->adaptive_read_buffering
     = (NILP (Vprocess_adaptive_read_buffering) ? 0
@@ -3170,7 +3268,9 @@ usage: (make-network-process &rest ARGS)  */)
   if (!NILP (host))
     {
       if (EQ (host, Qlocal))
-        host = build_string ("localhost");
+        /* Depending on setup, "localhost" may map to different IPv4 and/or
+           IPv6 addresses, so it's better to be explicit.  (Bug#6781) */
+        host = build_string ("127.0.0.1");
       CHECK_STRING (host);
     }
 
@@ -3605,6 +3705,7 @@ usage: (make-network-process &rest ARGS)  */)
       if (!FD_ISSET (inch, &connect_wait_mask))
         {
           FD_SET (inch, &connect_wait_mask);
+          FD_SET (inch, &write_mask);
           num_pending_connects++;
         }
     }
@@ -4008,6 +4109,7 @@ deactivate_process (Lisp_Object proc)
       if (FD_ISSET (inchannel, &connect_wait_mask))
         {
           FD_CLR (inchannel, &connect_wait_mask);
+          FD_CLR (inchannel, &write_mask);
           if (--num_pending_connects < 0)
             abort ();
         }
@@ -4386,10 +4488,8 @@ wait_reading_process_output (int time_limit, int microsecs, int read_kbd,
 {
   register int channel, nfds;
   SELECT_TYPE Available;
-#ifdef NON_BLOCKING_CONNECT
-  SELECT_TYPE Connecting;
-  int check_connect;
-#endif
+  SELECT_TYPE Writeok;
+  int check_write;
   int check_delay, no_avail;
   int xerrno;
   Lisp_Object proc;
@@ -4399,11 +4499,9 @@ wait_reading_process_output (int time_limit, int microsecs, int read_kbd,
   int count = SPECPDL_INDEX ();
 
   FD_ZERO (&Available);
-#ifdef NON_BLOCKING_CONNECT
-  FD_ZERO (&Connecting);
-#endif
+  FD_ZERO (&Writeok);
 
-  if (time_limit == 0 && wait_proc && !NILP (Vinhibit_quit)
+  if (time_limit == 0 && microsecs == 0 && wait_proc && !NILP (Vinhibit_quit)
       && !(CONSP (wait_proc->status) && EQ (XCAR (wait_proc->status), Qexit)))
     message ("Blocking call to accept-process-output with quit inhibited!!");
 
@@ -4537,19 +4635,16 @@ wait_reading_process_output (int time_limit, int microsecs, int read_kbd,
       if (update_tick != process_tick)
         {
           SELECT_TYPE Atemp;
-#ifdef NON_BLOCKING_CONNECT
           SELECT_TYPE Ctemp;
-#endif
 
           if (kbd_on_hold_p ())
             FD_ZERO (&Atemp);
           else
             Atemp = input_wait_mask;
-          IF_NON_BLOCKING_CONNECT (Ctemp = connect_wait_mask);
+          Ctemp = write_mask;
 
           EMACS_SET_SECS_USECS (timeout, 0, 0);
-          if ((select (max (max (max_process_desc, max_keyboard_desc),
-                              max_gpm_desc) + 1,
+          if ((select (max (max_process_desc, max_input_desc) + 1,
                        &Atemp,
 #ifdef NON_BLOCKING_CONNECT
                        (num_pending_connects > 0 ? &Ctemp : (SELECT_TYPE *)0),
@@ -4620,13 +4715,13 @@ wait_reading_process_output (int time_limit, int microsecs, int read_kbd,
             break;
           FD_SET (wait_proc->infd, &Available);
           check_delay = 0;
-          IF_NON_BLOCKING_CONNECT (check_connect = 0);
+          check_write = 0;
         }
       else if (!NILP (wait_for_cell))
         {
           Available = non_process_wait_mask;
           check_delay = 0;
-          IF_NON_BLOCKING_CONNECT (check_connect = 0);
+          check_write = 0;
         }
       else
         {
@@ -4634,7 +4729,12 @@ wait_reading_process_output (int time_limit, int microsecs, int read_kbd,
             Available = non_keyboard_wait_mask;
           else
             Available = input_wait_mask;
-          IF_NON_BLOCKING_CONNECT (check_connect = (num_pending_connects > 0));
+          Writeok = write_mask;
+#ifdef SELECT_CANT_DO_WRITE_MASK
+          check_write = 0;
+#else
+          check_write = 1;
+#endif
           check_delay = wait_channel >= 0 ? 0 : process_output_delay_count;
         }
 
@@ -4659,10 +4759,6 @@ wait_reading_process_output (int time_limit, int microsecs, int read_kbd,
         }
       else
         {
-#ifdef NON_BLOCKING_CONNECT
-          if (check_connect)
-            Connecting = connect_wait_mask;
-#endif
 
 #ifdef ADAPTIVE_READ_BUFFERING
           /* Set the timeout for adaptive read buffering if any
@@ -4704,15 +4800,10 @@ wait_reading_process_output (int time_limit, int microsecs, int read_kbd,
 #else
           nfds = select
 #endif
-                        (max (max (max_process_desc, max_keyboard_desc),
-                              max_gpm_desc) + 1,
-                         &Available,
-#ifdef NON_BLOCKING_CONNECT
-                         (check_connect ? &Connecting : (SELECT_TYPE *)0),
-#else
-                         (SELECT_TYPE *)0,
-#endif
-                         (SELECT_TYPE *)0, &timeout);
+            (max (max_process_desc, max_input_desc) + 1,
+             &Available,
+             (check_write ? &Writeok : (SELECT_TYPE *)0),
+             (SELECT_TYPE *)0, &timeout);
         }
 
       xerrno = errno;
@@ -4752,7 +4843,7 @@ wait_reading_process_output (int time_limit, int microsecs, int read_kbd,
       if (no_avail)
         {
           FD_ZERO (&Available);
-          IF_NON_BLOCKING_CONNECT (check_connect = 0);
+          check_write = 0;
         }
 
 #if 0 /* When polling is used, interrupt_input is 0,
@@ -4848,12 +4939,26 @@ wait_reading_process_output (int time_limit, int microsecs, int read_kbd,
       if (no_avail || nfds == 0)
         continue;
 
+      for (channel = 0; channel <= max_input_desc; ++channel)
+        {
+          struct fd_callback_data *d = &fd_callback_info[channel];
+          if (FD_ISSET (channel, &Available)
+              && d->func != 0
+              && (d->condition & FOR_READ) != 0)
+            d->func (channel, d->data, 1);
+          if (FD_ISSET (channel, &write_mask)
+              && d->func != 0
+              && (d->condition & FOR_WRITE) != 0)
+            d->func (channel, d->data, 0);
+          }
+
       /* Really FIRST_PROC_DESC should be 0 on Unix,
          but this is safer in the short run.  */
       for (channel = 0; channel <= max_process_desc; channel++)
         {
           if (FD_ISSET (channel, &Available)
-              && FD_ISSET (channel, &non_keyboard_wait_mask))
+              && FD_ISSET (channel, &non_keyboard_wait_mask)
+              && !FD_ISSET (channel, &non_process_wait_mask))
             {
               int nread;
 
@@ -4958,12 +5063,13 @@ wait_reading_process_output (int time_limit, int microsecs, int read_kbd,
                 }
             }
 #ifdef NON_BLOCKING_CONNECT
-          if (check_connect && FD_ISSET (channel, &Connecting)
+          if (FD_ISSET (channel, &Writeok)
               && FD_ISSET (channel, &connect_wait_mask))
             {
               struct Lisp_Process *p;
 
               FD_CLR (channel, &connect_wait_mask);
+              FD_CLR (channel, &write_mask);
               if (--num_pending_connects < 0)
                 abort ();
 
@@ -5073,7 +5179,7 @@ read_process_output (Lisp_Object proc, register int channel)
   char *chars;
   register Lisp_Object outstream;
   register struct Lisp_Process *p = XPROCESS (proc);
-  register int opoint;
+  register EMACS_INT opoint;
   struct coding_system *coding = proc_decode_coding_system[channel];
   int carryover = p->decoding_carryover;
   int readmax = 4096;
@@ -5097,7 +5203,13 @@ read_process_output (Lisp_Object proc, register int channel)
 #endif
   if (proc_buffered_char[channel] < 0)
     {
-      nbytes = emacs_read (channel, chars + carryover, readmax);
+#ifdef HAVE_GNUTLS
+      if (XPROCESS (proc)->gnutls_p)
+        nbytes = emacs_gnutls_read (channel, XPROCESS (proc),
+                                    chars + carryover, readmax);
+      else
+#endif
+        nbytes = emacs_read (channel, chars + carryover, readmax);
 #ifdef ADAPTIVE_READ_BUFFERING
       if (nbytes > 0 && p->adaptive_read_buffering)
         {
@@ -5130,7 +5242,13 @@ read_process_output (Lisp_Object proc, register int channel)
     {
       chars[carryover] = proc_buffered_char[channel];
       proc_buffered_char[channel] = -1;
-      nbytes = emacs_read (channel, chars + carryover + 1,  readmax - 1);
+#ifdef HAVE_GNUTLS
+      if (XPROCESS (proc)->gnutls_p)
+        nbytes = emacs_gnutls_read (channel, XPROCESS (proc),
+                                    chars + carryover + 1, readmax - 1);
+      else
+#endif
+        nbytes = emacs_read (channel, chars + carryover + 1,  readmax - 1);
       if (nbytes < 0)
         nbytes = 1;
       else
@@ -5263,10 +5381,10 @@ read_process_output (Lisp_Object proc, register int channel)
   else if (!NILP (p->buffer) && !NILP (XBUFFER (p->buffer)->name))
     {
       Lisp_Object old_read_only;
-      int old_begv, old_zv;
-      int old_begv_byte, old_zv_byte;
-      int before, before_byte;
-      int opoint_byte;
+      EMACS_INT old_begv, old_zv;
+      EMACS_INT old_begv_byte, old_zv_byte;
+      EMACS_INT before, before_byte;
+      EMACS_INT opoint_byte;
       Lisp_Object text;
       struct buffer *b;
 
@@ -5403,11 +5521,11 @@ send_process_trap (int ignore)
 
 static void
 send_process (volatile Lisp_Object proc, const unsigned char *volatile buf,
-              volatile int len, volatile Lisp_Object object)
+              volatile EMACS_INT len, volatile Lisp_Object object)
 {
   /* Use volatile to protect variables from being clobbered by longjmp.  */
   struct Lisp_Process *p = XPROCESS (proc);
-  int rv;
+  EMACS_INT rv;
   struct coding_system *coding;
   struct gcpro gcpro1;
   SIGTYPE (*volatile old_sigpipe) (int);
@@ -5464,8 +5582,8 @@ send_process (volatile Lisp_Object proc, const unsigned char *volatile buf,
       coding->dst_object = Qt;
       if (BUFFERP (object))
         {
-          int from_byte, from, to;
-          int save_pt, save_pt_byte;
+          EMACS_INT from_byte, from, to;
+          EMACS_INT save_pt, save_pt_byte;
           struct buffer *cur = current_buffer;
 
           set_buffer_internal (XBUFFER (object));
@@ -5517,7 +5635,7 @@ send_process (volatile Lisp_Object proc, const unsigned char *volatile buf,
       process_sent_to = proc;
       while (len > 0)
         {
-          int this = len;
+          EMACS_INT this = len;
 
           /* Send this batch, using one or more write calls.  */
           while (this > 0)
@@ -5540,7 +5658,14 @@ send_process (volatile Lisp_Object proc, const unsigned char *volatile buf,
               else
 #endif
                 {
-                  rv = emacs_write (outfd, (char *) buf, this);
+#ifdef HAVE_GNUTLS
+                  if (XPROCESS (proc)->gnutls_p)
+                    rv = emacs_gnutls_write (outfd,
+                                             XPROCESS (proc), 
+                                             (char *) buf, this);
+                  else
+#endif
+                    rv = emacs_write (outfd, (char *) buf, this);
 #ifdef ADAPTIVE_READ_BUFFERING
                   if (p->read_output_delay > 0
                       && p->adaptive_read_buffering == 1)
@@ -5651,7 +5776,7 @@ Output from processes can arrive in between bunches.  */)
   (Lisp_Object process, Lisp_Object start, Lisp_Object end)
 {
   Lisp_Object proc;
-  int start1, end1;
+  EMACS_INT start1, end1;
 
   proc = get_process (process);
   validate_region (&start, &end);
@@ -6592,8 +6717,8 @@ status_notify (struct Lisp_Process *deleting_process)
             {
               Lisp_Object tem;
               struct buffer *old = current_buffer;
-              int opoint, opoint_byte;
-              int before, before_byte;
+              EMACS_INT opoint, opoint_byte;
+              EMACS_INT before, before_byte;
 
               /* Avoid error if buffer is deleted
                  (probably that's why the process is dead, too) */
@@ -6711,35 +6836,16 @@ DEFUN ("process-filter-multibyte-p", Fprocess_filter_multibyte_p,
 
 
 
-static int add_gpm_wait_descriptor_called_flag;
-
 void
 add_gpm_wait_descriptor (int desc)
 {
-  if (! add_gpm_wait_descriptor_called_flag)
-    FD_CLR (0, &input_wait_mask);
-  add_gpm_wait_descriptor_called_flag = 1;
-  FD_SET (desc, &input_wait_mask);
-  FD_SET (desc, &gpm_wait_mask);
-  if (desc > max_gpm_desc)
-    max_gpm_desc = desc;
+  add_keyboard_wait_descriptor (desc);
 }
 
 void
 delete_gpm_wait_descriptor (int desc)
 {
-  int fd;
-  int lim = max_gpm_desc;
-
-  FD_CLR (desc, &input_wait_mask);
-  FD_CLR (desc, &non_process_wait_mask);
-
-  if (desc == max_gpm_desc)
-    for (fd = 0; fd < lim; fd++)
-      if (FD_ISSET (fd, &input_wait_mask)
-          && !FD_ISSET (fd, &non_keyboard_wait_mask)
-          && !FD_ISSET (fd, &non_process_wait_mask))
-        max_gpm_desc = fd;
+  delete_keyboard_wait_descriptor (desc);
 }
 
 /* Return nonzero if *MASK has a bit set
@@ -6750,7 +6856,7 @@ keyboard_bit_set (fd_set *mask)
 {
   int fd;
 
-  for (fd = 0; fd <= max_keyboard_desc; fd++)
+  for (fd = 0; fd <= max_input_desc; fd++)
     if (FD_ISSET (fd, mask) && FD_ISSET (fd, &input_wait_mask)
         && !FD_ISSET (fd, &non_keyboard_wait_mask))
       return 1;
@@ -6989,11 +7095,11 @@ wait_reading_process_output (int time_limit, int microsecs, int read_kbd,
 void
 add_keyboard_wait_descriptor (int desc)
 {
-#ifdef subprocesses
+#ifdef subprocesses /* actually means "not MSDOS" */
   FD_SET (desc, &input_wait_mask);
   FD_SET (desc, &non_process_wait_mask);
-  if (desc > max_keyboard_desc)
-    max_keyboard_desc = desc;
+  if (desc > max_input_desc)
+    max_input_desc = desc;
 #endif
 }
 
@@ -7004,18 +7110,16 @@ delete_keyboard_wait_descriptor (int desc)
 {
 #ifdef subprocesses
   int fd;
-  int lim = max_keyboard_desc;
+  int lim = max_input_desc;
 
   FD_CLR (desc, &input_wait_mask);
   FD_CLR (desc, &non_process_wait_mask);
 
-  if (desc == max_keyboard_desc)
+  if (desc == max_input_desc)
     for (fd = 0; fd < lim; fd++)
-      if (FD_ISSET (fd, &input_wait_mask)
-          && !FD_ISSET (fd, &non_keyboard_wait_mask)
-          && !FD_ISSET (fd, &gpm_wait_mask))
-        max_keyboard_desc = fd;
-#endif /* subprocesses */
+      if (FD_ISSET (fd, &input_wait_mask) || FD_ISSET (fd, &write_mask))
+        max_input_desc = fd;
+#endif
 }
 
 /* Setup coding systems of PROCESS.  */
@@ -7272,7 +7376,9 @@ init_process (void)
   FD_ZERO (&input_wait_mask);
   FD_ZERO (&non_keyboard_wait_mask);
   FD_ZERO (&non_process_wait_mask);
+  FD_ZERO (&write_mask);
   max_process_desc = 0;
+  memset (fd_callback_info, 0, sizeof (fd_callback_info));
 
 #ifdef NON_BLOCKING_CONNECT
   FD_ZERO (&connect_wait_mask);
diff --git a/src/process.h b/src/process.h
index 35b01aba6a4..0350e95310d 100644
--- a/src/process.h
+++ b/src/process.h
@@ -24,6 +24,10 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include <unistd.h>
 #endif
 
+#ifdef HAVE_GNUTLS
+#include "gnutls.h"
+#endif
+
 /* This structure records information about a subprocess
    or network connection.
 
@@ -76,6 +80,10 @@ struct Lisp_Process
     /* Working buffer for encoding.  */
     Lisp_Object encoding_buf;
 
+#ifdef HAVE_GNUTLS
+    Lisp_Object gnutls_cred_type;
+#endif
+
     /* After this point, there are no Lisp_Objects any more.  */
     /* alloc.c assumes that `pid' is the first such non-Lisp slot.  */
 
@@ -121,6 +129,15 @@ struct Lisp_Process
        needs to be synced to `status'.  */
     unsigned int raw_status_new : 1;
     int raw_status;
+
+#ifdef HAVE_GNUTLS
+    gnutls_initstage_t gnutls_initstage;
+    gnutls_session_t gnutls_state;
+    gnutls_certificate_client_credentials gnutls_x509_cred;
+    gnutls_anon_client_credentials_t gnutls_anon_cred;
+    int gnutls_log_level;
+    int gnutls_p;
+#endif
 };
 
 /* Every field in the preceding structure except for the first two
@@ -177,5 +194,12 @@ extern void hold_keyboard_input (void);
 extern void unhold_keyboard_input (void);
 extern int kbd_on_hold_p (void);
 
+typedef void (*fd_callback)(int fd, void *data, int for_read);
+
+extern void add_read_fd (int fd, fd_callback func, void *data);
+extern void delete_read_fd (int fd);
+extern void add_write_fd (int fd, fd_callback func, void *data);
+extern void delete_write_fd (int fd);
+
 /* arch-tag: dffedfc4-d7bc-4b58-a26f-c16155449c72
    (do not change this comment) */
diff --git a/src/region-cache.c b/src/region-cache.c
index 45eb723c885..9037b5df4b4 100644
--- a/src/region-cache.c
+++ b/src/region-cache.c
@@ -62,7 +62,7 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
    revalidate_region_cache to see how this helps.  */
 
 struct boundary {
-  int pos;
+  EMACS_INT pos;
   int value;
 };
 
@@ -72,16 +72,16 @@ struct region_cache {
   struct boundary *boundaries;
 
   /* boundaries[gap_start ... gap_start + gap_len - 1] is the gap.  */
-  int gap_start, gap_len;
+  EMACS_INT gap_start, gap_len;
 
   /* The number of elements allocated to boundaries, not including the
      gap.  */
-  int cache_len;
+  EMACS_INT cache_len;
 
   /* The areas that haven't changed since the last time we cleaned out
      invalid entries from the cache.  These overlap when the buffer is
      entirely unchanged.  */
-  int beg_unchanged, end_unchanged;
+  EMACS_INT beg_unchanged, end_unchanged;
 
   /* The first and last positions in the buffer.  Because boundaries
      store their positions relative to the start (BEG) and end (Z) of
@@ -91,7 +91,7 @@ struct region_cache {
 
      Yes, buffer_beg is always 1.  It's there for symmetry with
      buffer_end and the BEG and BUF_BEG macros.  */
-  int buffer_beg, buffer_end;
+  EMACS_INT buffer_beg, buffer_end;
 };
 
 /* Return the position of boundary i in cache c.  */
@@ -172,17 +172,17 @@ free_region_cache (struct region_cache *c)
    This operation should be logarithmic in the number of cache
    entries.  It would be nice if it took advantage of locality of
    reference, too, by searching entries near the last entry found.  */
-static int
-find_cache_boundary (struct region_cache *c, int pos)
+static EMACS_INT
+find_cache_boundary (struct region_cache *c, EMACS_INT pos)
 {
-  int low = 0, high = c->cache_len;
+  EMACS_INT low = 0, high = c->cache_len;
 
   while (low + 1 < high)
     {
       /* mid is always a valid index, because low < high and ">> 1"
          rounds down.  */
-      int mid = (low + high) >> 1;
-      int boundary = BOUNDARY_POS (c, mid);
+      EMACS_INT mid = (low + high) >> 1;
+      EMACS_INT boundary = BOUNDARY_POS (c, mid);
 
       if (pos < boundary)
         high = mid;
@@ -207,13 +207,13 @@ find_cache_boundary (struct region_cache *c, int pos)
 /* Move the gap of cache C to index POS, and make sure it has space
    for at least MIN_SIZE boundaries.  */
 static void
-move_cache_gap (struct region_cache *c, int pos, int min_size)
+move_cache_gap (struct region_cache *c, EMACS_INT pos, EMACS_INT min_size)
 {
   /* Copy these out of the cache and into registers.  */
-  int gap_start = c->gap_start;
-  int gap_len = c->gap_len;
-  int buffer_beg = c->buffer_beg;
-  int buffer_end = c->buffer_end;
+  EMACS_INT gap_start = c->gap_start;
+  EMACS_INT gap_len = c->gap_len;
+  EMACS_INT buffer_beg = c->buffer_beg;
+  EMACS_INT buffer_end = c->buffer_end;
 
   if (pos < 0
       || pos > c->cache_len)
@@ -245,7 +245,7 @@ move_cache_gap (struct region_cache *c, int pos, int min_size)
      when the portion after the gap is smallest.  */
   if (gap_len < min_size)
     {
-      int i;
+      EMACS_INT i;
 
       /* Always make at least NEW_CACHE_GAP elements, as long as we're
          expanding anyway.  */
@@ -292,7 +292,8 @@ move_cache_gap (struct region_cache *c, int pos, int min_size)
 /* Insert a new boundary in cache C; it will have cache index INDEX,
    and have the specified POS and VALUE.  */
 static void
-insert_cache_boundary (struct region_cache *c, int index, int pos, int value)
+insert_cache_boundary (struct region_cache *c, EMACS_INT index, EMACS_INT pos,
+                       int value)
 {
   /* index must be a valid cache index.  */
   if (index < 0 || index > c->cache_len)
@@ -328,9 +329,10 @@ insert_cache_boundary (struct region_cache *c, int index, int pos, int value)
 /* Delete the i'th entry from cache C if START <= i < END.  */
 
 static void
-delete_cache_boundaries (struct region_cache *c, int start, int end)
+delete_cache_boundaries (struct region_cache *c,
+                         EMACS_INT start, EMACS_INT end)
 {
-  int len = end - start;
+  EMACS_INT len = end - start;
 
   /* Gotta be in range.  */
   if (start < 0
@@ -380,7 +382,8 @@ delete_cache_boundaries (struct region_cache *c, int start, int end)
 
 /* Set the value in cache C for the region START..END to VALUE.  */
 static void
-set_cache_region (struct region_cache *c, int start, int end, int value)
+set_cache_region (struct region_cache *c,
+                  EMACS_INT start, EMACS_INT end, int value)
 {
   if (start > end)
     abort ();
@@ -403,8 +406,8 @@ set_cache_region (struct region_cache *c, int start, int end, int value)
        index of the earliest boundary after the last character in
        start..end.  (This tortured terminology is intended to answer
        all the "< or <=?" sort of questions.)  */
-    int start_ix = find_cache_boundary (c, start);
-    int end_ix   = find_cache_boundary (c, end - 1) + 1;
+    EMACS_INT start_ix = find_cache_boundary (c, start);
+    EMACS_INT end_ix   = find_cache_boundary (c, end - 1) + 1;
 
     /* We must remember the value established by the last boundary
        before end; if that boundary's domain stretches beyond end,
@@ -481,7 +484,8 @@ set_cache_region (struct region_cache *c, int start, int end, int value)
    buffer positions in the presence of insertions and deletions; the
    args to pass are the same before and after such an operation.)  */
 void
-invalidate_region_cache (struct buffer *buf, struct region_cache *c, int head, int tail)
+invalidate_region_cache (struct buffer *buf, struct region_cache *c,
+                         EMACS_INT head, EMACS_INT tail)
 {
   /* Let chead = c->beg_unchanged, and
          ctail = c->end_unchanged.
@@ -619,7 +623,7 @@ revalidate_region_cache (struct buffer *buf, struct region_cache *c)
      corresponds to the modified region of the buffer.  */
   else
     {
-      int modified_ix;
+      EMACS_INT modified_ix;
 
       /* These positions are correct, relative to both the cache basis
          and the buffer basis.  */
@@ -687,7 +691,8 @@ revalidate_region_cache (struct buffer *buf, struct region_cache *c)
    buffer positions) is "known," for the purposes of CACHE (e.g. "has
    no newlines", in the case of the line cache).  */
 void
-know_region_cache (struct buffer *buf, struct region_cache *c, int start, int end)
+know_region_cache (struct buffer *buf, struct region_cache *c,
+                   EMACS_INT start, EMACS_INT end)
 {
   revalidate_region_cache (buf, c);
 
@@ -701,14 +706,15 @@ know_region_cache (struct buffer *buf, struct region_cache *c, int start, int en
    the purposes of CACHE.  If NEXT is non-zero, set *NEXT to the nearest
    position after POS where the knownness changes.  */
 int
-region_cache_forward (struct buffer *buf, struct region_cache *c, int pos, int *next)
+region_cache_forward (struct buffer *buf, struct region_cache *c,
+                      EMACS_INT pos, EMACS_INT *next)
 {
   revalidate_region_cache (buf, c);
 
   {
-    int i = find_cache_boundary (c, pos);
+    EMACS_INT i = find_cache_boundary (c, pos);
     int i_value = BOUNDARY_VALUE (c, i);
-    int j;
+    EMACS_INT j;
 
     /* Beyond the end of the buffer is unknown, by definition.  */
     if (pos >= BUF_Z (buf))
@@ -736,7 +742,8 @@ region_cache_forward (struct buffer *buf, struct region_cache *c, int pos, int *
 /* Return true if the text immediately before POS in BUF is known, for
    the purposes of CACHE.  If NEXT is non-zero, set *NEXT to the nearest
    position before POS where the knownness changes.  */
-int region_cache_backward (struct buffer *buf, struct region_cache *c, int pos, int *next)
+int region_cache_backward (struct buffer *buf, struct region_cache *c,
+                           EMACS_INT pos, EMACS_INT *next)
 {
   revalidate_region_cache (buf, c);
 
@@ -749,9 +756,9 @@ int region_cache_backward (struct buffer *buf, struct region_cache *c, int pos,
     }
 
   {
-    int i = find_cache_boundary (c, pos - 1);
+    EMACS_INT i = find_cache_boundary (c, pos - 1);
     int i_value = BOUNDARY_VALUE (c, i);
-    int j;
+    EMACS_INT j;
 
     if (next)
       {
@@ -777,17 +784,17 @@ void
 pp_cache (struct region_cache *c)
 {
   int i;
-  int beg_u = c->buffer_beg + c->beg_unchanged;
-  int end_u = c->buffer_end - c->end_unchanged;
+  EMACS_INT beg_u = c->buffer_beg + c->beg_unchanged;
+  EMACS_INT end_u = c->buffer_end - c->end_unchanged;
 
   fprintf (stderr,
-           "basis: %d..%d    modified: %d..%d\n",
-           c->buffer_beg, c->buffer_end,
-           beg_u, end_u);
+           "basis: %ld..%ld    modified: %ld..%ld\n",
+           (long)c->buffer_beg, (long)c->buffer_end,
+           (long)beg_u, (long)end_u);
 
   for (i = 0; i < c->cache_len; i++)
     {
-      int pos = BOUNDARY_POS (c, i);
+      EMACS_INT pos = BOUNDARY_POS (c, i);
 
       putc (((pos < beg_u) ? 'v'
              : (pos == beg_u) ? '-'
@@ -797,7 +804,7 @@ pp_cache (struct region_cache *c)
              : (pos == end_u) ? '-'
              : ' '),
             stderr);
-      fprintf (stderr, "%d : %d\n", pos, BOUNDARY_VALUE (c, i));
+      fprintf (stderr, "%ld : %d\n", (long)pos, BOUNDARY_VALUE (c, i));
     }
 }
 
diff --git a/src/region-cache.h b/src/region-cache.h
index e2972f2ea0a..e99eac90c85 100644
--- a/src/region-cache.h
+++ b/src/region-cache.h
@@ -71,7 +71,7 @@ void free_region_cache (struct region_cache *);
    no newlines", in the case of the line cache).  */
 extern void know_region_cache (struct buffer *BUF,
                                struct region_cache *CACHE,
-                               int START, int END);
+                               EMACS_INT START, EMACS_INT END);
 
 /* Indicate that a section of BUF has changed, to invalidate CACHE.
    HEAD is the number of chars unchanged at the beginning of the buffer.
@@ -83,7 +83,7 @@ extern void know_region_cache (struct buffer *BUF,
    args to pass are the same before and after such an operation.)  */
 extern void invalidate_region_cache (struct buffer *BUF,
                                      struct region_cache *CACHE,
-                                     int HEAD, int TAIL);
+                                     EMACS_INT HEAD, EMACS_INT TAIL);
 
 /* The scanning functions.
 
@@ -99,16 +99,16 @@ extern void invalidate_region_cache (struct buffer *BUF,
    position after POS where the knownness changes.  */
 extern int region_cache_forward (struct buffer *BUF,
                                  struct region_cache *CACHE,
-                                 int POS,
-                                 int *NEXT);
+                                 EMACS_INT POS,
+                                 EMACS_INT *NEXT);
 
 /* Return true if the text immediately before POS in BUF is known, for
    the purposes of CACHE.  If NEXT is non-zero, set *NEXT to the nearest
    position before POS where the knownness changes.  */
 extern int region_cache_backward (struct buffer *BUF,
                                   struct region_cache *CACHE,
-                                  int POS,
-                                  int *NEXT);
+                                  EMACS_INT POS,
+                                  EMACS_INT *NEXT);
 
 /* arch-tag: 70f79125-ef22-4f58-9aec-a48ca2791435
    (do not change this comment) */
diff --git a/src/s/aix4-2.h b/src/s/aix4-2.h
index 0a3d48db639..29702028649 100644
--- a/src/s/aix4-2.h
+++ b/src/s/aix4-2.h
@@ -37,10 +37,6 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #define PTY_NAME_SPRINTF strcpy (pty_name, "/dev/ptc");
 #define PTY_TTY_NAME_SPRINTF strcpy (pty_name, ttyname (fd));
 
-/* Define HAVE_TERMIO if the system provides sysV-style ioctls
-   for terminal control.  */
-#define HAVE_TERMIOS
-
 /* Define HAVE_PTYS if the system supports pty devices.  */
 #define HAVE_PTYS
 
diff --git a/src/s/bsd-common.h b/src/s/bsd-common.h
index bf78f4ec347..b17ca7a012f 100644
--- a/src/s/bsd-common.h
+++ b/src/s/bsd-common.h
@@ -42,7 +42,6 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #undef KERNEL_FILE
 #undef LDAV_SYMBOL
 
-#define HAVE_TERMIOS
 #define NO_TERMIO
 
 /* If the system's imake configuration file defines `NeedWidePrototypes'
diff --git a/src/s/cygwin.h b/src/s/cygwin.h
index 1b78ada53bd..4d58542e660 100644
--- a/src/s/cygwin.h
+++ b/src/s/cygwin.h
@@ -45,16 +45,6 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
    through a pipe. */
 #undef INTERRUPT_INPUT
 
-/* Define HAVE_TERMIOS if the system provides POSIX-style
-   functions and macros for terminal control.
-
-   Define HAVE_TERMIO if the system provides sysV-style ioctls
-   for terminal control.
-
-   Do not define both.  HAVE_TERMIOS is preferred, if it is
-   supported on your system.  */
-#define HAVE_TERMIOS
-
 /* Define HAVE_PTYS if the system supports pty devices.  */
 #define HAVE_PTYS
 #define PTY_ITERATION           for (i = 0; i < 1; i++) /* ick */
diff --git a/src/s/darwin.h b/src/s/darwin.h
index 146bfd693a2..73e19602275 100644
--- a/src/s/darwin.h
+++ b/src/s/darwin.h
@@ -63,15 +63,6 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
   if system supports pty's.  'a' means it is /dev/ptya0  */
 #define FIRST_PTY_LETTER 'p'
 
-/* Define HAVE_TERMIOS if the system provides POSIX-style
-   functions and macros for terminal control.
-
-   Define HAVE_TERMIO if the system provides sysV-style ioctls
-   for terminal control.
-
-   Do not define both.  HAVE_TERMIOS is preferred, if it is supported
-   on your system. */
-#define HAVE_TERMIOS
 #define NO_TERMIO
 
 /* Define HAVE_PTYS if the system supports pty devices.
diff --git a/src/s/gnu-linux.h b/src/s/gnu-linux.h
index cf3b3079726..9327423b42f 100644
--- a/src/s/gnu-linux.h
+++ b/src/s/gnu-linux.h
@@ -80,10 +80,6 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 
 #endif  /* not HAVE_GRANTPT */
 
-/*  Define HAVE_TERMIOS if the system provides POSIX-style
-    functions and macros for terminal control.  */
-#define HAVE_TERMIOS
-
 /* Define HAVE_PTYS if the system supports pty devices.  */
 #define HAVE_PTYS
 
diff --git a/src/s/hpux10-20.h b/src/s/hpux10-20.h
index d34ff16104b..0932e6f7112 100644
--- a/src/s/hpux10-20.h
+++ b/src/s/hpux10-20.h
@@ -35,11 +35,8 @@ 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_TERMIOS
 #define NO_TERMIO
 
-#define ORDINARY_LINK
-
 /* Define HAVE_PTYS if the system supports pty devices.  */
 #define HAVE_PTYS
 
@@ -78,9 +75,6 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
    HP-UX 10.20, and that it works for HP-UX 0 as well.  */
 #define NO_EDITRES
 
-/* Tested in getloadavg.c.  */
-#define HAVE_PSTAT_GETDYNAMIC
-
 /* Eric Backus <ericb@lsid.hp.com> says, HP-UX 9.x on HP 700 machines
    has a broken `rint' in some library versions including math library
    version number A.09.05.
diff --git a/src/s/template.h b/src/s/template.h
index dd1e56f8553..eb7ca85c5e5 100644
--- a/src/s/template.h
+++ b/src/s/template.h
@@ -63,18 +63,6 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
    if system supports pty's.  'a' means it is /dev/ptya0.  */
 #define FIRST_PTY_LETTER 'a'
 
-/* Define HAVE_TERMIOS if the system provides POSIX-style
-   functions and macros for terminal control.
-
-   Define HAVE_TERMIO if the system provides sysV-style ioctls
-   for terminal control.
-
-   Do not define both.  HAVE_TERMIOS is preferred, if it is
-   supported on your system.  */
-
-#define HAVE_TERMIOS
-/* #define HAVE_TERMIO */
-
 /* Define HAVE_PTYS if the system supports pty devices.  */
 #define HAVE_PTYS
 
diff --git a/src/s/usg5-4-common.h b/src/s/usg5-4-common.h
index 7ff5c6f7be3..4dcb8e50200 100644
--- a/src/s/usg5-4-common.h
+++ b/src/s/usg5-4-common.h
@@ -31,10 +31,6 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
    It sets the Lisp variable system-type.  */
 #define SYSTEM_TYPE "usg-unix-v"
 
-/* Define HAVE_TERMIO if the system provides sysV-style ioctls
-   for terminal control.  */
-#define HAVE_TERMIO
-
 /* The file containing the kernel's symbol table is called /unix.  */
 #define KERNEL_FILE "/unix"
 
@@ -78,7 +74,6 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 
 /* Define HAVE_PTYS if the system supports pty devices.  */
 #define HAVE_PTYS
-#define HAVE_TERMIOS
 
 /* It is possible to receive SIGCHLD when there are no children
    waiting, because a previous waitsys(2) cleaned up the carcass of child
diff --git a/src/scroll.c b/src/scroll.c
index bdb7f691ee7..ce26acbce64 100644
--- a/src/scroll.c
+++ b/src/scroll.c
@@ -94,7 +94,7 @@ calculate_scrolling (FRAME_PTR frame,
                      int free_at_end)
 {
   register int i, j;
-  int frame_lines = FRAME_LINES (frame);
+  EMACS_INT frame_lines = FRAME_LINES (frame);
   register struct matrix_elt *p, *p1;
   register int cost, cost1;
 
@@ -115,7 +115,7 @@ calculate_scrolling (FRAME_PTR frame,
   /* Discourage long scrolls on fast lines.
      Don't scroll nearly a full frame height unless it saves
      at least 1/4 second.  */
-  int extra_cost = baud_rate / (10 * 4 * FRAME_LINES (frame));
+  int extra_cost = (int) (baud_rate / (10 * 4 * FRAME_LINES (frame)));
 
   if (baud_rate <= 0)
     extra_cost = 1;
@@ -428,7 +428,7 @@ calculate_direct_scrolling (FRAME_PTR frame,
                             int free_at_end)
 {
   register int i, j;
-  int frame_lines = FRAME_LINES (frame);
+  EMACS_INT frame_lines = FRAME_LINES (frame);
   register struct matrix_elt *p, *p1;
   register int cost, cost1, delta;
 
@@ -448,7 +448,7 @@ calculate_direct_scrolling (FRAME_PTR frame,
   /* Discourage long scrolls on fast lines.
      Don't scroll nearly a full frame height unless it saves
      at least 1/4 second.  */
-  int extra_cost = baud_rate / (10 * 4 * FRAME_LINES (frame));
+  int extra_cost = (int) (baud_rate / (10 * 4 * FRAME_LINES (frame)));
 
   if (baud_rate <= 0)
     extra_cost = 1;
@@ -886,9 +886,9 @@ scroll_cost (FRAME_PTR frame, int from, int to, int amount)
 {
   /* Compute how many lines, at bottom of frame,
      will not be involved in actual motion.  */
-  int limit = to;
-  int offset;
-  int height = FRAME_LINES (frame);
+  EMACS_INT limit = to;
+  EMACS_INT offset;
+  EMACS_INT height = FRAME_LINES (frame);
 
   if (amount == 0)
     return 0;
@@ -921,8 +921,8 @@ scroll_cost (FRAME_PTR frame, int from, int to, int amount)
 static void
 line_ins_del (FRAME_PTR frame, int ov1, int pf1, int ovn, int pfn, register int *ov, register int *mf)
 {
-  register int i;
-  register int frame_lines = FRAME_LINES (frame);
+  register EMACS_INT i;
+  register EMACS_INT frame_lines = FRAME_LINES (frame);
   register int insert_overhead = ov1 * 10;
   register int next_insert_cost = ovn * 10;
 
diff --git a/src/search.c b/src/search.c
index 0e9840b2e5f..f2957c335a2 100644
--- a/src/search.c
+++ b/src/search.c
@@ -100,15 +100,15 @@ Lisp_Object Vinhibit_changing_match_data;
 
 static void set_search_regs (EMACS_INT, EMACS_INT);
 static void save_search_regs (void);
-static EMACS_INT simple_search (int, unsigned char *, int, int,
-                                Lisp_Object, EMACS_INT, EMACS_INT,
+static EMACS_INT simple_search (EMACS_INT, unsigned char *, EMACS_INT,
+                                EMACS_INT, Lisp_Object, EMACS_INT, EMACS_INT,
                                 EMACS_INT, EMACS_INT);
-static EMACS_INT boyer_moore (int, unsigned char *, int, int,
+static EMACS_INT boyer_moore (EMACS_INT, unsigned char *, EMACS_INT, EMACS_INT,
                               Lisp_Object, Lisp_Object,
                               EMACS_INT, EMACS_INT,
                               EMACS_INT, EMACS_INT, int);
 static EMACS_INT search_buffer (Lisp_Object, EMACS_INT, EMACS_INT,
-                                EMACS_INT, EMACS_INT, int, int,
+                                EMACS_INT, EMACS_INT, EMACS_INT, int,
                                 Lisp_Object, Lisp_Object, int);
 static void matcher_overflow (void) NO_RETURN;
 
@@ -286,7 +286,7 @@ looking_at_1 (Lisp_Object string, int posix)
   Lisp_Object val;
   unsigned char *p1, *p2;
   EMACS_INT s1, s2;
-  register int i;
+  register EMACS_INT i;
   struct re_pattern_buffer *bufp;
 
   if (running_asynch_code)
@@ -396,7 +396,7 @@ string_match_1 (Lisp_Object regexp, Lisp_Object string, Lisp_Object start, int p
     pos = 0, pos_byte = 0;
   else
     {
-      int len = SCHARS (string);
+      EMACS_INT len = SCHARS (string);
 
       CHECK_NUMBER (start);
       pos = XINT (start);
@@ -509,7 +509,7 @@ fast_c_string_match_ignore_case (Lisp_Object regexp, const char *string)
 {
   int val;
   struct re_pattern_buffer *bufp;
-  int len = strlen (string);
+  size_t len = strlen (string);
 
   regexp = string_make_unibyte (regexp);
   re_match_object = Qt;
@@ -654,8 +654,9 @@ newline_cache_on_off (struct buffer *buf)
    If ALLOW_QUIT is non-zero, set immediate_quit.  That's good to do
    except when inside redisplay.  */
 
-int
-scan_buffer (register int target, EMACS_INT start, EMACS_INT end, int count, int *shortage, int allow_quit)
+EMACS_INT
+scan_buffer (register int target, EMACS_INT start, EMACS_INT end,
+             EMACS_INT count, int *shortage, int allow_quit)
 {
   struct region_cache *newline_cache;
   int direction;
@@ -695,7 +696,7 @@ scan_buffer (register int target, EMACS_INT start, EMACS_INT end, int count, int
            to see where we can avoid some scanning.  */
         if (target == '\n' && newline_cache)
           {
-            int next_change;
+            EMACS_INT next_change;
             immediate_quit = 0;
             while (region_cache_forward
                    (current_buffer, newline_cache, start_byte, &next_change))
@@ -767,7 +768,7 @@ scan_buffer (register int target, EMACS_INT start, EMACS_INT end, int count, int
         /* Consult the newline cache, if appropriate.  */
         if (target == '\n' && newline_cache)
           {
-            int next_change;
+            EMACS_INT next_change;
             immediate_quit = 0;
             while (region_cache_backward
                    (current_buffer, newline_cache, start_byte, &next_change))
@@ -846,8 +847,10 @@ scan_buffer (register int target, EMACS_INT start, EMACS_INT end, int count, int
    If ALLOW_QUIT is non-zero, set immediate_quit.  That's good to do
    except in special cases.  */
 
-int
-scan_newline (EMACS_INT start, EMACS_INT start_byte, EMACS_INT limit, EMACS_INT limit_byte, register int count, int allow_quit)
+EMACS_INT
+scan_newline (EMACS_INT start, EMACS_INT start_byte,
+              EMACS_INT limit, EMACS_INT limit_byte,
+              register EMACS_INT count, int allow_quit)
 {
   int direction = ((count > 0) ? 1 : -1);
 
@@ -940,8 +943,8 @@ scan_newline (EMACS_INT start, EMACS_INT start_byte, EMACS_INT limit, EMACS_INT
   return count * direction;
 }
 
-int
-find_next_newline_no_quit (EMACS_INT from, int cnt)
+EMACS_INT
+find_next_newline_no_quit (EMACS_INT from, EMACS_INT cnt)
 {
   return scan_buffer ('\n', from, 0, cnt, (int *) 0, 0);
 }
@@ -950,11 +953,11 @@ find_next_newline_no_quit (EMACS_INT from, int cnt)
    not after, and only search up to TO.  This isn't just
    find_next_newline (...)-1, because you might hit TO.  */
 
-int
-find_before_next_newline (EMACS_INT from, EMACS_INT to, int cnt)
+EMACS_INT
+find_before_next_newline (EMACS_INT from, EMACS_INT to, EMACS_INT cnt)
 {
   int shortage;
-  int pos = scan_buffer ('\n', from, to, cnt, &shortage, 1);
+  EMACS_INT pos = scan_buffer ('\n', from, to, cnt, &shortage, 1);
 
   if (shortage == 0)
     pos--;
@@ -965,10 +968,11 @@ find_before_next_newline (EMACS_INT from, EMACS_INT to, int cnt)
 /* Subroutines of Lisp buffer search functions. */
 
 static Lisp_Object
-search_command (Lisp_Object string, Lisp_Object bound, Lisp_Object noerror, Lisp_Object count, int direction, int RE, int posix)
+search_command (Lisp_Object string, Lisp_Object bound, Lisp_Object noerror,
+                Lisp_Object count, int direction, int RE, int posix)
 {
   register int np;
-  int lim, lim_byte;
+  EMACS_INT lim, lim_byte;
   int n = direction;
 
   if (!NILP (count))
@@ -1044,7 +1048,7 @@ search_command (Lisp_Object string, Lisp_Object bound, Lisp_Object noerror, Lisp
 static int
 trivial_regexp_p (Lisp_Object regexp)
 {
-  int len = SBYTES (regexp);
+  EMACS_INT len = SBYTES (regexp);
   unsigned char *s = SDATA (regexp);
   while (--len >= 0)
     {
@@ -1109,11 +1113,11 @@ static struct re_registers search_regs_1;
 
 static EMACS_INT
 search_buffer (Lisp_Object string, EMACS_INT pos, EMACS_INT pos_byte,
-               EMACS_INT lim, EMACS_INT lim_byte, int n,
+               EMACS_INT lim, EMACS_INT lim_byte, EMACS_INT n,
                int RE, Lisp_Object trt, Lisp_Object inverse_trt, int posix)
 {
-  int len = SCHARS (string);
-  int len_byte = SBYTES (string);
+  EMACS_INT len = SCHARS (string);
+  EMACS_INT len_byte = SBYTES (string);
   register int i;
 
   if (running_asynch_code)
@@ -1130,7 +1134,7 @@ search_buffer (Lisp_Object string, EMACS_INT pos, EMACS_INT pos_byte,
   if (RE && !(trivial_regexp_p (string) && NILP (Vsearch_spaces_regexp)))
     {
       unsigned char *p1, *p2;
-      int s1, s2;
+      EMACS_INT s1, s2;
       struct re_pattern_buffer *bufp;
 
       bufp = compile_pattern (string,
@@ -1166,7 +1170,7 @@ search_buffer (Lisp_Object string, EMACS_INT pos, EMACS_INT pos_byte,
 
       while (n < 0)
         {
-          int val;
+          EMACS_INT val;
           val = re_search_2 (bufp, (char *) p1, s1, (char *) p2, s2,
                              pos_byte - BEGV_BYTE, lim_byte - pos_byte,
                              (NILP (Vinhibit_changing_match_data)
@@ -1210,7 +1214,7 @@ search_buffer (Lisp_Object string, EMACS_INT pos, EMACS_INT pos_byte,
         }
       while (n > 0)
         {
-          int val;
+          EMACS_INT val;
           val = re_search_2 (bufp, (char *) p1, s1, (char *) p2, s2,
                              pos_byte - BEGV_BYTE, lim_byte - pos_byte,
                              (NILP (Vinhibit_changing_match_data)
@@ -1255,8 +1259,8 @@ search_buffer (Lisp_Object string, EMACS_INT pos, EMACS_INT pos_byte,
   else                          /* non-RE case */
     {
       unsigned char *raw_pattern, *pat;
-      int raw_pattern_size;
-      int raw_pattern_size_byte;
+      EMACS_INT raw_pattern_size;
+      EMACS_INT raw_pattern_size_byte;
       unsigned char *patbuf;
       int multibyte = !NILP (current_buffer->enable_multibyte_characters);
       unsigned char *base_pat;
@@ -1450,13 +1454,16 @@ search_buffer (Lisp_Object string, EMACS_INT pos, EMACS_INT pos_byte,
    boyer_moore cannot work.  */
 
 static EMACS_INT
-simple_search (int n, unsigned char *pat, int len, int len_byte, Lisp_Object trt, EMACS_INT pos, EMACS_INT pos_byte, EMACS_INT lim, EMACS_INT lim_byte)
+simple_search (EMACS_INT n, unsigned char *pat,
+               EMACS_INT len, EMACS_INT len_byte, Lisp_Object trt,
+               EMACS_INT pos, EMACS_INT pos_byte,
+               EMACS_INT lim, EMACS_INT lim_byte)
 {
   int multibyte = ! NILP (current_buffer->enable_multibyte_characters);
   int forward = n > 0;
   /* Number of buffer bytes matched.  Note that this may be different
      from len_byte in a multibyte buffer.  */
-  int match_byte;
+  EMACS_INT match_byte;
 
   if (lim > pos && multibyte)
     while (n > 0)
@@ -1466,7 +1473,7 @@ simple_search (int n, unsigned char *pat, int len, int len_byte, Lisp_Object trt
             /* Try matching at position POS.  */
             EMACS_INT this_pos = pos;
             EMACS_INT this_pos_byte = pos_byte;
-            int this_len = len;
+            EMACS_INT this_len = len;
             unsigned char *p = pat;
             if (pos + len > lim || pos_byte + len_byte > lim_byte)
               goto stop;
@@ -1511,7 +1518,7 @@ simple_search (int n, unsigned char *pat, int len, int len_byte, Lisp_Object trt
           {
             /* Try matching at position POS.  */
             EMACS_INT this_pos = pos;
-            int this_len = len;
+            EMACS_INT this_len = len;
             unsigned char *p = pat;
 
             if (pos + len > lim)
@@ -1551,7 +1558,7 @@ simple_search (int n, unsigned char *pat, int len, int len_byte, Lisp_Object trt
             /* Try matching at position POS.  */
             EMACS_INT this_pos = pos;
             EMACS_INT this_pos_byte = pos_byte;
-            int this_len = len;
+            EMACS_INT this_len = len;
             const unsigned char *p = pat + len_byte;
 
             if (this_pos - len < lim || (pos_byte - len_byte) < lim_byte)
@@ -1594,7 +1601,7 @@ simple_search (int n, unsigned char *pat, int len, int len_byte, Lisp_Object trt
           {
             /* Try matching at position POS.  */
             EMACS_INT this_pos = pos - len;
-            int this_len = len;
+            EMACS_INT this_len = len;
             unsigned char *p = pat;
 
             if (this_pos < lim)
@@ -1657,18 +1664,20 @@ simple_search (int n, unsigned char *pat, int len, int len_byte, Lisp_Object trt
    If that criterion is not satisfied, do not call this function.  */
 
 static EMACS_INT
-boyer_moore (int n, unsigned char *base_pat, int len, int len_byte,
+boyer_moore (EMACS_INT n, unsigned char *base_pat,
+             EMACS_INT len, EMACS_INT len_byte,
              Lisp_Object trt, Lisp_Object inverse_trt,
              EMACS_INT pos, EMACS_INT pos_byte,
              EMACS_INT lim, EMACS_INT lim_byte, int char_base)
 {
   int direction = ((n > 0) ? 1 : -1);
-  register int dirlen;
+  register EMACS_INT dirlen;
   EMACS_INT limit;
   int stride_for_teases = 0;
   int BM_tab[0400];
   register unsigned char *cursor, *p_limit;
-  register int i, j;
+  register EMACS_INT i;
+  register int j;
   unsigned char *pat, *pat_end;
   int multibyte = ! NILP (current_buffer->enable_multibyte_characters);
 
@@ -2098,10 +2107,11 @@ static Lisp_Object
 wordify (Lisp_Object string, int lax)
 {
   register unsigned char *p, *o;
-  register int i, i_byte, len, punct_count = 0, word_count = 0;
+  register EMACS_INT i, i_byte, len, punct_count = 0, word_count = 0;
   Lisp_Object val;
   int prev_c = 0;
-  int adjust, whitespace_at_end;
+  EMACS_INT adjust;
+  int whitespace_at_end;
 
   CHECK_STRING (string);
   p = SDATA (string);
@@ -2151,7 +2161,7 @@ wordify (Lisp_Object string, int lax)
   for (i = 0, i_byte = 0; i < len; )
     {
       int c;
-      int i_byte_orig = i_byte;
+      EMACS_INT i_byte_orig = i_byte;
 
       FETCH_STRING_CHAR_AS_MULTIBYTE_ADVANCE (c, string, i, i_byte);
 
@@ -2392,7 +2402,7 @@ since only regular expressions have distinguished subexpressions.  */)
   (Lisp_Object newtext, Lisp_Object fixedcase, Lisp_Object literal, Lisp_Object string, Lisp_Object subexp)
 {
   enum { nochange, all_caps, cap_initial } case_action;
-  register int pos, pos_byte;
+  register EMACS_INT pos, pos_byte;
   int some_multiletter_word;
   int some_lowercase;
   int some_uppercase;
@@ -2540,8 +2550,8 @@ since only regular expressions have distinguished subexpressions.  */)
 
           for (pos_byte = 0, pos = 0; pos_byte < length;)
             {
-              int substart = -1;
-              int subend = 0;
+              EMACS_INT substart = -1;
+              EMACS_INT subend = 0;
               int delbackslash = 0;
 
               FETCH_STRING_CHAR_ADVANCE (c, newtext, pos, pos_byte);
@@ -2634,9 +2644,9 @@ since only regular expressions have distinguished subexpressions.  */)
      perform substitution on the replacement string.  */
   if (NILP (literal))
     {
-      int length = SBYTES (newtext);
+      EMACS_INT length = SBYTES (newtext);
       unsigned char *substed;
-      int substed_alloc_size, substed_len;
+      EMACS_INT substed_alloc_size, substed_len;
       int buf_multibyte = !NILP (current_buffer->enable_multibyte_characters);
       int str_multibyte = STRING_MULTIBYTE (newtext);
       Lisp_Object rev_tbl;
@@ -2656,7 +2666,7 @@ since only regular expressions have distinguished subexpressions.  */)
         {
           unsigned char str[MAX_MULTIBYTE_LENGTH];
           const unsigned char *add_stuff = NULL;
-          int add_len = 0;
+          EMACS_INT add_len = 0;
           int idx = -1;
 
           if (str_multibyte)
@@ -2750,7 +2760,8 @@ since only regular expressions have distinguished subexpressions.  */)
         {
           if (buf_multibyte)
             {
-              int nchars = multibyte_chars_in_text (substed, substed_len);
+              EMACS_INT nchars =
+                multibyte_chars_in_text (substed, substed_len);
 
               newtext = make_multibyte_string (substed, nchars, substed_len);
             }
diff --git a/src/syntax.c b/src/syntax.c
index f0a7dca42dc..2f4f5236a40 100644
--- a/src/syntax.c
+++ b/src/syntax.c
@@ -185,7 +185,8 @@ INTERVAL interval_of (int, Lisp_Object);
    start/end of OBJECT.  */
 
 void
-update_syntax_table (int charpos, int count, int init, Lisp_Object object)
+update_syntax_table (EMACS_INT charpos, int count, int init,
+                     Lisp_Object object)
 {
   Lisp_Object tmp_table;
   int cnt = 0, invalidate = 1;
@@ -475,7 +476,7 @@ find_defun_start (EMACS_INT pos, EMACS_INT pos_byte)
 /* Return the SYNTAX_COMEND_FIRST of the character before POS, POS_BYTE.  */
 
 static int
-prev_char_comend_first (int pos, int pos_byte)
+prev_char_comend_first (EMACS_INT pos, EMACS_INT pos_byte)
 {
   int c, val;
 
@@ -557,8 +558,9 @@ back_comment (EMACS_INT from, EMACS_INT from_byte, EMACS_INT stop, int comnested
      that determines quote parity to the comment-end.  */
   while (from != stop)
     {
-      int temp_byte, prev_syntax;
-      int com2start, com2end;
+      EMACS_INT temp_byte;
+      int prev_syntax, com2start, com2end;
+      int comstart;
 
       /* Move back and examine a character.  */
       DEC_BOTH (from, from_byte);
@@ -578,7 +580,8 @@ back_comment (EMACS_INT from, EMACS_INT from_byte, EMACS_INT stop, int comnested
                        || SYNTAX_FLAGS_COMMENT_NESTED (syntax)) == comnested);
       com2end = (SYNTAX_FLAGS_COMEND_FIRST (syntax)
                  && SYNTAX_FLAGS_COMEND_SECOND (prev_syntax));
-
+      comstart = (com2start || code == Scomment);
+      
       /* Nasty cases with overlapping 2-char comment markers:
          - snmp-mode: -- c -- foo -- c --
                       --- c --
@@ -589,15 +592,17 @@ back_comment (EMACS_INT from, EMACS_INT from_byte, EMACS_INT stop, int comnested
                       ///   */
 
       /* If a 2-char comment sequence partly overlaps with another,
-         we don't try to be clever.  */
-      if (from > stop && (com2end || com2start))
+         we don't try to be clever.  E.g. |*| in C, or }% in modes that
+         have %..\n and %{..}%.  */
+      if (from > stop && (com2end || comstart))
         {
-          int next = from, next_byte = from_byte, next_c, next_syntax;
+          EMACS_INT next = from, next_byte = from_byte;
+          int next_c, next_syntax;
           DEC_BOTH (next, next_byte);
           UPDATE_SYNTAX_TABLE_BACKWARD (next);
           next_c = FETCH_CHAR_AS_MULTIBYTE (next_byte);
           next_syntax = SYNTAX_WITH_FLAGS (next_c);
-          if (((com2start || comnested)
+          if (((comstart || comnested)
                && SYNTAX_FLAGS_COMEND_SECOND (syntax)
                && SYNTAX_FLAGS_COMEND_FIRST (next_syntax))
               || ((com2end || comnested)
@@ -1239,12 +1244,12 @@ Lisp_Object Vfind_word_boundary_function_table;
    If that many words cannot be found before the end of the buffer, return 0.
    COUNT negative means scan backward and stop at word beginning.  */
 
-int
-scan_words (register int from, register int count)
+EMACS_INT
+scan_words (register EMACS_INT from, register EMACS_INT count)
 {
-  register int beg = BEGV;
-  register int end = ZV;
-  register int from_byte = CHAR_TO_BYTE (from);
+  register EMACS_INT beg = BEGV;
+  register EMACS_INT end = ZV;
+  register EMACS_INT from_byte = CHAR_TO_BYTE (from);
   register enum syntaxcode code;
   int ch0, ch1;
   Lisp_Object func, script, pos;
@@ -1452,14 +1457,14 @@ skip_chars (int forwardp, Lisp_Object string, Lisp_Object lim, int handle_iso_cl
   int *char_ranges;
   int n_char_ranges = 0;
   int negate = 0;
-  register int i, i_byte;
+  register EMACS_INT i, i_byte;
   /* Set to 1 if the current buffer is multibyte and the region
      contains non-ASCII chars.  */
   int multibyte;
   /* Set to 1 if STRING is multibyte and it contains non-ASCII
      chars.  */
   int string_multibyte;
-  int size_byte;
+  EMACS_INT size_byte;
   const unsigned char *str;
   int len;
   Lisp_Object iso_classes;
@@ -1771,9 +1776,9 @@ skip_chars (int forwardp, Lisp_Object string, Lisp_Object lim, int handle_iso_cl
     }
 
   {
-    int start_point = PT;
-    int pos = PT;
-    int pos_byte = PT_BYTE;
+    EMACS_INT start_point = PT;
+    EMACS_INT pos = PT;
+    EMACS_INT pos_byte = PT_BYTE;
     unsigned char *p = PT_ADDR, *endp, *stop;
 
     if (forwardp)
@@ -1943,9 +1948,9 @@ skip_syntaxes (int forwardp, Lisp_Object string, Lisp_Object lim)
   register unsigned int c;
   unsigned char fastmap[0400];
   int negate = 0;
-  register int i, i_byte;
+  register EMACS_INT i, i_byte;
   int multibyte;
-  int size_byte;
+  EMACS_INT size_byte;
   unsigned char *str;
 
   CHECK_STRING (string);
@@ -1998,9 +2003,9 @@ skip_syntaxes (int forwardp, Lisp_Object string, Lisp_Object lim)
       fastmap[i] ^= 1;
 
   {
-    int start_point = PT;
-    int pos = PT;
-    int pos_byte = PT_BYTE;
+    EMACS_INT start_point = PT;
+    EMACS_INT pos = PT;
+    EMACS_INT pos_byte = PT_BYTE;
     unsigned char *p = PT_ADDR, *endp, *stop;
 
     if (forwardp)
@@ -2391,7 +2396,8 @@ between them, return t; otherwise return nil.  */)
           if (code == Scomment_fence)
             {
               /* Skip until first preceding unquoted comment_fence.  */
-              int found = 0, ini = from, ini_byte = from_byte;
+              int found = 0;
+              EMACS_INT ini = from, ini_byte = from_byte;
 
               while (1)
                 {
@@ -2907,11 +2913,11 @@ DEFUN ("backward-prefix-chars", Fbackward_prefix_chars, Sbackward_prefix_chars,
 This includes chars with "quote" or "prefix" syntax (' or p).  */)
   (void)
 {
-  int beg = BEGV;
-  int opoint = PT;
-  int opoint_byte = PT_BYTE;
-  int pos = PT;
-  int pos_byte = PT_BYTE;
+  EMACS_INT beg = BEGV;
+  EMACS_INT opoint = PT;
+  EMACS_INT opoint_byte = PT_BYTE;
+  EMACS_INT pos = PT;
+  EMACS_INT pos_byte = PT_BYTE;
   int c;
 
   if (pos <= beg)
diff --git a/src/syntax.h b/src/syntax.h
index 48146572d19..15e6c729308 100644
--- a/src/syntax.h
+++ b/src/syntax.h
@@ -19,7 +19,7 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 
 
 extern Lisp_Object Qsyntax_table_p;
-extern void update_syntax_table (int, int, int, Lisp_Object);
+extern void update_syntax_table (EMACS_INT, int, int, Lisp_Object);
 
 /* The standard syntax table is stored where it will automatically
    be used in all new buffers.  */
@@ -301,7 +301,7 @@ extern struct gl_state_s gl_state;
 extern int parse_sexp_lookup_properties;
 extern INTERVAL interval_of (int, Lisp_Object);
 
-extern int scan_words (int, int);
+extern EMACS_INT scan_words (EMACS_INT, EMACS_INT);
 
 /* arch-tag: 28833cca-cd73-4741-8c85-a3111166a0e0
    (do not change this comment) */
diff --git a/src/term.c b/src/term.c
index f090cdd2792..a2f7a9cbabe 100644
--- a/src/term.c
+++ b/src/term.c
@@ -31,10 +31,6 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include <unistd.h>
 #endif
 
-#ifdef HAVE_SYS_IOCTL_H
-#include <sys/ioctl.h>
-#endif
-
 #include <signal.h>
 #include <stdarg.h>
 #include <setjmp.h>
@@ -247,7 +243,6 @@ tty_set_terminal_modes (struct terminal *terminal)
             cmputc ('\n');
         }
 
-      OUTPUT_IF (tty, tty->TS_termcap_modes);
       OUTPUT_IF (tty, visible_cursor ? tty->TS_cursor_visible : tty->TS_cursor_normal);
       OUTPUT_IF (tty, tty->TS_keypad_mode);
       losecursor (tty);
@@ -599,7 +594,7 @@ encode_terminal_code (struct glyph *src, int src_len, struct coding_system *codi
           if (src->u.cmp.automatic)
             {
               gstring = composition_gstring_from_id (src->u.cmp.id);
-              required = src->u.cmp.to + 1 - src->u.cmp.from;
+              required = src->slice.cmp.to + 1 - src->slice.cmp.from;
             }
           else
             {
@@ -616,7 +611,7 @@ encode_terminal_code (struct glyph *src, int src_len, struct coding_system *codi
             }
 
           if (src->u.cmp.automatic)
-            for (i = src->u.cmp.from; i <= src->u.cmp.to; i++)
+            for (i = src->slice.cmp.from; i <= src->slice.cmp.to; i++)
               {
                 Lisp_Object g = LGSTRING_GLYPH (gstring, i);
                 int c = LGLYPH_CHAR (g);
@@ -1796,8 +1791,8 @@ append_composite_glyph (struct it *it)
         {
           glyph->u.cmp.automatic = 1;
           glyph->u.cmp.id = it->cmp_it.id;
-          glyph->u.cmp.from = it->cmp_it.from;
-          glyph->u.cmp.to = it->cmp_it.to - 1;
+          glyph->slice.cmp.from = it->cmp_it.from;
+          glyph->slice.cmp.to = it->cmp_it.to - 1;
         }
 
       glyph->face_id = it->face_id;
@@ -2619,9 +2614,10 @@ term_clear_mouse_face (void)
    If POS is after end of W, return end of last line in W.
    - taken from msdos.c */
 static int
-fast_find_position (struct window *w, int pos, int *hpos, int *vpos)
+fast_find_position (struct window *w, EMACS_INT pos, int *hpos, int *vpos)
 {
-  int i, lastcol, line_start_position, maybe_next_line_p = 0;
+  int i, lastcol, maybe_next_line_p = 0;
+  EMACS_INT line_start_position;
   int yb = window_text_bottom_y (w);
   struct glyph_row *row = MATRIX_ROW (w->current_matrix, 0), *best_row = row;
 
@@ -2659,7 +2655,7 @@ fast_find_position (struct window *w, int pos, int *hpos, int *vpos)
   for (i = 0; i < row->used[TEXT_AREA]; i++)
     {
       struct glyph *glyph = row->glyphs[TEXT_AREA] + i;
-      int charpos;
+      EMACS_INT charpos;
 
       charpos = glyph->charpos;
       if (charpos == pos)
@@ -2720,7 +2716,8 @@ term_mouse_highlight (struct frame *f, int x, int y)
       && XFASTINT (w->last_modified) == BUF_MODIFF (b)
       && XFASTINT (w->last_overlay_modified) == BUF_OVERLAY_MODIFF (b))
     {
-      int pos, i, nrows = w->current_matrix->nrows;
+      int i, nrows = w->current_matrix->nrows;
+      EMACS_INT pos;
       struct glyph_row *row;
       struct glyph *glyph;
 
@@ -2764,7 +2761,8 @@ term_mouse_highlight (struct frame *f, int x, int y)
       /* Check for mouse-face.  */
       {
         Lisp_Object mouse_face, overlay, position, *overlay_vec;
-        int noverlays, obegv, ozv;
+        int noverlays;
+        EMACS_INT obegv, ozv;
         struct buffer *obuf;
 
         /* If we get an out-of-range value, return now; avoid an error.  */
@@ -3405,6 +3403,15 @@ init_tty (const char *name, const char *terminal_type, int must_succeed)
   tty->Wcm = (struct cm *) xmalloc (sizeof (struct cm));
   Wcm_clear (tty);
 
+  encode_terminal_src_size = 0;
+  encode_terminal_dst_size = 0;
+
+#ifdef HAVE_GPM
+  terminal->mouse_position_hook = term_mouse_position;
+  mouse_face_window = Qnil;
+#endif
+
+  
 #ifndef DOS_NT
   set_tty_hooks (terminal);
 
@@ -3458,78 +3465,6 @@ init_tty (const char *name, const char *terminal_type, int must_succeed)
 
   add_keyboard_wait_descriptor (fileno (tty->input));
 
-#endif  /* !DOS_NT */
-
-  encode_terminal_src_size = 0;
-  encode_terminal_dst_size = 0;
-
-#ifdef HAVE_GPM
-  terminal->mouse_position_hook = term_mouse_position;
-  mouse_face_window = Qnil;
-#endif
-
-#ifdef DOS_NT
-#ifdef WINDOWSNT
-  initialize_w32_display (terminal);
-#else  /* MSDOS */
-  if (strcmp (terminal_type, "internal") == 0)
-    terminal->type = output_msdos_raw;
-  initialize_msdos_display (terminal);
-#endif  /* MSDOS */
-  tty->output = stdout;
-  tty->input = stdin;
-  /* The following two are inaccessible from w32console.c.  */
-  terminal->delete_frame_hook = &tty_free_frame_resources;
-  terminal->delete_terminal_hook = &delete_tty;
-
-  tty->name = xstrdup (name);
-  terminal->name = xstrdup (name);
-  tty->type = xstrdup (terminal_type);
-
-  add_keyboard_wait_descriptor (0);
-
-  Wcm_clear (tty);
-
-#ifdef WINDOWSNT
-  {
-    struct frame *f = XFRAME (selected_frame);
-
-    FrameRows (tty) = FRAME_LINES (f);
-    FrameCols (tty) = FRAME_COLS (f);
-    tty->specified_window = FRAME_LINES (f);
-
-    FRAME_CAN_HAVE_SCROLL_BARS (f) = 0;
-    FRAME_VERTICAL_SCROLL_BAR_TYPE (f) = vertical_scroll_bar_none;
-  }
-#else  /* MSDOS */
-  {
-    int height, width;
-    get_tty_size (fileno (tty->input), &width, &height);
-    FrameCols (tty) = width;
-    FrameRows (tty) = height;
-  }
-#endif  /* MSDOS */
-  tty->delete_in_insert_mode = 1;
-
-  UseTabs (tty) = 0;
-  terminal->scroll_region_ok = 0;
-
-  /* Seems to insert lines when it's not supposed to, messing up the
-     display.  In doing a trace, it didn't seem to be called much, so I
-     don't think we're losing anything by turning it off.  */
-  terminal->line_ins_del_ok = 0;
-#ifdef WINDOWSNT
-  terminal->char_ins_del_ok = 1;
-  baud_rate = 19200;
-#else  /* MSDOS */
-  terminal->char_ins_del_ok = 0;
-  init_baud_rate (fileno (tty->input));
-#endif  /* MSDOS */
-
-  tty->TN_max_colors = 16;  /* Required to be non-zero for tty-display-color-p */
-
-#else  /* not DOS_NT */
-
   Wcm_clear (tty);
 
   tty->termcap_term_buffer = (char *) xmalloc (buffer_size);
@@ -3681,7 +3616,64 @@ use the Bourne shell command `TERM=... export TERM' (C-shell:\n\
   tty->TF_underscore = tgetflag ("ul");
   tty->TF_teleray = tgetflag ("xt");
 
-#endif /* !DOS_NT  */
+#else /* DOS_NT */
+#ifdef WINDOWSNT
+  {
+    struct frame *f = XFRAME (selected_frame);
+
+    initialize_w32_display (terminal);
+
+    FrameRows (tty) = FRAME_LINES (f);
+    FrameCols (tty) = FRAME_COLS (f);
+    tty->specified_window = FRAME_LINES (f);
+
+    FRAME_CAN_HAVE_SCROLL_BARS (f) = 0;
+    FRAME_VERTICAL_SCROLL_BAR_TYPE (f) = vertical_scroll_bar_none;
+    terminal->char_ins_del_ok = 1;
+    baud_rate = 19200;
+  }
+#else  /* MSDOS */
+  {
+    int height, width;
+    if (strcmp (terminal_type, "internal") == 0)
+      terminal->type = output_msdos_raw;
+    initialize_msdos_display (terminal);
+
+    get_tty_size (fileno (tty->input), &width, &height);
+    FrameCols (tty) = width;
+    FrameRows (tty) = height;
+    terminal->char_ins_del_ok = 0;
+    init_baud_rate (fileno (tty->input));
+  }
+#endif  /* MSDOS */
+  tty->output = stdout;
+  tty->input = stdin;
+  /* The following two are inaccessible from w32console.c.  */
+  terminal->delete_frame_hook = &tty_free_frame_resources;
+  terminal->delete_terminal_hook = &delete_tty;
+
+  tty->name = xstrdup (name);
+  terminal->name = xstrdup (name);
+  tty->type = xstrdup (terminal_type);
+
+  add_keyboard_wait_descriptor (0);
+
+  /* FIXME: this should be removed,  done earlier. */
+  Wcm_clear (tty);
+
+  tty->delete_in_insert_mode = 1;
+
+  UseTabs (tty) = 0;
+  terminal->scroll_region_ok = 0;
+
+  /* Seems to insert lines when it's not supposed to, messing up the
+     display.  In doing a trace, it didn't seem to be called much, so I
+     don't think we're losing anything by turning it off.  */
+  terminal->line_ins_del_ok = 0;
+
+  tty->TN_max_colors = 16;  /* Required to be non-zero for tty-display-color-p */
+#endif  /* DOS_NT */
+
   terminal->kboard = (KBOARD *) xmalloc (sizeof (KBOARD));
   init_kboard (terminal->kboard);
   terminal->kboard->Vwindow_system = Qnil;
diff --git a/src/termhooks.h b/src/termhooks.h
index 7762dd15efe..b16c36f9551 100644
--- a/src/termhooks.h
+++ b/src/termhooks.h
@@ -228,9 +228,11 @@ struct input_event
   /* For an ASCII_KEYSTROKE_EVENT and MULTIBYTE_CHAR_KEYSTROKE_EVENT,
      this is the character.
      For a NON_ASCII_KEYSTROKE_EVENT, this is the keysym code.
-     For a mouse event, this is the button number.  */
+     For a mouse event, this is the button number.
+     For a HELP_EVENT, this is the position within the object
+      (stored in ARG below) where the help was found.  */
   /* In WindowsNT, for a mouse wheel event, this is the delta.  */
-  int code;
+  EMACS_INT code;
   enum scroll_bar_part part;
 
   int modifiers;                /* See enum below for interpretation.  */
diff --git a/src/textprop.c b/src/textprop.c
index 0e398e41e4a..88e869b13e9 100644
--- a/src/textprop.c
+++ b/src/textprop.c
@@ -125,7 +125,7 @@ INTERVAL
 validate_interval_range (Lisp_Object object, Lisp_Object *begin, Lisp_Object *end, int force)
 {
   register INTERVAL i;
-  int searchpos;
+  EMACS_INT searchpos;
 
   CHECK_STRING_OR_BUFFER (object);
   CHECK_NUMBER_COERCE_MARKER (*begin);
@@ -161,7 +161,7 @@ validate_interval_range (Lisp_Object object, Lisp_Object *begin, Lisp_Object *en
     }
   else
     {
-      int len = SCHARS (object);
+      EMACS_INT len = SCHARS (object);
 
       if (! (0 <= XINT (*begin) && XINT (*begin) <= XINT (*end)
              && XINT (*end) <= len))
@@ -519,7 +519,7 @@ INTERVAL
 interval_of (int position, Lisp_Object object)
 {
   register INTERVAL i;
-  int beg, end;
+  EMACS_INT beg, end;
 
   if (NILP (object))
     XSETBUFFER (object, current_buffer);
@@ -984,7 +984,7 @@ past position LIMIT; return LIMIT if nothing is found before LIMIT.  */)
 /* Return 1 if there's a change in some property between BEG and END.  */
 
 int
-property_change_between_p (int beg, int end)
+property_change_between_p (EMACS_INT beg, EMACS_INT end)
 {
   register INTERVAL i, next;
   Lisp_Object object, pos;
@@ -1173,7 +1173,8 @@ Return t if any property value actually changed, nil otherwise.  */)
   (Lisp_Object start, Lisp_Object end, Lisp_Object properties, Lisp_Object object)
 {
   register INTERVAL i, unchanged;
-  register int s, len, modified = 0;
+  register EMACS_INT s, len;
+  register int modified = 0;
   struct gcpro gcpro1;
 
   properties = validate_plist (properties);
@@ -1202,7 +1203,7 @@ Return t if any property value actually changed, nil otherwise.  */)
          skip it.  */
       if (interval_has_all_properties (properties, i))
         {
-          int got = (LENGTH (i) - (s - i->position));
+          EMACS_INT got = (LENGTH (i) - (s - i->position));
           if (got >= len)
             RETURN_UNGCPRO (Qnil);
           len -= got;
@@ -1377,7 +1378,7 @@ void
 set_text_properties_1 (Lisp_Object start, Lisp_Object end, Lisp_Object properties, Lisp_Object buffer, INTERVAL i)
 {
   register INTERVAL prev_changed = NULL_INTERVAL;
-  register int s, len;
+  register EMACS_INT s, len;
   INTERVAL unchanged;
 
   s = XINT (start);
@@ -1466,7 +1467,8 @@ Use `set-text-properties' if you want to remove all text properties.  */)
   (Lisp_Object start, Lisp_Object end, Lisp_Object properties, Lisp_Object object)
 {
   register INTERVAL i, unchanged;
-  register int s, len, modified = 0;
+  register EMACS_INT s, len;
+  register int modified = 0;
 
   if (NILP (object))
     XSETBUFFER (object, current_buffer);
@@ -1484,7 +1486,7 @@ Use `set-text-properties' if you want to remove all text properties.  */)
          it covers the entire region.  */
       if (! interval_has_some_properties (properties, i))
         {
-          int got = (LENGTH (i) - (s - i->position));
+          EMACS_INT got = (LENGTH (i) - (s - i->position));
           if (got >= len)
             return Qnil;
           len -= got;
@@ -1551,7 +1553,8 @@ Return t if any property was actually removed, nil otherwise.  */)
   (Lisp_Object start, Lisp_Object end, Lisp_Object list_of_properties, Lisp_Object object)
 {
   register INTERVAL i, unchanged;
-  register int s, len, modified = 0;
+  register EMACS_INT s, len;
+  register int modified = 0;
   Lisp_Object properties;
   properties = list_of_properties;
 
@@ -1571,7 +1574,7 @@ Return t if any property was actually removed, nil otherwise.  */)
          it covers the entire region.  */
       if (! interval_has_some_properties_list (properties, i))
         {
-          int got = (LENGTH (i) - (s - i->position));
+          EMACS_INT got = (LENGTH (i) - (s - i->position));
           if (got >= len)
             return Qnil;
           len -= got;
@@ -1658,7 +1661,7 @@ markers).  If OBJECT is a string, START and END are 0-based indices into it.  */
   (Lisp_Object start, Lisp_Object end, Lisp_Object property, Lisp_Object value, Lisp_Object object)
 {
   register INTERVAL i;
-  register int e, pos;
+  register EMACS_INT e, pos;
 
   if (NILP (object))
     XSETBUFFER (object, current_buffer);
@@ -1694,7 +1697,7 @@ markers).  If OBJECT is a string, START and END are 0-based indices into it.  */
   (Lisp_Object start, Lisp_Object end, Lisp_Object property, Lisp_Object value, Lisp_Object object)
 {
   register INTERVAL i;
-  register int s, e;
+  register EMACS_INT s, e;
 
   if (NILP (object))
     XSETBUFFER (object, current_buffer);
@@ -1806,7 +1809,8 @@ copy_text_properties (Lisp_Object start, Lisp_Object end, Lisp_Object src, Lisp_
   Lisp_Object res;
   Lisp_Object stuff;
   Lisp_Object plist;
-  int s, e, e2, p, len, modified = 0;
+  EMACS_INT s, e, e2, p, len;
+  int modified = 0;
   struct gcpro gcpro1, gcpro2;
 
   i = validate_interval_range (src, &start, &end, soft);
@@ -1902,12 +1906,12 @@ text_property_list (Lisp_Object object, Lisp_Object start, Lisp_Object end, Lisp
   i = validate_interval_range (object, &start, &end, soft);
   if (!NULL_INTERVAL_P (i))
     {
-      int s = XINT (start);
-      int e = XINT (end);
+      EMACS_INT s = XINT (start);
+      EMACS_INT e = XINT (end);
 
       while (s < e)
         {
-          int interval_end, len;
+          EMACS_INT interval_end, len;
           Lisp_Object plist;
 
           interval_end = i->position + LENGTH (i);
@@ -1985,7 +1989,7 @@ Lisp_Object
 extend_property_ranges (Lisp_Object list, Lisp_Object new_end)
 {
   Lisp_Object prev = Qnil, head = list;
-  int max = XINT (new_end);
+  EMACS_INT max = XINT (new_end);
 
   for (; CONSP (list); prev = list, list = XCDR (list))
     {
@@ -2059,7 +2063,7 @@ verify_interval_modification (struct buffer *buf, int start, int end)
 
   if (start > end)
     {
-      int temp = start;
+      EMACS_INT temp = start;
       start = end;
       end = temp;
     }
diff --git a/src/undo.c b/src/undo.c
index 14a8268394a..cd3ad97349b 100644
--- a/src/undo.c
+++ b/src/undo.c
@@ -67,7 +67,7 @@ int undo_inhibit_record_point;
    undo record that will be added just after this command terminates.  */
 
 static void
-record_point (int pt)
+record_point (EMACS_INT pt)
 {
   int at_boundary;
 
@@ -129,7 +129,7 @@ record_point (int pt)
    because we don't need to record the contents.)  */
 
 void
-record_insert (int beg, int length)
+record_insert (EMACS_INT beg, EMACS_INT length)
 {
   Lisp_Object lbeg, lend;
 
@@ -164,7 +164,7 @@ record_insert (int beg, int length)
    of the characters in STRING, at location BEG.  */
 
 void
-record_delete (int beg, Lisp_Object string)
+record_delete (EMACS_INT beg, Lisp_Object string)
 {
   Lisp_Object sbeg;
 
@@ -192,7 +192,7 @@ record_delete (int beg, Lisp_Object string)
    won't be inverted automatically by undoing the buffer modification.  */
 
 void
-record_marker_adjustment (Lisp_Object marker, int adjustment)
+record_marker_adjustment (Lisp_Object marker, EMACS_INT adjustment)
 {
   if (EQ (current_buffer->undo_list, Qt))
     return;
@@ -215,7 +215,7 @@ record_marker_adjustment (Lisp_Object marker, int adjustment)
    The replacement must not change the number of characters.  */
 
 void
-record_change (int beg, int length)
+record_change (EMACS_INT beg, EMACS_INT length)
 {
   record_delete (beg, make_buffer_string (beg, beg + length, 1));
   record_insert (beg, length);
@@ -250,7 +250,9 @@ record_first_change (void)
    for LENGTH characters starting at position BEG in BUFFER.  */
 
 void
-record_property_change (int beg, int length, Lisp_Object prop, Lisp_Object value, Lisp_Object buffer)
+record_property_change (EMACS_INT beg, EMACS_INT length,
+                        Lisp_Object prop, Lisp_Object value,
+                        Lisp_Object buffer)
 {
   Lisp_Object lbeg, lend, entry;
   struct buffer *obuf = current_buffer, *buf = XBUFFER (buffer);
@@ -601,7 +603,7 @@ Return what remains of the list.  */)
                 {
                   /* Element (STRING . POS) means STRING was deleted.  */
                   Lisp_Object membuf;
-                  int pos = XINT (cdr);
+                  EMACS_INT pos = XINT (cdr);
 
                   membuf = car;
                   if (pos < 0)
diff --git a/src/w32.c b/src/w32.c
index f1ed6ae0be9..4ccda449b47 100644
--- a/src/w32.c
+++ b/src/w32.c
@@ -78,15 +78,15 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 /* Some versions of compiler define MEMORYSTATUSEX, some don't, so we
    use a different name to avoid compilation problems.  */
 typedef struct _MEMORY_STATUS_EX {
-        DWORD dwLength;
-        DWORD dwMemoryLoad;
-        DWORDLONG ullTotalPhys;
-        DWORDLONG ullAvailPhys;
-        DWORDLONG ullTotalPageFile;
-        DWORDLONG ullAvailPageFile;
-        DWORDLONG ullTotalVirtual;
-        DWORDLONG ullAvailVirtual;
-        DWORDLONG ullAvailExtendedVirtual;
+  DWORD dwLength;
+  DWORD dwMemoryLoad;
+  DWORDLONG ullTotalPhys;
+  DWORDLONG ullAvailPhys;
+  DWORDLONG ullTotalPageFile;
+  DWORDLONG ullAvailPageFile;
+  DWORDLONG ullTotalVirtual;
+  DWORDLONG ullAvailVirtual;
+  DWORDLONG ullAvailExtendedVirtual;
 } MEMORY_STATUS_EX,*LPMEMORY_STATUS_EX;
 
 #include <lmcons.h>
@@ -94,23 +94,27 @@ typedef struct _MEMORY_STATUS_EX {
 
 #include <tlhelp32.h>
 #include <psapi.h>
+#include <w32api.h>
+#if !defined(__MINGW32__) || __W32API_MAJOR_VERSION < 3 || (__W32API_MAJOR_VERSION == 3 && __W32API_MINOR_VERSION < 15)
 /* This either is not in psapi.h or guarded by higher value of
-   _WIN32_WINNT than what we use.  */
+   _WIN32_WINNT than what we use.  w32api suplied with MinGW 3.15
+   defines it in psapi.h  */
 typedef struct _PROCESS_MEMORY_COUNTERS_EX {
-        DWORD cb;
-        DWORD PageFaultCount;
-        DWORD PeakWorkingSetSize;
-        DWORD WorkingSetSize;
-        DWORD QuotaPeakPagedPoolUsage;
-        DWORD QuotaPagedPoolUsage;
-        DWORD QuotaPeakNonPagedPoolUsage;
-        DWORD QuotaNonPagedPoolUsage;
-        DWORD PagefileUsage;
-        DWORD PeakPagefileUsage;
-        DWORD PrivateUsage;
+  DWORD cb;
+  DWORD PageFaultCount;
+  DWORD PeakWorkingSetSize;
+  DWORD WorkingSetSize;
+  DWORD QuotaPeakPagedPoolUsage;
+  DWORD QuotaPagedPoolUsage;
+  DWORD QuotaPeakNonPagedPoolUsage;
+  DWORD QuotaNonPagedPoolUsage;
+  DWORD PagefileUsage;
+  DWORD PeakPagefileUsage;
+  DWORD PrivateUsage;
 } PROCESS_MEMORY_COUNTERS_EX,*PPROCESS_MEMORY_COUNTERS_EX;
+#endif
 
-#ifdef HAVE_SOCKETS     /* TCP connection support, if kernel can do it */
+/* TCP connection support.  */
 #include <sys/socket.h>
 #undef socket
 #undef bind
@@ -129,7 +133,6 @@ typedef struct _PROCESS_MEMORY_COUNTERS_EX {
 #undef accept
 #undef recvfrom
 #undef sendto
-#endif
 
 #include "w32.h"
 #include "ndir.h"
@@ -169,7 +172,6 @@ static BOOL g_b_init_is_windows_9x;
 static BOOL g_b_init_open_process_token;
 static BOOL g_b_init_get_token_information;
 static BOOL g_b_init_lookup_account_sid;
-static BOOL g_b_init_get_sid_identifier_authority;
 static BOOL g_b_init_get_sid_sub_authority;
 static BOOL g_b_init_get_sid_sub_authority_count;
 static BOOL g_b_init_get_file_security;
@@ -232,8 +234,6 @@ typedef BOOL (WINAPI * LookupAccountSid_Proc) (
     LPTSTR DomainName,
     LPDWORD cbDomainName,
     PSID_NAME_USE peUse);
-typedef PSID_IDENTIFIER_AUTHORITY (WINAPI * GetSidIdentifierAuthority_Proc) (
-    PSID pSid);
 typedef PDWORD (WINAPI * GetSidSubAuthority_Proc) (
     PSID pSid,
     DWORD n);
@@ -300,13 +300,11 @@ typedef BOOL (WINAPI * GetSystemTimes_Proc) (
     LPFILETIME lpKernelTime,
     LPFILETIME lpUserTime);
 
-
-
   /* ** A utility function ** */
 static BOOL
 is_windows_9x (void)
 {
-  static BOOL s_b_ret=0;
+  static BOOL s_b_ret = 0;
   OSVERSIONINFO os_ver;
   if (g_b_init_is_windows_9x == 0)
     {
@@ -363,10 +361,10 @@ w32_get_internal_run_time (void)
 
   /* ** The wrapper functions ** */
 
-BOOL WINAPI open_process_token (
-    HANDLE ProcessHandle,
-    DWORD DesiredAccess,
-    PHANDLE TokenHandle)
+static BOOL WINAPI
+open_process_token (HANDLE ProcessHandle,
+                    DWORD DesiredAccess,
+                    PHANDLE TokenHandle)
 {
   static OpenProcessToken_Proc s_pfn_Open_Process_Token = NULL;
   HMODULE hm_advapi32 = NULL;
@@ -393,12 +391,12 @@ BOOL WINAPI open_process_token (
       );
 }
 
-BOOL WINAPI get_token_information (
-    HANDLE TokenHandle,
-    TOKEN_INFORMATION_CLASS TokenInformationClass,
-    LPVOID TokenInformation,
-    DWORD TokenInformationLength,
-    PDWORD ReturnLength)
+static BOOL WINAPI
+get_token_information (HANDLE TokenHandle,
+                       TOKEN_INFORMATION_CLASS TokenInformationClass,
+                       LPVOID TokenInformation,
+                       DWORD TokenInformationLength,
+                       PDWORD ReturnLength)
 {
   static GetTokenInformation_Proc s_pfn_Get_Token_Information = NULL;
   HMODULE hm_advapi32 = NULL;
@@ -427,14 +425,14 @@ BOOL WINAPI get_token_information (
       );
 }
 
-BOOL WINAPI lookup_account_sid (
-    LPCTSTR lpSystemName,
-    PSID Sid,
-    LPTSTR Name,
-    LPDWORD cbName,
-    LPTSTR DomainName,
-    LPDWORD cbDomainName,
-    PSID_NAME_USE peUse)
+static BOOL WINAPI
+lookup_account_sid (LPCTSTR lpSystemName,
+                    PSID Sid,
+                    LPTSTR Name,
+                    LPDWORD cbName,
+                    LPTSTR DomainName,
+                    LPDWORD cbDomainName,
+                    PSID_NAME_USE peUse)
 {
   static LookupAccountSid_Proc s_pfn_Lookup_Account_Sid = NULL;
   HMODULE hm_advapi32 = NULL;
@@ -465,33 +463,8 @@ BOOL WINAPI lookup_account_sid (
       );
 }
 
-PSID_IDENTIFIER_AUTHORITY WINAPI get_sid_identifier_authority (
-    PSID pSid)
-{
-  static GetSidIdentifierAuthority_Proc s_pfn_Get_Sid_Identifier_Authority = NULL;
-  HMODULE hm_advapi32 = NULL;
-  if (is_windows_9x () == TRUE)
-    {
-      return NULL;
-    }
-  if (g_b_init_get_sid_identifier_authority == 0)
-    {
-      g_b_init_get_sid_identifier_authority = 1;
-      hm_advapi32 = LoadLibrary ("Advapi32.dll");
-      s_pfn_Get_Sid_Identifier_Authority =
-        (GetSidIdentifierAuthority_Proc) GetProcAddress (
-            hm_advapi32, "GetSidIdentifierAuthority");
-    }
-  if (s_pfn_Get_Sid_Identifier_Authority == NULL)
-    {
-      return NULL;
-    }
-  return (s_pfn_Get_Sid_Identifier_Authority (pSid));
-}
-
-PDWORD WINAPI get_sid_sub_authority (
-    PSID pSid,
-    DWORD n)
+static PDWORD WINAPI
+get_sid_sub_authority (PSID pSid, DWORD n)
 {
   static GetSidSubAuthority_Proc s_pfn_Get_Sid_Sub_Authority = NULL;
   static DWORD zero = 0U;
@@ -515,8 +488,8 @@ PDWORD WINAPI get_sid_sub_authority (
   return (s_pfn_Get_Sid_Sub_Authority (pSid, n));
 }
 
-PUCHAR WINAPI get_sid_sub_authority_count (
-    PSID pSid)
+static PUCHAR WINAPI
+get_sid_sub_authority_count (PSID pSid)
 {
   static GetSidSubAuthorityCount_Proc s_pfn_Get_Sid_Sub_Authority_Count = NULL;
   static UCHAR zero = 0U;
@@ -540,12 +513,12 @@ PUCHAR WINAPI get_sid_sub_authority_count (
   return (s_pfn_Get_Sid_Sub_Authority_Count (pSid));
 }
 
-BOOL WINAPI get_file_security (
-    LPCTSTR lpFileName,
-    SECURITY_INFORMATION RequestedInformation,
-    PSECURITY_DESCRIPTOR pSecurityDescriptor,
-    DWORD nLength,
-    LPDWORD lpnLengthNeeded)
+static BOOL WINAPI
+get_file_security (LPCTSTR lpFileName,
+                   SECURITY_INFORMATION RequestedInformation,
+                   PSECURITY_DESCRIPTOR pSecurityDescriptor,
+                   DWORD nLength,
+                   LPDWORD lpnLengthNeeded)
 {
   static GetFileSecurity_Proc s_pfn_Get_File_Security = NULL;
   HMODULE hm_advapi32 = NULL;
@@ -570,10 +543,10 @@ BOOL WINAPI get_file_security (
                                    lpnLengthNeeded));
 }
 
-BOOL WINAPI get_security_descriptor_owner (
-    PSECURITY_DESCRIPTOR pSecurityDescriptor,
-    PSID *pOwner,
-    LPBOOL lpbOwnerDefaulted)
+static BOOL WINAPI
+get_security_descriptor_owner (PSECURITY_DESCRIPTOR pSecurityDescriptor,
+                               PSID *pOwner,
+                               LPBOOL lpbOwnerDefaulted)
 {
   static GetSecurityDescriptorOwner_Proc s_pfn_Get_Security_Descriptor_Owner = NULL;
   HMODULE hm_advapi32 = NULL;
@@ -597,10 +570,10 @@ BOOL WINAPI get_security_descriptor_owner (
                                                lpbOwnerDefaulted));
 }
 
-BOOL WINAPI get_security_descriptor_group (
-    PSECURITY_DESCRIPTOR pSecurityDescriptor,
-    PSID *pGroup,
-    LPBOOL lpbGroupDefaulted)
+static BOOL WINAPI
+get_security_descriptor_group (PSECURITY_DESCRIPTOR pSecurityDescriptor,
+                               PSID *pGroup,
+                               LPBOOL lpbGroupDefaulted)
 {
   static GetSecurityDescriptorGroup_Proc s_pfn_Get_Security_Descriptor_Group = NULL;
   HMODULE hm_advapi32 = NULL;
@@ -624,8 +597,8 @@ BOOL WINAPI get_security_descriptor_group (
                                                lpbGroupDefaulted));
 }
 
-BOOL WINAPI is_valid_sid (
-    PSID sid)
+static BOOL WINAPI
+is_valid_sid (PSID sid)
 {
   static IsValidSid_Proc s_pfn_Is_Valid_Sid = NULL;
   HMODULE hm_advapi32 = NULL;
@@ -648,9 +621,8 @@ BOOL WINAPI is_valid_sid (
   return (s_pfn_Is_Valid_Sid (sid));
 }
 
-BOOL WINAPI equal_sid (
-    PSID sid1,
-    PSID sid2)
+static BOOL WINAPI
+equal_sid (PSID sid1, PSID sid2)
 {
   static EqualSid_Proc s_pfn_Equal_Sid = NULL;
   HMODULE hm_advapi32 = NULL;
@@ -673,8 +645,8 @@ BOOL WINAPI equal_sid (
   return (s_pfn_Equal_Sid (sid1, sid2));
 }
 
-DWORD WINAPI get_length_sid (
-    PSID sid)
+static DWORD WINAPI
+get_length_sid (PSID sid)
 {
   static GetLengthSid_Proc s_pfn_Get_Length_Sid = NULL;
   HMODULE hm_advapi32 = NULL;
@@ -697,10 +669,8 @@ DWORD WINAPI get_length_sid (
   return (s_pfn_Get_Length_Sid (sid));
 }
 
-BOOL WINAPI copy_sid (
-    DWORD destlen,
-    PSID dest,
-    PSID src)
+static BOOL WINAPI
+copy_sid (DWORD destlen, PSID dest, PSID src)
 {
   static CopySid_Proc s_pfn_Copy_Sid = NULL;
   HMODULE hm_advapi32 = NULL;
@@ -729,8 +699,8 @@ BOOL WINAPI copy_sid (
   supported in Windows NT / 2k / XP
 */
 
-void WINAPI get_native_system_info (
-    LPSYSTEM_INFO lpSystemInfo)
+static void WINAPI
+get_native_system_info (LPSYSTEM_INFO lpSystemInfo)
 {
   static GetNativeSystemInfo_Proc s_pfn_Get_Native_System_Info = NULL;
   if (is_windows_9x () != TRUE)
@@ -749,10 +719,10 @@ void WINAPI get_native_system_info (
     lpSystemInfo->dwNumberOfProcessors = -1;
 }
 
-BOOL WINAPI get_system_times (
-    LPFILETIME lpIdleTime,
-    LPFILETIME lpKernelTime,
-    LPFILETIME lpUserTime)
+static BOOL WINAPI
+get_system_times (LPFILETIME lpIdleTime,
+                  LPFILETIME lpKernelTime,
+                  LPFILETIME lpUserTime)
 {
   static GetSystemTimes_Proc s_pfn_Get_System_times = NULL;
   if (is_windows_9x () == TRUE)
@@ -830,17 +800,6 @@ getwd (char *dir)
 #endif
 }
 
-#ifndef HAVE_SOCKETS
-/* Emulate gethostname.  */
-int
-gethostname (char *buffer, int size)
-{
-  /* NT only allows small host names, so the buffer is
-     certainly large enough.  */
-  return !GetComputerName (buffer, &size);
-}
-#endif /* HAVE_SOCKETS */
-
 /* Emulate getloadavg.  */
 
 struct load_sample {
@@ -1086,7 +1045,7 @@ getpwnam (char *name)
   return pw;
 }
 
-void
+static void
 init_user_info (void)
 {
   /* Find the user's real name by opening the process token and
@@ -1292,7 +1251,7 @@ unixtodos_filename (register char *p)
 /* Remove all CR's that are followed by a LF.
    (From msdos.c...probably should figure out a way to share it,
    although this code isn't going to ever change.)  */
-int
+static int
 crlf_to_lf (register int n, register unsigned char *buf)
 {
   unsigned char *np = buf;
@@ -1431,7 +1390,7 @@ w32_get_long_filename (char * name, char * buf, int size)
   return TRUE;
 }
 
-int
+static int
 is_unc_volume (const char *filename)
 {
   const char *ptr = filename;
@@ -1933,7 +1892,25 @@ get_emacs_configuration (void)
 char *
 get_emacs_configuration_options (void)
 {
-  static char options_buffer[256];
+  static char *options_buffer;
+  char cv[32];  /* Enough for COMPILER_VERSION.  */
+  char *options[] = {
+    cv,  /* To be filled later.  */
+#ifdef EMACSDEBUG
+    " --no-opt",
+#endif
+    /* configure.bat already sets USER_CFLAGS and USER_LDFLAGS
+       with a starting space to save work here.  */
+#ifdef USER_CFLAGS
+    " --cflags", USER_CFLAGS,
+#endif
+#ifdef USER_LDFLAGS
+    " --ldflags", USER_LDFLAGS,
+#endif
+    NULL
+  };
+  size_t size = 0;
+  int i;
 
 /* Work out the effective configure options for this build.  */
 #ifdef _MSC_VER
@@ -1946,18 +1923,19 @@ get_emacs_configuration_options (void)
 #endif
 #endif
 
-  sprintf (options_buffer, COMPILER_VERSION);
-#ifdef EMACSDEBUG
-  strcat (options_buffer, " --no-opt");
-#endif
-#ifdef USER_CFLAGS
-  strcat (options_buffer, " --cflags");
-  strcat (options_buffer, USER_CFLAGS);
-#endif
-#ifdef USER_LDFLAGS
-  strcat (options_buffer, " --ldflags");
-  strcat (options_buffer, USER_LDFLAGS);
-#endif
+  if (_snprintf (cv, sizeof (cv) - 1, COMPILER_VERSION) < 0)
+    return "Error: not enough space for compiler version";
+  cv[sizeof (cv) - 1] = '\0';
+
+  for (i = 0; options[i]; i++)
+    size += strlen (options[i]);
+
+  options_buffer = xmalloc (size + 1);
+  options_buffer[0] = '\0';
+
+  for (i = 0; options[i]; i++)
+    strcat (options_buffer, options[i]);
+
   return options_buffer;
 }
 
@@ -2068,7 +2046,7 @@ add_volume_info (char * root_dir, volume_info_data * info)
 /* Wrapper for GetVolumeInformation, which uses caching to avoid
    performance penalty (~2ms on 486 for local drives, 7.5ms for local
    cdrom drive, ~5-10ms or more for remote drives on LAN).  */
-volume_info_data *
+static volume_info_data *
 GetCachedVolumeInformation (char * root_dir)
 {
   volume_info_data * info;
@@ -2159,7 +2137,7 @@ GetCachedVolumeInformation (char * root_dir)
 
 /* Get information on the volume where name is held; set path pointer to
    start of pathname in name (past UNC header\volume header if present).  */
-int
+static int
 get_volume_info (const char * name, const char ** pPath)
 {
   char temp[MAX_PATH];
@@ -2210,7 +2188,7 @@ get_volume_info (const char * name, const char ** pPath)
 
 /* Determine if volume is FAT format (ie. only supports short 8.3
    names); also set path pointer to start of pathname in name.  */
-int
+static int
 is_fat_volume (const char * name, const char ** pPath)
 {
   if (get_volume_info (name, pPath))
@@ -2348,9 +2326,9 @@ static WIN32_FIND_DATA dir_find_data;
 /* Support shares on a network resource as subdirectories of a read-only
    root directory. */
 static HANDLE wnet_enum_handle = INVALID_HANDLE_VALUE;
-HANDLE open_unc_volume (const char *);
-char  *read_unc_volume (HANDLE, char *, int);
-void   close_unc_volume (HANDLE);
+static HANDLE open_unc_volume (const char *);
+static char  *read_unc_volume (HANDLE, char *, int);
+static void   close_unc_volume (HANDLE);
 
 DIR *
 opendir (char *filename)
@@ -2486,7 +2464,7 @@ readdir (DIR *dirp)
   return &dir_static;
 }
 
-HANDLE
+static HANDLE
 open_unc_volume (const char *path)
 {
   NETRESOURCE nr;
@@ -2511,7 +2489,7 @@ open_unc_volume (const char *path)
     return INVALID_HANDLE_VALUE;
 }
 
-char *
+static char *
 read_unc_volume (HANDLE henum, char *readbuf, int size)
 {
   DWORD count;
@@ -2536,14 +2514,14 @@ read_unc_volume (HANDLE henum, char *readbuf, int size)
   return readbuf;
 }
 
-void
+static void
 close_unc_volume (HANDLE henum)
 {
   if (henum != INVALID_HANDLE_VALUE)
     WNetCloseEnum (henum);
 }
 
-DWORD
+static DWORD
 unc_volume_file_attributes (const char *path)
 {
   HANDLE henum;
@@ -3003,8 +2981,7 @@ convert_time (FILETIME ft)
   return (time_t) ((tmp - utc_base) / 10000000L);
 }
 
-
-void
+static void
 convert_from_time_t (time_t time, FILETIME * pft)
 {
   ULARGE_INTEGER tmp;
@@ -3225,10 +3202,9 @@ get_name_and_id (PSECURITY_DESCRIPTOR psd, const char *fname,
 }
 
 static void
-get_file_owner_and_group (
-    PSECURITY_DESCRIPTOR psd,
-    const char *fname,
-    struct stat *st)
+get_file_owner_and_group (PSECURITY_DESCRIPTOR psd,
+                          const char *fname,
+                          struct stat *st)
 {
   int dflt_usr = 0, dflt_grp = 0;
 
@@ -3481,7 +3457,6 @@ stat (const char * path, struct stat * buf)
   buf->st_dev = volume_info.serialnum;
   buf->st_rdev = volume_info.serialnum;
 
-
   buf->st_size = wfd.nFileSizeHigh;
   buf->st_size <<= 32;
   buf->st_size += wfd.nFileSizeLow;
@@ -3654,9 +3629,8 @@ utime (const char *name, struct utimbuf *times)
 
 /* Helper wrapper functions.  */
 
-HANDLE WINAPI create_toolhelp32_snapshot (
-    DWORD Flags,
-    DWORD Ignored)
+static HANDLE WINAPI
+create_toolhelp32_snapshot (DWORD Flags, DWORD Ignored)
 {
   static CreateToolhelp32Snapshot_Proc s_pfn_Create_Toolhelp32_Snapshot = NULL;
 
@@ -3674,9 +3648,8 @@ HANDLE WINAPI create_toolhelp32_snapshot (
   return (s_pfn_Create_Toolhelp32_Snapshot (Flags, Ignored));
 }
 
-BOOL WINAPI process32_first (
-    HANDLE hSnapshot,
-    LPPROCESSENTRY32 lppe)
+static BOOL WINAPI
+process32_first (HANDLE hSnapshot, LPPROCESSENTRY32 lppe)
 {
   static Process32First_Proc s_pfn_Process32_First = NULL;
 
@@ -3694,9 +3667,8 @@ BOOL WINAPI process32_first (
   return (s_pfn_Process32_First (hSnapshot, lppe));
 }
 
-BOOL WINAPI process32_next (
-    HANDLE hSnapshot,
-    LPPROCESSENTRY32 lppe)
+static BOOL WINAPI
+process32_next (HANDLE hSnapshot, LPPROCESSENTRY32 lppe)
 {
   static Process32Next_Proc s_pfn_Process32_Next = NULL;
 
@@ -3714,11 +3686,11 @@ BOOL WINAPI process32_next (
   return (s_pfn_Process32_Next (hSnapshot, lppe));
 }
 
-BOOL WINAPI open_thread_token (
-    HANDLE ThreadHandle,
-    DWORD DesiredAccess,
-    BOOL OpenAsSelf,
-    PHANDLE TokenHandle)
+static BOOL WINAPI
+open_thread_token (HANDLE ThreadHandle,
+                   DWORD DesiredAccess,
+                   BOOL OpenAsSelf,
+                   PHANDLE TokenHandle)
 {
   static OpenThreadToken_Proc s_pfn_Open_Thread_Token = NULL;
   HMODULE hm_advapi32 = NULL;
@@ -3748,8 +3720,8 @@ BOOL WINAPI open_thread_token (
       );
 }
 
-BOOL WINAPI impersonate_self (
-    SECURITY_IMPERSONATION_LEVEL ImpersonationLevel)
+static BOOL WINAPI
+impersonate_self (SECURITY_IMPERSONATION_LEVEL ImpersonationLevel)
 {
   static ImpersonateSelf_Proc s_pfn_Impersonate_Self = NULL;
   HMODULE hm_advapi32 = NULL;
@@ -3771,7 +3743,8 @@ BOOL WINAPI impersonate_self (
   return s_pfn_Impersonate_Self (ImpersonationLevel);
 }
 
-BOOL WINAPI revert_to_self (void)
+static BOOL WINAPI
+revert_to_self (void)
 {
   static RevertToSelf_Proc s_pfn_Revert_To_Self = NULL;
   HMODULE hm_advapi32 = NULL;
@@ -3793,10 +3766,10 @@ BOOL WINAPI revert_to_self (void)
   return s_pfn_Revert_To_Self ();
 }
 
-BOOL WINAPI get_process_memory_info (
-    HANDLE h_proc,
-    PPROCESS_MEMORY_COUNTERS mem_counters,
-    DWORD bufsize)
+static BOOL WINAPI
+get_process_memory_info (HANDLE h_proc,
+                         PPROCESS_MEMORY_COUNTERS mem_counters,
+                         DWORD bufsize)
 {
   static GetProcessMemoryInfo_Proc s_pfn_Get_Process_Memory_Info = NULL;
   HMODULE hm_psapi = NULL;
@@ -3819,10 +3792,10 @@ BOOL WINAPI get_process_memory_info (
   return s_pfn_Get_Process_Memory_Info (h_proc, mem_counters, bufsize);
 }
 
-BOOL WINAPI get_process_working_set_size (
-    HANDLE h_proc,
-    DWORD *minrss,
-    DWORD *maxrss)
+static BOOL WINAPI
+get_process_working_set_size (HANDLE h_proc,
+                              DWORD *minrss,
+                              DWORD *maxrss)
 {
   static GetProcessWorkingSetSize_Proc
     s_pfn_Get_Process_Working_Set_Size = NULL;
@@ -3845,8 +3818,8 @@ BOOL WINAPI get_process_working_set_size (
   return s_pfn_Get_Process_Working_Set_Size (h_proc, minrss, maxrss);
 }
 
-BOOL WINAPI global_memory_status (
-    MEMORYSTATUS *buf)
+static BOOL WINAPI
+global_memory_status (MEMORYSTATUS *buf)
 {
   static GlobalMemoryStatus_Proc s_pfn_Global_Memory_Status = NULL;
 
@@ -3868,8 +3841,8 @@ BOOL WINAPI global_memory_status (
   return s_pfn_Global_Memory_Status (buf);
 }
 
-BOOL WINAPI global_memory_status_ex (
-    MEMORY_STATUS_EX *buf)
+static BOOL WINAPI
+global_memory_status_ex (MEMORY_STATUS_EX *buf)
 {
   static GlobalMemoryStatusEx_Proc s_pfn_Global_Memory_Status_Ex = NULL;
 
@@ -4348,8 +4321,6 @@ system_process_attributes (Lisp_Object pid)
 }
 
 
-#ifdef HAVE_SOCKETS
-
 /* Wrappers for  winsock functions to map between our file descriptors
    and winsock's handles; also set h_errno for convenience.
 
@@ -4429,7 +4400,6 @@ init_winsock (int load_now)
   if (winsock_lib != NULL)
     return TRUE;
 
-  pfn_SetHandleInformation = NULL;
   pfn_SetHandleInformation
     = (void *) GetProcAddress (GetModuleHandle ("kernel32.dll"),
                                "SetHandleInformation");
@@ -4636,15 +4606,9 @@ sys_strerror (int error_no)
    but I believe the method of keeping the socket handle separate (and
    insuring it is not inheritable) is the correct one. */
 
-//#define SOCK_REPLACE_HANDLE
-
-#ifdef SOCK_REPLACE_HANDLE
-#define SOCK_HANDLE(fd) ((SOCKET) _get_osfhandle (fd))
-#else
 #define SOCK_HANDLE(fd) ((SOCKET) fd_info[fd].hnd)
-#endif
 
-int socket_to_fd (SOCKET s);
+static int socket_to_fd (SOCKET s);
 
 int
 sys_socket (int af, int type, int protocol)
@@ -4670,7 +4634,7 @@ sys_socket (int af, int type, int protocol)
 }
 
 /* Convert a SOCKET to a file descriptor.  */
-int
+static int
 socket_to_fd (SOCKET s)
 {
   int fd;
@@ -4686,13 +4650,6 @@ socket_to_fd (SOCKET s)
   fd = _open ("NUL:", _O_RDWR);
   if (fd >= 0)
     {
-#ifdef SOCK_REPLACE_HANDLE
-      /* now replace handle to NUL with our socket handle */
-      CloseHandle ((HANDLE) _get_osfhandle (fd));
-      _free_osfhnd (fd);
-      _set_osfhnd (fd, s);
-      /* setmode (fd, _O_BINARY); */
-#else
       /* Make a non-inheritable copy of the socket handle.  Note
          that it is possible that sockets aren't actually kernel
          handles, which appears to be the case on Windows 9x when
@@ -4738,7 +4695,6 @@ socket_to_fd (SOCKET s)
           }
       }
       fd_info[fd].hnd = (HANDLE) s;
-#endif
 
       /* set our own internal flags */
       fd_info[fd].flags = FILE_SOCKET | FILE_BINARY | FILE_READ | FILE_WRITE;
@@ -4771,7 +4727,6 @@ socket_to_fd (SOCKET s)
   return -1;
 }
 
-
 int
 sys_bind (int s, const struct sockaddr * addr, int namelen)
 {
@@ -4793,7 +4748,6 @@ sys_bind (int s, const struct sockaddr * addr, int namelen)
   return SOCKET_ERROR;
 }
 
-
 int
 sys_connect (int s, const struct sockaddr * name, int namelen)
 {
@@ -4906,7 +4860,6 @@ sys_getpeername (int s, struct sockaddr *addr, int * namelen)
   return SOCKET_ERROR;
 }
 
-
 int
 sys_shutdown (int s, int how)
 {
@@ -5099,8 +5052,6 @@ fcntl (int s, int cmd, int options)
   return SOCKET_ERROR;
 }
 
-#endif /* HAVE_SOCKETS */
-
 
 /* Shadow main io functions: we need to handle pipes and sockets more
    intelligently, and implement non-blocking mode as well. */
@@ -5135,18 +5086,15 @@ sys_close (int fd)
             }
           if (i == MAXDESC)
             {
-#ifdef HAVE_SOCKETS
               if (fd_info[fd].flags & FILE_SOCKET)
                 {
-#ifndef SOCK_REPLACE_HANDLE
                   if (winsock_lib == NULL) abort ();
 
                   pfn_shutdown (SOCK_HANDLE (fd), 2);
                   rc = pfn_closesocket (SOCK_HANDLE (fd));
-#endif
+
                   winsock_inuse--; /* count open sockets */
                 }
-#endif
               delete_child (cp);
             }
         }
@@ -5178,7 +5126,6 @@ sys_dup (int fd)
   return new_fd;
 }
 
-
 int
 sys_dup2 (int src, int dst)
 {
@@ -5314,7 +5261,6 @@ _sys_read_ahead (int fd)
             return STATUS_READ_ERROR;
         }
     }
-#ifdef HAVE_SOCKETS
   else if (fd_info[fd].flags & FILE_SOCKET)
     {
       unsigned long nblock = 0;
@@ -5330,7 +5276,6 @@ _sys_read_ahead (int fd)
           pfn_ioctlsocket (SOCK_HANDLE (fd), FIONBIO, &nblock);
         }
     }
-#endif
 
   if (rc == sizeof (char))
     cp->status = STATUS_READ_SUCCEEDED;
@@ -5502,7 +5447,6 @@ sys_read (int fd, char * buffer, unsigned int count)
                   nchars += rc;
                 }
             }
-#ifdef HAVE_SOCKETS
           else /* FILE_SOCKET */
             {
               if (winsock_lib == NULL) abort ();
@@ -5529,7 +5473,6 @@ sys_read (int fd, char * buffer, unsigned int count)
                   nchars += res;
                 }
             }
-#endif
         }
       else
         {
@@ -5654,9 +5597,7 @@ sys_write (int fd, const void * buffer, unsigned int count)
             }
         }
     }
-  else
-#ifdef HAVE_SOCKETS
-  if (fd < MAXDESC && fd_info[fd].flags & FILE_SOCKET)
+  else if (fd < MAXDESC && fd_info[fd].flags & FILE_SOCKET)
     {
       unsigned long nblock = 0;
       if (winsock_lib == NULL) abort ();
@@ -5684,7 +5625,6 @@ sys_write (int fd, const void * buffer, unsigned int count)
         }
     }
   else
-#endif
     {
       /* Some networked filesystems don't like too large writes, so
          break them into smaller chunks.  See the Comments section of
@@ -5776,10 +5716,8 @@ check_windows_init_file (void)
 void
 term_ntproc (void)
 {
-#ifdef HAVE_SOCKETS
   /* shutdown the socket interface if necessary */
   term_winsock ();
-#endif
 
   term_w32select ();
 }
@@ -5787,7 +5725,6 @@ term_ntproc (void)
 void
 init_ntproc (void)
 {
-#ifdef HAVE_SOCKETS
   /* Initialise the socket interface now if available and requested by
      the user by defining PRELOAD_WINSOCK; otherwise loading will be
      delayed until open-network-stream is called (w32-has-winsock can
@@ -5801,7 +5738,6 @@ init_ntproc (void)
 
   if (getenv ("PRELOAD_WINSOCK") != NULL)
     init_winsock (TRUE);
-#endif
 
   /* Initial preparation for subprocess support: replace our standard
      handles with non-inheritable versions. */
@@ -5893,7 +5829,7 @@ init_ntproc (void)
         shutdown_handler ensures that buffers' autosave files are
         up to date when the user logs off, or the system shuts down.
 */
-BOOL WINAPI
+static BOOL WINAPI
 shutdown_handler (DWORD type)
 {
   /* Ctrl-C and Ctrl-Break are already suppressed, so don't handle them.  */
@@ -5926,7 +5862,6 @@ globals_of_w32 (void)
   g_b_init_open_process_token = 0;
   g_b_init_get_token_information = 0;
   g_b_init_lookup_account_sid = 0;
-  g_b_init_get_sid_identifier_authority = 0;
   g_b_init_get_sid_sub_authority = 0;
   g_b_init_get_sid_sub_authority_count = 0;
   g_b_init_get_file_security = 0;
diff --git a/src/w32fns.c b/src/w32fns.c
index f91ad948828..5e5f11c813d 100644
--- a/src/w32fns.c
+++ b/src/w32fns.c
@@ -262,7 +262,6 @@ typedef BOOL (WINAPI * GetMonitorInfo_Proc)
   (IN HMONITOR monitor, OUT struct MONITOR_INFO* info);
 
 TrackMouseEvent_Proc track_mouse_event_fn = NULL;
-ClipboardSequence_Proc clipboard_sequence_fn = NULL;
 ImmGetCompositionString_Proc get_composition_string_fn = NULL;
 ImmGetContext_Proc get_ime_context_fn = NULL;
 ImmReleaseContext_Proc release_ime_context_fn = NULL;
@@ -7183,9 +7182,6 @@ globals_of_w32fns (void)
   */
   track_mouse_event_fn = (TrackMouseEvent_Proc)
     GetProcAddress (user32_lib, "TrackMouseEvent");
-  /* ditto for GetClipboardSequenceNumber.  */
-  clipboard_sequence_fn = (ClipboardSequence_Proc)
-    GetProcAddress (user32_lib, "GetClipboardSequenceNumber");
 
   monitor_from_point_fn = (MonitorFromPoint_Proc)
     GetProcAddress (user32_lib, "MonitorFromPoint");
diff --git a/src/w32proc.c b/src/w32proc.c
index af923723709..ae4e725b6ef 100644
--- a/src/w32proc.c
+++ b/src/w32proc.c
@@ -1694,8 +1694,6 @@ set_process_dir (char * dir)
   process_dir = dir;
 }
 
-#ifdef HAVE_SOCKETS
-
 /* To avoid problems with winsock implementations that work over dial-up
    connections causing or requiring a connection to exist while Emacs is
    running, Emacs no longer automatically loads winsock on startup if it
@@ -1759,8 +1757,6 @@ socket connections still exist.  */)
   return term_winsock () ? Qt : Qnil;
 }
 
-#endif /* HAVE_SOCKETS */
-
 
 /* Some miscellaneous functions that are Windows specific, but not GUI
    specific (ie. are applicable in terminal or batch mode as well).  */
@@ -2268,10 +2264,9 @@ syms_of_ntproc (void)
   DEFSYM (Qhigh, "high");
   DEFSYM (Qlow, "low");
 
-#ifdef HAVE_SOCKETS
   defsubr (&Sw32_has_winsock);
   defsubr (&Sw32_unload_winsock);
-#endif
+
   defsubr (&Sw32_short_file_name);
   defsubr (&Sw32_long_file_name);
   defsubr (&Sw32_set_process_priority);
diff --git a/src/window.c b/src/window.c
index 1fabe72d72d..7591401ee42 100644
--- a/src/window.c
+++ b/src/window.c
@@ -311,7 +311,7 @@ display row, and VPOS is the row number (0-based) containing POS.  */)
   (Lisp_Object pos, Lisp_Object window, Lisp_Object partially)
 {
   register struct window *w;
-  register int posint;
+  register EMACS_INT posint;
   register struct buffer *buf;
   struct text_pos top;
   Lisp_Object in_window = Qnil;
@@ -2500,7 +2500,7 @@ window-start value is reasonable when this function is called.  */)
   (Lisp_Object window)
 {
   struct window *w;
-  int startpos;
+  EMACS_INT startpos;
   int top, new_top;
 
   if (NILP (window))
@@ -3629,7 +3629,7 @@ selected window before each command.  */)
      redisplay_window has altered point after scrolling,
      because it makes the change only in the window.  */
   {
-    register int new_point = marker_position (w->pointm);
+    register EMACS_INT new_point = marker_position (w->pointm);
     if (new_point < BEGV)
       SET_PT (BEGV);
     else if (new_point > ZV)
@@ -4848,7 +4848,7 @@ window_scroll_pixel_based (Lisp_Object window, int n, int whole, int noerror)
               /* Maybe modify window start instead of scrolling.  */
               if (rbot > 0 || w->vscroll < 0)
                 {
-                  int spos;
+                  EMACS_INT spos;
 
                   Fset_window_vscroll (window, make_number (0), Qt);
                   /* If there are other text lines above the current row,
@@ -4902,7 +4902,7 @@ window_scroll_pixel_based (Lisp_Object window, int n, int whole, int noerror)
   start_display (&it, w, start);
   if (whole)
     {
-      int start_pos = IT_CHARPOS (it);
+      EMACS_INT start_pos = IT_CHARPOS (it);
       int dy = WINDOW_FRAME_LINE_HEIGHT (w);
       dy = max ((window_box_height (w)
                  - next_screen_context_lines * dy),
@@ -4981,8 +4981,8 @@ window_scroll_pixel_based (Lisp_Object window, int n, int whole, int noerror)
 
   if (! vscrolled)
     {
-      int pos = IT_CHARPOS (it);
-      int bytepos;
+      EMACS_INT pos = IT_CHARPOS (it);
+      EMACS_INT bytepos;
 
       /* If in the middle of a multi-glyph character move forward to
          the next character.  */
@@ -5052,7 +5052,7 @@ window_scroll_pixel_based (Lisp_Object window, int n, int whole, int noerror)
     }
   else if (n < 0)
     {
-      int charpos, bytepos;
+      EMACS_INT charpos, bytepos;
       int partial_p;
 
       /* Save our position, for the
@@ -5122,13 +5122,13 @@ static void
 window_scroll_line_based (Lisp_Object window, int n, int whole, int noerror)
 {
   register struct window *w = XWINDOW (window);
-  register int opoint = PT, opoint_byte = PT_BYTE;
-  register int pos, pos_byte;
+  register EMACS_INT opoint = PT, opoint_byte = PT_BYTE;
+  register EMACS_INT pos, pos_byte;
   register int ht = window_internal_height (w);
   register Lisp_Object tem;
   int lose;
   Lisp_Object bolp;
-  int startpos;
+  EMACS_INT startpos;
   Lisp_Object original_pos = Qnil;
 
   /* If scrolling screen-fulls, compute the number of lines to
@@ -5573,7 +5573,7 @@ and redisplay normally--don't erase and redraw the frame.  */)
   struct buffer *buf = XBUFFER (w->buffer);
   struct buffer *obuf = current_buffer;
   int center_p = 0;
-  int charpos, bytepos;
+  EMACS_INT charpos, bytepos;
   int iarg;
   int this_scroll_margin;
 
@@ -5914,7 +5914,7 @@ the return value is nil.  Otherwise the value is t.  */)
   Lisp_Object new_current_buffer;
   Lisp_Object frame;
   FRAME_PTR f;
-  int old_point = -1;
+  EMACS_INT old_point = -1;
 
   CHECK_WINDOW_CONFIGURATION (configuration);
 
diff --git a/src/xdisp.c b/src/xdisp.c
index 2ec271cdb6b..9b0f94ef657 100644
--- a/src/xdisp.c
+++ b/src/xdisp.c
@@ -907,7 +907,7 @@ Lisp_Object Qinhibit_free_realized_faces;
 Lisp_Object help_echo_string;
 Lisp_Object help_echo_window;
 Lisp_Object help_echo_object;
-int help_echo_pos;
+EMACS_INT help_echo_pos;
 
 /* Temporary variable for XTread_socket.  */
 
@@ -956,7 +956,8 @@ static void pint2hrstr (char *, int, int);
 static struct text_pos run_window_scroll_functions (Lisp_Object,
                                                     struct text_pos);
 static void reconsider_clip_changes (struct window *, struct buffer *);
-static int text_outside_line_unchanged_p (struct window *, int, int);
+static int text_outside_line_unchanged_p (struct window *,
+                                          EMACS_INT, EMACS_INT);
 static void store_mode_line_noprop_char (char);
 static int store_mode_line_noprop (const unsigned char *, int, int);
 static void x_consider_frame_title (Lisp_Object);
@@ -991,8 +992,9 @@ static int append_space_for_newline (struct it *, int);
 static int cursor_row_fully_visible_p (struct window *, int, int);
 static int try_scrolling (Lisp_Object, int, EMACS_INT, EMACS_INT, int, int);
 static int try_cursor_movement (Lisp_Object, struct text_pos, int *);
-static int trailing_whitespace_p (int);
-static int message_log_check_duplicate (int, int, int, int);
+static int trailing_whitespace_p (EMACS_INT);
+static int message_log_check_duplicate (EMACS_INT, EMACS_INT,
+                                        EMACS_INT, EMACS_INT);
 static void push_it (struct it *);
 static void pop_it (struct it *);
 static void sync_frame_with_window_matrix_rows (struct window *);
@@ -1015,13 +1017,14 @@ static int store_mode_line_string (const char *, Lisp_Object, int, int, int, Lis
 static const char *decode_mode_spec (struct window *, int, int, int,
                                      Lisp_Object *);
 static void display_menu_bar (struct window *);
-static int display_count_lines (int, int, int, int, int *);
+static int display_count_lines (EMACS_INT, EMACS_INT, EMACS_INT, int,
+                                EMACS_INT *);
 static int display_string (const unsigned char *, Lisp_Object, Lisp_Object,
                            EMACS_INT, EMACS_INT, struct it *, int, int, int, int);
 static void compute_line_metrics (struct it *);
 static void run_redisplay_end_trigger_hook (struct it *);
-static int get_overlay_strings (struct it *, int);
-static int get_overlay_strings_1 (struct it *, int, int);
+static int get_overlay_strings (struct it *, EMACS_INT);
+static int get_overlay_strings_1 (struct it *, EMACS_INT, int);
 static void next_overlay_string (struct it *);
 static void reseat (struct it *, struct text_pos, int);
 static void reseat_1 (struct it *, struct text_pos, int);
@@ -1036,11 +1039,11 @@ static int next_element_from_buffer (struct it *);
 static int next_element_from_composition (struct it *);
 static int next_element_from_image (struct it *);
 static int next_element_from_stretch (struct it *);
-static void load_overlay_strings (struct it *, int);
+static void load_overlay_strings (struct it *, EMACS_INT);
 static int init_from_display_pos (struct it *, struct window *,
                                   struct display_pos *);
 static void reseat_to_string (struct it *, const unsigned char *,
-                              Lisp_Object, int, int, int, int);
+                              Lisp_Object, EMACS_INT, EMACS_INT, int, int);
 static enum move_it_result
        move_it_in_display_line_to (struct it *, EMACS_INT, int,
                                    enum move_operation_enum);
@@ -1052,10 +1055,10 @@ static int init_to_row_end (struct it *, struct window *,
 static void back_to_previous_line_start (struct it *);
 static int forward_to_next_line_start (struct it *, int *);
 static struct text_pos string_pos_nchars_ahead (struct text_pos,
-                                                Lisp_Object, int);
-static struct text_pos string_pos (int, Lisp_Object);
-static struct text_pos c_string_pos (int, const unsigned char *, int);
-static int number_of_chars (const unsigned char *, int);
+                                                Lisp_Object, EMACS_INT);
+static struct text_pos string_pos (EMACS_INT, Lisp_Object);
+static struct text_pos c_string_pos (EMACS_INT, const unsigned char *, int);
+static EMACS_INT number_of_chars (const unsigned char *, int);
 static void compute_stop_pos (struct it *);
 static void compute_string_pos (struct text_pos *, struct text_pos,
                                 Lisp_Object);
@@ -1362,7 +1365,7 @@ line_bottom_y (struct it *it)
    Set *ROWH and *VPOS to row's visible height and VPOS (row number).  */
 
 int
-pos_visible_p (struct window *w, int charpos, int *x, int *y,
+pos_visible_p (struct window *w, EMACS_INT charpos, int *x, int *y,
                int *rtop, int *rbot, int *rowh, int *vpos)
 {
   struct it it;
@@ -1522,13 +1525,13 @@ string_char_and_length (const unsigned char *str, int *len)
    in STRING, return the position NCHARS ahead (NCHARS >= 0).  */
 
 static struct text_pos
-string_pos_nchars_ahead (struct text_pos pos, Lisp_Object string, int nchars)
+string_pos_nchars_ahead (struct text_pos pos, Lisp_Object string, EMACS_INT nchars)
 {
   xassert (STRINGP (string) && nchars >= 0);
 
   if (STRING_MULTIBYTE (string))
     {
-      int rest = SBYTES (string) - BYTEPOS (pos);
+      EMACS_INT rest = SBYTES (string) - BYTEPOS (pos);
       const unsigned char *p = SDATA (string) + BYTEPOS (pos);
       int len;
 
@@ -1552,7 +1555,7 @@ string_pos_nchars_ahead (struct text_pos pos, Lisp_Object string, int nchars)
    for character position CHARPOS in STRING.  */
 
 static INLINE struct text_pos
-string_pos (int charpos, Lisp_Object string)
+string_pos (EMACS_INT charpos, Lisp_Object string)
 {
   struct text_pos pos;
   xassert (STRINGP (string));
@@ -1567,7 +1570,7 @@ string_pos (int charpos, Lisp_Object string)
    means recognize multibyte characters.  */
 
 static struct text_pos
-c_string_pos (int charpos, const unsigned char *s, int multibyte_p)
+c_string_pos (EMACS_INT charpos, const unsigned char *s, int multibyte_p)
 {
   struct text_pos pos;
 
@@ -1576,7 +1579,8 @@ c_string_pos (int charpos, const unsigned char *s, int multibyte_p)
 
   if (multibyte_p)
     {
-      int rest = strlen (s), len;
+      EMACS_INT rest = strlen (s);
+      int len;
 
       SET_TEXT_POS (pos, 0, 0);
       while (charpos--)
@@ -1598,14 +1602,15 @@ c_string_pos (int charpos, const unsigned char *s, int multibyte_p)
 /* Value is the number of characters in C string S.  MULTIBYTE_P
    non-zero means recognize multibyte characters.  */
 
-static int
+static EMACS_INT
 number_of_chars (const unsigned char *s, int multibyte_p)
 {
-  int nchars;
+  EMACS_INT nchars;
 
   if (multibyte_p)
     {
-      int rest = strlen (s), len;
+      EMACS_INT rest = strlen (s);
+      int len;
       unsigned char *p = (unsigned char *) s;
 
       for (nchars = 0; rest > 0; ++nchars)
@@ -2653,7 +2658,7 @@ init_iterator (struct it *it, struct window *w,
               && WINDOWP (minibuf_selected_window)
               && w == XWINDOW (minibuf_selected_window))))
     {
-      int charpos = marker_position (current_buffer->mark);
+      EMACS_INT charpos = marker_position (current_buffer->mark);
       it->region_beg_charpos = min (PT, charpos);
       it->region_end_charpos = max (PT, charpos);
     }
@@ -2899,7 +2904,7 @@ in_ellipses_for_invisible_text_p (struct display_pos *pos, struct window *w)
 {
   Lisp_Object prop, window;
   int ellipses_p = 0;
-  int charpos = CHARPOS (pos->pos);
+  EMACS_INT charpos = CHARPOS (pos->pos);
 
   /* If POS specifies a position in a display vector, this might
      be for an ellipsis displayed for invisible text.  We won't
@@ -3177,7 +3182,7 @@ compute_stop_pos (struct it *it)
 {
   register INTERVAL iv, next_iv;
   Lisp_Object object, limit, position;
-  EMACS_INT charpos, bytepos, stoppos;
+  EMACS_INT charpos, bytepos;
 
   /* If nowhere else, stop at the end.  */
   it->stop_charpos = it->end_charpos;
@@ -3267,12 +3272,15 @@ 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,
-                                stoppos, it->string);
+  if (it->cmp_it.id < 0)
+    {
+      EMACS_INT stoppos = it->end_charpos;
+
+      if (it->bidi_p && it->bidi_it.scan_dir < 0)
+        stoppos = -1;
+      composition_compute_stop_pos (&it->cmp_it, charpos, bytepos,
+                                    stoppos, it->string);
+    }
 
   xassert (STRINGP (it->string)
            || (it->stop_charpos >= BEGV
@@ -3452,7 +3460,8 @@ handle_face_prop (struct it *it)
     }
   else
     {
-      int base_face_id, bufpos;
+      int base_face_id;
+      EMACS_INT bufpos;
       int i;
       Lisp_Object from_overlay
         = (it->current.overlay_string_index >= 0
@@ -3576,7 +3585,8 @@ face_before_or_after_it_pos (struct it *it, int before_p)
 
   if (STRINGP (it->string))
     {
-      int bufpos, base_face_id;
+      EMACS_INT bufpos;
+      int base_face_id;
 
       /* No face change past the end of the string (for the case
          we are padding with spaces).  No face change before the
@@ -3619,7 +3629,6 @@ face_before_or_after_it_pos (struct it *it, int before_p)
       if (STRING_MULTIBYTE (it->string))
         {
           const unsigned char *p = SDATA (it->string) + BYTEPOS (pos);
-          int rest = SBYTES (it->string) - BYTEPOS (pos);
           int c, len;
           struct face *face = FACE_FROM_ID (it->f, face_id);
 
@@ -3821,7 +3830,8 @@ handle_invisible_prop (struct it *it)
                      not have a chance to do it, if we are going to
                      skip any text at the beginning, which resets the
                      FIRST_ELT flag.  */
-                  bidi_paragraph_init (it->paragraph_embedding, &it->bidi_it);
+                  bidi_paragraph_init (it->paragraph_embedding,
+                                       &it->bidi_it, 1);
                 }
               do
                 {
@@ -4636,7 +4646,6 @@ string_buffer_position_lim (struct window *w, Lisp_Object string,
 EMACS_INT
 string_buffer_position (struct window *w, Lisp_Object string, EMACS_INT around_charpos)
 {
-  Lisp_Object limit, prop, pos;
   const int MAX_DISTANCE = 1000;
   EMACS_INT found = string_buffer_position_lim (w, string, around_charpos,
                                                 around_charpos + MAX_DISTANCE,
@@ -4867,11 +4876,11 @@ compare_overlay_entries (const void *e1, const void *e2)
    compare_overlay_entries.  */
 
 static void
-load_overlay_strings (struct it *it, int charpos)
+load_overlay_strings (struct it *it, EMACS_INT charpos)
 {
   Lisp_Object overlay, window, str, invisible;
   struct Lisp_Overlay *ov;
-  int start, end;
+  EMACS_INT start, end;
   int size = 20;
   int n = 0, i, j, invis_p;
   struct overlay_entry *entries
@@ -5017,7 +5026,7 @@ load_overlay_strings (struct it *it, int charpos)
    least one overlay string was found.  */
 
 static int
-get_overlay_strings_1 (struct it *it, int charpos, int compute_stop_p)
+get_overlay_strings_1 (struct it *it, EMACS_INT charpos, int compute_stop_p)
 {
   /* Get the first OVERLAY_STRING_CHUNK_SIZE overlay strings to
      process.  This fills IT->overlay_strings with strings, and sets
@@ -5068,7 +5077,7 @@ get_overlay_strings_1 (struct it *it, int charpos, int compute_stop_p)
 }
 
 static int
-get_overlay_strings (struct it *it, int charpos)
+get_overlay_strings (struct it *it, EMACS_INT charpos)
 {
   it->string = Qnil;
   it->method = GET_FROM_BUFFER;
@@ -5143,7 +5152,7 @@ iterate_out_of_display_property (struct it *it)
      of a new paragraph, next_element_from_buffer may not have a
      chance to do that.  */
   if (it->bidi_it.first_elt && it->bidi_it.charpos < ZV)
-    bidi_paragraph_init (it->paragraph_embedding, &it->bidi_it);
+    bidi_paragraph_init (it->paragraph_embedding, &it->bidi_it, 1);
   /* prev_stop can be zero, so check against BEGV as well.  */
   while (it->bidi_it.charpos >= BEGV
          && it->prev_stop <= it->bidi_it.charpos
@@ -5314,8 +5323,8 @@ forward_to_next_line_start (struct it *it, int *skipped_p)
      short-cut.  */
   if (!newline_found_p)
     {
-      int start = IT_CHARPOS (*it);
-      int limit = find_next_newline_no_quit (start, 1);
+      EMACS_INT start = IT_CHARPOS (*it);
+      EMACS_INT limit = find_next_newline_no_quit (start, 1);
       Lisp_Object pos;
 
       xassert (!STRINGP (it->string));
@@ -5386,7 +5395,7 @@ back_to_previous_visible_line_start (struct it *it)
 
       {
         struct it it2;
-        int pos;
+        EMACS_INT pos;
         EMACS_INT beg, end;
         Lisp_Object val, overlay;
 
@@ -5508,7 +5517,7 @@ reseat_at_next_visible_line_start (struct it *it, int on_newline_p)
 static void
 reseat (struct it *it, struct text_pos pos, int force_p)
 {
-  int original_pos = IT_CHARPOS (*it);
+  EMACS_INT original_pos = IT_CHARPOS (*it);
 
   reseat_1 (it, pos, 0);
 
@@ -5575,7 +5584,10 @@ reseat_1 (struct it *it, struct text_pos pos, int set_stop_p)
   it->string_from_display_prop_p = 0;
   it->face_before_selective_p = 0;
   if (it->bidi_p)
-    it->bidi_it.first_elt = 1;
+    {
+      it->bidi_it.first_elt = 1;
+      it->bidi_it.paragraph_dir = NEUTRAL_DIR;
+    }
 
   if (set_stop_p)
     {
@@ -5605,7 +5617,8 @@ reseat_1 (struct it *it, struct text_pos pos, int set_stop_p)
 
 static void
 reseat_to_string (struct it *it, const unsigned char *s, Lisp_Object string,
-                  int charpos, int precision, int field_width, int multibyte)
+                  EMACS_INT charpos, EMACS_INT precision, int field_width,
+                  int multibyte)
 {
   /* No region in strings.  */
   it->region_beg_charpos = it->region_end_charpos = -1;
@@ -6008,9 +6021,9 @@ get_next_display_element (struct it *it)
         }
       else
         {
-          int pos = (it->s ? -1
-                     : STRINGP (it->string) ? IT_STRING_CHARPOS (*it)
-                     : IT_CHARPOS (*it));
+          EMACS_INT pos = (it->s ? -1
+                           : STRINGP (it->string) ? IT_STRING_CHARPOS (*it)
+                           : IT_CHARPOS (*it));
 
           it->face_id = FACE_FOR_CHAR (it->f, face, it->char_to_display, pos,
                                        it->string);
@@ -6125,7 +6138,7 @@ set_iterator_to_next (struct it *it, int reseat_p)
                   it->cmp_it.id = -1;
                   composition_compute_stop_pos (&it->cmp_it, IT_CHARPOS (*it),
                                                 IT_BYTEPOS (*it),
-                                                it->stop_charpos, Qnil);
+                                                it->end_charpos, Qnil);
                 }
             }
           else if (! it->cmp_it.reversed_p)
@@ -6148,7 +6161,7 @@ set_iterator_to_next (struct it *it, int reseat_p)
                 {
                   /* No more grapheme clusters in this composition.
                      Find the next stop position.  */
-                  EMACS_INT stop = it->stop_charpos;
+                  EMACS_INT stop = it->end_charpos;
                   if (it->bidi_it.scan_dir < 0)
                     /* Now we are scanning backward and don't know
                        where to stop.  */
@@ -6176,7 +6189,7 @@ set_iterator_to_next (struct it *it, int reseat_p)
                 {
                   /* No more grapheme clusters in this composition.
                      Find the next stop position.  */
-                  EMACS_INT stop = it->stop_charpos;
+                  EMACS_INT stop = it->end_charpos;
                   if (it->bidi_it.scan_dir < 0)
                     /* Now we are scanning backward and don't know
                        where to stop.  */
@@ -6201,7 +6214,7 @@ set_iterator_to_next (struct it *it, int reseat_p)
               /* If this is a new paragraph, determine its base
                  direction (a.k.a. its base embedding level).  */
               if (it->bidi_it.new_paragraph)
-                bidi_paragraph_init (it->paragraph_embedding, &it->bidi_it);
+                bidi_paragraph_init (it->paragraph_embedding, &it->bidi_it, 0);
               bidi_move_to_visually_next (&it->bidi_it);
               IT_BYTEPOS (*it) = it->bidi_it.bytepos;
               IT_CHARPOS (*it) = it->bidi_it.charpos;
@@ -6209,7 +6222,7 @@ set_iterator_to_next (struct it *it, int reseat_p)
                 {
                   /* As the scan direction was changed, we must
                      re-compute the stop position for composition.  */
-                  EMACS_INT stop = it->stop_charpos;
+                  EMACS_INT stop = it->end_charpos;
                   if (it->bidi_it.scan_dir < 0)
                     stop = -1;
                   composition_compute_stop_pos (&it->cmp_it, IT_CHARPOS (*it),
@@ -6287,7 +6300,7 @@ set_iterator_to_next (struct it *it, int reseat_p)
               composition_compute_stop_pos (&it->cmp_it,
                                             IT_STRING_CHARPOS (*it),
                                             IT_STRING_BYTEPOS (*it),
-                                            it->stop_charpos, it->string);
+                                            it->end_charpos, it->string);
             }
         }
       else
@@ -6443,7 +6456,6 @@ next_element_from_string (struct it *it)
         }
       else if (STRING_MULTIBYTE (it->string))
         {
-          int remaining = SBYTES (it->string) - IT_STRING_BYTEPOS (*it);
           const unsigned char *s = (SDATA (it->string)
                                     + IT_STRING_BYTEPOS (*it));
           it->c = string_char_and_length (s, &it->len);
@@ -6479,7 +6491,6 @@ next_element_from_string (struct it *it)
         }
       else if (STRING_MULTIBYTE (it->string))
         {
-          int maxlen = SBYTES (it->string) - IT_STRING_BYTEPOS (*it);
           const unsigned char *s = (SDATA (it->string)
                                     + IT_STRING_BYTEPOS (*it));
           it->c = string_char_and_length (s, &it->len);
@@ -6532,13 +6543,7 @@ next_element_from_c_string (struct it *it)
       BYTEPOS (it->position) = CHARPOS (it->position) = -1;
     }
   else if (it->multibyte_p)
-    {
-      /* Implementation note: The calls to strlen apparently aren't a
-         performance problem because there is no noticeable performance
-         difference between Emacs running in unibyte or multibyte mode.  */
-      int maxlen = strlen (it->s) - IT_BYTEPOS (*it);
-      it->c = string_char_and_length (it->s + IT_BYTEPOS (*it), &it->len);
-    }
+    it->c = string_char_and_length (it->s + IT_BYTEPOS (*it), &it->len);
   else
     it->c = it->s[IT_BYTEPOS (*it)], it->len = 1;
 
@@ -6673,12 +6678,12 @@ next_element_from_buffer (struct it *it)
         {
           /* If we are at the beginning of a line, we can produce the
              next element right away.  */
-          bidi_paragraph_init (it->paragraph_embedding, &it->bidi_it);
+          bidi_paragraph_init (it->paragraph_embedding, &it->bidi_it, 1);
           bidi_move_to_visually_next (&it->bidi_it);
         }
       else
         {
-          int orig_bytepos = IT_BYTEPOS (*it);
+          EMACS_INT orig_bytepos = IT_BYTEPOS (*it);
 
           /* We need to prime the bidi iterator starting at the line's
              beginning, before we will be able to produce the next
@@ -6687,7 +6692,7 @@ next_element_from_buffer (struct it *it)
           IT_BYTEPOS (*it) = CHAR_TO_BYTE (IT_CHARPOS (*it));
           it->bidi_it.charpos = IT_CHARPOS (*it);
           it->bidi_it.bytepos = IT_BYTEPOS (*it);
-          bidi_paragraph_init (it->paragraph_embedding, &it->bidi_it);
+          bidi_paragraph_init (it->paragraph_embedding, &it->bidi_it, 1);
           do
             {
               /* Now return to buffer position where we were asked to
@@ -6704,7 +6709,7 @@ next_element_from_buffer (struct it *it)
       IT_BYTEPOS (*it) = it->bidi_it.bytepos;
       SET_TEXT_POS (it->position, IT_CHARPOS (*it), IT_BYTEPOS (*it));
       {
-        EMACS_INT stop = it->stop_charpos;
+        EMACS_INT stop = it->end_charpos;
         if (it->bidi_it.scan_dir < 0)
           stop = -1;
         composition_compute_stop_pos (&it->cmp_it, IT_CHARPOS (*it),
@@ -6910,7 +6915,7 @@ next_element_from_composition (struct it *it)
           if (it->bidi_p)
             {
               if (it->bidi_it.new_paragraph)
-                bidi_paragraph_init (it->paragraph_embedding, &it->bidi_it);
+                bidi_paragraph_init (it->paragraph_embedding, &it->bidi_it, 0);
               /* Resync the bidi iterator with IT's new position.
                  FIXME: this doesn't support bidirectional text.  */
               while (it->bidi_it.charpos < IT_CHARPOS (*it))
@@ -7407,7 +7412,7 @@ move_it_in_display_line (struct it *it,
    TO_CHARPOS.  */
 
 void
-move_it_to (struct it *it, int to_charpos, int to_x, int to_y, int to_vpos, int op)
+move_it_to (struct it *it, EMACS_INT to_charpos, int to_x, int to_y, int to_vpos, int op)
 {
   enum move_it_result skip, skip2 = MOVE_X_REACHED;
   int line_height, line_start_x = 0, reached = 0;
@@ -7662,7 +7667,7 @@ move_it_vertically_backward (struct it *it, int dy)
 {
   int nlines, h;
   struct it it2, it3;
-  int start_pos;
+  EMACS_INT start_pos;
 
  move_further_back:
   xassert (dy >= 0);
@@ -7823,12 +7828,12 @@ move_it_past_eol (struct it *it)
 void
 move_it_by_lines (struct it *it, int dvpos, int need_y_p)
 {
-  struct position pos;
 
   /* The commented-out optimization uses vmotion on terminals.  This
      gives bad results, because elements like it->what, on which
      callers such as pos_visible_p rely, aren't updated. */
-  /*  if (!FRAME_WINDOW_P (it->f))
+  /* struct position pos;
+    if (!FRAME_WINDOW_P (it->f))
     {
       struct text_pos textpos;
 
@@ -7857,7 +7862,7 @@ move_it_by_lines (struct it *it, int dvpos, int need_y_p)
   else
     {
       struct it it2;
-      int start_charpos, i;
+      EMACS_INT start_charpos, i;
 
       /* Start at the beginning of the screen line containing IT's
          position.  This may actually move vertically backwards,
@@ -7937,7 +7942,7 @@ add_to_log (const char *format, Lisp_Object arg1, Lisp_Object arg2)
   Lisp_Object args[3];
   Lisp_Object msg, fmt;
   char *buffer;
-  int len;
+  EMACS_INT len;
   struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
   USE_SAFE_ALLOCA;
 
@@ -7986,7 +7991,7 @@ message_log_maybe_newline (void)
    so the buffer M must NOT point to a Lisp string.  */
 
 void
-message_dolog (const char *m, int nbytes, int nlflag, int multibyte)
+message_dolog (const char *m, EMACS_INT nbytes, int nlflag, int multibyte)
 {
   if (!NILP (Vmemory_full))
     return;
@@ -7996,8 +8001,8 @@ message_dolog (const char *m, int nbytes, int nlflag, int multibyte)
       struct buffer *oldbuf;
       Lisp_Object oldpoint, oldbegv, oldzv;
       int old_windows_or_buffers_changed = windows_or_buffers_changed;
-      int point_at_end = 0;
-      int zv_at_end = 0;
+      EMACS_INT point_at_end = 0;
+      EMACS_INT zv_at_end = 0;
       Lisp_Object old_deactivate_mark, tem;
       struct gcpro gcpro1;
 
@@ -8030,7 +8035,8 @@ message_dolog (const char *m, int nbytes, int nlflag, int multibyte)
       if (multibyte
           && NILP (current_buffer->enable_multibyte_characters))
         {
-          int i, c, char_bytes;
+          EMACS_INT i;
+          int c, char_bytes;
           unsigned char work[1];
 
           /* Convert a multibyte string to single-byte
@@ -8047,7 +8053,8 @@ message_dolog (const char *m, int nbytes, int nlflag, int multibyte)
       else if (! multibyte
                && ! NILP (current_buffer->enable_multibyte_characters))
         {
-          int i, c, char_bytes;
+          EMACS_INT i;
+          int c, char_bytes;
           unsigned char *msg = (unsigned char *) m;
           unsigned char str[MAX_MULTIBYTE_LENGTH];
           /* Convert a single-byte string to multibyte
@@ -8065,7 +8072,8 @@ message_dolog (const char *m, int nbytes, int nlflag, int multibyte)
 
       if (nlflag)
         {
-          int this_bol, this_bol_byte, prev_bol, prev_bol_byte, dup;
+          EMACS_INT this_bol, this_bol_byte, prev_bol, prev_bol_byte;
+          int dup;
           insert_1 ("\n", 1, 1, 0, 0);
 
           scan_newline (Z, Z_BYTE, BEG, BEG_BYTE, -2, 0);
@@ -8156,11 +8164,11 @@ message_dolog (const char *m, int nbytes, int nlflag, int multibyte)
    value N > 1 if we should also append " [N times]".  */
 
 static int
-message_log_check_duplicate (int prev_bol, int prev_bol_byte,
-                             int this_bol, int this_bol_byte)
+message_log_check_duplicate (EMACS_INT prev_bol, EMACS_INT prev_bol_byte,
+                             EMACS_INT this_bol, EMACS_INT this_bol_byte)
 {
-  int i;
-  int len = Z_BYTE - 1 - this_bol_byte;
+  EMACS_INT i;
+  EMACS_INT len = Z_BYTE - 1 - this_bol_byte;
   int seen_dots = 0;
   unsigned char *p1 = BUF_BYTE_ADDRESS (current_buffer, prev_bol_byte);
   unsigned char *p2 = BUF_BYTE_ADDRESS (current_buffer, this_bol_byte);
@@ -8195,7 +8203,7 @@ message_log_check_duplicate (int prev_bol, int prev_bol_byte,
    This may GC, so the buffer M must NOT point to a Lisp string.  */
 
 void
-message2 (const char *m, int nbytes, int multibyte)
+message2 (const char *m, EMACS_INT nbytes, int multibyte)
 {
   /* First flush out any partial line written with print.  */
   message_log_maybe_newline ();
@@ -8208,7 +8216,7 @@ message2 (const char *m, int nbytes, int multibyte)
 /* The non-logging counterpart of message2.  */
 
 void
-message2_nolog (const char *m, int nbytes, int multibyte)
+message2_nolog (const char *m, EMACS_INT nbytes, int multibyte)
 {
   struct frame *sf = SELECTED_FRAME ();
   message_enable_multibyte = multibyte;
@@ -8270,7 +8278,7 @@ message2_nolog (const char *m, int nbytes, int multibyte)
    This function cancels echoing.  */
 
 void
-message3 (Lisp_Object m, int nbytes, int multibyte)
+message3 (Lisp_Object m, EMACS_INT nbytes, int multibyte)
 {
   struct gcpro gcpro1;
 
@@ -8302,7 +8310,7 @@ message3 (Lisp_Object m, int nbytes, int multibyte)
    and make this cancel echoing.  */
 
 void
-message3_nolog (Lisp_Object m, int nbytes, int multibyte)
+message3_nolog (Lisp_Object m, EMACS_INT nbytes, int multibyte)
 {
   struct frame *sf = SELECTED_FRAME ();
   message_enable_multibyte = multibyte;
@@ -8488,7 +8496,7 @@ vmessage (const char *m, va_list ap)
         {
           if (m)
             {
-              int len;
+              EMACS_INT len;
 
               len = doprnt (FRAME_MESSAGE_BUF (f),
                             FRAME_MESSAGE_BUF_SIZE (f), m, (char *)0, ap);
@@ -9185,7 +9193,7 @@ check_message_stack (void)
    time we display it---but don't redisplay it now.  */
 
 void
-truncate_echo_area (int nchars)
+truncate_echo_area (EMACS_INT nchars)
 {
   if (nchars == 0)
     echo_area_buffer[0] = Qnil;
@@ -9232,7 +9240,8 @@ truncate_message_1 (EMACS_INT nchars, Lisp_Object a2, EMACS_INT a3, EMACS_INT a4
   */
 
 void
-set_message (const char *s, Lisp_Object string, int nbytes, int multibyte_p)
+set_message (const char *s, Lisp_Object string,
+             EMACS_INT nbytes, int multibyte_p)
 {
   message_enable_multibyte
     = ((s && multibyte_p)
@@ -9268,7 +9277,7 @@ set_message_1 (EMACS_INT a1, Lisp_Object a2, EMACS_INT nbytes, EMACS_INT multiby
 
   if (STRINGP (string))
     {
-      int nchars;
+      EMACS_INT nchars;
 
       if (nbytes == 0)
         nbytes = SBYTES (string);
@@ -9287,7 +9296,8 @@ set_message_1 (EMACS_INT a1, Lisp_Object a2, EMACS_INT nbytes, EMACS_INT multiby
       if (multibyte_p && NILP (current_buffer->enable_multibyte_characters))
         {
           /* Convert from multi-byte to single-byte.  */
-          int i, c, n;
+          EMACS_INT i;
+          int c, n;
           unsigned char work[1];
 
           /* Convert a multibyte string to single-byte.  */
@@ -9304,7 +9314,8 @@ set_message_1 (EMACS_INT a1, Lisp_Object a2, EMACS_INT nbytes, EMACS_INT multiby
                && !NILP (current_buffer->enable_multibyte_characters))
         {
           /* Convert from single-byte to multi-byte.  */
-          int i, c, n;
+          EMACS_INT i;
+          int c, n;
           const unsigned char *msg = (const unsigned char *) s;
           unsigned char str[MAX_MULTIBYTE_LENGTH];
 
@@ -9624,7 +9635,7 @@ static int
 store_mode_line_noprop (const unsigned char *str, int field_width, int precision)
 {
   int n = 0;
-  int dummy, nbytes;
+  EMACS_INT dummy, nbytes;
 
   /* Copy at most PRECISION chars from STR.  */
   nbytes = strlen (str);
@@ -10986,7 +10997,7 @@ hscroll_window_tree (Lisp_Object window)
               struct it it;
               int hscroll;
               struct buffer *saved_current_buffer;
-              int pt;
+              EMACS_INT pt;
               int wanted_x;
 
               /* Find point in a display of infinite width.  */
@@ -11099,7 +11110,7 @@ int debug_dvpos, debug_dy;
 
 /* Delta in characters and bytes for try_window_id.  */
 
-int debug_delta, debug_delta_bytes;
+EMACS_INT debug_delta, debug_delta_bytes;
 
 /* Values of window_end_pos and window_end_vpos at the end of
    try_window_id.  */
@@ -11151,7 +11162,8 @@ debug_method_add (w, fmt, a1, a2, a3, a4, a5, a6, a7, a8, a9)
    redisplay_internal for display optimization.  */
 
 static INLINE int
-text_outside_line_unchanged_p (struct window *w, int start, int end)
+text_outside_line_unchanged_p (struct window *w,
+                               EMACS_INT start, EMACS_INT end)
 {
   int unchanged_p = 1;
 
@@ -11374,8 +11386,8 @@ overlay_arrow_at_row (struct it *it, struct glyph_row *row)
    position.  BUF and PT are the current point buffer and position.  */
 
 int
-check_point_in_composition (struct buffer *prev_buf, int prev_pt,
-                            struct buffer *buf, int pt)
+check_point_in_composition (struct buffer *prev_buf, EMACS_INT prev_pt,
+                            struct buffer *buf, EMACS_INT pt)
 {
   EMACS_INT start, end;
   Lisp_Object prop;
@@ -11428,7 +11440,7 @@ reconsider_clip_changes (struct window *w, struct buffer *b)
   if (!b->clip_changed
       && BUFFERP (w->buffer) && !NILP (w->window_end_valid))
     {
-      int pt;
+      EMACS_INT pt;
 
       if (w == XWINDOW (selected_window))
         pt = BUF_PT (current_buffer);
@@ -11830,7 +11842,7 @@ redisplay_internal (int preserve_echo_area)
                 {
                   struct glyph_row *row
                     = MATRIX_ROW (w->current_matrix, this_line_vpos + 1);
-                  int delta, delta_bytes;
+                  EMACS_INT delta, delta_bytes;
 
                   /* We used to distinguish between two cases here,
                      conditioned by Z - CHARPOS (tlendpos) == ZV, for
@@ -12459,14 +12471,15 @@ redisplay_window_1 (Lisp_Object window)
 
 int
 set_cursor_from_row (struct window *w, struct glyph_row *row,
-                     struct glyph_matrix *matrix, int delta, int delta_bytes,
+                     struct glyph_matrix *matrix,
+                     EMACS_INT delta, EMACS_INT delta_bytes,
                      int dy, int dvpos)
 {
   struct glyph *glyph = row->glyphs[TEXT_AREA];
   struct glyph *end = glyph + row->used[TEXT_AREA];
   struct glyph *cursor = NULL;
   /* The last known character position in row.  */
-  int last_pos = MATRIX_ROW_START_CHARPOS (row) + delta;
+  EMACS_INT last_pos = MATRIX_ROW_START_CHARPOS (row) + delta;
   int x = row->x;
   EMACS_INT pt_old = PT - delta;
   EMACS_INT pos_before = MATRIX_ROW_START_CHARPOS (row) + delta;
@@ -12603,7 +12616,7 @@ set_cursor_from_row (struct window *w, struct glyph_row *row,
         else if (STRINGP (glyph->object))
           {
             Lisp_Object chprop;
-            int glyph_pos = glyph->charpos;
+            EMACS_INT glyph_pos = glyph->charpos;
 
             chprop = Fget_char_property (make_number (glyph_pos), Qcursor,
                                          glyph->object);
@@ -12670,7 +12683,7 @@ set_cursor_from_row (struct window *w, struct glyph_row *row,
         else if (STRINGP (glyph->object))
           {
             Lisp_Object chprop;
-            int glyph_pos = glyph->charpos;
+            EMACS_INT glyph_pos = glyph->charpos;
 
             chprop = Fget_char_property (make_number (glyph_pos), Qcursor,
                                          glyph->object);
@@ -12788,7 +12801,7 @@ set_cursor_from_row (struct window *w, struct glyph_row *row,
                              be a character in the string with the
                              `cursor' property, which means display
                              cursor on that character's glyph.  */
-                          int strpos = glyph->charpos;
+                          EMACS_INT strpos = glyph->charpos;
 
                           cursor = glyph;
                           for (glyph += incr;
@@ -12797,7 +12810,7 @@ set_cursor_from_row (struct window *w, struct glyph_row *row,
                                glyph += incr)
                             {
                               Lisp_Object cprop;
-                              int gpos = glyph->charpos;
+                              EMACS_INT gpos = glyph->charpos;
 
                               cprop = Fget_char_property (make_number (gpos),
                                                           Qcursor,
@@ -13687,7 +13700,7 @@ try_cursor_movement (Lisp_Object window, struct text_pos startp, int *scroll_ste
 void
 set_vertical_scroll_bar (struct window *w)
 {
-  int start, end, whole;
+  EMACS_INT start, end, whole;
 
   /* Calculate the start and end positions for the current window.
      At some point, it would be nice to choose between scrollbars
@@ -13751,7 +13764,7 @@ redisplay_window (Lisp_Object window, int just_this_one_p)
   int rc;
   int centering_position = -1;
   int last_line_misfit = 0;
-  int beg_unchanged, end_unchanged;
+  EMACS_INT beg_unchanged, end_unchanged;
 
   SET_TEXT_POS (lpoint, PT, PT_BYTE);
   opoint = lpoint;
@@ -13893,8 +13906,8 @@ redisplay_window (Lisp_Object window, int just_this_one_p)
      window, set up appropriate value.  */
   if (!EQ (window, selected_window))
     {
-      int new_pt = XMARKER (w->pointm)->charpos;
-      int new_pt_byte = marker_byte_position (w->pointm);
+      EMACS_INT new_pt = XMARKER (w->pointm)->charpos;
+      EMACS_INT new_pt_byte = marker_byte_position (w->pointm);
       if (new_pt < BEGV)
         {
           new_pt = BEGV;
@@ -15052,7 +15065,7 @@ try_window_reusing_current_matrix (struct window *w)
 
 static struct glyph_row *find_last_unchanged_at_beg_row (struct window *);
 static struct glyph_row *find_first_unchanged_at_end_row (struct window *,
-                                                          int *, int *);
+                                                          EMACS_INT *, EMACS_INT *);
 static struct glyph_row *
 find_last_row_displaying_text (struct glyph_matrix *, struct it *,
                                struct glyph_row *);
@@ -15100,7 +15113,7 @@ find_last_row_displaying_text (struct glyph_matrix *matrix, struct it *it,
 static struct glyph_row *
 find_last_unchanged_at_beg_row (struct window *w)
 {
-  int first_changed_pos = BEG + BEG_UNCHANGED;
+  EMACS_INT first_changed_pos = BEG + BEG_UNCHANGED;
   struct glyph_row *row;
   struct glyph_row *row_found = NULL;
   int yb = window_text_bottom_y (w);
@@ -15147,7 +15160,8 @@ find_last_unchanged_at_beg_row (struct window *w)
    changes.  */
 
 static struct glyph_row *
-find_first_unchanged_at_end_row (struct window *w, int *delta, int *delta_bytes)
+find_first_unchanged_at_end_row (struct window *w,
+                                 EMACS_INT *delta, EMACS_INT *delta_bytes)
 {
   struct glyph_row *row;
   struct glyph_row *row_found = NULL;
@@ -15175,9 +15189,11 @@ find_first_unchanged_at_end_row (struct window *w, int *delta, int *delta_bytes)
          corresponds to window_end_pos.  This allows us to translate
          buffer positions in the current matrix to current buffer
          positions for characters not in changed text.  */
-      int Z_old = MATRIX_ROW_END_CHARPOS (row) + XFASTINT (w->window_end_pos);
-      int Z_BYTE_old = MATRIX_ROW_END_BYTEPOS (row) + w->window_end_bytepos;
-      int last_unchanged_pos, last_unchanged_pos_old;
+      EMACS_INT Z_old =
+        MATRIX_ROW_END_CHARPOS (row) + XFASTINT (w->window_end_pos);
+      EMACS_INT Z_BYTE_old =
+        MATRIX_ROW_END_BYTEPOS (row) + w->window_end_bytepos;
+      EMACS_INT last_unchanged_pos, last_unchanged_pos_old;
       struct glyph_row *first_text_row
         = MATRIX_FIRST_TEXT_ROW (w->current_matrix);
 
@@ -15264,8 +15280,8 @@ sync_frame_with_window_matrix_rows (struct window *w)
    containing CHARPOS or null.  */
 
 struct glyph_row *
-row_containing_pos (struct window *w, int charpos, struct glyph_row *start,
-                    struct glyph_row *end, int dy)
+row_containing_pos (struct window *w, EMACS_INT charpos,
+                    struct glyph_row *start, struct glyph_row *end, int dy)
 {
   struct glyph_row *row = start;
   struct glyph_row *best_row = NULL;
@@ -15378,13 +15394,14 @@ try_window_id (struct window *w)
   struct glyph_row *bottom_row;
   int bottom_vpos;
   struct it it;
-  int delta = 0, delta_bytes = 0, stop_pos, dvpos, dy;
+  EMACS_INT delta = 0, delta_bytes = 0, stop_pos;
+  int dvpos, dy;
   struct text_pos start_pos;
   struct run run;
   int first_unchanged_at_end_vpos = 0;
   struct glyph_row *last_text_row, *last_text_row_at_end;
   struct text_pos start;
-  int first_changed_charpos, last_changed_charpos;
+  EMACS_INT first_changed_charpos, last_changed_charpos;
 
 #if GLYPH_DEBUG
   if (inhibit_try_window_id)
@@ -15511,7 +15528,7 @@ try_window_id (struct window *w)
           || (last_changed_charpos < CHARPOS (start) - 1
               && FETCH_BYTE (BYTEPOS (start) - 1) == '\n')))
     {
-      int Z_old, delta, Z_BYTE_old, delta_bytes;
+      EMACS_INT Z_old, delta, Z_BYTE_old, delta_bytes;
       struct glyph_row *r0;
 
       /* Compute how many chars/bytes have been added to or removed
@@ -16210,7 +16227,7 @@ dump_glyph (row, glyph, area)
       if (glyph->u.cmp.automatic)
         fprintf (stderr,
                  "[%d-%d]",
-                 glyph->u.cmp.from, glyph->u.cmp.to);
+                 glyph->slice.cmp.from, glyph->slice.cmp.to);
       fprintf (stderr, " . %4d %1.1d%1.1d\n",
                glyph->face_id,
                glyph->left_box_line_p,
@@ -16895,9 +16912,9 @@ extend_face_to_end_of_line (struct it *it)
    trailing whitespace.  */
 
 static int
-trailing_whitespace_p (int charpos)
+trailing_whitespace_p (EMACS_INT charpos)
 {
-  int bytepos = CHAR_TO_BYTE (charpos);
+  EMACS_INT bytepos = CHAR_TO_BYTE (charpos);
   int c = 0;
 
   while (bytepos < ZV_BYTE
@@ -17992,8 +18009,9 @@ See also `bidi-paragraph-direction'.  */)
       itb.bytepos = bytepos;
       itb.first_elt = 1;
       itb.separator_limit = -1;
+      itb.paragraph_dir = NEUTRAL_DIR;
 
-      bidi_paragraph_init (NEUTRAL_DIR, &itb);
+      bidi_paragraph_init (NEUTRAL_DIR, &itb, 1);
       if (buf != current_buffer)
         set_buffer_temp (old);
       switch (itb.paragraph_dir)
@@ -18372,7 +18390,7 @@ display_mode_element (struct it *it, int depth, int field_width, int precision,
       {
         /* A string: output it and check for %-constructs within it.  */
         unsigned char c;
-        int offset = 0;
+        EMACS_INT offset = 0;
 
         if (SCHARS (elt) > 0
             && (!NILP (props) || risky))
@@ -18469,7 +18487,7 @@ display_mode_element (struct it *it, int depth, int field_width, int precision,
                && (mode_line_target != MODE_LINE_DISPLAY
                    || it->current_x < it->last_visible_x))
           {
-            int last_offset = offset;
+            EMACS_INT last_offset = offset;
 
             /* Advance to end of string or next format specifier.  */
             while ((c = SREF (elt, offset++)) != '\0' && c != '%')
@@ -18477,7 +18495,7 @@ display_mode_element (struct it *it, int depth, int field_width, int precision,
 
             if (offset - 1 != last_offset)
               {
-                int nchars, nbytes;
+                EMACS_INT nchars, nbytes;
 
                 /* Output to end of string or up to '%'.  Field width
                    is length of string.  Don't output more than
@@ -18496,11 +18514,11 @@ display_mode_element (struct it *it, int depth, int field_width, int precision,
                     break;
                   case MODE_LINE_STRING:
                     {
-                      int bytepos = last_offset;
-                      int charpos = string_byte_to_char (elt, bytepos);
-                      int endpos = (precision <= 0
-                                    ? string_byte_to_char (elt, offset)
-                                    : charpos + nchars);
+                      EMACS_INT bytepos = last_offset;
+                      EMACS_INT charpos = string_byte_to_char (elt, bytepos);
+                      EMACS_INT endpos = (precision <= 0
+                                          ? string_byte_to_char (elt, offset)
+                                          : charpos + nchars);
 
                       n += store_mode_line_string (NULL,
                                                    Fsubstring (elt, make_number (charpos),
@@ -18510,8 +18528,8 @@ display_mode_element (struct it *it, int depth, int field_width, int precision,
                     break;
                   case MODE_LINE_DISPLAY:
                     {
-                      int bytepos = last_offset;
-                      int charpos = string_byte_to_char (elt, bytepos);
+                      EMACS_INT bytepos = last_offset;
+                      EMACS_INT charpos = string_byte_to_char (elt, bytepos);
 
                       if (precision <= 0)
                         nchars = string_byte_to_char (elt, offset) - charpos;
@@ -18524,7 +18542,7 @@ display_mode_element (struct it *it, int depth, int field_width, int precision,
               }
             else /* c == '%' */
               {
-                int percent_position = offset;
+                EMACS_INT percent_position = offset;
 
                 /* Get the specified minimum width.  Zero means
                    don't pad.  */
@@ -18546,7 +18564,7 @@ display_mode_element (struct it *it, int depth, int field_width, int precision,
                 else if (c != 0)
                   {
                     int multibyte;
-                    int bytepos, charpos;
+                    EMACS_INT bytepos, charpos;
                     const unsigned char *spec;
                     Lisp_Object string;
 
@@ -18820,7 +18838,7 @@ static int
 store_mode_line_string (const char *string, Lisp_Object lisp_string, int copy_string,
                         int field_width, int precision, Lisp_Object props)
 {
-  int len;
+  EMACS_INT len;
   int n = 0;
 
   if (string != NULL)
@@ -19365,22 +19383,23 @@ decode_mode_spec (struct window *w, register int c, int field_width,
 
     case 'i':
       {
-        int size = ZV - BEGV;
+        EMACS_INT size = ZV - BEGV;
         pint2str (decode_mode_spec_buf, field_width, size);
         return decode_mode_spec_buf;
       }
 
     case 'I':
       {
-        int size = ZV - BEGV;
+        EMACS_INT size = ZV - BEGV;
         pint2hrstr (decode_mode_spec_buf, field_width, size);
         return decode_mode_spec_buf;
       }
 
     case 'l':
       {
-        int startpos, startpos_byte, line, linepos, linepos_byte;
-        int topline, nlines, junk, height;
+        EMACS_INT startpos, startpos_byte, line, linepos, linepos_byte;
+        int topline, nlines, height;
+        EMACS_INT junk;
 
         /* %c and %l are ignored in `frame-title-format'.  */
         if (mode_line_target == MODE_LINE_TITLE)
@@ -19441,9 +19460,9 @@ decode_mode_spec (struct window *w, register int c, int field_width,
         else if (nlines < height + 25 || nlines > height * 3 + 50
                  || linepos == BUF_BEGV (b))
           {
-            int limit = BUF_BEGV (b);
-            int limit_byte = BUF_BEGV_BYTE (b);
-            int position;
+            EMACS_INT limit = BUF_BEGV (b);
+            EMACS_INT limit_byte = BUF_BEGV_BYTE (b);
+            EMACS_INT position;
             int distance = (height * 2 + 30) * line_number_display_limit_width;
 
             if (startpos - distance > limit)
@@ -19505,8 +19524,8 @@ decode_mode_spec (struct window *w, register int c, int field_width,
 
     case 'p':
       {
-        int pos = marker_position (w->start);
-        int total = BUF_ZV (b) - BUF_BEGV (b);
+        EMACS_INT pos = marker_position (w->start);
+        EMACS_INT total = BUF_ZV (b) - BUF_BEGV (b);
 
         if (XFASTINT (w->window_end_pos) <= BUF_Z (b) - BUF_ZV (b))
           {
@@ -19528,7 +19547,7 @@ decode_mode_spec (struct window *w, register int c, int field_width,
                so get us a 2-digit number that is close.  */
             if (total == 100)
               total = 99;
-            sprintf (decode_mode_spec_buf, "%2d%%", total);
+            sprintf (decode_mode_spec_buf, "%2ld%%", (long)total);
             return decode_mode_spec_buf;
           }
       }
@@ -19536,9 +19555,9 @@ decode_mode_spec (struct window *w, register int c, int field_width,
       /* Display percentage of size above the bottom of the screen.  */
     case 'P':
       {
-        int toppos = marker_position (w->start);
-        int botpos = BUF_Z (b) - XFASTINT (w->window_end_pos);
-        int total = BUF_ZV (b) - BUF_BEGV (b);
+        EMACS_INT toppos = marker_position (w->start);
+        EMACS_INT botpos = BUF_Z (b) - XFASTINT (w->window_end_pos);
+        EMACS_INT total = BUF_ZV (b) - BUF_BEGV (b);
 
         if (botpos >= BUF_ZV (b))
           {
@@ -19559,9 +19578,9 @@ decode_mode_spec (struct window *w, register int c, int field_width,
             if (total == 100)
               total = 99;
             if (toppos <= BUF_BEGV (b))
-              sprintf (decode_mode_spec_buf, "Top%2d%%", total);
+              sprintf (decode_mode_spec_buf, "Top%2ld%%", (long)total);
             else
-              sprintf (decode_mode_spec_buf, "%2d%%", total);
+              sprintf (decode_mode_spec_buf, "%2ld%%", (long)total);
             return decode_mode_spec_buf;
           }
       }
@@ -19652,8 +19671,9 @@ decode_mode_spec (struct window *w, register int c, int field_width,
    Set *BYTE_POS_PTR to 1 if we found COUNT lines, 0 if we hit LIMIT.  */
 
 static int
-display_count_lines (int start, int start_byte, int limit_byte, int count,
-                     int *byte_pos_ptr)
+display_count_lines (EMACS_INT start, EMACS_INT start_byte,
+                     EMACS_INT limit_byte, int count,
+                     EMACS_INT *byte_pos_ptr)
 {
   register unsigned char *cursor;
   unsigned char *base;
@@ -20595,8 +20615,8 @@ fill_gstring_glyph_string (struct glyph_string *s, int face_id,
   glyph = s->row->glyphs[s->area] + start;
   last = s->row->glyphs[s->area] + end;
   s->cmp_id = glyph->u.cmp.id;
-  s->cmp_from = glyph->u.cmp.from;
-  s->cmp_to = glyph->u.cmp.to + 1;
+  s->cmp_from = glyph->slice.cmp.from;
+  s->cmp_to = glyph->slice.cmp.to + 1;
   s->face = FACE_FROM_ID (s->f, face_id);
   lgstring = composition_gstring_from_id (s->cmp_id);
   s->font = XFONT_OBJECT (LGSTRING_FONT (lgstring));
@@ -20604,8 +20624,8 @@ fill_gstring_glyph_string (struct glyph_string *s, int face_id,
   while (glyph < last
          && glyph->u.cmp.automatic
          && glyph->u.cmp.id == s->cmp_id
-         && s->cmp_to == glyph->u.cmp.from)
-    s->cmp_to = (glyph++)->u.cmp.to + 1;
+         && s->cmp_to == glyph->slice.cmp.from)
+    s->cmp_to = (glyph++)->slice.cmp.to + 1;
 
   for (i = s->cmp_from; i < s->cmp_to; i++)
     {
@@ -20695,7 +20715,7 @@ fill_image_glyph_string (struct glyph_string *s)
   xassert (s->first_glyph->type == IMAGE_GLYPH);
   s->img = IMAGE_FROM_ID (s->f, s->first_glyph->u.img_id);
   xassert (s->img);
-  s->slice = s->first_glyph->slice;
+  s->slice = s->first_glyph->slice.img;
   s->face = FACE_FROM_ID (s->f, s->first_glyph->face_id);
   s->font = s->face->font;
   s->width = s->first_glyph->pixel_width;
@@ -20801,8 +20821,8 @@ x_get_glyph_overhangs (struct glyph *glyph, struct frame *f, int *left, int *rig
           Lisp_Object gstring = composition_gstring_from_id (glyph->u.cmp.id);
           struct font_metrics metrics;
 
-          composition_gstring_width (gstring, glyph->u.cmp.from,
-                                     glyph->u.cmp.to + 1, &metrics);
+          composition_gstring_width (gstring, glyph->slice.cmp.from,
+                                     glyph->slice.cmp.to + 1, &metrics);
           if (metrics.rbearing > metrics.width)
             *right = metrics.rbearing - metrics.width;
           if (metrics.lbearing < 0)
@@ -21507,7 +21527,7 @@ append_glyph (struct it *it)
       glyph->glyph_not_available_p = it->glyph_not_available_p;
       glyph->face_id = it->face_id;
       glyph->u.ch = it->char_to_display;
-      glyph->slice = null_glyph_slice;
+      glyph->slice.img = null_glyph_slice;
       glyph->font_type = FONT_TYPE_UNKNOWN;
       if (it->bidi_p)
         {
@@ -21564,13 +21584,14 @@ append_composite_glyph (struct it *it)
         {
           glyph->u.cmp.automatic = 0;
           glyph->u.cmp.id = it->cmp_it.id;
+          glyph->slice.cmp.from = glyph->slice.cmp.to = 0;
         }
       else
         {
           glyph->u.cmp.automatic = 1;
           glyph->u.cmp.id = it->cmp_it.id;
-          glyph->u.cmp.from = it->cmp_it.from;
-          glyph->u.cmp.to = it->cmp_it.to - 1;
+          glyph->slice.cmp.from = it->cmp_it.from;
+          glyph->slice.cmp.to = it->cmp_it.to - 1;
         }
       glyph->avoid_cursor_p = it->avoid_cursor_p;
       glyph->multibyte_p = it->multibyte_p;
@@ -21581,7 +21602,6 @@ append_composite_glyph (struct it *it)
       glyph->padding_p = 0;
       glyph->glyph_not_available_p = 0;
       glyph->face_id = it->face_id;
-      glyph->slice = null_glyph_slice;
       glyph->font_type = FONT_TYPE_UNKNOWN;
       if (it->bidi_p)
         {
@@ -21760,7 +21780,7 @@ produce_image_glyph (struct it *it)
           glyph->glyph_not_available_p = 0;
           glyph->face_id = it->face_id;
           glyph->u.img_id = img->id;
-          glyph->slice = slice;
+          glyph->slice.img = slice;
           glyph->font_type = FONT_TYPE_UNKNOWN;
           if (it->bidi_p)
             {
@@ -21821,7 +21841,7 @@ append_stretch_glyph (struct it *it, Lisp_Object object,
       glyph->face_id = it->face_id;
       glyph->u.stretch.ascent = ascent;
       glyph->u.stretch.height = height;
-      glyph->slice = null_glyph_slice;
+      glyph->slice.img = null_glyph_slice;
       glyph->font_type = FONT_TYPE_UNKNOWN;
       if (it->bidi_p)
         {
@@ -21910,11 +21930,7 @@ produce_stretch_glyph (struct it *it)
 
       it2 = *it;
       if (it->multibyte_p)
-        {
-          int maxlen = ((IT_BYTEPOS (*it) >= GPT ? ZV : GPT)
-                        - IT_BYTEPOS (*it));
-          it2.c = it2.char_to_display = STRING_CHAR_AND_LENGTH (p, it2.len);
-        }
+        it2.c = it2.char_to_display = STRING_CHAR_AND_LENGTH (p, it2.len);
       else
         {
           it2.c = it2.char_to_display = *p, it2.len = 1;
@@ -22400,7 +22416,7 @@ x_produce_glyphs (struct it *it)
           XChar2b char2b;
           struct font_metrics *pcm;
           int font_not_found_p;
-          int pos;
+          EMACS_INT pos;
 
           for (glyph_len = cmp->glyph_len; glyph_len > 0; glyph_len--)
             if ((c = COMPOSITION_GLYPH (cmp, glyph_len - 1)) != '\t')
@@ -24162,7 +24178,8 @@ note_mode_line_or_margin_highlight (Lisp_Object window, int x, int y,
   Display_Info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
   Cursor cursor = FRAME_X_OUTPUT (f)->nontext_cursor;
   Lisp_Object pointer = Qnil;
-  int charpos, dx, dy, width, height;
+  int dx, dy, width, height;
+  EMACS_INT charpos;
   Lisp_Object string, object = Qnil;
   Lisp_Object pos, help;
 
@@ -24493,7 +24510,8 @@ note_mouse_highlight (struct frame *f, int x, int y)
       Lisp_Object *overlay_vec = NULL;
       int noverlays;
       struct buffer *obuf;
-      int obegv, ozv, same_region;
+      EMACS_INT obegv, ozv;
+      int same_region;
 
       /* Find the glyph under X/Y.  */
       glyph = x_y_to_hpos_vpos (w, x, y, &hpos, &vpos, &dx, &dy, &area);
@@ -24508,8 +24526,8 @@ note_mouse_highlight (struct frame *f, int x, int y)
               if ((image_map = Fplist_get (XCDR (img->spec), QCmap),
                    !NILP (image_map))
                   && (hotspot = find_hot_spot (image_map,
-                                               glyph->slice.x + dx,
-                                               glyph->slice.y + dy),
+                                               glyph->slice.img.x + dx,
+                                               glyph->slice.img.y + dy),
                       CONSP (hotspot))
                   && (hotspot = XCDR (hotspot), CONSP (hotspot)))
                 {
@@ -24679,7 +24697,7 @@ note_mouse_highlight (struct frame *f, int x, int y)
                   /* If we are on a display string with no mouse-face,
                      check if the text under it has one.  */
                   struct glyph_row *r = MATRIX_ROW (w->current_matrix, vpos);
-                  int start = MATRIX_ROW_START_CHARPOS (r);
+                  EMACS_INT start = MATRIX_ROW_START_CHARPOS (r);
                   pos = string_buffer_position (w, object, start);
                   if (pos > 0)
                     {
@@ -24758,7 +24776,7 @@ note_mouse_highlight (struct frame *f, int x, int y)
         else
           {
             Lisp_Object object = glyph->object;
-            int charpos = glyph->charpos;
+            EMACS_INT charpos = glyph->charpos;
 
             /* Try text properties.  */
             if (STRINGP (object)
@@ -24773,7 +24791,7 @@ note_mouse_highlight (struct frame *f, int x, int y)
                        see if the buffer text ``under'' it does.  */
                     struct glyph_row *r
                       = MATRIX_ROW (w->current_matrix, vpos);
-                    int start = MATRIX_ROW_START_CHARPOS (r);
+                    EMACS_INT start = MATRIX_ROW_START_CHARPOS (r);
                     EMACS_INT pos = string_buffer_position (w, object, start);
                     if (pos > 0)
                       {
@@ -24813,7 +24831,7 @@ note_mouse_highlight (struct frame *f, int x, int y)
           if (NILP (pointer))
             {
               Lisp_Object object = glyph->object;
-              int charpos = glyph->charpos;
+              EMACS_INT charpos = glyph->charpos;
 
               /* Try text properties.  */
               if (STRINGP (object)
@@ -24828,7 +24846,7 @@ note_mouse_highlight (struct frame *f, int x, int y)
                          see if the buffer text ``under'' it does.  */
                       struct glyph_row *r
                         = MATRIX_ROW (w->current_matrix, vpos);
-                      int start = MATRIX_ROW_START_CHARPOS (r);
+                      EMACS_INT start = MATRIX_ROW_START_CHARPOS (r);
                       EMACS_INT pos = string_buffer_position (w, object,
                                                               start);
                       if (pos > 0)
diff --git a/src/xgselect.c b/src/xgselect.c
index 56e14fe6e14..487f9882b81 100644
--- a/src/xgselect.c
+++ b/src/xgselect.c
@@ -109,11 +109,17 @@ xg_select (int max_fds, SELECT_TYPE *rfds, SELECT_TYPE *wfds, SELECT_TYPE *efds,
               if (rfds && FD_ISSET (i, rfds)) ++retval;
               else ++our_fds;
             }
+          else if (rfds)
+            FD_CLR (i, rfds);
+
           if (have_wfds && FD_ISSET (i, &all_wfds))
             {
               if (wfds && FD_ISSET (i, wfds)) ++retval;
               else ++our_fds;
             }
+          else if (wfds)
+            FD_CLR (i, wfds);
+
           if (efds && FD_ISSET (i, efds))
             ++retval;
         }
diff --git a/src/xml.c b/src/xml.c
index c1098b15a20..5829f1da538 100644
--- a/src/xml.c
+++ b/src/xml.c
@@ -30,50 +30,55 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 
 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;
+  if (node->type == XML_ELEMENT_NODE)
+    {
+      Lisp_Object result = Fcons (intern (node->name), Qnil);
+      xmlNode *child;
+      xmlAttr *property;
+      Lisp_Object plist = Qnil;
+
+      /* First add the attributes. */
+      property = node->properties;
+      while (property != NULL)
+        {
+          if (property->children &&
+              property->children->content)
+            {
+              plist = Fcons (Fcons (intern (property->name),
+                                    build_string (property->children->content)),
+                             plist);
+            }
+          property = property->next;
+        }
+      result = Fcons (Fnreverse (plist), result);
+
+      /* 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);
     }
-    /* Then add the children of the node. */
-    child = node->children;
-    while (child != NULL) {
-      result = Fcons (make_dom (child), result);
-      child = child->next;
+  else if (node->type == XML_TEXT_NODE)
+    {
+      if (node->content)
+        return build_string (node->content);
+      else
+        return Qnil;
     }
-    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
+  else
     return Qnil;
 }
 
 static Lisp_Object
-parse_buffer (Lisp_Object string, Lisp_Object base_url, int htmlp)
+parse_string (Lisp_Object string, Lisp_Object base_url, int htmlp)
 {
   xmlDoc *doc;
   xmlNode *node;
-  Lisp_Object result;
+  Lisp_Object result = Qnil;
   int ibeg, iend;
   char *burl = "";
 
@@ -81,50 +86,50 @@ parse_buffer (Lisp_Object string, Lisp_Object base_url, int htmlp)
 
   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);
+  if (! NILP (base_url))
+    {
+      CHECK_STRING (base_url);
+      burl = SDATA (base_url);
+    }
 
-    xmlFreeDoc (doc);
-    xmlCleanupParser ();
-  }
+  doc = htmlp
+    ? htmlReadMemory (SDATA (string), SBYTES (string), burl, "utf-8",
+                      HTML_PARSE_RECOVER|HTML_PARSE_NONET|
+                      HTML_PARSE_NOWARNING|HTML_PARSE_NOERROR)
+    : 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.*/)
+DEFUN ("xml-parse-html-string-internal", Fxml_parse_html_string_internal,
+       Sxml_parse_html_string_internal,
+       1, 2, 0,
+       doc: /* Parse STRING as an HTML document and return the parse tree.
+If BASE-URL is non-nil, it is used to expand relative URLs.  */)
   (Lisp_Object string, Lisp_Object base_url)
 {
-  return parse_buffer (string, base_url, 1);
+  return parse_string (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.*/)
+DEFUN ("xml-parse-string-internal", Fxml_parse_string_internal,
+       Sxml_parse_string_internal,
+       1, 2, 0,
+       doc: /* Parse STRING as an XML document and return the parse tree.
+If BASE-URL is non-nil, it is used to expand relative URLs.  */)
   (Lisp_Object string, Lisp_Object base_url)
 {
-  return parse_buffer (string, base_url, 0);
+  return parse_string (string, base_url, 0);
 }
 
 
@@ -134,8 +139,8 @@ the XML document.*/)
 void
 syms_of_xml (void)
 {
-  defsubr (&Shtml_parse_string);
-  defsubr (&Sxml_parse_string);
+  defsubr (&Sxml_parse_html_string_internal);
+  defsubr (&Sxml_parse_string_internal);
 }
 
 #endif /* HAVE_LIBXML2 */
diff --git a/src/xrdb.c b/src/xrdb.c
index d81f08747ac..d2898e1d8f8 100644
--- a/src/xrdb.c
+++ b/src/xrdb.c
@@ -127,7 +127,7 @@ x_get_customization_string (XrmDatabase db, const char *name, const char *class)
    Return NULL otherwise.  */
 
 static char *
-magic_file_p (const char *string, int string_len, const char *class, const char *escaped_suffix, const char *suffix)
+magic_file_p (const char *string, EMACS_INT string_len, const char *class, const char *escaped_suffix, const char *suffix)
 {
   char *lang = getenv ("LANG");
 
diff --git a/src/xterm.c b/src/xterm.c
index 2ebe8a80378..f9dd21c87fe 100644
--- a/src/xterm.c
+++ b/src/xterm.c
@@ -4004,7 +4004,7 @@ xt_action_hook (Widget widget, XtPointer client_data, String action_name,
                 XEvent *event, String *params, Cardinal *num_params)
 {
   int scroll_bar_p;
-  char *end_action;
+  const char *end_action;
 
 #ifdef USE_MOTIF
   scroll_bar_p = XmIsScrollBar (widget);
@@ -8285,19 +8285,89 @@ x_set_sticky (struct frame *f, Lisp_Object new_value, Lisp_Object old_value)
                 "_NET_WM_STATE_STICKY", NULL);
 }
 
+/* Return the current _NET_WM_STATE.
+   SIZE_STATE is set to one of the FULLSCREEN_* values.
+   STICKY is set to 1 if the sticky state is set, 0 if not.  */
+
+static void
+get_current_vm_state (struct frame *f,
+                      Window window,
+                      int *size_state,
+                      int *sticky)
+{
+  Atom actual_type;
+  unsigned long actual_size, bytes_remaining;
+  int i, rc, actual_format;
+  struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
+  long max_len = 65536;
+  Display *dpy = FRAME_X_DISPLAY (f);
+  unsigned char *tmp_data = NULL;
+  Atom target_type = XA_ATOM;
+
+  *sticky = 0;
+  *size_state = FULLSCREEN_NONE;
+
+  BLOCK_INPUT;
+  x_catch_errors (dpy);
+  rc = XGetWindowProperty (dpy, window, dpyinfo->Xatom_net_wm_state,
+                           0, max_len, False, target_type,
+                           &actual_type, &actual_format, &actual_size,
+                           &bytes_remaining, &tmp_data);
+
+  if (rc != Success || actual_type != target_type || x_had_errors_p (dpy))
+    {
+      if (tmp_data) XFree (tmp_data);
+      x_uncatch_errors ();
+      UNBLOCK_INPUT;
+      return;
+    }
+
+  x_uncatch_errors ();
+
+  for (i = 0; i < actual_size; ++i)
+    {
+      Atom a = ((Atom*)tmp_data)[i];
+      if (a == dpyinfo->Xatom_net_wm_state_maximized_horz) 
+        {
+          if (*size_state == FULLSCREEN_HEIGHT)
+            *size_state = FULLSCREEN_MAXIMIZED;
+          else
+            *size_state = FULLSCREEN_WIDTH;
+        }
+      else if (a == dpyinfo->Xatom_net_wm_state_maximized_vert)
+        {
+          if (*size_state == FULLSCREEN_WIDTH)
+            *size_state = FULLSCREEN_MAXIMIZED;
+          else
+            *size_state = FULLSCREEN_HEIGHT;
+        }
+      else if (a == dpyinfo->Xatom_net_wm_state_fullscreen_atom)
+        *size_state = FULLSCREEN_BOTH;
+      else if (a == dpyinfo->Xatom_net_wm_state_sticky)
+        *sticky = 1;
+    }
+
+  if (tmp_data) XFree (tmp_data);
+  UNBLOCK_INPUT;
+}
+
 /* Do fullscreen as specified in extended window manager hints */
 
 static int
 do_ewmh_fullscreen (struct frame *f)
 {
   int have_net_atom = wm_supports (f, "_NET_WM_STATE");
+  Lisp_Object lval = get_frame_param (f, Qfullscreen);
+  int cur, dummy;
+
+  get_current_vm_state (f, FRAME_OUTER_WINDOW (f), &cur, &dummy);
 
   /* Some window managers don't say they support _NET_WM_STATE, but they do say
      they support _NET_WM_STATE_FULLSCREEN.  Try that also.  */
   if (!have_net_atom)
       have_net_atom = wm_supports (f, "_NET_WM_STATE_FULLSCREEN");
 
-  if (have_net_atom)
+  if (have_net_atom && cur != f->want_fullscreen)
     {
       Lisp_Object frame;
       const char *fs = "_NET_WM_STATE_FULLSCREEN";
@@ -8306,26 +8376,41 @@ do_ewmh_fullscreen (struct frame *f)
 
       XSETFRAME (frame, f);
 
-      set_wm_state (frame, 0, fs, NULL);
-      set_wm_state (frame, 0, fh, NULL);
-      set_wm_state (frame, 0, fw, NULL);
-
-      /* If there are _NET_ atoms we assume we have extended window manager
-         hints.  */
+      /* Keep number of calls to set_wm_state as low as possible.
+         Some window managers, or possible Gtk+, hangs when too many
+         are sent at once.  */
       switch (f->want_fullscreen)
         {
         case FULLSCREEN_BOTH:
+          if (cur == FULLSCREEN_WIDTH || cur == FULLSCREEN_MAXIMIZED
+              || cur == FULLSCREEN_HEIGHT)
+            set_wm_state (frame, 0, fw, fh);
           set_wm_state (frame, 1, fs, NULL);
           break;
         case FULLSCREEN_WIDTH:
-          set_wm_state (frame, 1, fw, NULL);
+          if (cur == FULLSCREEN_BOTH || cur == FULLSCREEN_HEIGHT
+              || cur == FULLSCREEN_MAXIMIZED)
+            set_wm_state (frame, 0, fs, fh);
+          if (cur != FULLSCREEN_MAXIMIZED)
+            set_wm_state (frame, 1, fw, NULL);
           break;
         case FULLSCREEN_HEIGHT:
-          set_wm_state (frame, 1, fh, NULL);
+          if (cur == FULLSCREEN_BOTH || cur == FULLSCREEN_WIDTH
+              || cur == FULLSCREEN_MAXIMIZED)
+            set_wm_state (frame, 0, fs, fw);
+          if (cur != FULLSCREEN_MAXIMIZED)
+            set_wm_state (frame, 1, fh, NULL);
           break;
         case FULLSCREEN_MAXIMIZED:
+          if (cur == FULLSCREEN_BOTH)
+            set_wm_state (frame, 0, fs, NULL);
           set_wm_state (frame, 1, fw, fh);
           break;
+        case FULLSCREEN_NONE:
+          if (cur == FULLSCREEN_BOTH)
+            set_wm_state (frame, 0, fs, NULL);
+          else
+            set_wm_state (frame, 0, fw, fh);
         }
 
       f->want_fullscreen = FULLSCREEN_NONE;
@@ -8351,57 +8436,11 @@ XTfullscreen_hook (FRAME_PTR f)
 static void
 x_handle_net_wm_state (struct frame *f, XPropertyEvent *event)
 {
-  Atom actual_type;
-  unsigned long actual_size, bytes_remaining;
-  int i, rc, actual_format, value = FULLSCREEN_NONE;
-  struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
-  long max_len = 65536;
-  Display *dpy = FRAME_X_DISPLAY (f);
-  unsigned char *tmp_data = NULL;
-  Atom target_type = XA_ATOM;
+  int value = FULLSCREEN_NONE;
   Lisp_Object lval;
   int sticky = 0;
 
-  BLOCK_INPUT;
-  x_catch_errors (dpy);
-  rc = XGetWindowProperty (dpy, event->window,
-                           event->atom, 0, max_len, False, target_type,
-                           &actual_type, &actual_format, &actual_size,
-                           &bytes_remaining, &tmp_data);
-
-  if (rc != Success || actual_type != target_type || x_had_errors_p (dpy))
-    {
-      if (tmp_data) XFree (tmp_data);
-      x_uncatch_errors ();
-      UNBLOCK_INPUT;
-      return;
-    }
-
-  x_uncatch_errors ();
-
-  for (i = 0; i < actual_size; ++i)
-    {
-      Atom a = ((Atom*)tmp_data)[i];
-      if (a == dpyinfo->Xatom_net_wm_state_maximized_horz)
-        {
-          if (value == FULLSCREEN_HEIGHT)
-            value = FULLSCREEN_MAXIMIZED;
-          else
-            value = FULLSCREEN_WIDTH;
-        }
-      else if (a == dpyinfo->Xatom_net_wm_state_maximized_vert)
-        {
-          if (value == FULLSCREEN_WIDTH)
-            value = FULLSCREEN_MAXIMIZED;
-          else
-            value = FULLSCREEN_HEIGHT;
-        }
-      else if (a == dpyinfo->Xatom_net_wm_state_fullscreen_atom)
-        value = FULLSCREEN_BOTH;
-      else if (a == dpyinfo->Xatom_net_wm_state_sticky)
-        sticky = 1;
-    }
-
+  get_current_vm_state (f, event->window, &value, &sticky);
   lval = Qnil;
   switch (value)
     {
@@ -8421,9 +8460,6 @@ x_handle_net_wm_state (struct frame *f, XPropertyEvent *event)
 
   store_frame_param (f, Qfullscreen, lval);
   store_frame_param (f, Qsticky, sticky ? Qt : Qnil);
-
-  if (tmp_data) XFree (tmp_data);
-  UNBLOCK_INPUT;
 }
 
 /* Check if we need to resize the frame due to a fullscreen request.