Merge from trunk

76 files changed, 1830 insertions, 1298 deletions

diff --git a/src/ChangeLog.trunk b/src/ChangeLog.trunk
index 6fa2d821565..a6623803a6e 100644
--- a/src/ChangeLog.trunk
+++ b/src/ChangeLog.trunk
@@ -1,3 +1,431 @@
+2011-03-30  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * eval.c (struct backtrace): Don't cheat with negative numbers, but do
+        steal a few bits to be more compact.
+        (interactive_p, Fbacktrace, Fbacktrace_frame, mark_backtrace):
+        Remove unneeded casts.
+
+        * bytecode.c (Fbyte_code): CAR and CDR can GC.
+
+2011-03-30  Zachary Kanfer  <zkanfer@gmail.com>  (tiny change)
+
+        * keyboard.c (Fexecute_extended_command): Do log the "suggest key
+        binding" message (bug#7967).
+
+2011-03-30  Paul Eggert  <eggert@cs.ucla.edu>
+
+        Fix more problems found by GCC 4.6.0's static checks.
+
+        * unexelf.c (unexec) [! (defined _SYSTYPE_SYSV || defined __sgi)]:
+        Remove unused local var.
+
+        * editfns.c (Fmessage_box): Remove unused local var.
+
+        * xdisp.c (try_window_reusing_current_matrix, x_produce_glyphs):
+        (note_mode_line_or_margin_highlight, note_mouse_highlight):
+        Omit unused local vars.
+        * window.c (shrink_windows): Omit unused local var.
+        * menu.c (digest_single_submenu): Omit unused local var.
+        * dispnew.c (update_window) [PERIODIC_PREEMPTION_CHECKING]:
+        Omit unused local var.
+
+        * keyboard.c (parse_modifiers_uncached, parse_modifiers):
+        Don't assume string length fits in int.
+        (keyremap_step, read_key_sequence): Use size_t for sizes.
+        (read_key_sequence): Don't check last_real_key_start redundantly.
+
+        * callproc.c (Fcall_process, Fcall_process_region): Use SAFE_ALLOCA
+        instead of alloca (Bug#8344).
+
+        * eval.c (Fbacktrace): Don't assume nargs fits in int.
+        (Fbacktrace_frame): Don't assume nframes fits in int.
+
+        * syntax.c (scan_sexps_forward): Avoid pointer wraparound.
+
+        * xterm.c (x_make_frame_visible, same_x_server): Redo to avoid overflow
+        concerns.
+
+        * term.c (produce_glyphless_glyph): Remove unnecessary test.
+
+        * cm.c (calccost): Turn while-do into do-while, for clarity.
+
+        * keyboard.c (syms_of_keyboard): Use the same style as later
+        in this function when indexing through an array.  This also
+        works around GCC bug 48267.
+
+        * image.c (tiff_load): Fix off-by-one image count (Bug#8336).
+
+        * xselect.c (x_check_property_data): Return correct size (Bug#8335).
+
+        * chartab.c (sub_char_table_ref_and_range): Redo for slight
+        efficiency gain, and to bypass a gcc -Wstrict-overflow warning.
+
+        * keyboard.c, keyboard.h (num_input_events): Now size_t.
+        This avoids undefined behavior on integer overflow, and is a bit
+        more convenient anyway since it is compared to a size_t variable.
+
+        Variadic C functions now count arguments with size_t, not int.
+        This avoids an unnecessary limitation on 64-bit machines, which
+        caused (substring ...) to crash on large vectors (Bug#8344).
+        * lisp.h (struct Lisp_Subr.function.aMANY): Now takes size_t, not int.
+        (DEFUN_ARGS_MANY, internal_condition_case_n, safe_call): Likewise.
+        All variadic functions and their callers changed accordingly.
+        (struct gcpro.nvars): Now size_t, not int.  All uses changed.
+        * data.c (arith_driver, float_arith_driver): Likewise.
+        * editfns.c (general_insert_function): Likewise.
+        * eval.c (struct backtrace.nargs, interactive_p)
+        (internal_condition_case_n, run_hook_with_args, apply_lambda)
+        (funcall_lambda, mark_backtrace): Likewise.
+        * fns.c (concat): Likewise.
+        * frame.c (x_set_frame_parameters): Likewise.
+        * fns.c (get_key_arg): Now accepts and returns size_t, and returns
+        0 if not found, not -1.  All callers changed.
+
+        * alloc.c (garbage_collect): Don't assume stack size fits in int.
+        (stack_copy_size): Now size_t, not int.
+        (stack_copy, stack_copy_size): Define only if MAX_SAVE_STACK > 0.
+
+2011-03-28  Juanma Barranquero  <lekktu@gmail.com>
+
+        * coding.c (encode_designation_at_bol): Remove parameter `charbuf_end',
+        unused since 2002-03-01T01:17:24Z!handa@m17n.org and 2008-02-01T16:01:31Z!miles@gnu.org.
+        All callers changed.
+
+        * lisp.h (multibyte_char_to_unibyte):
+        * character.c (multibyte_char_to_unibyte): Remove parameter `rev_tbl',
+        unused since 2002-03-01T01:16:34Z!handa@m17n.org and 2008-02-01T16:01:31Z!miles@gnu.org.
+        * character.h (CHAR_TO_BYTE8):
+        * cmds.c (internal_self_insert):
+        * editfns.c (general_insert_function):
+        * keymap.c (push_key_description):
+        * search.c (Freplace_match):
+        * xdisp.c (message_dolog, set_message_1): All callers changed.
+
+2011-03-28  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * keyboard.c (safe_run_hook_funcall): New function.
+        (safe_run_hooks_1, safe_run_hooks_error, safe_run_hooks): On error,
+        don't set the hook to nil, but remove the offending function instead.
+        (Qcommand_hook_internal): Remove, unused.
+        (syms_of_keyboard): Don't initialize Qcommand_hook_internal nor define
+        Vcommand_hook_internal.
+
+        * eval.c (enum run_hooks_condition): Remove.
+        (funcall_nil, funcall_not): New functions.
+        (run_hook_with_args): Call each function through a `funcall' argument.
+        Remove `cond' argument, now redundant.
+        (Frun_hooks, Frun_hook_with_args, Frun_hook_with_args_until_success)
+        (Frun_hook_with_args_until_failure): Adjust accordingly.
+        (run_hook_wrapped_funcall, Frun_hook_wrapped): New functions.
+
+2011-03-28  Juanma Barranquero  <lekktu@gmail.com>
+
+        * dispextern.h (string_buffer_position): Remove declaration.
+
+        * print.c (strout): Remove parameter `multibyte', unused since
+        1999-08-21T19:30:21Z!gerd@gnu.org.  All callers changed.
+
+        * search.c (boyer_moore): Remove parameters `len', `pos' and `lim',
+        never used since function introduction in 1998-02-08T21:33:56Z!rms@gnu.org.
+        All callers changed.
+
+        * w32.c (_wsa_errlist): Use braces for struct initializers.
+
+        * xdisp.c (string_buffer_position_lim): Remove parameter `w',
+        never used since function introduction in 2001-03-09T18:41:50Z!gerd@gnu.org.
+        All callers changed.
+        (string_buffer_position): Likewise.  Also, make static (it's never
+        used outside xdisp.c).
+        (cursor_row_p): Remove parameter `w', unused since
+        2000-10-17T16:08:57Z!gerd@gnu.org.  All callers changed.
+        (decode_mode_spec): Remove parameter `precision', introduced during
+        Gerd Moellmann's rewrite at 1999-07-21T21:43:52Z!gerd@gnu.org, but never used.
+        All callers changed.
+
+2011-03-27  Jan Djärv  <jan.h.d@swipnet.se>
+
+        * nsterm.m (syms_of_nsterm): Use doc: for ns-auto-hide-menu-bar.
+
+2011-03-27  Anders Lindgren  <andlind@gmail.com>
+
+        * nsterm.m (ns_menu_bar_is_hidden): New variable.
+        (ns_constrain_all_frames, ns_menu_bar_should_be_hidden)
+        (ns_update_auto_hide_menu_bar): New functions.
+        (ns_update_begin): Call ns_update_auto_hide_menu_bar.
+        (applicationDidBecomeActive): Call ns_update_auto_hide_menu_bar and
+        ns_constrain_all_frames.
+        (constrainFrameRect): Return at once if ns_menu_bar_should_be_hidden.
+        (syms_of_nsterm): DEFVAR ns-auto-hide-menu-bar, init to Qnil.
+
+2011-03-27  Jan Djärv  <jan.h.d@swipnet.se>
+
+        * nsmenu.m (runDialogAt): Remove argument to timer_check.
+
+2011-03-27  Glenn Morris  <rgm@gnu.org>
+
+        * syssignal.h: Replace RETSIGTYPE with void.
+        * atimer.c, data.c, dispnew.c, emacs.c, floatfns.c, keyboard.c:
+        * keyboard.h, lisp.h, process.c, sysdep.c, xterm.c:
+        Replace SIGTYPE with void everywhere.
+        * s/usg5-4-common.h (SIGTYPE): Remove definition.
+        * s/template.h (SIGTYPE): Remove commented out definition.
+
+2011-03-26  Eli Zaretskii  <eliz@gnu.org>
+
+        * xdisp.c (redisplay_window): Don't check buffer's clip_changed
+        flag as a prerequisite for invoking try_scrolling.  (Bug#6671)
+
+2011-03-26  Juanma Barranquero  <lekktu@gmail.com>
+
+        * w32.c (read_unc_volume): Use parameter `henum', instead of
+        global variable `wget_enum_handle'.
+
+        * keymap.c (describe_vector): Remove parameters `indices' and
+        `char_table_depth', unused since 2002-03-01T01:43:26Z!handa@m17n.org.
+        (describe_map, Fdescribe_vector): Adjust calls to `describe_vector'.
+
+        * keyboard.h (timer_check, show_help_echo): Remove unused parameters.
+
+        * keyboard.c (timer_check): Remove parameter `do_it_now',
+        unused since 1996-04-12T06:01:29Z!rms@gnu.org.
+        (show_help_echo): Remove parameter `ok_to_overwrite_keystroke_echo',
+        unused since 2008-04-19T19:30:53Z!monnier@iro.umontreal.ca.
+
+        * keyboard.c (read_char):
+        * w32menu.c (w32_menu_display_help):
+        * xmenu.c (show_help_event, menu_help_callback):
+        Adjust calls to `show_help_echo'.
+
+        * gtkutil.c (xg_maybe_add_timer):
+        * keyboard.c (readable_events):
+        * process.c (wait_reading_process_output):
+        * xmenu.c (x_menu_wait_for_event): Adjust calls to `timer_check'.
+
+        * insdel.c (adjust_markers_gap_motion):
+        Remove; no-op since 1998-01-02T21:29:48Z!rms@gnu.org.
+        (gap_left, gap_right): Don't call it.
+
+2011-03-25  Chong Yidong  <cyd@stupidchicken.com>
+
+        * xdisp.c (handle_fontified_prop): Discard changes to clip_changed
+        incurred during fontification.
+
+2011-03-25  Juanma Barranquero  <lekktu@gmail.com>
+
+        * buffer.c (defvar_per_buffer): Remove unused parameter `doc'.
+        (DEFVAR_PER_BUFFER): Don't pass it.
+
+        * dispnew.c (row_equal_p, add_row_entry): Remove unused parameter `w'.
+        (scrolling_window): Don't pass it.
+
+2011-03-25  Juanma Barranquero  <lekktu@gmail.com>
+
+        * dispextern.h (glyph_matric): Use #if GLYPH_DEBUG, not #ifdef.
+
+        * fileio.c (check_executable) [DOS_NT]: Remove unused variables `len'
+        and `suffix'.
+        (Fset_file_selinux_context) [HAVE_LIBSELINUX]: Move here declaration
+        of variables specific to SELinux and computation of `encoded_absname'.
+
+        * image.c (XPutPixel): Remove unused variable `height'.
+
+        * keyboard.c (make_lispy_event): Remove unused variable `hpos'.
+
+        * unexw32.c (get_section_info): Remove unused variable `section'.
+
+        * w32.c (stat): Remove unused variables `drive_root' and `devtype'.
+        (system_process_attributes): Remove unused variable `sess'.
+        (sys_read): Remove unused variable `err'.
+
+        * w32fns.c (top): Wrap variables with #if GLYPH_DEBUG, not #ifdef.
+        (w32_wnd_proc): Remove unused variable `isdead'.
+        (unwind_create_frame): Use #if GLYPH_DEBUG, not #ifdef.
+        (Fx_server_max_request_size): Remove unused variable `dpyinfo'.
+        (x_create_tip_frame): Remove unused variable `tem'.
+
+        * w32inevt.c (w32_console_read_socket):
+        Remove unused variable `no_events'.
+
+        * w32term.c (x_draw_composite_glyph_string_foreground):
+        Remove unused variable `width'.
+
+2011-03-24  Juanma Barranquero  <lekktu@gmail.com>
+
+        * w32term.c (x_set_glyph_string_clipping):
+        Don't pass uninitialized region to CombineRgn.
+
+2011-03-23  Juanma Barranquero  <lekktu@gmail.com>
+
+        * w32fns.c (x_set_menu_bar_lines): Remove unused variable `olines'.
+        (w32_wnd_proc): Pass NULL to Windows API, not uninitialized buffer.
+        (Fx_close_connection): Remove unused variable `i'.
+
+        * w32font.c (w32font_draw): Return number of glyphs.
+        (w32font_open_internal): Remove unused variable `i'.
+        (w32font_driver): Add missing initializer.
+
+        * w32menu.c (utf8to16): Remove unused variable `utf16'.
+        (fill_in_menu): Remove unused variable `items_added'.
+
+        * w32term.c (last_mouse_press_frame): Remove static global variable.
+        (w32_clip_to_row): Remove unused variable `f'.
+        (x_delete_terminal): Remove unused variable `i'.
+
+        * w32uniscribe.c (uniscribe_shape): Remove unused variable `nclusters'.
+        (NOTHING): Remove unused static global variable.
+        (uniscribe_check_otf): Remove unused variable `table'.
+        (uniscribe_font_driver): Add missing initializers.
+
+2011-03-23  Julien Danjou  <julien@danjou.info>
+
+        * term.c (Fsuspend_tty, Fresume_tty):
+        * minibuf.c (read_minibuf, run_exit_minibuf_hook):
+        * window.c (temp_output_buffer_show):
+        * insdel.c (signal_before_change):
+        * frame.c (Fhandle_switch_frame):
+        * fileio.c (Fdo_auto_save):
+        * emacs.c (Fkill_emacs):
+        * editfns.c (save_excursion_restore):
+        * cmds.c (internal_self_insert):
+        * callint.c (Fcall_interactively):
+        * buffer.c (Fkill_all_local_variables):
+        * keyboard.c (Fcommand_execute, Fsuspend_emacs, safe_run_hooks_1):
+        Use Frun_hooks.
+        (command_loop_1): Use Frun_hooks.  Call safe_run_hooks
+        unconditionnaly since it does the check itself.
+
+2011-03-23  Paul Eggert  <eggert@cs.ucla.edu>
+
+        Fix more problems found by GCC 4.5.2's static checks.
+
+        * coding.c (encode_coding_raw_text): Avoid unnecessary test
+        the first time through the loop, since we know p0 < p1 then.
+        This also avoids a gcc -Wstrict-overflow warning.
+
+        * lisp.h (SAFE_ALLOCA, SAFE_ALLOCA_LISP): Avoid 'int' overflow
+        leading to a memory leak, possible in functions like
+        load_charset_map_from_file that can allocate an unbounded number
+        of objects (Bug#8318).
+
+        * xmenu.c (set_frame_menubar): Use EMACS_UINT, not int, for indexes
+        that could (at least in theory) be that large.
+
+        * xdisp.c (message_log_check_duplicate): Return unsigned long, not int.
+        This is less likely to overflow, and avoids undefined behavior if
+        overflow does occur.  All callers changed.  Use strtoul to scan
+        for the unsigned long integer.
+        (pint2hrstr): Simplify and tune code slightly.
+        This also avoids a (bogus) GCC warning with gcc -Wstrict-overflow.
+
+        * scroll.c (do_scrolling): Work around GCC bug 48228.
+        See <http://gcc.gnu.org/bugzilla/show_bug.cgi?id=48228>.
+
+        * frame.c (Fmodify_frame_parameters): Simplify loop counter.
+        This also avoids a warning with gcc -Wstrict-overflow.
+        (validate_x_resource_name): Simplify count usage.
+        This also avoids a warning with gcc -Wstrict-overflow.
+
+        * fileio.c (Fcopy_file): Report error if fchown or fchmod
+        fail (Bug#8306).
+
+        * emacs.c (Fdaemon_initialized): Do not ignore I/O errors (Bug#8303).
+
+        * process.c (Fmake_network_process): Use socklen_t, not int,
+        where POSIX says socklen_t is required in portable programs.
+        This fixes a porting bug on hosts like 64-bit HP-UX, where
+        socklen_t is wider than int (Bug#8277).
+        (Fmake_network_process, server_accept_connection):
+        (wait_reading_process_output, read_process_output):
+        Likewise.
+
+        * process.c: Rename or move locals to avoid shadowing.
+        (list_processes_1, Fmake_network_process):
+        (read_process_output_error_handler, exec_sentinel_error_handler):
+        Rename or move locals.
+        (Fmake_network_process): Define label "retry_connect" only if needed.
+        (Fnetwork_interface_info): Fix pointer signedness.
+        (process_send_signal): Add cast to avoid pointer signedness problem.
+        (FIRST_PROC_DESC, IF_NON_BLOCKING_CONNECT): Remove unused macros.
+        (create_process): Use 'volatile' to avoid vfork clobbering (Bug#8298).
+
+        Make tparam.h and terminfo.c consistent.
+        * cm.c (tputs, tgoto, BC, UP): Remove extern decls.
+        Include tparam.h instead, since it declares them.
+        * cm.h (PC): Remove extern decl; tparam.h now does this.
+        * deps.mk (cm.o, terminfo.o): Depend on tparam.h.
+        * terminfo.c: Include tparam.h, to check interfaces.
+        (tparm): Make 1st arg a const pointer in decl.  Put it at top level.
+        (tparam): Adjust signature to match interface in tparam.h;
+        this removes some undefined behavior.  Check that outstring and len
+        are zero, which they always are with Emacs.
+        * tparam.h (PC, BC, UP): New extern decls.
+
+        * xftfont.c (xftfont_shape): Now static, and defined only if needed.
+        (xftfont_open): Rename locals to avoid shadowing.
+
+        * ftfont.c (ftfont_resolve_generic_family): Fix pointer signedness.
+        (ftfont_otf_capability, ftfont_shape): Omit decls if not needed.
+        (OTF_TAG_SYM): Omit macro if not needed.
+        (ftfont_list): Remove unused local.
+        (get_adstyle_property, ftfont_pattern_entity):
+        (ftfont_lookup_cache, ftfont_open, ftfont_anchor_point):
+        Rename locals to avoid shadowing.
+
+        * xfont.c (xfont_list_family): Mark var as initialized.
+
+        * xml.c (make_dom): Now static.
+
+        * composite.c (composition_compute_stop_pos): Rename local to
+        avoid shadowing.
+        (composition_reseat_it): Remove unused locals.
+        (find_automatic_composition, composition_adjust_point): Likewise.
+        (composition_update_it): Mark var as initialized.
+        (find_automatic_composition): Mark vars as initialized,
+        with a FIXME (Bug#8290).
+
+        character.h: Rename locals to avoid shadowing.
+        * character.h (PREV_CHAR_BOUNDARY, FETCH_STRING_CHAR_ADVANCE):
+        (FETCH_STRING_CHAR_AS_MULTIBYTE_ADVANCE, FETCH_CHAR_ADVANCE):
+        (FETCH_CHAR_ADVANCE_NO_CHECK, INC_POS, DEC_POS, BUF_INC_POS):
+        (BUF_DEC_POS): Be more systematic about renaming local temporaries
+        to avoid shadowing.
+
+        * textprop.c (property_change_between_p): Remove; unused.
+
+        * intervals.c (interval_start_pos): Now static.
+
+        * intervals.h (CHECK_TOTAL_LENGTH): Avoid empty "else".
+
+        * atimer.c (start_atimer, append_atimer_lists, set_alarm):
+        Rename locals to avoid shadowing.
+
+        * sound.c (wav_play, au_play, Fplay_sound_internal):
+        Fix pointer signedness.
+        (alsa_choose_format): Remove unused local var.
+        (wav_play): Initialize a variable to 0, to prevent undefined
+        behavior (Bug#8278).
+
+        * region-cache.c (insert_cache_boundary): Redo var to avoid shadowing.
+
+        * region-cache.h (pp_cache): New decl, for gcc -Wmissing-prototypes.
+
+        * callproc.c (Fcall_process): Use 'volatile' to avoid vfork
+        clobbering (Bug#8298).
+        * sysdep.c (sys_subshell): Likewise.
+        Previously, the sys_subshell 'volatile' was incorrectly IF_LINTted out.
+
+        * lisp.h (child_setup): Now NO_RETURN unless DOS_NT.
+        This should get cleaned up, so that child_setup has the
+        same signature on all platforms.
+
+        * callproc.c (call_process_cleanup): Now static.
+        (relocate_fd): Rename locals to avoid shadowing.
+
+2011-03-22  Chong Yidong  <cyd@stupidchicken.com>
+
+        * xterm.c (x_clear_frame): Remove XClearWindow call.  This appears
+        not to be necessary, and produces flickering.
+
 2011-03-20  Glenn Morris  <rgm@gnu.org>
 
         * config.in: Remove file.
@@ -138,8 +566,8 @@
         gcc -Wbad-function-cast warning.
         (default_value, arithcompare, arith_driver, arith_error): Now static.
         (store_symval_forwarding): Rename local to avoid shadowing.
-        (Fmake_variable_buffer_local, Fmake_local_variable): Mark
-        variables as initialized.
+        (Fmake_variable_buffer_local, Fmake_local_variable):
+        Mark variables as initialized.
         (do_blv_forwarding, do_symval_forwarding): Remove; unused.
 
         * alloc.c (check_cons_list): Do not define unless GC_CHECK_CONS_LIST.
@@ -393,8 +821,8 @@
         (BUF_PT_BYTE): Rewrite to handle indirect buffers (Bug#8219).
         These macros can no longer be used for assignment.
 
-        * buffer.c (Fget_buffer_create, Fmake_indirect_buffer): Assign
-        struct members directly, instead of using BUF_BEGV etc.
+        * buffer.c (Fget_buffer_create, Fmake_indirect_buffer):
+        Assign struct members directly, instead of using BUF_BEGV etc.
         (record_buffer_markers, fetch_buffer_markers): New functions for
         recording and fetching special buffer markers.
         (set_buffer_internal_1, set_buffer_temp): Use them.
@@ -515,8 +943,8 @@
         * term.c (encode_terminal_code): Now external again, used by
         w32console.c and msdos.c.
 
-        * makefile.w32-in ($(BLD)/term.$(O), ($(BLD)/tparam.$(O)): Depend
-        on $(SRC)/tparam.h, see 2011-03-11T07:24:21Z!eggert@cs.ucla.edu.
+        * makefile.w32-in ($(BLD)/term.$(O), ($(BLD)/tparam.$(O)):
+        Depend on $(SRC)/tparam.h, see 2011-03-11T07:24:21Z!eggert@cs.ucla.edu.
 
 2011-03-11  Paul Eggert  <eggert@cs.ucla.edu>
 
@@ -580,8 +1008,8 @@
         (x_delete_glyphs, x_ins_del_lines): Mark with NO_RETURN.
         (x_connection_closed): Tell GCC not to suggest NO_RETURN.
 
-        * xfaces.c (clear_face_cache, Fx_list_fonts, Fface_font): Rename
-        or move locals to avoid shadowing.
+        * xfaces.c (clear_face_cache, Fx_list_fonts, Fface_font):
+        Rename or move locals to avoid shadowing.
         (tty_defined_color, merge_face_heights): Now static.
         (free_realized_faces_for_fontset): Remove; not used.
         (Fx_list_fonts): Mark variable that gcc -Wuninitialized
@@ -739,12 +1167,12 @@
         (xg_prepare_tooltip, xg_hide_tooltip): Call gdk_window_get_screen.
         (xg_prepare_tooltip, create_dialog, menubar_map_cb)
         (xg_update_frame_menubar, xg_tool_bar_detach_callback)
-        (xg_tool_bar_attach_callback, xg_update_tool_bar_sizes): Call
-        gtk_widget_get_preferred_size.
+        (xg_tool_bar_attach_callback, xg_update_tool_bar_sizes):
+        Call gtk_widget_get_preferred_size.
         (xg_frame_resized): gdk_window_get_geometry only takes 5
         parameters.
-        (xg_win_to_widget, xg_event_is_for_menubar): Call
-        gdk_x11_window_lookup_for_display.
+        (xg_win_to_widget, xg_event_is_for_menubar):
+        Call gdk_x11_window_lookup_for_display.
         (xg_set_widget_bg): New function.
         (delete_cb): New function.
         (xg_create_frame_widgets): connect delete-event to delete_cb.
@@ -840,7 +1268,7 @@
         (produce_glyphless_glyph): Make a pointer "const"
         since it might point to immutable storage.
         (update_window_cursor): Now static, since it's not used elsewhere.
-        (SKIP_GLYPHS): Removed unused macro.
+        (SKIP_GLYPHS): Remove unused macro.
 
 2011-03-06  Michael Shields  <shields@msrl.com>  (tiny change)
 
@@ -7337,7 +7765,7 @@
         * xterm.c (x_send_scroll_bar_event, SET_SAVED_MENU_EVENT)
         (handle_one_xevent, x_check_errors, xim_initialize, x_term_init):
         Likewise.
-        * character.h (BCOPY_SHORT): Removed.
+        * character.h (BCOPY_SHORT): Remove.
         * config.in: Regenerate.
         * dispnew.c (safe_bcopy): Only define as dummy if PROFILING.
         * emacs.c (main) [PROFILING]: Don't declare
@@ -10342,8 +10770,8 @@
         (POSIX_SIGNALS): Do not define.
 
         Remove support for old UNIX System V systems.
-        * s/unixware.h: Add the contents of s/usg-5-4-2.h.
-        * s/usg-5-4-2.h: Remove.
+        * s/unixware.h: Add the contents of s/usg5-4-2.h.
+        * s/usg5-4-2.h: Remove.
 
         Remove support for Solaris on PPC and for old versions.
         * s/sol2-6.h: Add the contents of s/sol-2.3.h, s/sol-2.4.h, s/sol-2.5.h.
@@ -19126,7 +19554,7 @@
         Set xftfont_info->ft_size.  Don't unlock the face.  Check BDF
         properties if appropriate.
         (xftfont_close): Unlock the face.
-        (xftfont_anchor_point, xftfont_shape): Deleted.
+        (xftfont_anchor_point, xftfont_shape): Delete.
         (syms_of_xftfont): Don't set members anchor_point and shape of
         xftfont_driver.
 
@@ -21031,7 +21459,7 @@
         Delete externs.
         (fontset_from_font_name): Extern it.
         (FS_LOAD_FONT, FONT_INFO_ID, FONT_INFO_FROM_ID)
-        (FONT_INFO_FROM_FACE): Deleted.
+        (FONT_INFO_FROM_FACE): Delete.
         (face_for_font): Adjust prototype.
 
         * fontset.c: Throughout the file, delete all USE_FONT_BACKEND
@@ -21048,7 +21476,7 @@
         (fontset_compare_rfontdef): New function.
         (reorder_font_vector): Remove the argument CHARSET-ID.  Sort
         rfont-defs by qsort.  Adjusted for the change of font-group vector.
-        (load_font_get_repertory): Deleted.
+        (load_font_get_repertory): Delete.
         (fontset_find_font): Use new macros to ref/set elements of
         font-def and rfont-def.
         (fontset_font): Fix the timing of remembering that no font for C.
@@ -21064,11 +21492,11 @@
         font-def.
         (Fnew_fontset): Use font_unparse_xlfd to generate
         FONTSET_ASCII (fontset).
-        (new_fontset_from_font_name): Deleted.
+        (new_fontset_from_font_name): Delete.
         (fontset_from_font): Rename from new_fontset_from_font.  Check if
         a fontset is already created for the font.  FIx updating of
         Vfontset_alias_alist.
-        (fontset_ascii_font): Deleted.
+        (fontset_ascii_font): Delete.
         (Ffont_info): Adjust for the format change of font-spec.
         (Finternal_char_font): Likewise.
         (Ffontset_info): Likewise.
@@ -21096,7 +21524,7 @@
         (ftfont_list): Return a list, not vector.
         (ftfont_match): Use ftfont_spec_pattern to get a pattern.
         (ftfont_list_family): Don't downcase names.
-        (ftfont_free_entity): Deleted.
+        (ftfont_free_entity): Delete.
         (ftfont_open): Return a font-object.  Adjusted for the change of
         struct font.  Get underline_thickness and underline_position from
         font property.  Don't update dpyinfo->smallest_font_height and
@@ -21148,13 +21576,13 @@
         (QCfoundry, QCadstyle, QCregistry, QCspacing, QCsize, QCavgwidth)
         (Qp): Extern them.
         (clear_font_table, load_face_font, xlfd_lookup_field_contents):
-        Deleted.
-        (struct font_name): Deleted.
-        (xlfd_numeric_value, xlfd_symbolic_value): Deleted.
+        Delete.
+        (struct font_name): Delete.
+        (xlfd_numeric_value, xlfd_symbolic_value): Delete.
         (compare_fonts_by_sort_order): New function.
         (xlfd_numeric_slant, xlfd_symbolic_slant, xlfd_numeric_weight)
         (xlfd_symbolic_weight, xlfd_numeric_swidth, xlfd_symbolic_swidth):
-        Deleted.
+        Delete.
         (Fx_family_fonts): Use font_list_entities, and sort fonts by
         compare_fonts_by_sort_order.
         (Fx_font_family_list): Call Ffont_family_list.
@@ -21167,9 +21595,9 @@
         (free_font_names, sort_fonts, x_face_list_fonts)
         (face_font_available_p, sorted_font_list, cmp_font_names)
         (font_list_1, concat_font_list, font_list, remove_duplicates):
-        Deleted.
+        Delete.
         (Fx_list_fonts): Use Ffont_list.
-        (LFACE_AVGWIDTH): Deleted.
+        (LFACE_AVGWIDTH): Delete.
         (check_lface_attrs): Don't check LFACE_AVGWIDTH.  Check LFACE_FONT
         by FONTP.
         (lface_fully_specified_p): Don't check LFACE_AVGWIDTH.
@@ -21191,7 +21619,7 @@
         (Fface_font): Get a font name from font->props[FONT_NAME_INDEX].
         (lface_same_font_attributes_p): Don't check LFACE_AVGWIDTH.
         Compare fonts by EQ.
-        (lookup_non_ascii_face): Deleted.
+        (lookup_non_ascii_face): Delete.
         (face_for_font): The 2nd argument changed.
         (x_supports_face_attributes_p): Don't check LFACE_AVGWIDTH.
         Check atomic font properties by case insensitive.
@@ -21214,7 +21642,7 @@
 
         * xfont.c: Include <stdlib.h> and "ccl.h".
         (struct xfont_info): New structure.
-        (xfont_query_font): Deleted.
+        (xfont_query_font): Delete.
         (xfont_find_ccl_program): Rename from x_find_ccl_program and
         moved from xterm.c.
         (xfont_driver): Adjust for the change of struct font_driver.
@@ -21230,7 +21658,7 @@
         dpyinfo->smallest_char_width.
         (xfont_close): Don't free struct font.
         (xfont_prepare_face): Adjust for the change of struct font.
-        (xfont_done_face): Deleted.
+        (xfont_done_face): Delete.
         (xfont_has_char): Adjust for the change of struct font.
         (xfont_encode_char, xfont_draw): Likewise.
         (xfont_check): New function.
@@ -21260,7 +21688,7 @@
         * xterm.c: Throughout the file, delete all USE_FONT_BACKEND
         conditionals.  Don't check enable_font_backend.  Delete all codes
         used only when USE_FONT_BACKEND is not defined.  Don't include ccl.h.
-        (x_per_char_metric, x_encode_char): Deleted.
+        (x_per_char_metric, x_encode_char): Delete.
         (x_set_cursor_gc, x_set_mouse_face_gc): Don't set GCFont.
         (x_compute_glyph_string_overhangs): Adjust for the change of
         `struct face'.
@@ -21269,10 +21697,10 @@
         (x_draw_glyph_string): Likewise.  Use font->underline_position and
         font->underline_thickness.
         (x_new_font): Rename from x_new_fontset2.
-        (x_new_fontset, x_get_font_info, x_list_fonts): Deleted.
+        (x_new_fontset, x_get_font_info, x_list_fonts): Delete.
         (x_check_font): Call `check' method of a font driver.
         (x_font_min_bounds, x_compute_min_glyph_bounds, x_load_font)
-        (x_query_font, x_get_font_repertory): Deleted.
+        (x_query_font, x_get_font_repertory): Delete.
         (x_find_ccl_program): Rename and moved to xfont.c.
         (x_redisplay_interface): Adjust for the change of `struct
         redisplay_interface'.
diff --git a/src/alloc.c b/src/alloc.c
index 0ca702fe0cd..07f1caae46b 100644
--- a/src/alloc.c
+++ b/src/alloc.c
@@ -254,8 +254,10 @@ const char *pending_malloc_warning;
 
 /* Buffer in which we save a copy of the C stack at each GC.  */
 
+#if MAX_SAVE_STACK > 0
 static char *stack_copy;
-static int stack_copy_size;
+static size_t stack_copy_size;
+#endif
 
 /* Non-zero means ignore malloc warnings.  Set during initialization.
    Currently not used.  */
@@ -2705,7 +2707,7 @@ DEFUN ("list", Flist, Slist, 0, MANY, 0,
        doc: /* Return a newly created list with specified arguments as elements.
 Any number of arguments, even zero arguments, are allowed.
 usage: (list &rest OBJECTS)  */)
-  (int nargs, register Lisp_Object *args)
+  (size_t nargs, register Lisp_Object *args)
 {
   register Lisp_Object val;
   val = Qnil;
@@ -2921,10 +2923,10 @@ DEFUN ("vector", Fvector, Svector, 0, MANY, 0,
        doc: /* Return a newly created vector with specified arguments as elements.
 Any number of arguments, even zero arguments, are allowed.
 usage: (vector &rest OBJECTS)  */)
-  (register int nargs, Lisp_Object *args)
+  (register size_t nargs, Lisp_Object *args)
 {
   register Lisp_Object len, val;
-  register int i;
+  register size_t i;
   register struct Lisp_Vector *p;
 
   XSETFASTINT (len, nargs);
@@ -2952,10 +2954,10 @@ argument to catch the left-over arguments.  If such an integer is used, the
 arguments will not be dynamically bound but will be instead pushed on the
 stack before executing the byte-code.
 usage: (make-byte-code ARGLIST BYTE-CODE CONSTANTS DEPTH &optional DOCSTRING INTERACTIVE-SPEC &rest ELEMENTS)  */)
-  (register int nargs, Lisp_Object *args)
+  (register size_t nargs, Lisp_Object *args)
 {
   register Lisp_Object len, val;
-  register int i;
+  register size_t i;
   register struct Lisp_Vector *p;
 
   XSETFASTINT (len, nargs);
@@ -4238,7 +4240,7 @@ static void
 check_gcpros (void)
 {
   struct gcpro *p;
-  int i;
+  size_t i;
 
   for (p = gcprolist; p; p = p->next)
     for (i = 0; i < p->nvars; ++i)
@@ -4847,7 +4849,7 @@ returns nil, because real GC can't be done.  */)
 {
   register struct specbinding *bind;
   char stack_top_variable;
-  register int i;
+  register size_t i;
   int message_p;
   Lisp_Object total[8];
   int count = SPECPDL_INDEX ();
@@ -4913,21 +4915,26 @@ returns nil, because real GC can't be done.  */)
 #if MAX_SAVE_STACK > 0
   if (NILP (Vpurify_flag))
     {
-      i = &stack_top_variable - stack_bottom;
-      if (i < 0) i = -i;
-      if (i < MAX_SAVE_STACK)
+      char *stack;
+      size_t stack_size;
+      if (&stack_top_variable < stack_bottom)
         {
-          if (stack_copy == 0)
-            stack_copy = (char *) xmalloc (stack_copy_size = i);
-          else if (stack_copy_size < i)
-            stack_copy = (char *) xrealloc (stack_copy, (stack_copy_size = i));
-          if (stack_copy)
+          stack = &stack_top_variable;
+          stack_size = stack_bottom - &stack_top_variable;
+        }
+      else
+        {
+          stack = stack_bottom;
+          stack_size = &stack_top_variable - stack_bottom;
+        }
+      if (stack_size <= MAX_SAVE_STACK)
+        {
+          if (stack_copy_size < stack_size)
             {
-              if ((EMACS_INT) (&stack_top_variable - stack_bottom) > 0)
-                memcpy (stack_copy, stack_bottom, i);
-              else
-                memcpy (stack_copy, &stack_top_variable, i);
+              stack_copy = (char *) xrealloc (stack_copy, stack_size);
+              stack_copy_size = stack_size;
             }
+          memcpy (stack_copy, stack, stack_size);
         }
     }
 #endif /* MAX_SAVE_STACK > 0 */
diff --git a/src/atimer.c b/src/atimer.c
index 309a4eaee4f..b947ea59ccd 100644
--- a/src/atimer.c
+++ b/src/atimer.c
@@ -64,7 +64,7 @@ static void set_alarm (void);
 static void schedule_atimer (struct atimer *);
 static struct atimer *append_atimer_lists (struct atimer *,
                                            struct atimer *);
-SIGTYPE alarm_signal_handler (int signo);
+void alarm_signal_handler (int signo);
 
 
 /* Start a new atimer of type TYPE.  TIME specifies when the timer is
@@ -86,7 +86,7 @@ SIGTYPE alarm_signal_handler (int signo);
    to cancel_atimer; don't free it yourself.  */
 
 struct atimer *
-start_atimer (enum atimer_type type, EMACS_TIME time, atimer_callback fn,
+start_atimer (enum atimer_type type, EMACS_TIME timestamp, atimer_callback fn,
               void *client_data)
 {
   struct atimer *t;
@@ -94,10 +94,10 @@ start_atimer (enum atimer_type type, EMACS_TIME time, atimer_callback fn,
   /* Round TIME up to the next full second if we don't have
      itimers.  */
 #ifndef HAVE_SETITIMER
-  if (EMACS_USECS (time) != 0)
+  if (EMACS_USECS (timestamp) != 0)
     {
-      EMACS_SET_USECS (time, 0);
-      EMACS_SET_SECS (time, EMACS_SECS (time) + 1);
+      EMACS_SET_USECS (timestamp, 0);
+      EMACS_SET_SECS (timestamp, EMACS_SECS (timestamp) + 1);
     }
 #endif /* not HAVE_SETITIMER */
 
@@ -123,18 +123,18 @@ start_atimer (enum atimer_type type, EMACS_TIME time, atimer_callback fn,
   switch (type)
     {
     case ATIMER_ABSOLUTE:
-      t->expiration = time;
+      t->expiration = timestamp;
       break;
 
     case ATIMER_RELATIVE:
       EMACS_GET_TIME (t->expiration);
-      EMACS_ADD_TIME (t->expiration, t->expiration, time);
+      EMACS_ADD_TIME (t->expiration, t->expiration, timestamp);
       break;
 
     case ATIMER_CONTINUOUS:
       EMACS_GET_TIME (t->expiration);
-      EMACS_ADD_TIME (t->expiration, t->expiration, time);
-      t->interval = time;
+      EMACS_ADD_TIME (t->expiration, t->expiration, timestamp);
+      t->interval = timestamp;
       break;
     }
 
@@ -187,24 +187,24 @@ cancel_atimer (struct atimer *timer)
 }
 
 
-/* Append two lists of atimers LIST1 and LIST2 and return the
+/* Append two lists of atimers LIST_1 and LIST_2 and return the
    result list.  */
 
 static struct atimer *
-append_atimer_lists (struct atimer *list1, struct atimer *list2)
+append_atimer_lists (struct atimer *list_1, struct atimer *list_2)
 {
-  if (list1 == NULL)
-    return list2;
-  else if (list2 == NULL)
-    return list1;
+  if (list_1 == NULL)
+    return list_2;
+  else if (list_2 == NULL)
+    return list_1;
   else
     {
       struct atimer *p;
 
-      for (p = list1; p->next; p = p->next)
+      for (p = list_1; p->next; p = p->next)
         ;
-      p->next = list2;
-      return list1;
+      p->next = list_2;
+      return list_1;
     }
 }
 
@@ -287,28 +287,28 @@ set_alarm (void)
 {
   if (atimers)
     {
-      EMACS_TIME now, time;
+      EMACS_TIME now, timestamp;
 #ifdef HAVE_SETITIMER
       struct itimerval it;
 #endif
 
       /* Determine s/us till the next timer is ripe.  */
       EMACS_GET_TIME (now);
-      EMACS_SUB_TIME (time, atimers->expiration, now);
+      EMACS_SUB_TIME (timestamp, atimers->expiration, now);
 
 #ifdef HAVE_SETITIMER
       /* Don't set the interval to 0; this disables the timer.  */
       if (EMACS_TIME_LE (atimers->expiration, now))
         {
-          EMACS_SET_SECS (time, 0);
-          EMACS_SET_USECS (time, 1000);
+          EMACS_SET_SECS (timestamp, 0);
+          EMACS_SET_USECS (timestamp, 1000);
         }
 
       memset (&it, 0, sizeof it);
-      it.it_value = time;
+      it.it_value = timestamp;
       setitimer (ITIMER_REAL, &it, 0);
 #else /* not HAVE_SETITIMER */
-      alarm (max (EMACS_SECS (time), 1));
+      alarm (max (EMACS_SECS (timestamp), 1));
 #endif /* not HAVE_SETITIMER */
     }
 }
@@ -388,7 +388,7 @@ run_timers (void)
 /* Signal handler for SIGALRM.  SIGNO is the signal number, i.e.
    SIGALRM.  */
 
-SIGTYPE
+void
 alarm_signal_handler (int signo)
 {
 #ifndef SYNC_INPUT
@@ -442,4 +442,3 @@ init_atimer (void)
   /* pending_signals is initialized in init_keyboard.*/
   signal (SIGALRM, alarm_signal_handler);
 }
-
diff --git a/src/buffer.c b/src/buffer.c
index d301e7f14f9..cdcd2ccecff 100644
--- a/src/buffer.c
+++ b/src/buffer.c
@@ -2520,8 +2520,7 @@ The first thing this function does is run
 the normal hook `change-major-mode-hook'.  */)
   (void)
 {
-  if (!NILP (Vrun_hooks))
-    call1 (Vrun_hooks, Qchange_major_mode_hook);
+  Frun_hooks (1, &Qchange_major_mode_hook);
 
   /* Make sure none of the bindings in local_var_alist
      remain swapped in, in their symbols.  */
@@ -5225,12 +5224,12 @@ init_buffer (void)
 #define DEFVAR_PER_BUFFER(lname, vname, type, doc)                      \
   do {                                                                  \
     static struct Lisp_Buffer_Objfwd bo_fwd;                            \
-    defvar_per_buffer (&bo_fwd, lname, vname, type, 0);                 \
+    defvar_per_buffer (&bo_fwd, lname, vname, type);                    \
   } while (0)
 
 static void
 defvar_per_buffer (struct Lisp_Buffer_Objfwd *bo_fwd, const char *namestring,
-                   Lisp_Object *address, Lisp_Object type, char *doc)
+                   Lisp_Object *address, Lisp_Object type)
 {
   struct Lisp_Symbol *sym;
   int offset;
diff --git a/src/bytecode.c b/src/bytecode.c
index d887668dd39..01ae8055ebf 100644
--- a/src/bytecode.c
+++ b/src/bytecode.c
@@ -425,7 +425,7 @@ according to which any remaining arguments are pushed on the stack
 before executing BYTESTR.
 
 usage: (byte-code BYTESTR VECTOR MAXDEP &optional ARGS-TEMPLATE &rest ARGS) */)
-     (int nargs, Lisp_Object *args)
+     (size_t nargs, Lisp_Object *args)
 {
   Lisp_Object args_tmpl = nargs >= 4 ? args[3] : Qnil;
   int pnargs = nargs >= 4 ? nargs - 4 : 0;
@@ -631,7 +631,16 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
           {
             Lisp_Object v1;
             v1 = TOP;
-            TOP = CAR (v1);
+            if (CONSP (v1))
+              TOP = XCAR (v1);
+            else if (NILP (v1))
+              TOP = Qnil;
+            else
+              {
+                BEFORE_POTENTIAL_GC ();
+                wrong_type_argument (Qlistp, v1);
+                AFTER_POTENTIAL_GC ();
+              }
             break;
           }
 
@@ -657,7 +666,17 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
           {
             Lisp_Object v1;
             v1 = TOP;
-            TOP = CDR (v1);
+            if (CONSP (v1))
+              TOP = XCDR (v1);
+            else if (NILP (v1))
+              TOP = Qnil;
+            else
+              {
+                BEFORE_POTENTIAL_GC ();
+                wrong_type_argument (Qlistp, v1);
+                AFTER_POTENTIAL_GC ();
+              }
+            break;
             break;
           }
 
@@ -994,13 +1013,13 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
             v1 = POP;
             v2 = TOP;
             CHECK_NUMBER (v2);
-            AFTER_POTENTIAL_GC ();
             op = XINT (v2);
             immediate_quit = 1;
             while (--op >= 0 && CONSP (v1))
               v1 = XCDR (v1);
             immediate_quit = 0;
             TOP = CAR (v1);
+            AFTER_POTENTIAL_GC ();
             break;
           }
 
diff --git a/src/callint.c b/src/callint.c
index 3c520742e27..489fa392e46 100644
--- a/src/callint.c
+++ b/src/callint.c
@@ -269,8 +269,9 @@ invoke it.  If KEYS is omitted or nil, the return value of
      recorded as a call to the function named callint_argfuns[varies[i]].  */
   int *varies;
 
-  register int i, j;
-  int count, foo;
+  register size_t i, j;
+  size_t count;
+  int foo;
   char prompt1[100];
   char *tem1;
   int arg_from_tty = 0;
@@ -430,8 +431,7 @@ invoke it.  If KEYS is omitted or nil, the return value of
                 error ("Attempt to select inactive minibuffer window");
 
               /* If the current buffer wants to clean up, let it.  */
-              if (!NILP (Vmouse_leave_buffer_hook))
-                call1 (Vrun_hooks, Qmouse_leave_buffer_hook);
+              Frun_hooks (1, &Qmouse_leave_buffer_hook);
 
               Fselect_window (w, Qnil);
             }
diff --git a/src/callproc.c b/src/callproc.c
index c53a92bbaf8..eb2a2268fe1 100644
--- a/src/callproc.c
+++ b/src/callproc.c
@@ -107,7 +107,7 @@ call_process_kill (Lisp_Object fdpid)
   return Qnil;
 }
 
-Lisp_Object
+static Lisp_Object
 call_process_cleanup (Lisp_Object arg)
 {
   Lisp_Object fdpid = Fcdr (arg);
@@ -177,10 +177,10 @@ and returns a numeric exit status or a signal description string.
 If you quit, the process is killed with SIGINT, or SIGKILL if you quit again.
 
 usage: (call-process PROGRAM &optional INFILE BUFFER DISPLAY &rest ARGS)  */)
-  (int nargs, register Lisp_Object *args)
+  (size_t nargs, register Lisp_Object *args)
 {
   Lisp_Object infile, buffer, current_dir, path;
-  int display_p;
+  volatile int display_p_volatile;
   int fd[2];
   int filefd;
   register int pid;
@@ -189,7 +189,9 @@ usage: (call-process PROGRAM &optional INFILE BUFFER DISPLAY &rest ARGS)  */)
   char buf[CALLPROC_BUFFER_SIZE_MAX];
   int bufsize = CALLPROC_BUFFER_SIZE_MIN;
   int count = SPECPDL_INDEX ();
+  volatile USE_SAFE_ALLOCA;
 
+  const unsigned char **volatile new_argv_volatile;
   register const unsigned char **new_argv;
   /* File to use for stderr in the child.
      t means use same as standard output.  */
@@ -220,7 +222,7 @@ usage: (call-process PROGRAM &optional INFILE BUFFER DISPLAY &rest ARGS)  */)
   /* Decide the coding-system for giving arguments.  */
   {
     Lisp_Object val, *args2;
-    int i;
+    size_t i;
 
     /* If arguments are supplied, we may have to encode them.  */
     if (nargs >= 5)
@@ -241,7 +243,7 @@ usage: (call-process PROGRAM &optional INFILE BUFFER DISPLAY &rest ARGS)  */)
           val = Qraw_text;
         else
           {
-            args2 = (Lisp_Object *) alloca ((nargs + 1) * sizeof *args2);
+            SAFE_ALLOCA (args2, Lisp_Object *, (nargs + 1) * sizeof *args2);
             args2[0] = Qcall_process;
             for (i = 0; i < nargs; i++) args2[i + 1] = args[i];
             coding_systems = Ffind_operation_coding_system (nargs + 1, args2);
@@ -343,7 +345,7 @@ usage: (call-process PROGRAM &optional INFILE BUFFER DISPLAY &rest ARGS)  */)
     UNGCPRO;
   }
 
-  display_p = INTERACTIVE && nargs >= 4 && !NILP (args[3]);
+  display_p_volatile = INTERACTIVE && nargs >= 4 && !NILP (args[3]);
 
   filefd = emacs_open (SSDATA (infile), O_RDONLY, 0);
   if (filefd < 0)
@@ -371,11 +373,12 @@ usage: (call-process PROGRAM &optional INFILE BUFFER DISPLAY &rest ARGS)  */)
       && SREF (path, 1) == ':')
     path = Fsubstring (path, make_number (2), Qnil);
 
-  new_argv = (const unsigned char **)
-    alloca (max (2, nargs - 2) * sizeof (char *));
+  SAFE_ALLOCA (new_argv, const unsigned char **,
+               (nargs > 4 ? nargs - 2 : 2) * sizeof *new_argv);
+  new_argv_volatile = new_argv;
   if (nargs > 4)
     {
-      register int i;
+      register size_t i;
       struct gcpro gcpro1, gcpro2, gcpro3, gcpro4, gcpro5;
 
       GCPRO5 (infile, buffer, current_dir, path, error_file);
@@ -542,6 +545,8 @@ usage: (call-process PROGRAM &optional INFILE BUFFER DISPLAY &rest ARGS)  */)
 
     pid = vfork ();
 
+    new_argv = new_argv_volatile;
+
     if (pid == 0)
       {
         if (fd[0] >= 0)
@@ -640,9 +645,9 @@ usage: (call-process PROGRAM &optional INFILE BUFFER DISPLAY &rest ARGS)  */)
         {
           if (EQ (coding_systems, Qt))
             {
-              int i;
+              size_t i;
 
-              args2 = (Lisp_Object *) alloca ((nargs + 1) * sizeof *args2);
+              SAFE_ALLOCA (args2, Lisp_Object *, (nargs + 1) * sizeof *args2);
               args2[0] = Qcall_process;
               for (i = 0; i < nargs; i++) args2[i + 1] = args[i];
               coding_systems
@@ -673,6 +678,7 @@ usage: (call-process PROGRAM &optional INFILE BUFFER DISPLAY &rest ARGS)  */)
     int first = 1;
     EMACS_INT total_read = 0;
     int carryover = 0;
+    int display_p = display_p_volatile;
     int display_on_the_fly = display_p;
     struct coding_system saved_coding;
 
@@ -805,6 +811,7 @@ usage: (call-process PROGRAM &optional INFILE BUFFER DISPLAY &rest ARGS)  */)
      when exiting.  */
   call_process_exited = 1;
 
+  SAFE_FREE ();
   unbind_to (count, Qnil);
 
   if (synch_process_termsig)
@@ -860,7 +867,7 @@ and returns a numeric exit status or a signal description string.
 If you quit, the process is killed with SIGINT, or SIGKILL if you quit again.
 
 usage: (call-process-region START END PROGRAM &optional DELETE BUFFER DISPLAY &rest ARGS)  */)
-  (int nargs, register Lisp_Object *args)
+  (size_t nargs, register Lisp_Object *args)
 {
   struct gcpro gcpro1;
   Lisp_Object filename_string;
@@ -869,7 +876,7 @@ usage: (call-process-region START END PROGRAM &optional DELETE BUFFER DISPLAY &r
   /* Qt denotes we have not yet called Ffind_operation_coding_system.  */
   Lisp_Object coding_systems;
   Lisp_Object val, *args2;
-  int i;
+  size_t i;
   char *tempfile;
   Lisp_Object tmpdir, pattern;
 
@@ -893,30 +900,35 @@ usage: (call-process-region START END PROGRAM &optional DELETE BUFFER DISPLAY &r
 #endif
     }
 
-  pattern = Fexpand_file_name (Vtemp_file_name_pattern, tmpdir);
-  tempfile = (char *) alloca (SBYTES (pattern) + 1);
-  memcpy (tempfile, SDATA (pattern), SBYTES (pattern) + 1);
-  coding_systems = Qt;
+  {
+    USE_SAFE_ALLOCA;
+    pattern = Fexpand_file_name (Vtemp_file_name_pattern, tmpdir);
+    SAFE_ALLOCA (tempfile, char *, SBYTES (pattern) + 1);
+    memcpy (tempfile, SDATA (pattern), SBYTES (pattern) + 1);
+    coding_systems = Qt;
 
 #ifdef HAVE_MKSTEMP
- {
-   int fd;
-
-   BLOCK_INPUT;
-   fd = mkstemp (tempfile);
-   UNBLOCK_INPUT;
-   if (fd == -1)
-     report_file_error ("Failed to open temporary file",
-                        Fcons (Vtemp_file_name_pattern, Qnil));
-   else
-     close (fd);
- }
+    {
+      int fd;
+
+      BLOCK_INPUT;
+      fd = mkstemp (tempfile);
+      UNBLOCK_INPUT;
+      if (fd == -1)
+        report_file_error ("Failed to open temporary file",
+                           Fcons (Vtemp_file_name_pattern, Qnil));
+      else
+        close (fd);
+    }
 #else
-  mktemp (tempfile);
+    mktemp (tempfile);
 #endif
 
-  filename_string = build_string (tempfile);
-  GCPRO1 (filename_string);
+    filename_string = build_string (tempfile);
+    GCPRO1 (filename_string);
+    SAFE_FREE ();
+  }
+
   start = args[0];
   end = args[1];
   /* Decide coding-system of the contents of the temporary file.  */
@@ -926,11 +938,13 @@ usage: (call-process-region START END PROGRAM &optional DELETE BUFFER DISPLAY &r
     val = Qraw_text;
   else
     {
-      args2 = (Lisp_Object *) alloca ((nargs + 1) * sizeof *args2);
+      USE_SAFE_ALLOCA;
+      SAFE_ALLOCA (args2, Lisp_Object *, (nargs + 1) * sizeof *args2);
       args2[0] = Qcall_process_region;
       for (i = 0; i < nargs; i++) args2[i + 1] = args[i];
       coding_systems = Ffind_operation_coding_system (nargs + 1, args2);
       val = CONSP (coding_systems) ? XCDR (coding_systems) : Qnil;
+      SAFE_FREE ();
     }
   val = complement_process_encoding_system (val);
 
@@ -1272,12 +1286,12 @@ relocate_fd (int fd, int minfd)
 #endif
       if (new == -1)
         {
-          const char *message1 = "Error while setting up child: ";
+          const char *message_1 = "Error while setting up child: ";
           const char *errmessage = strerror (errno);
-          const char *message2 = "\n";
-          emacs_write (2, message1, strlen (message1));
+          const char *message_2 = "\n";
+          emacs_write (2, message_1, strlen (message_1));
           emacs_write (2, errmessage, strlen (errmessage));
-          emacs_write (2, message2, strlen (message2));
+          emacs_write (2, message_2, strlen (message_2));
           _exit (1);
         }
       emacs_close (fd);
diff --git a/src/character.c b/src/character.c
index fdaf22f04f8..bac9f6af81e 100644
--- a/src/character.c
+++ b/src/character.c
@@ -232,13 +232,10 @@ translate_char (Lisp_Object table, int c)
 }
 
 /* Convert ASCII or 8-bit character C to unibyte.  If C is none of
-   them, return (C & 0xFF).
-
-   The argument REV_TBL is now ignored.  It will be removed in the
-   future.  */
+   them, return (C & 0xFF).  */
 
 int
-multibyte_char_to_unibyte (int c, Lisp_Object rev_tbl)
+multibyte_char_to_unibyte (int c)
 {
   if (c < 0x80)
     return c;
@@ -893,9 +890,10 @@ DEFUN ("string", Fstring, Sstring, 0, MANY, 0,
        doc: /*
 Concatenate all the argument characters and make the result a string.
 usage: (string &rest CHARACTERS)  */)
-  (int n, Lisp_Object *args)
+  (size_t n, Lisp_Object *args)
 {
-  int i, c;
+  size_t i;
+  int c;
   unsigned char *buf, *p;
   Lisp_Object str;
   USE_SAFE_ALLOCA;
@@ -918,9 +916,10 @@ usage: (string &rest CHARACTERS)  */)
 DEFUN ("unibyte-string", Funibyte_string, Sunibyte_string, 0, MANY, 0,
        doc: /* Concatenate all the argument bytes and make the result a unibyte string.
 usage: (unibyte-string &rest BYTES)  */)
-  (int n, Lisp_Object *args)
+  (size_t n, Lisp_Object *args)
 {
-  int i, c;
+  size_t i;
+  int c;
   unsigned char *buf, *p;
   Lisp_Object str;
   USE_SAFE_ALLOCA;
diff --git a/src/character.h b/src/character.h
index 4c468e14d2c..7a75ac186fa 100644
--- a/src/character.h
+++ b/src/character.h
@@ -69,7 +69,7 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #define CHAR_TO_BYTE8(c)        \
   (CHAR_BYTE8_P (c)             \
    ? (c) - 0x3FFF00             \
-   : multibyte_char_to_unibyte (c, Qnil))
+   : multibyte_char_to_unibyte (c))
 
 /* Return the raw 8-bit byte for character C,
    or -1 if C doesn't correspond to a byte.  */
@@ -278,11 +278,11 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
   do {                                                                  \
     if ((p) > (limit))                                                  \
       {                                                                 \
-        const unsigned char *pcb = (p);                                 \
+        const unsigned char *chp = (p);                                 \
         do {                                                            \
-          pcb--;                                                        \
-        } while (pcb >= limit && ! CHAR_HEAD_P (*pcb));                 \
-        (p) = (BYTES_BY_CHAR_HEAD (*pcb) == (p) - pcb) ? pcb : (p) - 1; \
+          chp--;                                                        \
+        } while (chp >= limit && ! CHAR_HEAD_P (*chp));                 \
+        (p) = (BYTES_BY_CHAR_HEAD (*chp) == (p) - chp) ? chp : (p) - 1; \
       }                                                                 \
   } while (0)
 
@@ -353,11 +353,11 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
       CHARIDX++;                                                        \
       if (STRING_MULTIBYTE (STRING))                                    \
         {                                                               \
-          unsigned char *string_ptr = &SDATA (STRING)[BYTEIDX];         \
-          int string_len;                                               \
+          unsigned char *chp = &SDATA (STRING)[BYTEIDX];                \
+          int chlen;                                                    \
                                                                         \
-          OUTPUT = STRING_CHAR_AND_LENGTH (string_ptr, string_len);     \
-          BYTEIDX += string_len;                                        \
+          OUTPUT = STRING_CHAR_AND_LENGTH (chp, chlen);                 \
+          BYTEIDX += chlen;                                             \
         }                                                               \
       else                                                              \
         {                                                               \
@@ -376,11 +376,11 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
       CHARIDX++;                                                              \
       if (STRING_MULTIBYTE (STRING))                                          \
         {                                                                     \
-          unsigned char *ptr = &SDATA (STRING)[BYTEIDX];                      \
-          int ptrlen;                                                         \
+          unsigned char *chp = &SDATA (STRING)[BYTEIDX];                      \
+          int chlen;                                                          \
                                                                               \
-          OUTPUT = STRING_CHAR_AND_LENGTH (ptr, ptrlen);                      \
-          BYTEIDX += ptrlen;                                                  \
+          OUTPUT = STRING_CHAR_AND_LENGTH (chp, chlen);                       \
+          BYTEIDX += chlen;                                                   \
         }                                                                     \
       else                                                                    \
         {                                                                     \
@@ -416,11 +416,11 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
       CHARIDX++;                                                \
       if (!NILP (BVAR (current_buffer, enable_multibyte_characters)))   \
         {                                                       \
-          unsigned char *ptr = BYTE_POS_ADDR (BYTEIDX);         \
-          int string_len;                                       \
+          unsigned char *chp = BYTE_POS_ADDR (BYTEIDX);         \
+          int chlen;                                            \
                                                                 \
-          OUTPUT= STRING_CHAR_AND_LENGTH (ptr, string_len);     \
-          BYTEIDX += string_len;                                \
+          OUTPUT= STRING_CHAR_AND_LENGTH (chp, chlen);          \
+          BYTEIDX += chlen;                                     \
         }                                                       \
       else                                                      \
         {                                                       \
@@ -436,11 +436,11 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #define FETCH_CHAR_ADVANCE_NO_CHECK(OUTPUT, CHARIDX, BYTEIDX)   \
   do                                                            \
     {                                                           \
-      unsigned char *ptr = BYTE_POS_ADDR (BYTEIDX);             \
-      int len;                                                  \
+      unsigned char *chp = BYTE_POS_ADDR (BYTEIDX);             \
+      int chlen;                                                        \
                                                                 \
-      OUTPUT = STRING_CHAR_AND_LENGTH (ptr, len);               \
-      BYTEIDX += len;                                           \
+      OUTPUT = STRING_CHAR_AND_LENGTH (chp, chlen);             \
+      BYTEIDX += chlen;                                         \
       CHARIDX++;                                                \
     }                                                           \
   while (0)
@@ -451,8 +451,8 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 
 #define INC_POS(pos_byte)                               \
   do {                                                  \
-    unsigned char *ptr = BYTE_POS_ADDR (pos_byte);      \
-    pos_byte += BYTES_BY_CHAR_HEAD (*ptr);              \
+    unsigned char *chp = BYTE_POS_ADDR (pos_byte);      \
+    pos_byte += BYTES_BY_CHAR_HEAD (*chp);              \
   } while (0)
 
 
@@ -461,16 +461,16 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 
 #define DEC_POS(pos_byte)                       \
   do {                                          \
-    unsigned char *ptr;                         \
+    unsigned char *chp;                         \
                                                 \
     pos_byte--;                                 \
     if (pos_byte < GPT_BYTE)                    \
-      ptr = BEG_ADDR + pos_byte - BEG_BYTE;     \
+      chp = BEG_ADDR + pos_byte - BEG_BYTE;     \
     else                                        \
-      ptr = BEG_ADDR + GAP_SIZE + pos_byte - BEG_BYTE; \
-    while (!CHAR_HEAD_P (*ptr))                 \
+      chp = BEG_ADDR + GAP_SIZE + pos_byte - BEG_BYTE; \
+    while (!CHAR_HEAD_P (*chp))                 \
       {                                         \
-        ptr--;                                  \
+        chp--;                                  \
         pos_byte--;                             \
       }                                         \
   } while (0)
@@ -510,8 +510,8 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 
 #define BUF_INC_POS(buf, pos_byte)                              \
   do {                                                          \
-    unsigned char *bbp = BUF_BYTE_ADDRESS (buf, pos_byte);      \
-    pos_byte += BYTES_BY_CHAR_HEAD (*bbp);                      \
+    unsigned char *chp = BUF_BYTE_ADDRESS (buf, pos_byte);      \
+    pos_byte += BYTES_BY_CHAR_HEAD (*chp);                      \
   } while (0)
 
 
@@ -520,15 +520,15 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 
 #define BUF_DEC_POS(buf, pos_byte)                                      \
   do {                                                                  \
-    unsigned char *p;                                                   \
+    unsigned char *chp;                                                 \
     pos_byte--;                                                         \
     if (pos_byte < BUF_GPT_BYTE (buf))                                  \
-      p = BUF_BEG_ADDR (buf) + pos_byte - BEG_BYTE;                     \
+      chp = BUF_BEG_ADDR (buf) + pos_byte - BEG_BYTE;                   \
     else                                                                \
-      p = BUF_BEG_ADDR (buf) + BUF_GAP_SIZE (buf) + pos_byte - BEG_BYTE;\
-    while (!CHAR_HEAD_P (*p))                                           \
+      chp = BUF_BEG_ADDR (buf) + BUF_GAP_SIZE (buf) + pos_byte - BEG_BYTE;\
+    while (!CHAR_HEAD_P (*chp))                                         \
       {                                                                 \
-        p--;                                                            \
+        chp--;                                                          \
         pos_byte--;                                                     \
       }                                                                 \
   } while (0)
diff --git a/src/charset.c b/src/charset.c
index d82b29ae44b..32836d459f3 100644
--- a/src/charset.c
+++ b/src/charset.c
@@ -845,7 +845,7 @@ DEFUN ("define-charset-internal", Fdefine_charset_internal,
        Sdefine_charset_internal, charset_arg_max, MANY, 0,
        doc: /* For internal use only.
 usage: (define-charset-internal ...)  */)
-  (int nargs, Lisp_Object *args)
+  (size_t nargs, Lisp_Object *args)
 {
   /* Charset attr vector.  */
   Lisp_Object attrs;
@@ -2171,11 +2171,12 @@ DEFUN ("set-charset-priority", Fset_charset_priority, Sset_charset_priority,
        1, MANY, 0,
        doc: /* Assign higher priority to the charsets given as arguments.
 usage: (set-charset-priority &rest charsets)  */)
-  (int nargs, Lisp_Object *args)
+  (size_t nargs, Lisp_Object *args)
 {
   Lisp_Object new_head, old_list, arglist[2];
   Lisp_Object list_2022, list_emacs_mule;
-  int i, id;
+  size_t i;
+  int id;
 
   old_list = Fcopy_sequence (Vcharset_ordered_list);
   new_head = Qnil;
diff --git a/src/chartab.c b/src/chartab.c
index 85aa5932ac3..9ad182131e9 100644
--- a/src/chartab.c
+++ b/src/chartab.c
@@ -215,7 +215,6 @@ sub_char_table_ref_and_range (Lisp_Object table, int c, int *from, int *to, Lisp
   struct Lisp_Sub_Char_Table *tbl = XSUB_CHAR_TABLE (table);
   int depth = XINT (tbl->depth);
   int min_char = XINT (tbl->min_char);
-  int max_char = min_char + chartab_chars[depth - 1] - 1;
   int chartab_idx = CHARTAB_IDX (c, depth, min_char), idx;
   Lisp_Object val;
 
@@ -244,8 +243,9 @@ sub_char_table_ref_and_range (Lisp_Object table, int c, int *from, int *to, Lisp
           break;
         }
     }
-  while ((c = min_char + (chartab_idx + 1) * chartab_chars[depth]) <= max_char
-         && *to >= c)
+  while (((c = (chartab_idx + 1) * chartab_chars[depth])
+          < chartab_chars[depth - 1])
+         && (c += min_char) <= *to)
     {
       Lisp_Object this_val;
 
diff --git a/src/cm.c b/src/cm.c
index 108ee5720f3..42f855f1694 100644
--- a/src/cm.c
+++ b/src/cm.c
@@ -27,19 +27,11 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include "cm.h"
 #include "termhooks.h"
 #include "termchar.h"
-
-
-/* For now, don't try to include termcap.h.  On some systems,
-   configure finds a non-standard termcap.h that the main build
-   won't find.  */
-extern void tputs (const char *, int, int (*)(int));
-extern char *tgoto (const char *, int, int);
+#include "tparam.h"
 
 #define BIG     9999            /* 9999 good on VAXen.  For 16 bit machines
                                    use about 2000.... */
 
-extern char *BC, *UP;
-
 int cost;               /* sums up costs */
 
 /* ARGSUSED */
@@ -222,8 +214,9 @@ calccost (struct tty_display_info *tty,
     }
     totalcost = c * deltay;
     if (doit)
-        while (--deltay >= 0)
+      do
           emacs_tputs (tty, p, 1, cmputc);
+      while (0 < --deltay);
 x:
     if ((deltax = dstx - srcx) == 0)
         goto done;
@@ -304,8 +297,9 @@ fail:
     }
     totalcost += c * deltax;
     if (doit)
-        while (--deltax >= 0)
+      do
           emacs_tputs (tty, p, 1, cmputc);
+      while (0 < --deltax);
 done:
     return totalcost;
 }
diff --git a/src/cm.h b/src/cm.h
index 5d430598f0c..8f23990ce55 100644
--- a/src/cm.h
+++ b/src/cm.h
@@ -96,8 +96,6 @@ struct cm
     int cc_vabs;
   };
 
-extern char PC;                 /* Pad character */
-
 /* Shorthand */
 #ifndef NoCMShortHand
 #define curY(tty)               (tty)->Wcm->cm_curY
diff --git a/src/cmds.c b/src/cmds.c
index fa1ac5028ae..1cf7ff24fec 100644
--- a/src/cmds.c
+++ b/src/cmds.c
@@ -352,7 +352,7 @@ internal_self_insert (int c, EMACS_INT n)
     {
       str[0] = (SINGLE_BYTE_CHAR_P (c)
                 ? c
-                : multibyte_char_to_unibyte (c, Qnil));
+                : multibyte_char_to_unibyte (c));
       len = 1;
     }
   if (!NILP (overwrite)
@@ -501,7 +501,7 @@ internal_self_insert (int c, EMACS_INT n)
     }
 
   /* Run hooks for electric keys.  */
-  call1 (Vrun_hooks, Qpost_self_insert_hook);
+  Frun_hooks (1, &Qpost_self_insert_hook);
 
   return hairy;
 }
diff --git a/src/coding.c b/src/coding.c
index 0c2836c19f6..9e28a1c9f9b 100644
--- a/src/coding.c
+++ b/src/coding.c
@@ -853,8 +853,7 @@ static unsigned char *alloc_destination (struct coding_system *,
                                          EMACS_INT, unsigned char *);
 static void setup_iso_safe_charsets (Lisp_Object);
 static unsigned char *encode_designation_at_bol (struct coding_system *,
-                                                 int *, int *,
-                                                 unsigned char *);
+                                                 int *, unsigned char *);
 static int detect_eol (const unsigned char *,
                        EMACS_INT, enum coding_category);
 static Lisp_Object adjust_coding_eol_type (struct coding_system *, int);
@@ -4299,7 +4298,7 @@ encode_invocation_designation (struct charset *charset,
 
 static unsigned char *
 encode_designation_at_bol (struct coding_system *coding, int *charbuf,
-                           int *charbuf_end, unsigned char *dst)
+                           unsigned char *dst)
 {
   struct charset *charset;
   /* Table of charsets to be designated to each graphic register.  */
@@ -4390,7 +4389,7 @@ encode_coding_iso_2022 (struct coding_system *coding)
           unsigned char *dst_prev = dst;
 
           /* We have to produce designation sequences if any now.  */
-          dst = encode_designation_at_bol (coding, charbuf, charbuf_end, dst);
+          dst = encode_designation_at_bol (coding, charbuf, dst);
           bol_designation = 0;
           /* We are sure that designation sequences are all ASCII bytes.  */
           produced_chars += dst - dst_prev;
@@ -5266,11 +5265,12 @@ encode_coding_raw_text (struct coding_system *coding)
                 unsigned char str[MAX_MULTIBYTE_LENGTH], *p0 = str, *p1 = str;
 
                 CHAR_STRING_ADVANCE (c, p1);
-                while (p0 < p1)
+                do
                   {
                     EMIT_ONE_BYTE (*p0);
                     p0++;
                   }
+                while (p0 < p1);
               }
           }
       else
@@ -9299,7 +9299,7 @@ function to call for FILENAME, that function should examine the
 contents of BUFFER instead of reading the file.
 
 usage: (find-operation-coding-system OPERATION ARGUMENTS...)  */)
-  (int nargs, Lisp_Object *args)
+  (size_t nargs, Lisp_Object *args)
 {
   Lisp_Object operation, target_idx, target, val;
   register Lisp_Object chain;
@@ -9308,17 +9308,17 @@ usage: (find-operation-coding-system OPERATION ARGUMENTS...)  */)
     error ("Too few arguments");
   operation = args[0];
   if (!SYMBOLP (operation)
-      || !INTEGERP (target_idx = Fget (operation, Qtarget_idx)))
+      || !NATNUMP (target_idx = Fget (operation, Qtarget_idx)))
     error ("Invalid first argument");
-  if (nargs < 1 + XINT (target_idx))
+  if (nargs < 1 + XFASTINT (target_idx))
     error ("Too few arguments for operation: %s",
            SDATA (SYMBOL_NAME (operation)));
-  target = args[XINT (target_idx) + 1];
+  target = args[XFASTINT (target_idx) + 1];
   if (!(STRINGP (target)
         || (EQ (operation, Qinsert_file_contents) && CONSP (target)
             && STRINGP (XCAR (target)) && BUFFERP (XCDR (target)))
         || (EQ (operation, Qopen_network_stream) && INTEGERP (target))))
-    error ("Invalid %dth argument", XINT (target_idx) + 1);
+    error ("Invalid %dth argument", XFASTINT (target_idx) + 1);
   if (CONSP (target))
     target = XCAR (target);
 
@@ -9375,9 +9375,9 @@ If multiple coding systems belong to the same category,
 all but the first one are ignored.
 
 usage: (set-coding-system-priority &rest coding-systems)  */)
-  (int nargs, Lisp_Object *args)
+  (size_t nargs, Lisp_Object *args)
 {
-  int i, j;
+  size_t i, j;
   int changed[coding_category_max];
   enum coding_category priorities[coding_category_max];
 
@@ -9420,7 +9420,7 @@ usage: (set-coding-system-priority &rest coding-systems)  */)
 
   /* Update `coding-category-list'.  */
   Vcoding_category_list = Qnil;
-  for (i = coding_category_max - 1; i >= 0; i--)
+  for (i = coding_category_max; i-- > 0; )
     Vcoding_category_list
       = Fcons (AREF (Vcoding_category_table, priorities[i]),
                Vcoding_category_list);
@@ -9481,7 +9481,7 @@ DEFUN ("define-coding-system-internal", Fdefine_coding_system_internal,
        Sdefine_coding_system_internal, coding_arg_max, MANY, 0,
        doc: /* For internal use only.
 usage: (define-coding-system-internal ...)  */)
-  (int nargs, Lisp_Object *args)
+  (size_t nargs, Lisp_Object *args)
 {
   Lisp_Object name;
   Lisp_Object spec_vec;         /* [ ATTRS ALIASE EOL_TYPE ] */
diff --git a/src/composite.c b/src/composite.c
index 0b0602bf283..bc5644a4612 100644
--- a/src/composite.c
+++ b/src/composite.c
@@ -1115,7 +1115,7 @@ composition_compute_stop_pos (struct composition_it *cmp_it, EMACS_INT charpos,
           if (! NILP (val))
             {
               Lisp_Object elt;
-              int ridx, back, len;
+              int ridx, back, blen;
 
               for (ridx = 0; CONSP (val); val = XCDR (val), ridx++)
                 {
@@ -1132,17 +1132,17 @@ composition_compute_stop_pos (struct composition_it *cmp_it, EMACS_INT charpos,
                         bpos = (NILP (string) ? CHAR_TO_BYTE (cpos)
                                 : string_char_to_byte (string, cpos));
                       if (STRINGP (AREF (elt, 0)))
-                        len = fast_looking_at (AREF (elt, 0), cpos, bpos,
-                                               start + 1, limit, string);
+                        blen = fast_looking_at (AREF (elt, 0), cpos, bpos,
+                                                start + 1, limit, string);
                       else
-                        len = 1;
-                      if (len > 0)
+                        blen = 1;
+                      if (blen > 0)
                         {
                           /* Make CPOS point to the last character of
-                             match.  Note that LEN is byte-length.  */
-                          if (len > 1)
+                             match.  Note that BLEN is byte-length.  */
+                          if (blen > 1)
                             {
-                              bpos += len;
+                              bpos += blen;
                               if (NILP (string))
                                 cpos = BYTE_TO_CHAR (bpos) - 1;
                               else
@@ -1248,8 +1248,8 @@ composition_reseat_it (struct composition_it *cmp_it, EMACS_INT charpos, EMACS_I
   else if (w)
     {
       Lisp_Object lgstring = Qnil;
-      Lisp_Object val, elt, re;
-      int len, i;
+      Lisp_Object val, elt;
+      int i;
 
       val = CHAR_TABLE_REF (Vcomposition_function_table, cmp_it->ch);
       for (i = 0; i < cmp_it->rule_idx; i++, val = XCDR (val));
@@ -1364,7 +1364,7 @@ composition_reseat_it (struct composition_it *cmp_it, EMACS_INT charpos, EMACS_I
 int
 composition_update_it (struct composition_it *cmp_it, EMACS_INT charpos, EMACS_INT bytepos, Lisp_Object string)
 {
-  int i, c;
+  int i, c IF_LINT (= 0);
 
   if (cmp_it->ch < 0)
     {
@@ -1489,9 +1489,14 @@ find_automatic_composition (EMACS_INT pos, EMACS_INT limit, EMACS_INT *start, EM
   EMACS_INT head, tail, stop;
   /* Limit to check a composition after POS.  */
   EMACS_INT fore_check_limit;
-  struct position_record orig, cur, check, prev;
+  struct position_record orig, cur;
+
+  /* FIXME: It's not obvious whether these two variables need initialization.
+     If they do, please supply initial values.
+     If not, please remove this comment.  */
+  struct position_record check IF_LINT (= {0}), prev IF_LINT (= {0});
+
   Lisp_Object check_val, val, elt;
-  int check_lookback;
   int c;
   Lisp_Object window;
   struct window *w;
@@ -1657,7 +1662,7 @@ find_automatic_composition (EMACS_INT pos, EMACS_INT limit, EMACS_INT *start, EM
 EMACS_INT
 composition_adjust_point (EMACS_INT last_pt, EMACS_INT new_pt)
 {
-  EMACS_INT charpos, bytepos, startpos, beg, end, pos;
+  EMACS_INT beg, end;
   Lisp_Object val;
   int i;
 
@@ -2032,4 +2037,3 @@ See also the documentation of `auto-composition-mode'.  */);
   defsubr (&Sfind_composition_internal);
   defsubr (&Scomposition_get_gstring);
 }
-
diff --git a/src/data.c b/src/data.c
index e5c485f5322..4b9d2ec0387 100644
--- a/src/data.c
+++ b/src/data.c
@@ -2476,13 +2476,13 @@ enum arithop
     Amin
   };
 
-static Lisp_Object float_arith_driver (double, int, enum arithop,
-                                       int, Lisp_Object *);
+static Lisp_Object float_arith_driver (double, size_t, enum arithop,
+                                       size_t, Lisp_Object *);
 static Lisp_Object
-arith_driver (enum arithop code, int nargs, register Lisp_Object *args)
+arith_driver (enum arithop code, size_t nargs, register Lisp_Object *args)
 {
   register Lisp_Object val;
-  register int argnum;
+  register size_t argnum;
   register EMACS_INT accum = 0;
   register EMACS_INT next;
 
@@ -2564,7 +2564,8 @@ arith_driver (enum arithop code, int nargs, register Lisp_Object *args)
 #define isnan(x) ((x) != (x))
 
 static Lisp_Object
-float_arith_driver (double accum, register int argnum, enum arithop code, int nargs, register Lisp_Object *args)
+float_arith_driver (double accum, register size_t argnum, enum arithop code,
+                    size_t nargs, register Lisp_Object *args)
 {
   register Lisp_Object val;
   double next;
@@ -2626,7 +2627,7 @@ float_arith_driver (double accum, register int argnum, enum arithop code, int na
 DEFUN ("+", Fplus, Splus, 0, MANY, 0,
        doc: /* Return sum of any number of arguments, which are numbers or markers.
 usage: (+ &rest NUMBERS-OR-MARKERS)  */)
-  (int nargs, Lisp_Object *args)
+  (size_t nargs, Lisp_Object *args)
 {
   return arith_driver (Aadd, nargs, args);
 }
@@ -2636,7 +2637,7 @@ DEFUN ("-", Fminus, Sminus, 0, MANY, 0,
 With one arg, negates it.  With more than one arg,
 subtracts all but the first from the first.
 usage: (- &optional NUMBER-OR-MARKER &rest MORE-NUMBERS-OR-MARKERS)  */)
-  (int nargs, Lisp_Object *args)
+  (size_t nargs, Lisp_Object *args)
 {
   return arith_driver (Asub, nargs, args);
 }
@@ -2644,7 +2645,7 @@ usage: (- &optional NUMBER-OR-MARKER &rest MORE-NUMBERS-OR-MARKERS)  */)
 DEFUN ("*", Ftimes, Stimes, 0, MANY, 0,
        doc: /* Return product of any number of arguments, which are numbers or markers.
 usage: (* &rest NUMBERS-OR-MARKERS)  */)
-  (int nargs, Lisp_Object *args)
+  (size_t nargs, Lisp_Object *args)
 {
   return arith_driver (Amult, nargs, args);
 }
@@ -2653,9 +2654,9 @@ DEFUN ("/", Fquo, Squo, 2, MANY, 0,
        doc: /* Return first argument divided by all the remaining arguments.
 The arguments must be numbers or markers.
 usage: (/ DIVIDEND DIVISOR &rest DIVISORS)  */)
-  (int nargs, Lisp_Object *args)
+  (size_t nargs, Lisp_Object *args)
 {
-  int argnum;
+  size_t argnum;
   for (argnum = 2; argnum < nargs; argnum++)
     if (FLOATP (args[argnum]))
       return float_arith_driver (0, 0, Adiv, nargs, args);
@@ -2737,7 +2738,7 @@ DEFUN ("max", Fmax, Smax, 1, MANY, 0,
        doc: /* Return largest of all the arguments (which must be numbers or markers).
 The value is always a number; markers are converted to numbers.
 usage: (max NUMBER-OR-MARKER &rest NUMBERS-OR-MARKERS)  */)
-  (int nargs, Lisp_Object *args)
+  (size_t nargs, Lisp_Object *args)
 {
   return arith_driver (Amax, nargs, args);
 }
@@ -2746,7 +2747,7 @@ DEFUN ("min", Fmin, Smin, 1, MANY, 0,
        doc: /* Return smallest of all the arguments (which must be numbers or markers).
 The value is always a number; markers are converted to numbers.
 usage: (min NUMBER-OR-MARKER &rest NUMBERS-OR-MARKERS)  */)
-  (int nargs, Lisp_Object *args)
+  (size_t nargs, Lisp_Object *args)
 {
   return arith_driver (Amin, nargs, args);
 }
@@ -2755,7 +2756,7 @@ DEFUN ("logand", Flogand, Slogand, 0, MANY, 0,
        doc: /* Return bitwise-and of all the arguments.
 Arguments may be integers, or markers converted to integers.
 usage: (logand &rest INTS-OR-MARKERS)  */)
-  (int nargs, Lisp_Object *args)
+  (size_t nargs, Lisp_Object *args)
 {
   return arith_driver (Alogand, nargs, args);
 }
@@ -2764,7 +2765,7 @@ DEFUN ("logior", Flogior, Slogior, 0, MANY, 0,
        doc: /* Return bitwise-or of all the arguments.
 Arguments may be integers, or markers converted to integers.
 usage: (logior &rest INTS-OR-MARKERS)  */)
-  (int nargs, Lisp_Object *args)
+  (size_t nargs, Lisp_Object *args)
 {
   return arith_driver (Alogior, nargs, args);
 }
@@ -2773,7 +2774,7 @@ DEFUN ("logxor", Flogxor, Slogxor, 0, MANY, 0,
        doc: /* Return bitwise-exclusive-or of all the arguments.
 Arguments may be integers, or markers converted to integers.
 usage: (logxor &rest INTS-OR-MARKERS)  */)
-  (int nargs, Lisp_Object *args)
+  (size_t nargs, Lisp_Object *args)
 {
   return arith_driver (Alogxor, nargs, args);
 }
@@ -3302,7 +3303,7 @@ syms_of_data (void)
   XSYMBOL (intern_c_string ("most-negative-fixnum"))->constant = 1;
 }
 
-static SIGTYPE
+static void
 arith_error (int signo)
 {
   sigsetmask (SIGEMPTYMASK);
diff --git a/src/dbusbind.c b/src/dbusbind.c
index 2c8de20a4d4..8a6870555d0 100644
--- a/src/dbusbind.c
+++ b/src/dbusbind.c
@@ -1051,7 +1051,7 @@ object is returned instead of a list containing this single Lisp object.
   => "i686"
 
 usage: (dbus-call-method BUS SERVICE PATH INTERFACE METHOD &optional :timeout TIMEOUT &rest ARGS)  */)
-  (int nargs, register Lisp_Object *args)
+  (size_t nargs, register Lisp_Object *args)
 {
   Lisp_Object bus, service, path, interface, method;
   Lisp_Object result;
@@ -1063,7 +1063,7 @@ usage: (dbus-call-method BUS SERVICE PATH INTERFACE METHOD &optional :timeout TI
   DBusError derror;
   unsigned int dtype;
   int timeout = -1;
-  int i = 5;
+  size_t i = 5;
   char signature[DBUS_MAXIMUM_SIGNATURE_LENGTH];
 
   /* Check parameters.  */
@@ -1116,7 +1116,7 @@ usage: (dbus-call-method BUS SERVICE PATH INTERFACE METHOD &optional :timeout TI
         {
           XD_DEBUG_VALID_LISP_OBJECT_P (args[i]);
           XD_DEBUG_VALID_LISP_OBJECT_P (args[i+1]);
-          XD_DEBUG_MESSAGE ("Parameter%d %s %s", i-4,
+          XD_DEBUG_MESSAGE ("Parameter%lu %s %s", (unsigned long) (i-4),
                             SDATA (format2 ("%s", args[i], Qnil)),
                             SDATA (format2 ("%s", args[i+1], Qnil)));
           ++i;
@@ -1124,7 +1124,7 @@ usage: (dbus-call-method BUS SERVICE PATH INTERFACE METHOD &optional :timeout TI
       else
         {
           XD_DEBUG_VALID_LISP_OBJECT_P (args[i]);
-          XD_DEBUG_MESSAGE ("Parameter%d %s", i-4,
+          XD_DEBUG_MESSAGE ("Parameter%lu %s", (unsigned long) (i-4),
                             SDATA (format2 ("%s", args[i], Qnil)));
         }
 
@@ -1233,7 +1233,7 @@ Example:
   -| i686
 
 usage: (dbus-call-method-asynchronously BUS SERVICE PATH INTERFACE METHOD HANDLER &optional :timeout TIMEOUT &rest ARGS)  */)
-  (int nargs, register Lisp_Object *args)
+  (size_t nargs, register Lisp_Object *args)
 {
   Lisp_Object bus, service, path, interface, method, handler;
   Lisp_Object result;
@@ -1243,7 +1243,7 @@ usage: (dbus-call-method-asynchronously BUS SERVICE PATH INTERFACE METHOD HANDLE
   DBusMessageIter iter;
   unsigned int dtype;
   int timeout = -1;
-  int i = 6;
+  size_t i = 6;
   char signature[DBUS_MAXIMUM_SIGNATURE_LENGTH];
 
   /* Check parameters.  */
@@ -1298,7 +1298,7 @@ usage: (dbus-call-method-asynchronously BUS SERVICE PATH INTERFACE METHOD HANDLE
         {
           XD_DEBUG_VALID_LISP_OBJECT_P (args[i]);
           XD_DEBUG_VALID_LISP_OBJECT_P (args[i+1]);
-          XD_DEBUG_MESSAGE ("Parameter%d %s %s", i-4,
+          XD_DEBUG_MESSAGE ("Parameter%lu %s %s", (unsigned long) (i-4),
                             SDATA (format2 ("%s", args[i], Qnil)),
                             SDATA (format2 ("%s", args[i+1], Qnil)));
           ++i;
@@ -1306,7 +1306,7 @@ usage: (dbus-call-method-asynchronously BUS SERVICE PATH INTERFACE METHOD HANDLE
       else
         {
           XD_DEBUG_VALID_LISP_OBJECT_P (args[i]);
-          XD_DEBUG_MESSAGE ("Parameter%d %s", i-4,
+          XD_DEBUG_MESSAGE ("Parameter%lu %s", (unsigned long) (i - 4),
                             SDATA (format2 ("%s", args[i], Qnil)));
         }
 
@@ -1357,7 +1357,7 @@ DEFUN ("dbus-method-return-internal", Fdbus_method_return_internal,
 This is an internal function, it shall not be used outside dbus.el.
 
 usage: (dbus-method-return-internal BUS SERIAL SERVICE &rest ARGS)  */)
-  (int nargs, register Lisp_Object *args)
+  (size_t nargs, register Lisp_Object *args)
 {
   Lisp_Object bus, serial, service;
   struct gcpro gcpro1, gcpro2, gcpro3;
@@ -1365,7 +1365,7 @@ usage: (dbus-method-return-internal BUS SERIAL SERVICE &rest ARGS)  */)
   DBusMessage *dmessage;
   DBusMessageIter iter;
   unsigned int dtype;
-  int i;
+  size_t i;
   char signature[DBUS_MAXIMUM_SIGNATURE_LENGTH];
 
   /* Check parameters.  */
@@ -1405,7 +1405,7 @@ usage: (dbus-method-return-internal BUS SERIAL SERVICE &rest ARGS)  */)
         {
           XD_DEBUG_VALID_LISP_OBJECT_P (args[i]);
           XD_DEBUG_VALID_LISP_OBJECT_P (args[i+1]);
-          XD_DEBUG_MESSAGE ("Parameter%d %s %s", i-2,
+          XD_DEBUG_MESSAGE ("Parameter%lu %s %s", (unsigned long) (i-2),
                             SDATA (format2 ("%s", args[i], Qnil)),
                             SDATA (format2 ("%s", args[i+1], Qnil)));
           ++i;
@@ -1413,7 +1413,7 @@ usage: (dbus-method-return-internal BUS SERIAL SERVICE &rest ARGS)  */)
       else
         {
           XD_DEBUG_VALID_LISP_OBJECT_P (args[i]);
-          XD_DEBUG_MESSAGE ("Parameter%d %s", i-2,
+          XD_DEBUG_MESSAGE ("Parameter%lu %s", (unsigned long) (i-2),
                             SDATA (format2 ("%s", args[i], Qnil)));
         }
 
@@ -1445,7 +1445,7 @@ DEFUN ("dbus-method-error-internal", Fdbus_method_error_internal,
 This is an internal function, it shall not be used outside dbus.el.
 
 usage: (dbus-method-error-internal BUS SERIAL SERVICE &rest ARGS)  */)
-  (int nargs, register Lisp_Object *args)
+  (size_t nargs, register Lisp_Object *args)
 {
   Lisp_Object bus, serial, service;
   struct gcpro gcpro1, gcpro2, gcpro3;
@@ -1453,7 +1453,7 @@ usage: (dbus-method-error-internal BUS SERIAL SERVICE &rest ARGS)  */)
   DBusMessage *dmessage;
   DBusMessageIter iter;
   unsigned int dtype;
-  int i;
+  size_t i;
   char signature[DBUS_MAXIMUM_SIGNATURE_LENGTH];
 
   /* Check parameters.  */
@@ -1494,7 +1494,7 @@ usage: (dbus-method-error-internal BUS SERIAL SERVICE &rest ARGS)  */)
         {
           XD_DEBUG_VALID_LISP_OBJECT_P (args[i]);
           XD_DEBUG_VALID_LISP_OBJECT_P (args[i+1]);
-          XD_DEBUG_MESSAGE ("Parameter%d %s %s", i-2,
+          XD_DEBUG_MESSAGE ("Parameter%lu %s %s", (unsigned long) (i-2),
                             SDATA (format2 ("%s", args[i], Qnil)),
                             SDATA (format2 ("%s", args[i+1], Qnil)));
           ++i;
@@ -1502,7 +1502,7 @@ usage: (dbus-method-error-internal BUS SERIAL SERVICE &rest ARGS)  */)
       else
         {
           XD_DEBUG_VALID_LISP_OBJECT_P (args[i]);
-          XD_DEBUG_MESSAGE ("Parameter%d %s", i-2,
+          XD_DEBUG_MESSAGE ("Parameter%lu %s", (unsigned long) (i-2),
                             SDATA (format2 ("%s", args[i], Qnil)));
         }
 
@@ -1557,7 +1557,7 @@ Example:
   "org.gnu.Emacs.FileManager" "FileModified" "/home/albinus/.emacs")
 
 usage: (dbus-send-signal BUS SERVICE PATH INTERFACE SIGNAL &rest ARGS)  */)
-  (int nargs, register Lisp_Object *args)
+  (size_t nargs, register Lisp_Object *args)
 {
   Lisp_Object bus, service, path, interface, signal;
   struct gcpro gcpro1, gcpro2, gcpro3, gcpro4, gcpro5;
@@ -1565,7 +1565,7 @@ usage: (dbus-send-signal BUS SERVICE PATH INTERFACE SIGNAL &rest ARGS)  */)
   DBusMessage *dmessage;
   DBusMessageIter iter;
   unsigned int dtype;
-  int i;
+  size_t i;
   char signature[DBUS_MAXIMUM_SIGNATURE_LENGTH];
 
   /* Check parameters.  */
@@ -1609,7 +1609,7 @@ usage: (dbus-send-signal BUS SERVICE PATH INTERFACE SIGNAL &rest ARGS)  */)
         {
           XD_DEBUG_VALID_LISP_OBJECT_P (args[i]);
           XD_DEBUG_VALID_LISP_OBJECT_P (args[i+1]);
-          XD_DEBUG_MESSAGE ("Parameter%d %s %s", i-4,
+          XD_DEBUG_MESSAGE ("Parameter%lu %s %s", (unsigned long) (i-4),
                             SDATA (format2 ("%s", args[i], Qnil)),
                             SDATA (format2 ("%s", args[i+1], Qnil)));
           ++i;
@@ -1617,7 +1617,7 @@ usage: (dbus-send-signal BUS SERVICE PATH INTERFACE SIGNAL &rest ARGS)  */)
       else
         {
           XD_DEBUG_VALID_LISP_OBJECT_P (args[i]);
-          XD_DEBUG_MESSAGE ("Parameter%d %s", i-4,
+          XD_DEBUG_MESSAGE ("Parameter%lu %s", (unsigned long) (i-4),
                             SDATA (format2 ("%s", args[i], Qnil)));
         }
 
@@ -1885,11 +1885,11 @@ Example:
   => :already-owner.
 
 usage: (dbus-register-service BUS SERVICE &rest FLAGS)  */)
-  (int nargs, register Lisp_Object *args)
+  (size_t nargs, register Lisp_Object *args)
 {
   Lisp_Object bus, service;
   DBusConnection *connection;
-  unsigned int i;
+  size_t i;
   unsigned int value;
   unsigned int flags = 0;
   int result;
@@ -1985,13 +1985,13 @@ INTERFACE, SIGNAL and HANDLER must not be nil.  Example:
 `dbus-unregister-object' for removing the registration.
 
 usage: (dbus-register-signal BUS SERVICE PATH INTERFACE SIGNAL HANDLER &rest ARGS) */)
-  (int nargs, register Lisp_Object *args)
+  (size_t nargs, register Lisp_Object *args)
 {
   Lisp_Object bus, service, path, interface, signal, handler;
   struct gcpro gcpro1, gcpro2, gcpro3, gcpro4, gcpro5, gcpro6;
   Lisp_Object uname, key, key1, value;
   DBusConnection *connection;
-  int i;
+  size_t i;
   char rule[DBUS_MAXIMUM_MATCH_RULE_LENGTH];
   char x[DBUS_MAXIMUM_MATCH_RULE_LENGTH];
   DBusError derror;
@@ -2061,7 +2061,8 @@ usage: (dbus-register-signal BUS SERVICE PATH INTERFACE SIGNAL HANDLER &rest ARG
         if (!NILP (args[i]))
           {
             CHECK_STRING (args[i]);
-            sprintf (x, ",arg%d='%s'", i-6, SDATA (args[i]));
+            sprintf (x, ",arg%lu='%s'", (unsigned long) (i-6),
+                     SDATA (args[i]));
             strcat (rule, x);
           }
 
diff --git a/src/deps.mk b/src/deps.mk
index 35754dfa7de..d84e80dca44 100644
--- a/src/deps.mk
+++ b/src/deps.mk
@@ -65,7 +65,7 @@ coding.o: coding.c coding.h ccl.h buffer.h character.h charset.h composite.h \
    window.h dispextern.h msdos.h frame.h termhooks.h \
    lisp.h globals.h $(config_h)
 cm.o: cm.c frame.h cm.h termhooks.h termchar.h dispextern.h msdos.h \
-   lisp.h globals.h $(config_h)
+   tparam.h lisp.h globals.h $(config_h)
 cmds.o: cmds.c syntax.h buffer.h character.h commands.h window.h lisp.h \
    globals.h $(config_h) msdos.h dispextern.h keyboard.h keymap.h systime.h \
    coding.h frame.h composite.h
@@ -196,7 +196,7 @@ termcap.o: termcap.c lisp.h tparam.h msdos.h $(config_h)
 terminal.o: terminal.c frame.h termchar.h termhooks.h charset.h coding.h \
    keyboard.h lisp.h globals.h $(config_h) dispextern.h composite.h systime.h \
    msdos.h
-terminfo.o: terminfo.c lisp.h globals.h $(config_h)
+terminfo.o: terminfo.c tparam.h lisp.h globals.h $(config_h)
 tparam.o: tparam.c tparam.h lisp.h $(config_h)
 undo.o: undo.c buffer.h commands.h window.h dispextern.h msdos.h \
    lisp.h globals.h $(config_h)
diff --git a/src/dispextern.h b/src/dispextern.h
index 9843dfd1fcd..17a9bc39fb2 100644
--- a/src/dispextern.h
+++ b/src/dispextern.h
@@ -662,7 +662,7 @@ struct glyph_matrix
      line.  */
   unsigned header_line_p : 1;
 
-#ifdef GLYPH_DEBUG
+#if GLYPH_DEBUG
   /* A string identifying the method used to display the matrix.  */
   char method[512];
 #endif
@@ -2953,8 +2953,6 @@ extern int  bidi_mirror_char (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,
-                                  EMACS_INT);
 int line_bottom_y (struct it *);
 int display_prop_intangible_p (Lisp_Object);
 void resize_echo_area_exactly (void);
diff --git a/src/dispnew.c b/src/dispnew.c
index 1408bea2fc6..3a78845fa56 100644
--- a/src/dispnew.c
+++ b/src/dispnew.c
@@ -1297,13 +1297,11 @@ line_draw_cost (struct glyph_matrix *matrix, int vpos)
 
 
 /* Test two glyph rows A and B for equality.  Value is non-zero if A
-   and B have equal contents.  W is the window to which the glyphs
-   rows A and B belong.  It is needed here to test for partial row
-   visibility.  MOUSE_FACE_P non-zero means compare the mouse_face_p
-   flags of A and B, too.  */
+   and B have equal contents.  MOUSE_FACE_P non-zero means compare the
+   mouse_face_p flags of A and B, too.  */
 
 static INLINE int
-row_equal_p (struct window *w, struct glyph_row *a, struct glyph_row *b, int mouse_face_p)
+row_equal_p (struct glyph_row *a, struct glyph_row *b, int mouse_face_p)
 {
   if (a == b)
     return 1;
@@ -3592,7 +3590,10 @@ update_window (struct window *w, int force_p)
       struct glyph_row *row, *end;
       struct glyph_row *mode_line_row;
       struct glyph_row *header_line_row;
-      int yb, changed_p = 0, mouse_face_overwritten_p = 0, n_updated;
+      int yb, changed_p = 0, mouse_face_overwritten_p = 0;
+#if ! PERIODIC_PREEMPTION_CHECKING
+      int n_updated = 0;
+#endif
 
       rif->update_window_begin_hook (w);
       yb = window_text_bottom_y (w);
@@ -3645,7 +3646,7 @@ update_window (struct window *w, int force_p)
         }
 
       /* Update the rest of the lines.  */
-      for (n_updated = 0; row < end && (force_p || !input_pending); ++row)
+      for (; row < end && (force_p || !input_pending); ++row)
         if (row->enabled_p)
           {
             int vpos = MATRIX_ROW_VPOS (row, desired_matrix);
@@ -4251,17 +4252,16 @@ static int runs_size;
 
 static struct run **runs;
 
-/* Add glyph row ROW to the scrolling hash table during the scrolling
-   of window W.  */
+/* Add glyph row ROW to the scrolling hash table.  */
 
 static INLINE struct row_entry *
-add_row_entry (struct window *w, struct glyph_row *row)
+add_row_entry (struct glyph_row *row)
 {
   struct row_entry *entry;
   int i = row->hash % row_table_size;
 
   entry = row_table[i];
-  while (entry && !row_equal_p (w, entry->row, row, 1))
+  while (entry && !row_equal_p (entry->row, row, 1))
     entry = entry->next;
 
   if (entry == NULL)
@@ -4328,7 +4328,7 @@ scrolling_window (struct window *w, int header_line_p)
           && c->y == d->y
           && MATRIX_ROW_BOTTOM_Y (c) <= yb
           && MATRIX_ROW_BOTTOM_Y (d) <= yb
-          && row_equal_p (w, c, d, 1))
+          && row_equal_p (c, d, 1))
         {
           assign_row (c, d);
           d->enabled_p = 0;
@@ -4381,8 +4381,7 @@ scrolling_window (struct window *w, int header_line_p)
          && (MATRIX_ROW (current_matrix, i - 1)->y
              == MATRIX_ROW (desired_matrix, j - 1)->y)
          && !MATRIX_ROW (desired_matrix, j - 1)->redraw_fringe_bitmaps_p
-         && row_equal_p (w,
-                         MATRIX_ROW (desired_matrix, i - 1),
+         && row_equal_p (MATRIX_ROW (desired_matrix, i - 1),
                          MATRIX_ROW (current_matrix, j - 1), 1))
     --i, --j;
   last_new = i;
@@ -4443,7 +4442,7 @@ scrolling_window (struct window *w, int header_line_p)
     {
       if (MATRIX_ROW (current_matrix, i)->enabled_p)
         {
-          entry = add_row_entry (w, MATRIX_ROW (current_matrix, i));
+          entry = add_row_entry (MATRIX_ROW (current_matrix, i));
           old_lines[i] = entry;
           ++entry->old_uses;
         }
@@ -4454,7 +4453,7 @@ scrolling_window (struct window *w, int header_line_p)
   for (i = first_new; i < last_new; ++i)
     {
       xassert (MATRIX_ROW_ENABLED_P (desired_matrix, i));
-      entry = add_row_entry (w, MATRIX_ROW (desired_matrix, i));
+      entry = add_row_entry (MATRIX_ROW (desired_matrix, i));
       ++entry->new_uses;
       entry->new_line_number = i;
       new_lines[i] = entry;
@@ -5570,7 +5569,7 @@ marginal_area_string (struct window *w, enum window_part part,
 
 #ifdef SIGWINCH
 
-static SIGTYPE
+static void
 window_change_signal (int signalnum) /* If we don't have an argument, */
                                 /* some compilers complain in signal calls.  */
 {
diff --git a/src/editfns.c b/src/editfns.c
index 1f98ff040b3..d0f1df694d5 100644
--- a/src/editfns.c
+++ b/src/editfns.c
@@ -101,7 +101,7 @@ static void general_insert_function (void (*) (const char *, EMACS_INT),
                                      void (*) (Lisp_Object, EMACS_INT,
                                                EMACS_INT, EMACS_INT,
                                                EMACS_INT, int),
-                                     int, int, Lisp_Object *);
+                                     int, size_t, 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 (EMACS_INT, EMACS_INT, EMACS_INT, EMACS_INT,
@@ -928,18 +928,21 @@ save_excursion_restore (Lisp_Object info)
   tem1 = BVAR (current_buffer, mark_active);
   BVAR (current_buffer, mark_active) = tem;
 
-  if (!NILP (Vrun_hooks))
+  /* If mark is active now, and either was not active
+     or was at a different place, run the activate hook.  */
+  if (! NILP (tem))
     {
-      /* If mark is active now, and either was not active
-         or was at a different place, run the activate hook.  */
-      if (! NILP (BVAR (current_buffer, mark_active)))
-        {
-          if (! EQ (omark, nmark))
-            call1 (Vrun_hooks, intern ("activate-mark-hook"));
-        }
-      /* If mark has ceased to be active, run deactivate hook.  */
-      else if (! NILP (tem1))
-        call1 (Vrun_hooks, intern ("deactivate-mark-hook"));
+      if (! EQ (omark, nmark))
+        {
+          tem = intern ("activate-mark-hook");
+          Frun_hooks (1, &tem);
+        }
+    }
+  /* If mark has ceased to be active, run deactivate hook.  */
+  else if (! NILP (tem1))
+    {
+      tem = intern ("deactivate-mark-hook");
+      Frun_hooks (1, &tem);
     }
 
   /* If buffer was visible in a window, and a different window was
@@ -1868,7 +1871,7 @@ Years before 1970 are not guaranteed to work.  On some systems,
 year values as low as 1901 do work.
 
 usage: (encode-time SECOND MINUTE HOUR DAY MONTH YEAR &optional ZONE)  */)
-  (int nargs, register Lisp_Object *args)
+  (size_t nargs, register Lisp_Object *args)
 {
   time_t value;
   struct tm tm;
@@ -2204,9 +2207,9 @@ general_insert_function (void (*insert_func)
                          void (*insert_from_string_func)
                               (Lisp_Object, EMACS_INT, EMACS_INT,
                                EMACS_INT, EMACS_INT, int),
-                         int inherit, int nargs, Lisp_Object *args)
+                         int inherit, size_t nargs, Lisp_Object *args)
 {
-  register int argnum;
+  register size_t argnum;
   register Lisp_Object val;
 
   for (argnum = 0; argnum < nargs; argnum++)
@@ -2223,7 +2226,7 @@ general_insert_function (void (*insert_func)
             {
               str[0] = (ASCII_CHAR_P (XINT (val))
                         ? XINT (val)
-                        : multibyte_char_to_unibyte (XINT (val), Qnil));
+                        : multibyte_char_to_unibyte (XINT (val)));
               len = 1;
             }
           (*insert_func) ((char *) str, len);
@@ -2269,7 +2272,7 @@ buffer; to accomplish this, apply `string-as-multibyte' to the string
 and insert the result.
 
 usage: (insert &rest ARGS)  */)
-  (int nargs, register Lisp_Object *args)
+  (size_t nargs, register Lisp_Object *args)
 {
   general_insert_function (insert, insert_from_string, 0, nargs, args);
   return Qnil;
@@ -2288,7 +2291,7 @@ If the current buffer is unibyte, multibyte strings are converted
 to unibyte for insertion.
 
 usage: (insert-and-inherit &rest ARGS)  */)
-  (int nargs, register Lisp_Object *args)
+  (size_t nargs, register Lisp_Object *args)
 {
   general_insert_function (insert_and_inherit, insert_from_string, 1,
                            nargs, args);
@@ -2305,7 +2308,7 @@ If the current buffer is unibyte, multibyte strings are converted
 to unibyte for insertion.
 
 usage: (insert-before-markers &rest ARGS)  */)
-  (int nargs, register Lisp_Object *args)
+  (size_t nargs, register Lisp_Object *args)
 {
   general_insert_function (insert_before_markers,
                            insert_from_string_before_markers, 0,
@@ -2324,7 +2327,7 @@ If the current buffer is unibyte, multibyte strings are converted
 to unibyte for insertion.
 
 usage: (insert-before-markers-and-inherit &rest ARGS)  */)
-  (int nargs, register Lisp_Object *args)
+  (size_t nargs, register Lisp_Object *args)
 {
   general_insert_function (insert_before_markers_and_inherit,
                            insert_from_string_before_markers, 1,
@@ -3396,7 +3399,7 @@ any existing message; this lets the minibuffer contents show.  See
 also `current-message'.
 
 usage: (message FORMAT-STRING &rest ARGS)  */)
-  (int nargs, Lisp_Object *args)
+  (size_t nargs, Lisp_Object *args)
 {
   if (NILP (args[0])
       || (STRINGP (args[0])
@@ -3424,7 +3427,7 @@ If the first argument is nil or the empty string, clear any existing
 message; let the minibuffer contents show.
 
 usage: (message-box FORMAT-STRING &rest ARGS)  */)
-  (int nargs, Lisp_Object *args)
+  (size_t nargs, Lisp_Object *args)
 {
   if (NILP (args[0]))
     {
@@ -3441,12 +3444,12 @@ usage: (message-box FORMAT-STRING &rest ARGS)  */)
       if (FRAME_WINDOW_P (XFRAME (selected_frame))
           || FRAME_MSDOS_P (XFRAME (selected_frame)))
       {
-        Lisp_Object pane, menu, obj;
+        Lisp_Object pane, menu;
         struct gcpro gcpro1;
         pane = Fcons (Fcons (build_string ("OK"), Qt), Qnil);
         GCPRO1 (pane);
         menu = Fcons (val, pane);
-        obj = Fx_popup_dialog (Qt, menu, Qt);
+        Fx_popup_dialog (Qt, menu, Qt);
         UNGCPRO;
         return val;
       }
@@ -3481,7 +3484,7 @@ If the first argument is nil or the empty string, clear any existing
 message; let the minibuffer contents show.
 
 usage: (message-or-box FORMAT-STRING &rest ARGS)  */)
-  (int nargs, Lisp_Object *args)
+  (size_t nargs, Lisp_Object *args)
 {
 #ifdef HAVE_MENUS
   if ((NILP (last_nonmenu_event) || CONSP (last_nonmenu_event))
@@ -3505,14 +3508,14 @@ First argument is the string to copy.
 Remaining arguments form a sequence of PROPERTY VALUE pairs for text
 properties to add to the result.
 usage: (propertize STRING &rest PROPERTIES)  */)
-  (int nargs, Lisp_Object *args)
+  (size_t nargs, Lisp_Object *args)
 {
   Lisp_Object properties, string;
   struct gcpro gcpro1, gcpro2;
-  int i;
+  size_t i;
 
   /* Number of args must be odd.  */
-  if ((nargs & 1) == 0 || nargs < 1)
+  if ((nargs & 1) == 0)
     error ("Wrong number of arguments");
 
   properties = string = Qnil;
@@ -3587,10 +3590,10 @@ decimal point itself is omitted.  For %s and %S, the precision
 specifier truncates the string to the given width.
 
 usage: (format STRING &rest OBJECTS)  */)
-  (int nargs, register Lisp_Object *args)
+  (size_t nargs, register Lisp_Object *args)
 {
-  register int n;               /* The number of the next arg to substitute */
-  register EMACS_INT total;     /* An estimate of the final length */
+  register size_t n;            /* The number of the next arg to substitute */
+  register size_t total;        /* An estimate of the final length */
   char *buf, *p;
   register char *format, *end, *format_start;
   int nchars;
@@ -3666,8 +3669,8 @@ usage: (format STRING &rest OBJECTS)  */)
 
   /* Allocate the info and discarded tables.  */
   {
-    int nbytes = (nargs+1) * sizeof *info;
-    int i;
+    size_t nbytes = (nargs+1) * sizeof *info;
+    size_t i;
     if (!info)
       info = (struct info *) alloca (nbytes);
     memset (info, 0, nbytes);
diff --git a/src/emacs.c b/src/emacs.c
index 052f22ea622..6bdd2550ed1 100644
--- a/src/emacs.c
+++ b/src/emacs.c
@@ -308,7 +308,7 @@ pthread_t main_thread;
 
 
 /* Handle bus errors, invalid instruction, etc.  */
-SIGTYPE
+void
 fatal_error_signal (int sig)
 {
   SIGNAL_THREAD_CHECK (sig);
@@ -345,7 +345,7 @@ fatal_error_signal (int sig)
 #ifdef SIGDANGER
 
 /* Handler for SIGDANGER.  */
-SIGTYPE
+void
 memory_warning_signal (sig)
      int sig;
 {
@@ -1972,14 +1972,15 @@ all of which are called before Emacs is actually killed.  */)
   (Lisp_Object arg)
 {
   struct gcpro gcpro1;
+  Lisp_Object hook;
 
   GCPRO1 (arg);
 
   if (feof (stdin))
     arg = Qt;
 
-  if (!NILP (Vrun_hooks))
-    call1 (Vrun_hooks, intern ("kill-emacs-hook"));
+  hook = intern ("kill-emacs-hook");
+  Frun_hooks (1, &hook);
 
   UNGCPRO;
 
@@ -2312,6 +2313,7 @@ from the parent process and its tty file descriptors.  */)
   (void)
 {
   int nfd;
+  int err = 0;
 
   if (!IS_DAEMON)
     error ("This function can only be called if emacs is run as a daemon");
@@ -2324,10 +2326,11 @@ from the parent process and its tty file descriptors.  */)
 
   /* Get rid of stdin, stdout and stderr.  */
   nfd = open ("/dev/null", O_RDWR);
-  dup2 (nfd, 0);
-  dup2 (nfd, 1);
-  dup2 (nfd, 2);
-  close (nfd);
+  err |= nfd < 0;
+  err |= dup2 (nfd, 0) < 0;
+  err |= dup2 (nfd, 1) < 0;
+  err |= dup2 (nfd, 2) < 0;
+  err |= close (nfd) != 0;
 
   /* Closing the pipe will notify the parent that it can exit.
      FIXME: In case some other process inherited the pipe, closing it here
@@ -2336,10 +2339,13 @@ from the parent process and its tty file descriptors.  */)
      Instead, we should probably close the pipe in start-process and
      call-process to make sure the pipe is never inherited by
      subprocesses.  */
-  write (daemon_pipe[1], "\n", 1);
-  close (daemon_pipe[1]);
+  err |= write (daemon_pipe[1], "\n", 1) < 0;
+  err |= close (daemon_pipe[1]) != 0;
   /* Set it to an invalid value so we know we've already run this function.  */
   daemon_pipe[1] = -1;
+
+  if (err)
+    error ("I/O error during daemon initialization");
   return Qt;
 }
 
diff --git a/src/eval.c b/src/eval.c
index c22e7d3f571..9f90e6df4b5 100644
--- a/src/eval.c
+++ b/src/eval.c
@@ -30,24 +30,28 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include "xterm.h"
 #endif
 
-/* This definition is duplicated in alloc.c and keyboard.c */
-/* Putting it in lisp.h makes cc bomb out! */
+/* This definition is duplicated in alloc.c and keyboard.c.  */
+/* Putting it in lisp.h makes cc bomb out!  */
 
 struct backtrace
 {
   struct backtrace *next;
   Lisp_Object *function;
-  Lisp_Object *args;    /* Points to vector of args. */
-  int nargs;            /* Length of vector.
-                           If nargs is UNEVALLED, args points to slot holding
-                           list of unevalled args */
-  char evalargs;
-  /* Nonzero means call value of debugger when done with this operation. */
-  char debug_on_exit;
+  Lisp_Object *args;    /* Points to vector of args.  */
+#define NARGS_BITS (BITS_PER_INT - 2)
+  /* Let's not use size_t because we want to allow negative values (for
+     UNEVALLED).  Also let's steal 2 bits so we save a word (or more for
+     alignment).  In any case I doubt Emacs would survive a function call with
+     more than 500M arguments.  */
+  int nargs : NARGS_BITS; /* Length of vector.
+                             If nargs is UNEVALLED, args points
+                             to slot holding list of unevalled args.  */
+  char evalargs : 1;
+  /* Nonzero means call value of debugger when done with this operation.  */
+  char debug_on_exit : 1;
 };
 
 struct backtrace *backtrace_list;
-
 struct catchtag *catchlist;
 
 #ifdef DEBUG_GCPRO
@@ -114,7 +118,7 @@ Lisp_Object Vsignaling_function;
 int handling_signal;
 
 static Lisp_Object apply_lambda (Lisp_Object fun, Lisp_Object args);
-static Lisp_Object funcall_lambda (Lisp_Object, int, Lisp_Object *);
+static Lisp_Object funcall_lambda (Lisp_Object, size_t, Lisp_Object *);
 static void unwind_to_catch (struct catchtag *, Lisp_Object) NO_RETURN;
 static int interactive_p (int);
 
@@ -148,7 +152,7 @@ init_eval (void)
   when_entered_debugger = -1;
 }
 
-/* unwind-protect function used by call_debugger.  */
+/* Unwind-protect function used by call_debugger.  */
 
 static Lisp_Object
 restore_stack_limits (Lisp_Object data)
@@ -578,7 +582,7 @@ interactive_p (int exclude_subrs_p)
              || btp->nargs == UNEVALLED))
     btp = btp->next;
 
-  /* btp now points at the frame of the innermost function that isn't
+  /* `btp' now points at the frame of the innermost function that isn't
      a special form, ignoring frames for Finteractive_p and/or
      Fbytecode at the top.  If this frame is for a built-in function
      (such as load or eval-region) return nil.  */
@@ -586,7 +590,7 @@ interactive_p (int exclude_subrs_p)
   if (exclude_subrs_p && SUBRP (fun))
     return 0;
 
-  /* btp points to the frame of a Lisp function that called interactive-p.
+  /* `btp' points to the frame of a Lisp function that called interactive-p.
      Return t if that function was called interactively.  */
   if (btp && btp->next && EQ (*btp->next->function, Qcall_interactively))
     return 1;
@@ -1028,17 +1032,17 @@ usage: (let VARLIST BODY...)  */)
   Lisp_Object *temps, tem, lexenv;
   register Lisp_Object elt, varlist;
   int count = SPECPDL_INDEX ();
-  register int argnum;
+  register size_t argnum;
   struct gcpro gcpro1, gcpro2;
   USE_SAFE_ALLOCA;
 
   varlist = Fcar (args);
 
-  /* Make space to hold the values to give the bound variables */
+  /* Make space to hold the values to give the bound variables.  */
   elt = Flength (varlist);
   SAFE_ALLOCA_LISP (temps, XFASTINT (elt));
 
-  /* Compute the values and store them in `temps' */
+  /* Compute the values and store them in `temps'.  */
 
   GCPRO2 (args, *temps);
   gcpro2.nvars = 0;
@@ -1155,7 +1159,7 @@ definitions to shadow the loaded ones for use in file byte-compilation.  */)
           /* SYM is not mentioned in ENVIRONMENT.
              Look at its function definition.  */
           if (EQ (def, Qunbound) || !CONSP (def))
-            /* Not defined or definition not suitable */
+            /* Not defined or definition not suitable.  */
             break;
           if (EQ (XCAR (def), Qautoload))
             {
@@ -1296,10 +1300,7 @@ unwind_to_catch (struct catchtag *catch, Lisp_Object value)
   byte_stack_list = catch->byte_stack;
   gcprolist = catch->gcpro;
 #ifdef DEBUG_GCPRO
-  if (gcprolist != 0)
-    gcpro_level = gcprolist->level + 1;
-  else
-    gcpro_level = 0;
+  gcpro_level = gcprolist ? gcprolist->level + 1 : gcpro_level = 0;
 #endif
   backtrace_list = catch->backlist;
   lisp_eval_depth = catch->lisp_eval_depth;
@@ -1594,8 +1595,8 @@ internal_condition_case_2 (Lisp_Object (*bfun) (Lisp_Object, Lisp_Object),
    and ARGS as second argument.  */
 
 Lisp_Object
-internal_condition_case_n (Lisp_Object (*bfun) (int, Lisp_Object*),
-                           int nargs,
+internal_condition_case_n (Lisp_Object (*bfun) (size_t, Lisp_Object *),
+                           size_t nargs,
                            Lisp_Object *args,
                            Lisp_Object handlers,
                            Lisp_Object (*hfun) (Lisp_Object))
@@ -1907,7 +1908,7 @@ maybe_call_debugger (Lisp_Object conditions, Lisp_Object sig, Lisp_Object data)
           ? debug_on_quit
           : wants_debugger (Vdebug_on_error, conditions))
       && ! skip_debugger (conditions, combined_data)
-      /* rms: what's this for? */
+      /* RMS: What's this for?  */
       && when_entered_debugger < num_nonmacro_input_events)
     {
       call_debugger (Fcons (Qerror, Fcons (combined_data, Qnil)));
@@ -1974,7 +1975,7 @@ find_handler_clause (Lisp_Object handlers, Lisp_Object conditions,
 }
 
 
-/* dump an error message; called like vprintf */
+/* Dump an error message; called like vprintf.  */
 void
 verror (const char *m, va_list ap)
 {
@@ -2011,7 +2012,7 @@ verror (const char *m, va_list ap)
 }
 
 
-/* dump an error message; called like printf */
+/* Dump an error message; called like printf.  */
 
 /* VARARGS 1 */
 void
@@ -2109,7 +2110,7 @@ this does nothing and returns nil.  */)
   CHECK_SYMBOL (function);
   CHECK_STRING (file);
 
-  /* If function is defined and not as an autoload, don't override */
+  /* If function is defined and not as an autoload, don't override.  */
   if (!EQ (XSYMBOL (function)->function, Qunbound)
       && !(CONSP (XSYMBOL (function)->function)
            && EQ (XCAR (XSYMBOL (function)->function), Qautoload)))
@@ -2269,7 +2270,7 @@ eval_sub (Lisp_Object form)
 
   backtrace.next = backtrace_list;
   backtrace_list = &backtrace;
-  backtrace.function = &original_fun; /* This also protects them from gc */
+  backtrace.function = &original_fun; /* This also protects them from gc.  */
   backtrace.args = &original_args;
   backtrace.nargs = UNEVALLED;
   backtrace.evalargs = 1;
@@ -2279,7 +2280,7 @@ eval_sub (Lisp_Object form)
     do_debug_on_call (Qt);
 
   /* At this point, only original_fun and original_args
-     have values that will be used below */
+     have values that will be used below.  */
  retry:
 
   /* Optimize for no indirection.  */
@@ -2300,8 +2301,9 @@ eval_sub (Lisp_Object form)
 
       CHECK_CONS_LIST ();
 
-      if (XINT (numargs) < XSUBR (fun)->min_args ||
-          (XSUBR (fun)->max_args >= 0 && XSUBR (fun)->max_args < XINT (numargs)))
+      if (XINT (numargs) < XSUBR (fun)->min_args
+          || (XSUBR (fun)->max_args >= 0
+              && XSUBR (fun)->max_args < XINT (numargs)))
         xsignal2 (Qwrong_number_of_arguments, original_fun, numargs);
 
       else if (XSUBR (fun)->max_args == UNEVALLED)
@@ -2311,9 +2313,9 @@ eval_sub (Lisp_Object form)
         }
       else if (XSUBR (fun)->max_args == MANY)
         {
-          /* Pass a vector of evaluated arguments */
+          /* Pass a vector of evaluated arguments.  */
           Lisp_Object *vals;
-          register int argnum = 0;
+          register size_t argnum = 0;
           USE_SAFE_ALLOCA;
 
           SAFE_ALLOCA_LISP (vals, XINT (numargs));
@@ -2443,9 +2445,9 @@ DEFUN ("apply", Fapply, Sapply, 2, MANY, 0,
 Then return the value FUNCTION returns.
 Thus, (apply '+ 1 2 '(3 4)) returns 10.
 usage: (apply FUNCTION &rest ARGUMENTS)  */)
-  (int nargs, Lisp_Object *args)
+  (size_t nargs, Lisp_Object *args)
 {
-  register int i, numargs;
+  register size_t i, numargs;
   register Lisp_Object spread_arg;
   register Lisp_Object *funcall_args;
   Lisp_Object fun, retval;
@@ -2475,7 +2477,7 @@ usage: (apply FUNCTION &rest ARGUMENTS)  */)
     fun = indirect_function (fun);
   if (EQ (fun, Qunbound))
     {
-      /* Let funcall get the error */
+      /* Let funcall get the error.  */
       fun = args[0];
       goto funcall;
     }
@@ -2484,11 +2486,11 @@ usage: (apply FUNCTION &rest ARGUMENTS)  */)
     {
       if (numargs < XSUBR (fun)->min_args
           || (XSUBR (fun)->max_args >= 0 && XSUBR (fun)->max_args < numargs))
-        goto funcall;           /* Let funcall get the error */
-      else if (XSUBR (fun)->max_args > numargs)
+        goto funcall;           /* Let funcall get the error.  */
+      else if (XSUBR (fun)->max_args >= 0 && XSUBR (fun)->max_args > numargs)
         {
           /* Avoid making funcall cons up a yet another new vector of arguments
-             by explicitly supplying nil's for optional values */
+             by explicitly supplying nil's for optional values.  */
           SAFE_ALLOCA_LISP (funcall_args, 1 + XSUBR (fun)->max_args);
           for (i = numargs; i < XSUBR (fun)->max_args;)
             funcall_args[++i] = Qnil;
@@ -2526,9 +2528,12 @@ usage: (apply FUNCTION &rest ARGUMENTS)  */)
 
 /* Run hook variables in various ways.  */
 
-enum run_hooks_condition {to_completion, until_success, until_failure};
-static Lisp_Object run_hook_with_args (int, Lisp_Object *,
-                                       enum run_hooks_condition);
+static Lisp_Object
+funcall_nil (size_t nargs, Lisp_Object *args)
+{
+  Ffuncall (nargs, args);
+  return Qnil;
+}
 
 DEFUN ("run-hooks", Frun_hooks, Srun_hooks, 0, MANY, 0,
        doc: /* Run each hook in HOOKS.
@@ -2545,15 +2550,15 @@ hook; they should use `run-mode-hooks' instead.
 Do not use `make-local-variable' to make a hook variable buffer-local.
 Instead, use `add-hook' and specify t for the LOCAL argument.
 usage: (run-hooks &rest HOOKS)  */)
-  (int nargs, Lisp_Object *args)
+  (size_t nargs, Lisp_Object *args)
 {
   Lisp_Object hook[1];
-  register int i;
+  register size_t i;
 
   for (i = 0; i < nargs; i++)
     {
       hook[0] = args[i];
-      run_hook_with_args (1, hook, to_completion);
+      run_hook_with_args (1, hook, funcall_nil);
     }
 
   return Qnil;
@@ -2574,9 +2579,9 @@ as that may change.
 Do not use `make-local-variable' to make a hook variable buffer-local.
 Instead, use `add-hook' and specify t for the LOCAL argument.
 usage: (run-hook-with-args HOOK &rest ARGS)  */)
-  (int nargs, Lisp_Object *args)
+  (size_t nargs, Lisp_Object *args)
 {
-  return run_hook_with_args (nargs, args, to_completion);
+  return run_hook_with_args (nargs, args, funcall_nil);
 }
 
 DEFUN ("run-hook-with-args-until-success", Frun_hook_with_args_until_success,
@@ -2594,9 +2599,15 @@ However, if they all return nil, we return nil.
 Do not use `make-local-variable' to make a hook variable buffer-local.
 Instead, use `add-hook' and specify t for the LOCAL argument.
 usage: (run-hook-with-args-until-success HOOK &rest ARGS)  */)
-  (int nargs, Lisp_Object *args)
+  (size_t nargs, Lisp_Object *args)
 {
-  return run_hook_with_args (nargs, args, until_success);
+  return run_hook_with_args (nargs, args, Ffuncall);
+}
+
+static Lisp_Object
+funcall_not (size_t nargs, Lisp_Object *args)
+{
+  return NILP (Ffuncall (nargs, args)) ? Qt : Qnil;
 }
 
 DEFUN ("run-hook-with-args-until-failure", Frun_hook_with_args_until_failure,
@@ -2613,23 +2624,47 @@ Then we return nil.  However, if they all return non-nil, we return non-nil.
 Do not use `make-local-variable' to make a hook variable buffer-local.
 Instead, use `add-hook' and specify t for the LOCAL argument.
 usage: (run-hook-with-args-until-failure HOOK &rest ARGS)  */)
-  (int nargs, Lisp_Object *args)
+  (size_t nargs, Lisp_Object *args)
 {
-  return run_hook_with_args (nargs, args, until_failure);
+  return NILP (run_hook_with_args (nargs, args, funcall_not)) ? Qt : Qnil;
+}
+
+static Lisp_Object
+run_hook_wrapped_funcall (size_t nargs, Lisp_Object *args)
+{
+  Lisp_Object tmp = args[0], ret;
+  args[0] = args[1];
+  args[1] = tmp;
+  ret = Ffuncall (nargs, args);
+  args[1] = args[0];
+  args[0] = tmp;
+  return ret;
+}
+
+DEFUN ("run-hook-wrapped", Frun_hook_wrapped, Srun_hook_wrapped, 2, MANY, 0,
+       doc: /* Run HOOK, passing each function through WRAP-FUNCTION.
+I.e. instead of calling each function FUN directly with arguments ARGS,
+it calls WRAP-FUNCTION with arguments FUN and ARGS.
+As soon as a call to WRAP-FUNCTION returns non-nil, `run-hook-wrapped'
+aborts and returns that value.
+usage: (run-hook-wrapped HOOK WRAP-FUNCTION &rest ARGS)  */)
+     (size_t nargs, Lisp_Object *args)
+{
+  return run_hook_with_args (nargs, args, run_hook_wrapped_funcall);
 }
 
 /* ARGS[0] should be a hook symbol.
    Call each of the functions in the hook value, passing each of them
    as arguments all the rest of ARGS (all NARGS - 1 elements).
-   COND specifies a condition to test after each call
-   to decide whether to stop.
+   FUNCALL specifies how to call each function on the hook.
    The caller (or its caller, etc) must gcpro all of ARGS,
    except that it isn't necessary to gcpro ARGS[0].  */
 
-static Lisp_Object
-run_hook_with_args (int nargs, Lisp_Object *args, enum run_hooks_condition cond)
+Lisp_Object
+run_hook_with_args (size_t nargs, Lisp_Object *args,
+                    Lisp_Object (*funcall) (size_t nargs, Lisp_Object *args))
 {
-  Lisp_Object sym, val, ret;
+  Lisp_Object sym, val, ret = Qnil;
   struct gcpro gcpro1, gcpro2, gcpro3;
 
   /* If we are dying or still initializing,
@@ -2639,14 +2674,13 @@ run_hook_with_args (int nargs, Lisp_Object *args, enum run_hooks_condition cond)
 
   sym = args[0];
   val = find_symbol_value (sym);
-  ret = (cond == until_failure ? Qt : Qnil);
 
   if (EQ (val, Qunbound) || NILP (val))
     return ret;
   else if (!CONSP (val) || EQ (XCAR (val), Qlambda))
     {
       args[0] = val;
-      return Ffuncall (nargs, args);
+      return funcall (nargs, args);
     }
   else
     {
@@ -2654,9 +2688,7 @@ run_hook_with_args (int nargs, Lisp_Object *args, enum run_hooks_condition cond)
       GCPRO3 (sym, val, global_vals);
 
       for (;
-           CONSP (val) && ((cond == to_completion)
-                           || (cond == until_success ? NILP (ret)
-                               : !NILP (ret)));
+           CONSP (val) && NILP (ret);
            val = XCDR (val))
         {
           if (EQ (XCAR (val), Qt))
@@ -2669,30 +2701,26 @@ run_hook_with_args (int nargs, Lisp_Object *args, enum run_hooks_condition cond)
               if (!CONSP (global_vals) || EQ (XCAR (global_vals), Qlambda))
                 {
                   args[0] = global_vals;
-                  ret = Ffuncall (nargs, args);
+                  ret = funcall (nargs, args);
                 }
               else
                 {
                   for (;
-                       (CONSP (global_vals)
-                        && (cond == to_completion
-                            || (cond == until_success
-                                ? NILP (ret)
-                                : !NILP (ret))));
+                       CONSP (global_vals) && NILP (ret);
                        global_vals = XCDR (global_vals))
                     {
                       args[0] = XCAR (global_vals);
                       /* In a global value, t should not occur.  If it does, we
                          must ignore it to avoid an endless loop.  */
                       if (!EQ (args[0], Qt))
-                        ret = Ffuncall (nargs, args);
+                        ret = funcall (nargs, args);
                     }
                 }
             }
           else
             {
               args[0] = XCAR (val);
-              ret = Ffuncall (nargs, args);
+              ret = funcall (nargs, args);
             }
         }
 
@@ -2714,7 +2742,7 @@ run_hook_with_args_2 (Lisp_Object hook, Lisp_Object arg1, Lisp_Object arg2)
   Frun_hook_with_args (3, temp);
 }
 
-/* Apply fn to arg */
+/* Apply fn to arg.  */
 Lisp_Object
 apply1 (Lisp_Object fn, Lisp_Object arg)
 {
@@ -2733,7 +2761,7 @@ apply1 (Lisp_Object fn, Lisp_Object arg)
   }
 }
 
-/* Call function fn on no arguments */
+/* Call function fn on no arguments.  */
 Lisp_Object
 call0 (Lisp_Object fn)
 {
@@ -2743,7 +2771,7 @@ call0 (Lisp_Object fn)
   RETURN_UNGCPRO (Ffuncall (1, &fn));
 }
 
-/* Call function fn with 1 argument arg1 */
+/* Call function fn with 1 argument arg1.  */
 /* ARGSUSED */
 Lisp_Object
 call1 (Lisp_Object fn, Lisp_Object arg1)
@@ -2758,7 +2786,7 @@ call1 (Lisp_Object fn, Lisp_Object arg1)
   RETURN_UNGCPRO (Ffuncall (2, args));
 }
 
-/* Call function fn with 2 arguments arg1, arg2 */
+/* Call function fn with 2 arguments arg1, arg2.  */
 /* ARGSUSED */
 Lisp_Object
 call2 (Lisp_Object fn, Lisp_Object arg1, Lisp_Object arg2)
@@ -2773,7 +2801,7 @@ call2 (Lisp_Object fn, Lisp_Object arg1, Lisp_Object arg2)
   RETURN_UNGCPRO (Ffuncall (3, args));
 }
 
-/* Call function fn with 3 arguments arg1, arg2, arg3 */
+/* Call function fn with 3 arguments arg1, arg2, arg3.  */
 /* ARGSUSED */
 Lisp_Object
 call3 (Lisp_Object fn, Lisp_Object arg1, Lisp_Object arg2, Lisp_Object arg3)
@@ -2789,7 +2817,7 @@ call3 (Lisp_Object fn, Lisp_Object arg1, Lisp_Object arg2, Lisp_Object arg3)
   RETURN_UNGCPRO (Ffuncall (4, args));
 }
 
-/* Call function fn with 4 arguments arg1, arg2, arg3, arg4 */
+/* Call function fn with 4 arguments arg1, arg2, arg3, arg4.  */
 /* ARGSUSED */
 Lisp_Object
 call4 (Lisp_Object fn, Lisp_Object arg1, Lisp_Object arg2, Lisp_Object arg3,
@@ -2807,7 +2835,7 @@ call4 (Lisp_Object fn, Lisp_Object arg1, Lisp_Object arg2, Lisp_Object arg3,
   RETURN_UNGCPRO (Ffuncall (5, args));
 }
 
-/* Call function fn with 5 arguments arg1, arg2, arg3, arg4, arg5 */
+/* Call function fn with 5 arguments arg1, arg2, arg3, arg4, arg5.  */
 /* ARGSUSED */
 Lisp_Object
 call5 (Lisp_Object fn, Lisp_Object arg1, Lisp_Object arg2, Lisp_Object arg3,
@@ -2826,7 +2854,7 @@ call5 (Lisp_Object fn, Lisp_Object arg1, Lisp_Object arg2, Lisp_Object arg3,
   RETURN_UNGCPRO (Ffuncall (6, args));
 }
 
-/* Call function fn with 6 arguments arg1, arg2, arg3, arg4, arg5, arg6 */
+/* Call function fn with 6 arguments arg1, arg2, arg3, arg4, arg5, arg6.  */
 /* ARGSUSED */
 Lisp_Object
 call6 (Lisp_Object fn, Lisp_Object arg1, Lisp_Object arg2, Lisp_Object arg3,
@@ -2846,7 +2874,7 @@ call6 (Lisp_Object fn, Lisp_Object arg1, Lisp_Object arg2, Lisp_Object arg3,
   RETURN_UNGCPRO (Ffuncall (7, args));
 }
 
-/* Call function fn with 7 arguments arg1, arg2, arg3, arg4, arg5, arg6, arg7 */
+/* Call function fn with 7 arguments arg1, arg2, arg3, arg4, arg5, arg6, arg7.  */
 /* ARGSUSED */
 Lisp_Object
 call7 (Lisp_Object fn, Lisp_Object arg1, Lisp_Object arg2, Lisp_Object arg3,
@@ -2907,16 +2935,16 @@ DEFUN ("funcall", Ffuncall, Sfuncall, 1, MANY, 0,
 Return the value that function returns.
 Thus, (funcall 'cons 'x 'y) returns (x . y).
 usage: (funcall FUNCTION &rest ARGUMENTS)  */)
-  (int nargs, Lisp_Object *args)
+  (size_t nargs, Lisp_Object *args)
 {
   Lisp_Object fun, original_fun;
   Lisp_Object funcar;
-  int numargs = nargs - 1;
+  size_t numargs = nargs - 1;
   Lisp_Object lisp_numargs;
   Lisp_Object val;
   struct backtrace backtrace;
   register Lisp_Object *internal_args;
-  register int i;
+  register size_t i;
 
   QUIT;
   if ((consing_since_gc > gc_cons_threshold
@@ -3070,21 +3098,21 @@ static Lisp_Object
 apply_lambda (Lisp_Object fun, Lisp_Object args)
 {
   Lisp_Object args_left;
-  Lisp_Object numargs;
+  size_t numargs;
   register Lisp_Object *arg_vector;
   struct gcpro gcpro1, gcpro2, gcpro3;
-  register int i;
+  register size_t i;
   register Lisp_Object tem;
   USE_SAFE_ALLOCA;
 
-  numargs = Flength (args);
-  SAFE_ALLOCA_LISP (arg_vector, XINT (numargs));
+  numargs = XINT (Flength (args));
+  SAFE_ALLOCA_LISP (arg_vector, numargs);
   args_left = args;
 
   GCPRO3 (*arg_vector, args_left, fun);
   gcpro1.nvars = 0;
 
-  for (i = 0; i < XINT (numargs);)
+  for (i = 0; i < numargs; )
     {
       tem = Fcar (args_left), args_left = Fcdr (args_left);
       tem = eval_sub (tem);
@@ -3097,7 +3125,7 @@ apply_lambda (Lisp_Object fun, Lisp_Object args)
   backtrace_list->args = arg_vector;
   backtrace_list->nargs = i;
   backtrace_list->evalargs = 0;
-  tem = funcall_lambda (fun, XINT (numargs), arg_vector);
+  tem = funcall_lambda (fun, numargs, arg_vector);
 
   /* Do the debug-on-exit now, while arg_vector still exists.  */
   if (backtrace_list->debug_on_exit)
@@ -3113,12 +3141,13 @@ apply_lambda (Lisp_Object fun, Lisp_Object args)
    FUN must be either a lambda-expression or a compiled-code object.  */
 
 static Lisp_Object
-funcall_lambda (Lisp_Object fun, int nargs,
+funcall_lambda (Lisp_Object fun, size_t nargs,
                 register Lisp_Object *arg_vector)
 {
   Lisp_Object val, syms_left, next, lexenv;
   int count = SPECPDL_INDEX ();
-  int i, optional, rest;
+  size_t i;
+  int optional, rest;
 
   if (CONSP (fun))
     {
@@ -3270,7 +3299,7 @@ grow_specpdl (void)
   specpdl_ptr = specpdl + count;
 }
 
-/* specpdl_ptr->symbol is a field which describes which variable is
+/* `specpdl_ptr->symbol' is a field which describes which variable is
    let-bound, so it can be properly undone when we unbind_to.
    It can have the following two shapes:
    - SYMBOL : if it's a plain symbol, it means that we have let-bound
@@ -3500,7 +3529,6 @@ Output stream used is value of `standard-output'.  */)
   (void)
 {
   register struct backtrace *backlist = backtrace_list;
-  register int i;
   Lisp_Object tail;
   Lisp_Object tem;
   struct gcpro gcpro1;
@@ -3523,13 +3551,14 @@ Output stream used is value of `standard-output'.  */)
       else
         {
           tem = *backlist->function;
-          Fprin1 (tem, Qnil);   /* This can QUIT */
+          Fprin1 (tem, Qnil);   /* This can QUIT.  */
           write_string ("(", -1);
           if (backlist->nargs == MANY)
-            {
+            {                   /* FIXME: Can this happen?  */
+              int i;
               for (tail = *backlist->args, i = 0;
                    !NILP (tail);
-                   tail = Fcdr (tail), i++)
+                   tail = Fcdr (tail), i = 1)
                 {
                   if (i) write_string (" ", -1);
                   Fprin1 (Fcar (tail), Qnil);
@@ -3537,6 +3566,7 @@ Output stream used is value of `standard-output'.  */)
             }
           else
             {
+              size_t i;
               for (i = 0; i < backlist->nargs; i++)
                 {
                   if (i) write_string (" ", -1);
@@ -3566,7 +3596,7 @@ If NFRAMES is more than the number of frames, the value is nil.  */)
   (Lisp_Object nframes)
 {
   register struct backtrace *backlist = backtrace_list;
-  register int i;
+  register EMACS_INT i;
   Lisp_Object tem;
 
   CHECK_NATNUM (nframes);
@@ -3581,7 +3611,7 @@ If NFRAMES is more than the number of frames, the value is nil.  */)
     return Fcons (Qnil, Fcons (*backlist->function, *backlist->args));
   else
     {
-      if (backlist->nargs == MANY)
+      if (backlist->nargs == MANY) /* FIXME: Can this happen?  */
         tem = *backlist->args;
       else
         tem = Flist (backlist->nargs, backlist->args);
@@ -3595,17 +3625,18 @@ void
 mark_backtrace (void)
 {
   register struct backtrace *backlist;
-  register int i;
+  register size_t i;
 
   for (backlist = backtrace_list; backlist; backlist = backlist->next)
     {
       mark_object (*backlist->function);
 
-      if (backlist->nargs == UNEVALLED || backlist->nargs == MANY)
-        i = 0;
+      if (backlist->nargs == UNEVALLED
+          || backlist->nargs == MANY) /* FIXME: Can this happen?  */
+        i = 1;
       else
-        i = backlist->nargs - 1;
-      for (; i >= 0; i--)
+        i = backlist->nargs;
+      while (i--)
         mark_object (backlist->args[i]);
     }
 }
@@ -3820,6 +3851,7 @@ alist of active lexical bindings.  */);
   defsubr (&Srun_hook_with_args);
   defsubr (&Srun_hook_with_args_until_success);
   defsubr (&Srun_hook_with_args_until_failure);
+  defsubr (&Srun_hook_wrapped);
   defsubr (&Sfetch_bytecode);
   defsubr (&Sbacktrace_debug);
   defsubr (&Sbacktrace);
diff --git a/src/fileio.c b/src/fileio.c
index 5d33fb93878..85431dfd5b1 100644
--- a/src/fileio.c
+++ b/src/fileio.c
@@ -1951,9 +1951,10 @@ on the system, we copy the SELinux context of FILE to NEWNAME.  */)
      owner and group.  */
   if (input_file_statable_p)
     {
-      if (! NILP (preserve_uid_gid))
-        fchown (ofd, st.st_uid, st.st_gid);
-      fchmod (ofd, st.st_mode & 07777);
+      if (!NILP (preserve_uid_gid) && fchown (ofd, st.st_uid, st.st_gid) != 0)
+        report_file_error ("Doing chown", Fcons (newname, Qnil));
+      if (fchmod (ofd, st.st_mode & 07777) != 0)
+        report_file_error ("Doing chmod", Fcons (newname, Qnil));
     }
 #endif  /* not MSDOS */
 
@@ -2358,8 +2359,6 @@ static int
 check_executable (char *filename)
 {
 #ifdef DOS_NT
-  int len = strlen (filename);
-  char *suffix;
   struct stat st;
   if (stat (filename, &st) < 0)
     return 0;
@@ -2785,13 +2784,14 @@ as a list ("user", "role", "type", "range"). Has no effect if SELinux
 is disabled. */)
   (Lisp_Object filename, Lisp_Object context)
 {
-  Lisp_Object absname, encoded_absname;
+  Lisp_Object absname;
   Lisp_Object handler;
+#if HAVE_LIBSELINUX
+  Lisp_Object encoded_absname;
   Lisp_Object user = CAR_SAFE (context);
   Lisp_Object role = CAR_SAFE (CDR_SAFE (context));
   Lisp_Object type = CAR_SAFE (CDR_SAFE (CDR_SAFE (context)));
   Lisp_Object range = CAR_SAFE (CDR_SAFE (CDR_SAFE (CDR_SAFE (context))));
-#if HAVE_LIBSELINUX
   security_context_t con;
   int fail, conlength;
   context_t parsed_con;
@@ -2805,12 +2805,11 @@ is disabled. */)
   if (!NILP (handler))
     return call3 (handler, Qset_file_selinux_context, absname, context);
 
-  encoded_absname = ENCODE_FILE (absname);
-
 #if HAVE_LIBSELINUX
   if (is_selinux_enabled ())
     {
       /* Get current file context. */
+      encoded_absname = ENCODE_FILE (absname);
       conlength = lgetfilecon (SSDATA (encoded_absname), &con);
       if (conlength > 0)
         {
@@ -5179,7 +5178,7 @@ A non-nil CURRENT-ONLY argument means save only current buffer.  */)
   (Lisp_Object no_message, Lisp_Object current_only)
 {
   struct buffer *old = current_buffer, *b;
-  Lisp_Object tail, buf;
+  Lisp_Object tail, buf, hook;
   int auto_saved = 0;
   int do_handled_files;
   Lisp_Object oquit;
@@ -5209,8 +5208,8 @@ A non-nil CURRENT-ONLY argument means save only current buffer.  */)
   /* No GCPRO needed, because (when it matters) all Lisp_Object variables
      point to non-strings reached from Vbuffer_alist.  */
 
-  if (!NILP (Vrun_hooks))
-    call1 (Vrun_hooks, intern ("auto-save-hook"));
+  hook = intern ("auto-save-hook");
+  Frun_hooks (1, &hook);
 
   if (STRINGP (Vauto_save_list_file_name))
     {
diff --git a/src/floatfns.c b/src/floatfns.c
index bc03509b757..1232fc0afa1 100644
--- a/src/floatfns.c
+++ b/src/floatfns.c
@@ -103,7 +103,7 @@ extern double logb (double);
 #endif
 
 #ifdef FLOAT_CATCH_SIGILL
-static SIGTYPE float_error ();
+static void float_error ();
 #endif
 
 /* Nonzero while executing in floating point.
@@ -126,7 +126,7 @@ static const char *float_error_fn_name;
    Handle errors which may result in signals or may set errno.
 
    Note that float_error may be declared to return void, so you can't
-   just cast the zero after the colon to (SIGTYPE) to make the types
+   just cast the zero after the colon to (void) to make the types
    check properly.  */
 
 #ifdef FLOAT_CHECK_ERRNO
@@ -960,7 +960,7 @@ Rounds the value toward zero.  */)
 }
 
 #ifdef FLOAT_CATCH_SIGILL
-static SIGTYPE
+static void
 float_error (signo)
      int signo;
 {
diff --git a/src/fns.c b/src/fns.c
index 9a009c8ab44..bce922859d1 100644
--- a/src/fns.c
+++ b/src/fns.c
@@ -348,7 +348,7 @@ Symbols are also allowed; their print names are used instead.  */)
   return i1 < SCHARS (s2) ? Qt : Qnil;
 }
 
-static Lisp_Object concat (int nargs, Lisp_Object *args,
+static Lisp_Object concat (size_t nargs, Lisp_Object *args,
                            enum Lisp_Type target_type, int last_special);
 
 /* ARGSUSED */
@@ -378,7 +378,7 @@ The result is a list whose elements are the elements of all the arguments.
 Each argument may be a list, vector or string.
 The last argument is not copied, just used as the tail of the new list.
 usage: (append &rest SEQUENCES)  */)
-  (int nargs, Lisp_Object *args)
+  (size_t nargs, Lisp_Object *args)
 {
   return concat (nargs, args, Lisp_Cons, 1);
 }
@@ -388,7 +388,7 @@ DEFUN ("concat", Fconcat, Sconcat, 0, MANY, 0,
 The result is a string whose elements are the elements of all the arguments.
 Each argument may be a string or a list or vector of characters (integers).
 usage: (concat &rest SEQUENCES)  */)
-  (int nargs, Lisp_Object *args)
+  (size_t nargs, Lisp_Object *args)
 {
   return concat (nargs, args, Lisp_String, 0);
 }
@@ -398,7 +398,7 @@ DEFUN ("vconcat", Fvconcat, Svconcat, 0, MANY, 0,
 The result is a vector whose elements are the elements of all the arguments.
 Each argument may be a list, vector or string.
 usage: (vconcat &rest SEQUENCES)   */)
-  (int nargs, Lisp_Object *args)
+  (size_t nargs, Lisp_Object *args)
 {
   return concat (nargs, args, Lisp_Vectorlike, 0);
 }
@@ -446,7 +446,8 @@ struct textprop_rec
 };
 
 static Lisp_Object
-concat (int nargs, Lisp_Object *args, enum Lisp_Type target_type, int last_special)
+concat (size_t nargs, Lisp_Object *args,
+        enum Lisp_Type target_type, int last_special)
 {
   Lisp_Object val;
   register Lisp_Object tail;
@@ -455,7 +456,7 @@ concat (int nargs, Lisp_Object *args, enum Lisp_Type target_type, int last_speci
   EMACS_INT toindex_byte = 0;
   register EMACS_INT result_len;
   register EMACS_INT result_len_byte;
-  register int argnum;
+  register size_t argnum;
   Lisp_Object last_tail;
   Lisp_Object prev;
   int some_multibyte;
@@ -2232,9 +2233,9 @@ DEFUN ("nconc", Fnconc, Snconc, 0, MANY, 0,
        doc: /* Concatenate any number of lists by altering them.
 Only the last argument is not altered, and need not be a list.
 usage: (nconc &rest LISTS)  */)
-  (int nargs, Lisp_Object *args)
+  (size_t nargs, Lisp_Object *args)
 {
-  register int argnum;
+  register size_t argnum;
   register Lisp_Object tail, tem, val;
 
   val = tail = Qnil;
@@ -2763,7 +2764,7 @@ DEFUN ("widget-apply", Fwidget_apply, Swidget_apply, 2, MANY, 0,
        doc: /* Apply the value of WIDGET's PROPERTY to the widget itself.
 ARGS are passed as extra arguments to the function.
 usage: (widget-apply WIDGET PROPERTY &rest ARGS)  */)
-  (int nargs, Lisp_Object *args)
+  (size_t nargs, Lisp_Object *args)
 {
   /* This function can GC. */
   Lisp_Object newargs[3];
@@ -3367,7 +3368,7 @@ Lisp_Object Qhash_table_test, Qkey_or_value, Qkey_and_value;
 /* Function prototypes.  */
 
 static struct Lisp_Hash_Table *check_hash_table (Lisp_Object);
-static int get_key_arg (Lisp_Object, int, Lisp_Object *, char *);
+static size_t get_key_arg (Lisp_Object, size_t, Lisp_Object *, char *);
 static void maybe_resize_hash_table (struct Lisp_Hash_Table *);
 static int cmpfn_eql (struct Lisp_Hash_Table *, Lisp_Object, unsigned,
                       Lisp_Object, unsigned);
@@ -3422,27 +3423,23 @@ next_almost_prime (int n)
 /* Find KEY in ARGS which has size NARGS.  Don't consider indices for
    which USED[I] is non-zero.  If found at index I in ARGS, set
    USED[I] and USED[I + 1] to 1, and return I + 1.  Otherwise return
-   -1.  This function is used to extract a keyword/argument pair from
+   0.  This function is used to extract a keyword/argument pair from
    a DEFUN parameter list.  */
 
-static int
-get_key_arg (Lisp_Object key, int nargs, Lisp_Object *args, char *used)
+static size_t
+get_key_arg (Lisp_Object key, size_t nargs, Lisp_Object *args, char *used)
 {
-  int i;
-
-  for (i = 0; i < nargs - 1; ++i)
-    if (!used[i] && EQ (args[i], key))
-      break;
+  size_t i;
 
-  if (i >= nargs - 1)
-    i = -1;
-  else
-    {
-      used[i++] = 1;
-      used[i] = 1;
-    }
+  for (i = 1; i < nargs; i++)
+    if (!used[i - 1] && EQ (args[i - 1], key))
+      {
+        used[i - 1] = 1;
+        used[i] = 1;
+        return i;
+      }
 
-  return i;
+  return 0;
 }
 
 
@@ -4290,12 +4287,12 @@ WEAK.  WEAK t is equivalent to `key-and-value'.  Default value of WEAK
 is nil.
 
 usage: (make-hash-table &rest KEYWORD-ARGS)  */)
-  (int nargs, Lisp_Object *args)
+  (size_t nargs, Lisp_Object *args)
 {
   Lisp_Object test, size, rehash_size, rehash_threshold, weak;
   Lisp_Object user_test, user_hash;
   char *used;
-  int i;
+  size_t i;
 
   /* The vector `used' is used to keep track of arguments that
      have been consumed.  */
@@ -4304,7 +4301,7 @@ usage: (make-hash-table &rest KEYWORD-ARGS)  */)
 
   /* See if there's a `:test TEST' among the arguments.  */
   i = get_key_arg (QCtest, nargs, args, used);
-  test = i < 0 ? Qeql : args[i];
+  test = i ? args[i] : Qeql;
   if (!EQ (test, Qeq) && !EQ (test, Qeql) && !EQ (test, Qequal))
     {
       /* See if it is a user-defined test.  */
@@ -4321,7 +4318,7 @@ usage: (make-hash-table &rest KEYWORD-ARGS)  */)
 
   /* See if there's a `:size SIZE' argument.  */
   i = get_key_arg (QCsize, nargs, args, used);
-  size = i < 0 ? Qnil : args[i];
+  size = i ? args[i] : Qnil;
   if (NILP (size))
     size = make_number (DEFAULT_HASH_SIZE);
   else if (!INTEGERP (size) || XINT (size) < 0)
@@ -4329,7 +4326,7 @@ usage: (make-hash-table &rest KEYWORD-ARGS)  */)
 
   /* Look for `:rehash-size SIZE'.  */
   i = get_key_arg (QCrehash_size, nargs, args, used);
-  rehash_size = i < 0 ? make_float (DEFAULT_REHASH_SIZE) : args[i];
+  rehash_size = i ? args[i] : make_float (DEFAULT_REHASH_SIZE);
   if (!NUMBERP (rehash_size)
       || (INTEGERP (rehash_size) && XINT (rehash_size) <= 0)
       || XFLOATINT (rehash_size) <= 1.0)
@@ -4337,7 +4334,7 @@ usage: (make-hash-table &rest KEYWORD-ARGS)  */)
 
   /* Look for `:rehash-threshold THRESHOLD'.  */
   i = get_key_arg (QCrehash_threshold, nargs, args, used);
-  rehash_threshold = i < 0 ? make_float (DEFAULT_REHASH_THRESHOLD) : args[i];
+  rehash_threshold = i ? args[i] : make_float (DEFAULT_REHASH_THRESHOLD);
   if (!FLOATP (rehash_threshold)
       || XFLOATINT (rehash_threshold) <= 0.0
       || XFLOATINT (rehash_threshold) > 1.0)
@@ -4345,7 +4342,7 @@ usage: (make-hash-table &rest KEYWORD-ARGS)  */)
 
   /* Look for `:weakness WEAK'.  */
   i = get_key_arg (QCweakness, nargs, args, used);
-  weak = i < 0 ? Qnil : args[i];
+  weak = i ? args[i] : Qnil;
   if (EQ (weak, Qt))
     weak = Qkey_and_value;
   if (!NILP (weak)
diff --git a/src/font.c b/src/font.c
index 9e8b7029c22..6b2e2f2712d 100644
--- a/src/font.c
+++ b/src/font.c
@@ -3831,10 +3831,10 @@ be an OpenType font, and whose GPOS table of `thai' script's default
 language system must contain `mark' feature.
 
 usage: (font-spec ARGS...)  */)
-  (int nargs, Lisp_Object *args)
+  (size_t nargs, Lisp_Object *args)
 {
   Lisp_Object spec = font_make_spec ();
-  int i;
+  size_t i;
 
   for (i = 0; i < nargs; i += 2)
     {
diff --git a/src/frame.c b/src/frame.c
index 05938f3e1f0..1b6d36092ae 100644
--- a/src/frame.c
+++ b/src/frame.c
@@ -890,7 +890,7 @@ to that frame.  */)
 {
   /* Preserve prefix arg that the command loop just cleared.  */
   KVAR (current_kboard, Vprefix_arg) = Vcurrent_prefix_arg;
-  call1 (Vrun_hooks, Qmouse_leave_buffer_hook);
+  Frun_hooks (1, &Qmouse_leave_buffer_hook);
   return do_switch_frame (event, 0, 0, Qnil);
 }
 
@@ -2529,7 +2529,7 @@ use is not recommended.  Explicitly check for a frame-parameter instead.  */)
         }
 
       /* Now process them in reverse of specified order.  */
-      for (i--; i >= 0; i--)
+      while (--i >= 0)
         {
           prop = parms[i];
           val = values[i];
@@ -2902,7 +2902,7 @@ x_set_frame_parameters (FRAME_PTR f, Lisp_Object alist)
   /* Record in these vectors all the parms specified.  */
   Lisp_Object *parms;
   Lisp_Object *values;
-  int i, p;
+  size_t i, p;
   int left_no_change = 0, top_no_change = 0;
   int icon_left_no_change = 0, icon_top_no_change = 0;
   int size_changed = 0;
@@ -2975,7 +2975,7 @@ x_set_frame_parameters (FRAME_PTR f, Lisp_Object alist)
     }
 
   /* Now process them in reverse of specified order.  */
-  for (i--; i >= 0; i--)
+  while (i-- != 0)
     {
       Lisp_Object prop, val;
 
@@ -3713,8 +3713,7 @@ validate_x_resource_name (void)
     return;
 
   /* If name is entirely invalid, or nearly so, use `emacs'.  */
-  if (good_count == 0
-      || (good_count == 1 && bad_count > 0))
+  if (good_count < 2)
     {
       Vx_resource_name = build_string ("emacs");
       return;
diff --git a/src/ftfont.c b/src/ftfont.c
index db6b29421dc..ad01149106e 100644
--- a/src/ftfont.c
+++ b/src/ftfont.c
@@ -168,11 +168,11 @@ get_adstyle_property (FcPattern *p)
   for (end = str; *end && *end != ' '; end++);
   if (*end)
     {
-      char *p = alloca (end - str + 1);
-      memcpy (p, str, end - str);
-      p[end - str] = '\0';
-      end = p + (end - str);
-      str = p;
+      char *newstr = alloca (end - str + 1);
+      memcpy (newstr, str, end - str);
+      newstr[end - str] = '\0';
+      end = newstr + (end - str);
+      str = newstr;
     }
   if (xstrcasecmp (str, "Regular") == 0
       || xstrcasecmp (str, "Bold") == 0
@@ -190,18 +190,18 @@ ftfont_pattern_entity (FcPattern *p, Lisp_Object extra)
 {
   Lisp_Object key, cache, entity;
   char *file, *str;
-  int index;
+  int idx;
   int numeric;
   double dbl;
   FcBool b;
 
   if (FcPatternGetString (p, FC_FILE, 0, (FcChar8 **) &file) != FcResultMatch)
     return Qnil;
-  if (FcPatternGetInteger (p, FC_INDEX, 0, &index) != FcResultMatch)
+  if (FcPatternGetInteger (p, FC_INDEX, 0, &idx) != FcResultMatch)
     return Qnil;
 
   key = Fcons (make_unibyte_string ((char *) file, strlen ((char *) file)),
-               make_number (index));
+               make_number (idx));
   cache = ftfont_lookup_cache (key, FTFONT_CACHE_FOR_ENTITY);
   entity = XCAR (cache);
   if (! NILP (entity))
@@ -265,7 +265,7 @@ ftfont_pattern_entity (FcPattern *p, Lisp_Object extra)
 
       ASET (entity, FONT_ADSTYLE_INDEX, get_adstyle_property (p));
       if ((ft_library || FT_Init_FreeType (&ft_library) == 0)
-          && FT_New_Face (ft_library, file, index, &ft_face) == 0)
+          && FT_New_Face (ft_library, file, idx, &ft_face) == 0)
         {
           BDF_PropertyRec rec;
 
@@ -311,8 +311,9 @@ ftfont_resolve_generic_family (Lisp_Object family, FcPattern *pattern)
   if (FcPatternGetLangSet (pattern, FC_LANG, 0, &langset) != FcResultMatch)
     {
       /* This is to avoid the effect of locale.  */
+      static const FcChar8 lang[] = "en";
       langset = FcLangSetCreate ();
-      FcLangSetAdd (langset, "en");
+      FcLangSetAdd (langset, lang);
       FcPatternAddLangSet (pattern, FC_LANG, langset);
       FcLangSetDestroy (langset);
     }
@@ -393,14 +394,14 @@ ftfont_lookup_cache (Lisp_Object key, enum ftfont_cache_for cache_for)
       ? ! cache_data->ft_face : ! cache_data->fc_charset)
     {
       char *filename = SSDATA (XCAR (key));
-      int index = XINT (XCDR (key));
+      int idx = XINT (XCDR (key));
 
       if (cache_for == FTFONT_CACHE_FOR_FACE)
         {
           if (! ft_library
               && FT_Init_FreeType (&ft_library) != 0)
             return Qnil;
-          if (FT_New_Face (ft_library, filename, index, &cache_data->ft_face)
+          if (FT_New_Face (ft_library, filename, idx, &cache_data->ft_face)
               != 0)
             return Qnil;
         }
@@ -412,7 +413,7 @@ ftfont_lookup_cache (Lisp_Object key, enum ftfont_cache_for cache_for)
           FcCharSet *charset = NULL;
 
           pat = FcPatternBuild (0, FC_FILE, FcTypeString, (FcChar8 *) filename,
-                                FC_INDEX, FcTypeInteger, index, NULL);
+                                FC_INDEX, FcTypeInteger, idx, NULL);
           if (! pat)
             goto finish;
           objset = FcObjectSetBuild (FC_CHARSET, FC_STYLE, NULL);
@@ -490,8 +491,12 @@ static int ftfont_get_bitmap (struct font *, unsigned,
                               struct font_bitmap *, int);
 static int ftfont_anchor_point (struct font *, unsigned, int,
                                 int *, int *);
+#ifdef HAVE_LIBOTF
 static Lisp_Object ftfont_otf_capability (struct font *);
+# ifdef HAVE_M17N_FLT
 static Lisp_Object ftfont_shape (Lisp_Object);
+# endif
+#endif
 
 #ifdef HAVE_OTF_GET_VARIATION_GLYPHS
 static int ftfont_variation_glyphs (struct font *, int c,
@@ -618,6 +623,7 @@ struct OpenTypeSpec
     (P)[4] = '\0';                              \
   } while (0)
 
+#ifdef HAVE_LIBOTF
 #define OTF_TAG_SYM(SYM, TAG)                   \
   do {                                          \
     char str[5];                                \
@@ -625,6 +631,7 @@ struct OpenTypeSpec
     OTF_TAG_STR (TAG, str);                     \
     (SYM) = font_intern_prop (str, 4, 1);       \
   } while (0)
+#endif
 
 
 static struct OpenTypeSpec *
@@ -864,7 +871,6 @@ ftfont_list (Lisp_Object frame, Lisp_Object spec)
   FcObjectSet *objset = NULL;
   FcCharSet *charset;
   Lisp_Object chars = Qnil;
-  FcResult result;
   char otlayout[15];            /* For "otlayout:XXXX" */
   struct OpenTypeSpec *otspec = NULL;
   int spacing = -1;
@@ -1153,7 +1159,7 @@ ftfont_open (FRAME_PTR f, Lisp_Object entity, int pixel_size)
   FT_Face ft_face;
   FT_Size ft_size;
   FT_UInt size;
-  Lisp_Object val, filename, index, cache, font_object;
+  Lisp_Object val, filename, idx, cache, font_object;
   int scalable;
   int spacing;
   char name[256];
@@ -1168,7 +1174,7 @@ ftfont_open (FRAME_PTR f, Lisp_Object entity, int pixel_size)
   if (NILP (cache))
     return Qnil;
   filename = XCAR (val);
-  index = XCDR (val);
+  idx = XCDR (val);
   val = XCDR (cache);
   cache_data = XSAVE_VALUE (XCDR (cache))->pointer;
   ft_face = cache_data->ft_face;
@@ -1210,7 +1216,7 @@ ftfont_open (FRAME_PTR f, Lisp_Object entity, int pixel_size)
   font = XFONT_OBJECT (font_object);
   ftfont_info = (struct ftfont_info *) font;
   ftfont_info->ft_size = ft_face->size;
-  ftfont_info->index = XINT (index);
+  ftfont_info->index = XINT (idx);
 #ifdef HAVE_LIBOTF
   ftfont_info->maybe_otf = ft_face->face_flags & FT_FACE_FLAG_SFNT;
   ftfont_info->otf = NULL;
@@ -1455,7 +1461,8 @@ ftfont_get_bitmap (struct font *font, unsigned int code, struct font_bitmap *bit
 }
 
 static int
-ftfont_anchor_point (struct font *font, unsigned int code, int index, int *x, int *y)
+ftfont_anchor_point (struct font *font, unsigned int code, int idx,
+                     int *x, int *y)
 {
   struct ftfont_info *ftfont_info = (struct ftfont_info *) font;
   FT_Face ft_face = ftfont_info->ft_size->face;
@@ -1466,10 +1473,10 @@ ftfont_anchor_point (struct font *font, unsigned int code, int index, int *x, in
     return -1;
   if (ft_face->glyph->format != FT_GLYPH_FORMAT_OUTLINE)
     return -1;
-  if (index >= ft_face->glyph->outline.n_points)
+  if (idx >= ft_face->glyph->outline.n_points)
     return -1;
-  *x = ft_face->glyph->outline.points[index].x;
-  *y = ft_face->glyph->outline.points[index].y;
+  *x = ft_face->glyph->outline.points[idx].x;
+  *y = ft_face->glyph->outline.points[idx].y;
   return 0;
 }
 
diff --git a/src/gtkutil.c b/src/gtkutil.c
index 754f61e366d..4e5ecce76c7 100644
--- a/src/gtkutil.c
+++ b/src/gtkutil.c
@@ -1555,7 +1555,7 @@ static gboolean
 xg_maybe_add_timer (gpointer data)
 {
   struct xg_dialog_data *dd = (struct xg_dialog_data *) data;
-  EMACS_TIME next_time = timer_check (1);
+  EMACS_TIME next_time = timer_check ();
   long secs = EMACS_SECS (next_time);
   long usecs = EMACS_USECS (next_time);
 
diff --git a/src/image.c b/src/image.c
index 91308c540b5..b37ba398d83 100644
--- a/src/image.c
+++ b/src/image.c
@@ -4483,7 +4483,6 @@ static void
 XPutPixel (XImagePtr ximg, int x, int y, COLORREF color)
 {
   int width = ximg->info.bmiHeader.biWidth;
-  int height = ximg->info.bmiHeader.biHeight;
   unsigned char * pixel;
 
   /* True color images.  */
@@ -6752,7 +6751,7 @@ tiff_load (struct frame *f, struct image *img)
   TIFF *tiff;
   int width, height, x, y, count;
   uint32 *buf;
-  int rc, rc2;
+  int rc;
   XImagePtr ximg;
   tiff_memory_source memsrc;
   Lisp_Object image;
@@ -6840,8 +6839,8 @@ tiff_load (struct frame *f, struct image *img)
   rc = fn_TIFFReadRGBAImage (tiff, width, height, buf, 0);
 
   /* Count the number of images in the file.  */
-  for (count = 1, rc2 = 1; rc2; count++)
-    rc2 = fn_TIFFSetDirectory (tiff, count);
+  for (count = 1; fn_TIFFSetDirectory (tiff, count); count++)
+    continue;
 
   if (count > 1)
     img->data.lisp_val = Fcons (Qcount,
diff --git a/src/insdel.c b/src/insdel.c
index ad3460f9a64..4bdcb4bc0b7 100644
--- a/src/insdel.c
+++ b/src/insdel.c
@@ -41,8 +41,6 @@ static void insert_from_buffer_1 (struct buffer *buf,
                                   int inherit);
 static void gap_left (EMACS_INT charpos, EMACS_INT bytepos, int newgap);
 static void gap_right (EMACS_INT charpos, EMACS_INT bytepos);
-static void adjust_markers_gap_motion (EMACS_INT from, EMACS_INT to,
-                                       EMACS_INT amount);
 static void adjust_markers_for_insert (EMACS_INT from, EMACS_INT from_byte,
                                        EMACS_INT to, EMACS_INT to_byte,
                                        int before_markers);
@@ -162,10 +160,9 @@ gap_left (EMACS_INT charpos, EMACS_INT bytepos, int newgap)
       memmove (to, from, i);
     }
 
-  /* Adjust markers, and buffer data structure, to put the gap at BYTEPOS.
-     BYTEPOS is where the loop above stopped, which may be what was specified
-     or may be where a quit was detected.  */
-  adjust_markers_gap_motion (bytepos, GPT_BYTE, GAP_SIZE);
+  /* Adjust buffer data structure, to put the gap at BYTEPOS.
+     BYTEPOS is where the loop above stopped, which may be what
+     was specified or may be where a quit was detected.  */
   GPT_BYTE = bytepos;
   GPT = charpos;
   if (bytepos < charpos)
@@ -217,8 +214,6 @@ gap_right (EMACS_INT charpos, EMACS_INT bytepos)
       from += i, to += i;
     }
 
-  adjust_markers_gap_motion (GPT_BYTE + GAP_SIZE, bytepos + GAP_SIZE,
-                             - GAP_SIZE);
   GPT = charpos;
   GPT_BYTE = bytepos;
   if (bytepos < charpos)
@@ -227,67 +222,6 @@ gap_right (EMACS_INT charpos, EMACS_INT bytepos)
   QUIT;
 }
 
-/* Add AMOUNT to the byte position of every marker in the current buffer
-   whose current byte position is between FROM (exclusive) and TO (inclusive).
-
-   Also, any markers past the outside of that interval, in the direction
-   of adjustment, are first moved back to the near end of the interval
-   and then adjusted by AMOUNT.
-
-   When the latter adjustment is done, if AMOUNT is negative,
-   we record the adjustment for undo.  (This case happens only for
-   deletion.)
-
-   The markers' character positions are not altered,
-   because gap motion does not affect character positions.  */
-
-int adjust_markers_test;
-
-static void
-adjust_markers_gap_motion (EMACS_INT from, EMACS_INT to, EMACS_INT amount)
-{
-  /* Now that a marker has a bytepos, not counting the gap,
-     nothing needs to be done here.  */
-#if 0
-  Lisp_Object marker;
-  register struct Lisp_Marker *m;
-  register EMACS_INT mpos;
-
-  marker = BUF_MARKERS (current_buffer);
-
-  while (!NILP (marker))
-    {
-      m = XMARKER (marker);
-      mpos = m->bytepos;
-      if (amount > 0)
-        {
-          if (mpos > to && mpos < to + amount)
-            {
-              if (adjust_markers_test)
-                abort ();
-              mpos = to + amount;
-            }
-        }
-      else
-        {
-          /* Here's the case where a marker is inside text being deleted.
-             AMOUNT can be negative for gap motion, too,
-             but then this range contains no markers.  */
-          if (mpos > from + amount && mpos <= from)
-            {
-              if (adjust_markers_test)
-                abort ();
-              mpos = from + amount;
-            }
-        }
-      if (mpos > from && mpos <= to)
-        mpos += amount;
-      m->bufpos = mpos;
-      marker = m->chain;
-    }
-#endif
-}
-
 /* Adjust all markers for a deletion
    whose range in bytes is FROM_BYTE to TO_BYTE.
    The range in charpos is FROM to TO.
@@ -2137,14 +2071,14 @@ signal_before_change (EMACS_INT start_int, EMACS_INT end_int,
 
   specbind (Qinhibit_modification_hooks, Qt);
 
-  /* If buffer is unmodified, run a special hook for that case.  */
+  /* If buffer is unmodified, run a special hook for that case.  The
+   check for Vfirst_change_hook is just a minor optimization. */
   if (SAVE_MODIFF >= MODIFF
-      && !NILP (Vfirst_change_hook)
-      && !NILP (Vrun_hooks))
+      && !NILP (Vfirst_change_hook))
     {
       PRESERVE_VALUE;
       PRESERVE_START_END;
-      call1 (Vrun_hooks, Qfirst_change_hook);
+      Frun_hooks (1, &Qfirst_change_hook);
     }
 
   /* Now run the before-change-functions if any.  */
diff --git a/src/intervals.c b/src/intervals.c
index 12b2789cc77..351677ad27e 100644
--- a/src/intervals.c
+++ b/src/intervals.c
@@ -586,7 +586,7 @@ split_interval_left (INTERVAL interval, EMACS_INT offset)
    Don't use this function on an interval which is the child
    of another interval!  */
 
-int
+static int
 interval_start_pos (INTERVAL source)
 {
   Lisp_Object parent;
@@ -2559,4 +2559,3 @@ set_intervals_multibyte (int multi_flag)
     set_intervals_multibyte_1 (BUF_INTERVALS (current_buffer), multi_flag,
                                BEG, BEG_BYTE, Z, Z_BYTE);
 }
-
diff --git a/src/intervals.h b/src/intervals.h
index f6c1c002ce0..d7c34012e1f 100644
--- a/src/intervals.h
+++ b/src/intervals.h
@@ -161,8 +161,13 @@ struct interval
    (INTERVAL_HAS_PARENT (i) ? INTERVAL_PARENT (i) : 0)
 
 /* Abort if interval I's size is negative.  */
-#define CHECK_TOTAL_LENGTH(i) \
-  if ((int) (i)->total_length < 0) abort (); else
+#define CHECK_TOTAL_LENGTH(i)          \
+  do                                   \
+    {                                  \
+      if ((int) (i)->total_length < 0) \
+        abort ();                      \
+    }                                  \
+  while (0)
 
 /* Reset this interval to its vanilla, or no-property state. */
 #define RESET_INTERVAL(i) \
@@ -339,4 +344,3 @@ extern Lisp_Object get_pos_property (Lisp_Object pos, Lisp_Object prop,
 extern void syms_of_textprop (void);
 
 #include "composite.h"
-
diff --git a/src/keyboard.c b/src/keyboard.c
index 63e7573fbe9..d307250b868 100644
--- a/src/keyboard.c
+++ b/src/keyboard.c
@@ -201,8 +201,8 @@ Lisp_Object unread_switch_frame;
 /* Last size recorded for a current buffer which is not a minibuffer.  */
 static EMACS_INT last_non_minibuf_size;
 
-/* Total number of times read_char has returned.  */
-int num_input_events;
+/* Total number of times read_char has returned, modulo SIZE_MAX + 1.  */
+size_t num_input_events;
 
 /* Value of num_nonmacro_input_events as of last auto save.  */
 
@@ -254,7 +254,6 @@ Lisp_Object Qecho_area_clear_hook;
 /* Hooks to run before and after each command.  */
 Lisp_Object Qpre_command_hook;
 Lisp_Object Qpost_command_hook;
-Lisp_Object Qcommand_hook_internal;
 
 Lisp_Object Qdeferred_action_function;
 
@@ -351,7 +350,7 @@ Lisp_Object Qmenu_bar;
 Lisp_Object recursive_edit_unwind (Lisp_Object buffer), command_loop (void);
 Lisp_Object Fthis_command_keys (void);
 Lisp_Object Qextended_command_history;
-EMACS_TIME timer_check (int do_it_now);
+EMACS_TIME timer_check (void);
 
 static void record_menu_key (Lisp_Object c);
 static int echo_length (void);
@@ -434,15 +433,15 @@ static void restore_getcjmp (jmp_buf);
 static Lisp_Object apply_modifiers (int, Lisp_Object);
 static void clear_event (struct input_event *);
 static Lisp_Object restore_kboard_configuration (Lisp_Object);
-static SIGTYPE interrupt_signal (int signalnum);
+static void interrupt_signal (int signalnum);
 #ifdef SIGIO
-static SIGTYPE input_available_signal (int signo);
+static void input_available_signal (int signo);
 #endif
 static void handle_interrupt (void);
 static void timer_start_idle (void);
 static void timer_stop_idle (void);
 static void timer_resume_idle (void);
-static SIGTYPE handle_user_signal (int);
+static void handle_user_signal (int);
 static char *find_user_signal_name (int);
 static int store_user_signal_events (void);
 
@@ -1270,7 +1269,7 @@ some_mouse_moved (void)
 /* This is the actual command reading loop,
    sans error-handling encapsulation.  */
 
-static int read_key_sequence (Lisp_Object *, int, Lisp_Object,
+static int read_key_sequence (Lisp_Object *, size_t, Lisp_Object,
                               int, int, int);
 void safe_run_hooks (Lisp_Object);
 static void adjust_point_for_property (EMACS_INT, int);
@@ -1492,10 +1491,7 @@ command_loop_1 (void)
 
       Vthis_command = cmd;
       real_this_command = cmd;
-      /* Note that the value cell will never directly contain nil
-         if the symbol is a local variable.  */
-      if (!NILP (Vpre_command_hook) && !NILP (Vrun_hooks))
-        safe_run_hooks (Qpre_command_hook);
+      safe_run_hooks (Qpre_command_hook);
 
       already_adjusted = 0;
 
@@ -1541,18 +1537,14 @@ command_loop_1 (void)
           }
       KVAR (current_kboard, Vlast_prefix_arg) = Vcurrent_prefix_arg;
 
-      /* Note that the value cell will never directly contain nil
-         if the symbol is a local variable.  */
-      if (!NILP (Vpost_command_hook) && !NILP (Vrun_hooks))
-        safe_run_hooks (Qpost_command_hook);
+      safe_run_hooks (Qpost_command_hook);
 
       /* If displaying a message, resize the echo area window to fit
          that message's size exactly.  */
       if (!NILP (echo_area_buffer[0]))
         resize_echo_area_exactly ();
 
-      if (!NILP (Vdeferred_action_list))
-        safe_run_hooks (Qdeferred_action_function);
+      safe_run_hooks (Qdeferred_action_function);
 
       /* If there is a prefix argument,
          1) We don't want Vlast_command to be ``universal-argument''
@@ -1621,7 +1613,10 @@ command_loop_1 (void)
                 }
 
               if (current_buffer != prev_buffer || MODIFF != prev_modiff)
-                call1 (Vrun_hooks, intern ("activate-mark-hook"));
+                {
+                  Lisp_Object hook = intern ("activate-mark-hook");
+                  Frun_hooks (1, &hook);
+                }
             }
 
           Vsaved_region_selection = Qnil;
@@ -1819,22 +1814,63 @@ adjust_point_for_property (EMACS_INT last_pt, int modified)
 static Lisp_Object
 safe_run_hooks_1 (void)
 {
-  if (NILP (Vrun_hooks))
-    return Qnil;
-  return call1 (Vrun_hooks, Vinhibit_quit);
+  eassert (CONSP (Vinhibit_quit));
+  return call0 (XCDR (Vinhibit_quit));
 }
 
-/* Subroutine for safe_run_hooks: handle an error by clearing out the hook.  */
+/* Subroutine for safe_run_hooks: handle an error by clearing out the function
+   from the hook.  */
+
+static Lisp_Object
+safe_run_hooks_error (Lisp_Object error_data)
+{
+  Lisp_Object hook
+    = CONSP (Vinhibit_quit) ? XCAR (Vinhibit_quit) : Vinhibit_quit;
+  Lisp_Object fun = CONSP (Vinhibit_quit) ? XCDR (Vinhibit_quit) : Qnil;
+  Lisp_Object args[4];
+  args[0] = build_string ("Error in %s (%s): %s");
+  args[1] = hook;
+  args[2] = fun;
+  args[3] = error_data;
+  Fmessage (4, args);
+  if (SYMBOLP (hook))
+    {
+      Lisp_Object val;
+      int found = 0;
+      Lisp_Object newval = Qnil;
+      for (val = find_symbol_value (hook); CONSP (val); val = XCDR (val))
+        if (EQ (fun, XCAR (val)))
+          found = 1;
+        else
+          newval = Fcons (XCAR (val), newval);
+      if (found)
+        return Fset (hook, Fnreverse (newval));
+      /* Not found in the local part of the hook.  Let's look at the global
+         part.  */
+      newval = Qnil;
+      for (val = (NILP (Fdefault_boundp (hook)) ? Qnil
+                  : Fdefault_value (hook));
+           CONSP (val); val = XCDR (val))
+        if (EQ (fun, XCAR (val)))
+          found = 1;
+        else
+          newval = Fcons (XCAR (val), newval);
+      if (found)
+        return Fset_default (hook, Fnreverse (newval));
+    }
+  return Qnil;
+}
 
 static Lisp_Object
-safe_run_hooks_error (Lisp_Object data)
+safe_run_hook_funcall (size_t nargs, Lisp_Object *args)
 {
-  Lisp_Object args[3];
-  args[0] = build_string ("Error in %s: %s");
-  args[1] = Vinhibit_quit;
-  args[2] = data;
-  Fmessage (3, args);
-  return Fset (Vinhibit_quit, Qnil);
+  eassert (nargs == 1);
+  if (CONSP (Vinhibit_quit))
+    XSETCDR (Vinhibit_quit, args[0]);
+  else
+    Vinhibit_quit = Fcons (Vinhibit_quit, args[0]);
+
+  return internal_condition_case (safe_run_hooks_1, Qt, safe_run_hooks_error);
 }
 
 /* If we get an error while running the hook, cause the hook variable
@@ -1844,10 +1880,13 @@ safe_run_hooks_error (Lisp_Object data)
 void
 safe_run_hooks (Lisp_Object hook)
 {
+  /* FIXME: our `internal_condition_case' does not provide any way to pass data
+     to its body or to its handlers other than via globals such as
+     dynamically-bound variables ;-)  */
   int count = SPECPDL_INDEX ();
   specbind (Qinhibit_quit, hook);
 
-  internal_condition_case (safe_run_hooks_1, Qt, safe_run_hooks_error);
+  run_hook_with_args (1, &hook, safe_run_hook_funcall);
 
   unbind_to (count, Qnil);
 }
@@ -2074,16 +2113,12 @@ make_ctrl_char (int c)
    the `display' property).  POS is the position in that string under
    the mouse.
 
-   OK_TO_OVERWRITE_KEYSTROKE_ECHO non-zero means it's okay if the help
-   echo overwrites a keystroke echo currently displayed in the echo
-   area.
-
    Note: this function may only be called with HELP nil or a string
    from X code running asynchronously.  */
 
 void
 show_help_echo (Lisp_Object help, Lisp_Object window, Lisp_Object object,
-                Lisp_Object pos, int ok_to_overwrite_keystroke_echo)
+                Lisp_Object pos)
 {
   if (!NILP (help) && !STRINGP (help))
     {
@@ -3013,7 +3048,7 @@ read_char (int commandflag, int nmaps, Lisp_Object *maps, Lisp_Object prev_event
       htem = Fcdr (htem);
       position = Fcar (htem);
 
-      show_help_echo (help, window, object, position, 0);
+      show_help_echo (help, window, object, position);
 
       /* We stopped being idle for this event; undo that.  */
       if (!end_time)
@@ -3315,7 +3350,7 @@ static int
 readable_events (int flags)
 {
   if (flags & READABLE_EVENTS_DO_TIMERS_NOW)
-    timer_check (1);
+    timer_check ();
 
   /* If the buffer contains only FOCUS_IN_EVENT events, and
      READABLE_EVENTS_FILTER_EVENTS is set, report it as empty.  */
@@ -4389,14 +4424,10 @@ timer_check_2 (void)
    Returns the time to wait until the next timer fires.
    If no timer is active, return -1.
 
-   As long as any timer is ripe, we run it.
-
-   DO_IT_NOW is now ignored.  It used to mean that we should
-   run the timer directly instead of queueing a timer-event.
-   Now we always run timers directly.  */
+   As long as any timer is ripe, we run it.  */
 
 EMACS_TIME
-timer_check (int do_it_now)
+timer_check (void)
 {
   EMACS_TIME nexttime;
 
@@ -5405,7 +5436,6 @@ make_lispy_event (struct input_event *event)
                 && (event->modifiers & down_modifier))
               {
                 Lisp_Object items, item;
-                int hpos;
                 int i;
 
                 /* Find the menu bar item under `column'.  */
@@ -5974,10 +6004,10 @@ make_lispy_switch_frame (Lisp_Object frame)
    This doesn't use any caches.  */
 
 static int
-parse_modifiers_uncached (Lisp_Object symbol, int *modifier_end)
+parse_modifiers_uncached (Lisp_Object symbol, EMACS_INT *modifier_end)
 {
   Lisp_Object name;
-  int i;
+  EMACS_INT i;
   int modifiers;
 
   CHECK_SYMBOL (symbol);
@@ -5987,7 +6017,7 @@ parse_modifiers_uncached (Lisp_Object symbol, int *modifier_end)
 
   for (i = 0; i+2 <= SBYTES (name); )
     {
-      int this_mod_end = 0;
+      EMACS_INT this_mod_end = 0;
       int this_mod = 0;
 
       /* See if the name continues with a modifier word.
@@ -6184,7 +6214,7 @@ parse_modifiers (Lisp_Object symbol)
     return elements;
   else
     {
-      int end;
+      EMACS_INT end;
       int modifiers = parse_modifiers_uncached (symbol, &end);
       Lisp_Object unmodified;
       Lisp_Object mask;
@@ -7097,7 +7127,7 @@ process_pending_signals (void)
 #ifdef SIGIO   /* for entire page */
 /* Note SIGIO has been undef'd if FIONREAD is missing.  */
 
-static SIGTYPE
+static void
 input_available_signal (int signo)
 {
   /* Must preserve main program's value of errno.  */
@@ -7175,7 +7205,7 @@ add_user_signal (int sig, const char *name)
   signal (sig, handle_user_signal);
 }
 
-static SIGTYPE
+static void
 handle_user_signal (int sig)
 {
   int old_errno = errno;
@@ -8769,7 +8799,7 @@ access_keymap_keyremap (Lisp_Object map, Lisp_Object key, Lisp_Object prompt,
    The return value is non-zero if the remapping actually took place.  */
 
 static int
-keyremap_step (Lisp_Object *keybuf, int bufsize, volatile keyremap *fkey,
+keyremap_step (Lisp_Object *keybuf, size_t bufsize, volatile keyremap *fkey,
                int input, int doit, int *diff, Lisp_Object prompt)
 {
   Lisp_Object next, key;
@@ -8862,7 +8892,7 @@ keyremap_step (Lisp_Object *keybuf, int bufsize, volatile keyremap *fkey,
    from the selected window's buffer.  */
 
 static int
-read_key_sequence (Lisp_Object *keybuf, int bufsize, Lisp_Object prompt,
+read_key_sequence (Lisp_Object *keybuf, size_t bufsize, Lisp_Object prompt,
                    int dont_downcase_last, int can_return_switch_frame,
                    int fix_current_buffer)
 {
@@ -9380,80 +9410,84 @@ read_key_sequence (Lisp_Object *keybuf, int bufsize, Lisp_Object prompt,
                     last_real_key_start = t - 1;
                 }
 
-              /* Key sequences beginning with mouse clicks are
-                 read using the keymaps in the buffer clicked on,
-                 not the current buffer.  If we're at the
-                 beginning of a key sequence, switch buffers.  */
-              if (last_real_key_start == 0
-                  && WINDOWP (window)
-                  && BUFFERP (XWINDOW (window)->buffer)
-                  && XBUFFER (XWINDOW (window)->buffer) != current_buffer)
+              if (last_real_key_start == 0)
                 {
-                  XVECTOR (raw_keybuf)->contents[raw_keybuf_count++] = key;
-                  keybuf[t] = key;
-                  mock_input = t + 1;
-
-                  /* Arrange to go back to the original buffer once we're
-                     done reading the key sequence.  Note that we can't
-                     use save_excursion_{save,restore} here, because they
-                     save point as well as the current buffer; we don't
-                     want to save point, because redisplay may change it,
-                     to accommodate a Fset_window_start or something.  We
-                     don't want to do this at the top of the function,
-                     because we may get input from a subprocess which
-                     wants to change the selected window and stuff (say,
-                     emacsclient).  */
-                  record_unwind_protect (Fset_buffer, Fcurrent_buffer ());
-
-                  if (! FRAME_LIVE_P (XFRAME (selected_frame)))
-                    Fkill_emacs (Qnil);
-                  set_buffer_internal (XBUFFER (XWINDOW (window)->buffer));
-                  orig_local_map = get_local_map (PT, current_buffer,
-                                                  Qlocal_map);
-                  orig_keymap = get_local_map (PT, current_buffer, Qkeymap);
-                  goto replay_sequence;
-                }
+                  /* Key sequences beginning with mouse clicks are
+                     read using the keymaps in the buffer clicked on,
+                     not the current buffer.  If we're at the
+                     beginning of a key sequence, switch buffers.  */
+                  if (WINDOWP (window)
+                      && BUFFERP (XWINDOW (window)->buffer)
+                      && XBUFFER (XWINDOW (window)->buffer) != current_buffer)
+                    {
+                      XVECTOR (raw_keybuf)->contents[raw_keybuf_count++] = key;
+                      keybuf[t] = key;
+                      mock_input = t + 1;
+
+                      /* Arrange to go back to the original buffer once we're
+                         done reading the key sequence.  Note that we can't
+                         use save_excursion_{save,restore} here, because they
+                         save point as well as the current buffer; we don't
+                         want to save point, because redisplay may change it,
+                         to accommodate a Fset_window_start or something.  We
+                         don't want to do this at the top of the function,
+                         because we may get input from a subprocess which
+                         wants to change the selected window and stuff (say,
+                         emacsclient).  */
+                      record_unwind_protect (Fset_buffer, Fcurrent_buffer ());
+
+                      if (! FRAME_LIVE_P (XFRAME (selected_frame)))
+                        Fkill_emacs (Qnil);
+                      set_buffer_internal (XBUFFER (XWINDOW (window)->buffer));
+                      orig_local_map = get_local_map (PT, current_buffer,
+                                                      Qlocal_map);
+                      orig_keymap = get_local_map (PT, current_buffer,
+                                                   Qkeymap);
+                      goto replay_sequence;
+                    }
 
-              /* For a mouse click, get the local text-property keymap
-                 of the place clicked on, rather than point.  */
-              if (last_real_key_start == 0
-                  && CONSP (XCDR (key))
-                  && ! localized_local_map)
-                {
-                  Lisp_Object map_here, start, pos;
+                  /* For a mouse click, get the local text-property keymap
+                     of the place clicked on, rather than point.  */
+                  if (CONSP (XCDR (key))
+                      && ! localized_local_map)
+                    {
+                      Lisp_Object map_here, start, pos;
 
-                  localized_local_map = 1;
-                  start = EVENT_START (key);
+                      localized_local_map = 1;
+                      start = EVENT_START (key);
 
-                  if (CONSP (start) && POSN_INBUFFER_P (start))
-                    {
-                      pos = POSN_BUFFER_POSN (start);
-                      if (INTEGERP (pos)
-                          && XINT (pos) >= BEGV
-                          && XINT (pos) <= ZV)
+                      if (CONSP (start) && POSN_INBUFFER_P (start))
                         {
-                          map_here = get_local_map (XINT (pos),
-                                                    current_buffer, Qlocal_map);
-                          if (!EQ (map_here, orig_local_map))
+                          pos = POSN_BUFFER_POSN (start);
+                          if (INTEGERP (pos)
+                              && XINT (pos) >= BEGV
+                              && XINT (pos) <= ZV)
                             {
-                              orig_local_map = map_here;
-                              ++localized_local_map;
-                            }
+                              map_here = get_local_map (XINT (pos),
+                                                        current_buffer,
+                                                        Qlocal_map);
+                              if (!EQ (map_here, orig_local_map))
+                                {
+                                  orig_local_map = map_here;
+                                  ++localized_local_map;
+                                }
 
-                          map_here = get_local_map (XINT (pos),
-                                                     current_buffer, Qkeymap);
-                          if (!EQ (map_here, orig_keymap))
-                            {
-                              orig_keymap = map_here;
-                              ++localized_local_map;
-                            }
+                              map_here = get_local_map (XINT (pos),
+                                                        current_buffer,
+                                                        Qkeymap);
+                              if (!EQ (map_here, orig_keymap))
+                                {
+                                  orig_keymap = map_here;
+                                  ++localized_local_map;
+                                }
 
-                          if (localized_local_map > 1)
-                            {
-                              keybuf[t] = key;
-                              mock_input = t + 1;
+                              if (localized_local_map > 1)
+                                {
+                                  keybuf[t] = key;
+                                  mock_input = t + 1;
 
-                              goto replay_sequence;
+                                  goto replay_sequence;
+                                }
                             }
                         }
                     }
@@ -10135,11 +10169,11 @@ a special event, so ignore the prefix argument and don't clear it.  */)
   if (SYMBOLP (cmd))
     {
       tem = Fget (cmd, Qdisabled);
-      if (!NILP (tem) && !NILP (Vrun_hooks))
+      if (!NILP (tem))
         {
           tem = Fsymbol_value (Qdisabled_command_function);
           if (!NILP (tem))
-            return call1 (Vrun_hooks, Qdisabled_command_function);
+            return Frun_hooks (1, &Qdisabled_command_function);
         }
     }
 
@@ -10312,9 +10346,9 @@ give to the command you invoke, if it asks for an argument.  */)
           sprintf (newmessage, "You can run the command `%s' with %s",
                    SDATA (SYMBOL_NAME (function)),
                    SDATA (binding));
-          message2_nolog (newmessage,
-                          strlen (newmessage),
-                          STRING_MULTIBYTE (binding));
+          message2 (newmessage,
+                    strlen (newmessage),
+                    STRING_MULTIBYTE (binding));
           if (NUMBERP (Vsuggest_key_bindings))
             waited = sit_for (Vsuggest_key_bindings, 0, 2);
           else
@@ -10623,6 +10657,7 @@ On such systems, Emacs starts a subshell instead of suspending.  */)
   int old_height, old_width;
   int width, height;
   struct gcpro gcpro1;
+  Lisp_Object hook;
 
   if (tty_list && tty_list->next)
     error ("There are other tty frames open; close them before suspending Emacs");
@@ -10631,8 +10666,8 @@ On such systems, Emacs starts a subshell instead of suspending.  */)
     CHECK_STRING (stuffstring);
 
   /* Run the functions in suspend-hook.  */
-  if (!NILP (Vrun_hooks))
-    call1 (Vrun_hooks, intern ("suspend-hook"));
+  hook = intern ("suspend-hook");
+  Frun_hooks (1, &hook);
 
   GCPRO1 (stuffstring);
   get_tty_size (fileno (CURTTY ()->input), &old_width, &old_height);
@@ -10656,8 +10691,8 @@ On such systems, Emacs starts a subshell instead of suspending.  */)
     change_frame_size (SELECTED_FRAME (), height, width, 0, 0, 0);
 
   /* Run suspend-resume-hook.  */
-  if (!NILP (Vrun_hooks))
-    call1 (Vrun_hooks, intern ("suspend-resume-hook"));
+  hook = intern ("suspend-resume-hook");
+  Frun_hooks (1, &hook);
 
   UNGCPRO;
   return Qnil;
@@ -10732,7 +10767,7 @@ clear_waiting_for_input (void)
    SIGINT was generated by C-g, so we call handle_interrupt.
    Otherwise, the handler kills Emacs.  */
 
-static SIGTYPE
+static void
 interrupt_signal (int signalnum)        /* If we don't have an argument, some */
                                         /* compilers complain in signal calls. */
 {
@@ -11458,9 +11493,6 @@ syms_of_keyboard (void)
   Qdeferred_action_function = intern_c_string ("deferred-action-function");
   staticpro (&Qdeferred_action_function);
 
-  Qcommand_hook_internal = intern_c_string ("command-hook-internal");
-  staticpro (&Qcommand_hook_internal);
-
   Qfunction_key = intern_c_string ("function-key");
   staticpro (&Qfunction_key);
   Qmouse_click = intern_c_string ("mouse-click");
@@ -11580,12 +11612,12 @@ syms_of_keyboard (void)
   last_point_position_window = Qnil;
 
   {
-    const struct event_head *p;
+    int i;
+    int len = sizeof (head_table) / sizeof (head_table[0]);
 
-    for (p = head_table;
-         p < head_table + (sizeof (head_table) / sizeof (head_table[0]));
-         p++)
+    for (i = 0; i < len; i++)
       {
+        const struct event_head *p = &head_table[i];
         *p->var = intern_c_string (p->name);
         staticpro (p->var);
         Fput (*p->var, Qevent_kind, *p->kind);
@@ -11928,22 +11960,18 @@ Buffer modification stores t in this variable.  */);
   Qdeactivate_mark = intern_c_string ("deactivate-mark");
   staticpro (&Qdeactivate_mark);
 
-  DEFVAR_LISP ("command-hook-internal", Vcommand_hook_internal,
-               doc: /* Temporary storage of `pre-command-hook' or `post-command-hook'.  */);
-  Vcommand_hook_internal = Qnil;
-
   DEFVAR_LISP ("pre-command-hook", Vpre_command_hook,
                doc: /* Normal hook run before each command is executed.
 If an unhandled error happens in running this hook,
-the hook value is set to nil, since otherwise the error
-might happen repeatedly and make Emacs nonfunctional.  */);
+the function in which the error occurred is unconditionally removed, since
+otherwise the error might happen repeatedly and make Emacs nonfunctional.  */);
   Vpre_command_hook = Qnil;
 
   DEFVAR_LISP ("post-command-hook", Vpost_command_hook,
                doc: /* Normal hook run after each command is executed.
 If an unhandled error happens in running this hook,
-the hook value is set to nil, since otherwise the error
-might happen repeatedly and make Emacs nonfunctional.  */);
+the function in which the error occurred is unconditionally removed, since
+otherwise the error might happen repeatedly and make Emacs nonfunctional.  */);
   Vpost_command_hook = Qnil;
 
 #if 0
diff --git a/src/keyboard.h b/src/keyboard.h
index 00745a09140..72bb821b2eb 100644
--- a/src/keyboard.h
+++ b/src/keyboard.h
@@ -194,8 +194,8 @@ extern KBOARD *all_kboards;
 /* Nonzero in the single-kboard state, 0 in the any-kboard state.  */
 extern int single_kboard;
 
-/* Total number of times read_char has returned.  */
-extern int num_input_events;
+/* Total number of times read_char has returned, modulo SIZE_MAX + 1.  */
+extern size_t num_input_events;
 
 /* Nonzero means polling for input is temporarily suppressed.  */
 extern int poll_suppress_count;
@@ -485,7 +485,7 @@ extern void push_frame_kboard (struct frame *);
 extern void pop_kboard (void);
 extern void temporarily_switch_to_single_kboard (struct frame *);
 extern void record_asynch_buffer_change (void);
-extern SIGTYPE input_poll_signal (int);
+extern void input_poll_signal (int);
 extern void start_polling (void);
 extern void stop_polling (void);
 extern void set_poll_suppress_count (int);
@@ -507,7 +507,7 @@ extern void kbd_buffer_store_event_hold (struct input_event *,
 extern void kbd_buffer_unget_event (struct input_event *);
 extern void poll_for_input_1 (void);
 extern void show_help_echo (Lisp_Object, Lisp_Object, Lisp_Object,
-                            Lisp_Object, int);
+                            Lisp_Object);
 extern void gen_help_event (Lisp_Object, Lisp_Object, Lisp_Object,
                             Lisp_Object, EMACS_INT);
 extern void kbd_buffer_store_help_event (Lisp_Object, Lisp_Object);
@@ -517,7 +517,7 @@ extern void add_user_signal (int, const char *);
 
 extern int tty_read_avail_input (struct terminal *, int,
                                  struct input_event *);
-extern EMACS_TIME timer_check (int);
+extern EMACS_TIME timer_check (void);
 extern void mark_kboards (void);
 
 #ifdef WINDOWSNT
diff --git a/src/keymap.c b/src/keymap.c
index 06968a0d944..10000b935aa 100644
--- a/src/keymap.c
+++ b/src/keymap.c
@@ -81,8 +81,7 @@ static void describe_map (Lisp_Object, Lisp_Object,
                           int, Lisp_Object, Lisp_Object*, int, int);
 static void describe_vector (Lisp_Object, Lisp_Object, Lisp_Object,
                              void (*) (Lisp_Object, Lisp_Object), int,
-                             Lisp_Object, Lisp_Object, int *,
-                             int, int, int);
+                             Lisp_Object, Lisp_Object, int, int);
 static void silly_event_symbol_error (Lisp_Object);
 static Lisp_Object get_keyelt (Lisp_Object, int);
 
@@ -2388,7 +2387,7 @@ push_key_description (register unsigned int c, register char *p, int force_multi
       /* Now we are sure that C is a valid character code.  */
       if (NILP (BVAR (current_buffer, enable_multibyte_characters))
           && ! force_multibyte)
-        *p++ = multibyte_char_to_unibyte (c, Qnil);
+        *p++ = multibyte_char_to_unibyte (c);
       else
         p += CHAR_STRING (c, (unsigned char *) p);
     }
@@ -3353,7 +3352,7 @@ describe_map (Lisp_Object map, Lisp_Object prefix,
           || CHAR_TABLE_P (XCAR (tail)))
         describe_vector (XCAR (tail),
                          prefix, Qnil, elt_describer, partial, shadow, map,
-                         (int *)0, 0, 1, mention_shadow);
+                         1, mention_shadow);
       else if (CONSP (XCAR (tail)))
         {
           int this_shadowed = 0;
@@ -3506,7 +3505,7 @@ DESCRIBER is the output function used; nil means use `princ'.  */)
   specbind (Qstandard_output, Fcurrent_buffer ());
   CHECK_VECTOR_OR_CHAR_TABLE (vector);
   describe_vector (vector, Qnil, describer, describe_vector_princ, 0,
-                   Qnil, Qnil, (int *)0, 0, 0, 0);
+                   Qnil, Qnil, 0, 0);
 
   return unbind_to (count, Qnil);
 }
@@ -3539,9 +3538,6 @@ DESCRIBER is the output function used; nil means use `princ'.  */)
 
    ARGS is simply passed as the second argument to ELT_DESCRIBER.
 
-   INDICES and CHAR_TABLE_DEPTH are ignored.  They will be removed in
-   the near future.
-
    KEYMAP_P is 1 if vector is known to be a keymap, so map ESC to M-.
 
    ARGS is simply passed as the second argument to ELT_DESCRIBER.  */
@@ -3550,8 +3546,7 @@ static void
 describe_vector (Lisp_Object vector, Lisp_Object prefix, Lisp_Object args,
                  void (*elt_describer) (Lisp_Object, Lisp_Object),
                  int partial, Lisp_Object shadow, Lisp_Object entire_map,
-                 int *indices, int char_table_depth, int keymap_p,
-                 int mention_shadow)
+                 int keymap_p, int mention_shadow)
 {
   Lisp_Object definition;
   Lisp_Object tem2;
diff --git a/src/lisp.h b/src/lisp.h
index 9cbaf24cacf..bd70dcebbdb 100644
--- a/src/lisp.h
+++ b/src/lisp.h
@@ -964,7 +964,7 @@ struct Lisp_Subr
       Lisp_Object (*a7) (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object);
       Lisp_Object (*a8) (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object);
       Lisp_Object (*aUNEVALLED) (Lisp_Object args);
-      Lisp_Object (*aMANY) (int, Lisp_Object *);
+      Lisp_Object (*aMANY) (size_t, Lisp_Object *);
     } function;
     short min_args, max_args;
     const char *symbol_name;
@@ -1814,7 +1814,7 @@ typedef struct {
 
 /* Note that the weird token-substitution semantics of ANSI C makes
    this work for MANY and UNEVALLED.  */
-#define DEFUN_ARGS_MANY         (int, Lisp_Object *)
+#define DEFUN_ARGS_MANY         (size_t, Lisp_Object *)
 #define DEFUN_ARGS_UNEVALLED    (Lisp_Object)
 #define DEFUN_ARGS_0    (void)
 #define DEFUN_ARGS_1    (Lisp_Object)
@@ -2084,7 +2084,7 @@ struct gcpro
   volatile Lisp_Object *var;
 
   /* Number of consecutive protected variables.  */
-  int nvars;
+  size_t nvars;
 
 #ifdef DEBUG_GCPRO
   int level;
@@ -2283,7 +2283,7 @@ void staticpro (Lisp_Object *);
 struct window;
 struct frame;
 
-/* Defined in data.c */
+/* Defined in data.c.  */
 extern Lisp_Object Qnil, Qt, Qquote, Qlambda, Qsubr, Qunbound;
 extern Lisp_Object Qerror_conditions, Qerror_message, Qtop_level;
 extern Lisp_Object Qerror, Qquit, Qwrong_type_argument, Qargs_out_of_range;
@@ -2408,7 +2408,7 @@ EXFUN (Fchar_width, 1);
 EXFUN (Fstring, MANY);
 extern EMACS_INT chars_in_text (const unsigned char *, EMACS_INT);
 extern EMACS_INT multibyte_chars_in_text (const unsigned char *, EMACS_INT);
-extern int multibyte_char_to_unibyte (int, Lisp_Object);
+extern int multibyte_char_to_unibyte (int);
 extern int multibyte_char_to_unibyte_safe (int);
 extern void init_character_once (void);
 extern void syms_of_character (void);
@@ -2817,7 +2817,7 @@ extern void init_obarray (void);
 extern void init_lread (void);
 extern void syms_of_lread (void);
 
-/* Defined in eval.c */
+/* Defined in eval.c.  */
 extern Lisp_Object Qautoload, Qexit, Qinteractive, Qcommandp, Qdefun, Qmacro;
 extern Lisp_Object Qinhibit_quit, Qclosure;
 extern Lisp_Object Vautoload_queue;
@@ -2835,6 +2835,9 @@ EXFUN (Frun_hooks, MANY);
 EXFUN (Frun_hook_with_args, MANY);
 EXFUN (Frun_hook_with_args_until_failure, MANY);
 extern void run_hook_with_args_2 (Lisp_Object, Lisp_Object, Lisp_Object);
+extern Lisp_Object run_hook_with_args (size_t nargs, Lisp_Object *args,
+                                       Lisp_Object (*funcall)
+                                       (size_t nargs, Lisp_Object *args));
 EXFUN (Fprogn, UNEVALLED);
 EXFUN (Finteractive_p, 0);
 EXFUN (Fthrow, 2) NO_RETURN;
@@ -2867,7 +2870,7 @@ extern Lisp_Object internal_lisp_condition_case (Lisp_Object, Lisp_Object, Lisp_
 extern Lisp_Object internal_condition_case (Lisp_Object (*) (void), Lisp_Object, Lisp_Object (*) (Lisp_Object));
 extern Lisp_Object internal_condition_case_1 (Lisp_Object (*) (Lisp_Object), Lisp_Object, Lisp_Object, Lisp_Object (*) (Lisp_Object));
 extern Lisp_Object internal_condition_case_2 (Lisp_Object (*) (Lisp_Object, Lisp_Object), Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object (*) (Lisp_Object));
-extern Lisp_Object internal_condition_case_n (Lisp_Object (*) (int, Lisp_Object *), int, Lisp_Object *, Lisp_Object, Lisp_Object (*) (Lisp_Object));
+extern Lisp_Object internal_condition_case_n (Lisp_Object (*) (size_t, Lisp_Object *), size_t, Lisp_Object *, Lisp_Object, Lisp_Object (*) (Lisp_Object));
 extern void specbind (Lisp_Object, Lisp_Object);
 extern void record_unwind_protect (Lisp_Object (*) (Lisp_Object), Lisp_Object);
 extern Lisp_Object unbind_to (int, Lisp_Object);
@@ -2877,7 +2880,7 @@ extern void do_autoload (Lisp_Object, Lisp_Object);
 extern Lisp_Object un_autoload (Lisp_Object);
 EXFUN (Ffetch_bytecode, 1);
 extern void init_eval_once (void);
-extern Lisp_Object safe_call (int, Lisp_Object *);
+extern Lisp_Object safe_call (size_t, Lisp_Object *);
 extern Lisp_Object safe_call1 (Lisp_Object, Lisp_Object);
 extern Lisp_Object safe_call2 (Lisp_Object, Lisp_Object, Lisp_Object);
 extern void init_eval (void);
@@ -3188,7 +3191,7 @@ extern Lisp_Object decode_env_path (const char *, const char *);
 extern Lisp_Object empty_unibyte_string, empty_multibyte_string;
 extern Lisp_Object Qfile_name_handler_alist;
 extern void (*fatal_error_signal_hook) (void);
-extern SIGTYPE fatal_error_signal (int);
+extern void fatal_error_signal (int);
 EXFUN (Fkill_emacs, 1) NO_RETURN;
 #if HAVE_SETLOCALE
 void fixup_locale (void);
@@ -3240,7 +3243,11 @@ extern void syms_of_process (void);
 extern void setup_process_coding_systems (Lisp_Object);
 
 EXFUN (Fcall_process, MANY);
-extern int child_setup (int, int, int, char **, int, Lisp_Object);
+extern int child_setup (int, int, int, char **, int, Lisp_Object)
+#ifndef DOS_NT
+ NO_RETURN
+#endif
+ ;
 extern void init_callproc_1 (void);
 extern void init_callproc (void);
 extern void set_initial_environment (void);
@@ -3607,7 +3614,7 @@ extern Lisp_Object safe_alloca_unwind (Lisp_Object);
     else                                                  \
       {                                                   \
         buf = (type) xmalloc (size);                      \
-        sa_must_free++;                                   \
+        sa_must_free = 1;                                 \
         record_unwind_protect (safe_alloca_unwind,        \
                                make_save_value (buf, 0)); \
       }                                                   \
@@ -3637,7 +3644,7 @@ extern Lisp_Object safe_alloca_unwind (Lisp_Object);
         buf = (Lisp_Object *) xmalloc (size_);            \
         arg_ = make_save_value (buf, nelt);               \
         XSAVE_VALUE (arg_)->dogc = 1;                     \
-        sa_must_free++;                                   \
+        sa_must_free = 1;                                 \
         record_unwind_protect (safe_alloca_unwind, arg_); \
       }                                                   \
   } while (0)
diff --git a/src/menu.c b/src/menu.c
index 851f1ac804b..a9098deed7e 100644
--- a/src/menu.c
+++ b/src/menu.c
@@ -662,13 +662,12 @@ digest_single_submenu (int start, int end, int top_level_items)
       else if (EQ (XVECTOR (menu_items)->contents[i], Qt))
         {
           /* Create a new pane.  */
-          Lisp_Object pane_name, prefix;
+          Lisp_Object pane_name;
           const char *pane_string;
 
           panes_seen++;
 
           pane_name = XVECTOR (menu_items)->contents[i + MENU_ITEMS_PANE_NAME];
-          prefix = XVECTOR (menu_items)->contents[i + MENU_ITEMS_PANE_PREFIX];
 
 #ifdef HAVE_NTGUI
           if (STRINGP (pane_name))
diff --git a/src/minibuf.c b/src/minibuf.c
index 986765ae6fb..4adf665f8f4 100644
--- a/src/minibuf.c
+++ b/src/minibuf.c
@@ -649,12 +649,7 @@ read_minibuf (Lisp_Object map, Lisp_Object initial, Lisp_Object prompt,
   if (STRINGP (input_method) && !NILP (Ffboundp (Qactivate_input_method)))
     call1 (Qactivate_input_method, input_method);
 
-  /* Run our hook, but not if it is empty.
-     (run-hooks would do nothing if it is empty,
-     but it's important to save time here in the usual case.)  */
-  if (!NILP (Vminibuffer_setup_hook) && !EQ (Vminibuffer_setup_hook, Qunbound)
-      && !NILP (Vrun_hooks))
-    call1 (Vrun_hooks, Qminibuffer_setup_hook);
+  Frun_hooks (1, &Qminibuffer_setup_hook);
 
   /* Don't allow the user to undo past this point.  */
   BVAR (current_buffer, undo_list) = Qnil;
@@ -806,10 +801,7 @@ get_minibuffer (int depth)
 static Lisp_Object
 run_exit_minibuf_hook (Lisp_Object data)
 {
-  if (!NILP (Vminibuffer_exit_hook) && !EQ (Vminibuffer_exit_hook, Qunbound)
-      && !NILP (Vrun_hooks))
-    safe_run_hooks (Qminibuffer_exit_hook);
-
+  safe_run_hooks (Qminibuffer_exit_hook);
   return Qnil;
 }
 
diff --git a/src/nsmenu.m b/src/nsmenu.m
index e8d4a256906..623c933ce8e 100644
--- a/src/nsmenu.m
+++ b/src/nsmenu.m
@@ -1705,7 +1705,6 @@ void process_dialog (id window, Lisp_Object list)
 - (Lisp_Object)runDialogAt: (NSPoint)p
 {
   NSInteger ret;
-  extern EMACS_TIME timer_check (int do_it_now); /* TODO: add to a header */
 
   /* initiate a session that will be ended by pop_down_menu */
   popupSession = [NSApp beginModalSessionForWindow: self];
@@ -1715,7 +1714,7 @@ void process_dialog (id window, Lisp_Object list)
     {
       /* Run this for timers.el, indep of atimers; might not return.
          TODO: use return value to avoid calling every iteration. */
-      timer_check (1);
+      timer_check ();
       [NSThread sleepUntilDate: [NSDate dateWithTimeIntervalSinceNow: 0.1]];
     }
 
diff --git a/src/nsterm.m b/src/nsterm.m
index c7cd411c614..91f0cbba585 100644
--- a/src/nsterm.m
+++ b/src/nsterm.m
@@ -170,6 +170,7 @@ BOOL ns_in_resize = NO;
 static BOOL ns_fake_keydown = NO;
 int ns_tmp_flags; /* FIXME */
 struct nsfont_info *ns_tmp_font; /* FIXME */
+static BOOL ns_menu_bar_is_hidden = NO;
 /*static int debug_lock = 0; */
 
 /* event loop */
@@ -505,6 +506,118 @@ ns_resize_handle_rect (NSWindow *window)
 }
 
 
+//
+// Window constraining
+// -------------------
+//
+// To ensure that the windows are not placed under the menu bar, they
+// are typically moved by the call-back constrainFrameRect. However,
+// by overriding it, it's possible to inhibit this, leaving the window
+// in it's original position.
+//
+// It's possible to hide the menu bar. However, technically, it's only
+// possible to hide it when the application is active. To ensure that
+// this work properly, the menu bar and window constraining are
+// deferred until the application becomes active.
+//
+// Even though it's not possible to manually move a window above the
+// top of the screen, it is allowed if it's done programmatically,
+// when the menu is hidden. This allows the editable area to cover the
+// full screen height.
+//
+// Test cases
+// ----------
+//
+// Use the following extra files:
+//
+//    init.el:
+//       ;; Hide menu and place frame slightly above the top of the screen.
+//       (setq ns-auto-hide-menu-bar t)
+//       (set-frame-position (selected-frame) 0 -20)
+//
+// Test 1:
+//
+//    emacs -Q -l init.el
+//
+//    Result: No menu bar, and the title bar should be above the screen.
+//
+// Test 2:
+//
+//    emacs -Q
+//
+//    Result: Menu bar visible, frame placed immediately below the menu.
+//
+
+static void
+ns_constrain_all_frames (void)
+{
+  Lisp_Object tail, frame;
+
+  FOR_EACH_FRAME (tail, frame)
+    {
+      struct frame *f = XFRAME (frame);
+      if (FRAME_NS_P (f))
+        {
+          NSView *view = FRAME_NS_VIEW (f);
+          /* This no-op will trigger the default window placing
+           * constriant system. */
+          f->output_data.ns->dont_constrain = 0;
+          [[view window] setFrameOrigin:[[view window] frame].origin];
+        }
+    }
+}
+
+
+/* True, if the menu bar should be hidden.  */
+
+static BOOL
+ns_menu_bar_should_be_hidden (void)
+{
+  return !NILP (ns_auto_hide_menu_bar)
+    && [NSApp respondsToSelector:@selector(setPresentationOptions:)];
+}
+
+
+/* Show or hide the menu bar, based on user setting.  */
+
+static void
+ns_update_auto_hide_menu_bar (void)
+{
+  BLOCK_INPUT;
+
+  NSTRACE (ns_update_auto_hide_menu_bar);
+
+  if (NSApp != nil
+      && [NSApp isActive]
+      && [NSApp respondsToSelector:@selector(setPresentationOptions:)])
+    {
+      // Note, "setPresentationOptions" triggers an error unless the
+      // application is active.
+      BOOL menu_bar_should_be_hidden = ns_menu_bar_should_be_hidden ();
+
+      if (menu_bar_should_be_hidden != ns_menu_bar_is_hidden)
+        {
+          NSApplicationPresentationOptions options
+            = NSApplicationPresentationAutoHideDock;
+
+          if (menu_bar_should_be_hidden)
+            options |= NSApplicationPresentationAutoHideMenuBar;
+
+          [NSApp setPresentationOptions: options];
+
+          ns_menu_bar_is_hidden = menu_bar_should_be_hidden;
+
+          if (!ns_menu_bar_is_hidden)
+            {
+              ns_constrain_all_frames ();
+            }
+        }
+    }
+
+  UNBLOCK_INPUT;
+}
+
+
 static void
 ns_update_begin (struct frame *f)
 /* --------------------------------------------------------------------------
@@ -515,6 +628,8 @@ ns_update_begin (struct frame *f)
   NSView *view = FRAME_NS_VIEW (f);
   NSTRACE (ns_update_begin);
 
+  ns_update_auto_hide_menu_bar ();
+
   ns_updating_frame = f;
   [view lockFocus];
 
@@ -4205,7 +4320,13 @@ ns_term_shutdown (int sig)
 }
 - (void)applicationDidBecomeActive: (NSNotification *)notification
 {
+  NSTRACE (applicationDidBecomeActive);
+
   //ns_app_active=YES;
+
+  ns_update_auto_hide_menu_bar ();
+  // No constrining takes place when the application is not active.
+  ns_constrain_all_frames ();
 }
 - (void)applicationDidResignActive: (NSNotification *)notification
 {
@@ -5689,7 +5810,10 @@ ns_term_shutdown (int sig)
   /* When making the frame visible for the first time, we want to
      constrain.  Other times not.  */
   struct frame *f = ((EmacsView *)[self delegate])->emacsframe;
-  if (f->output_data.ns->dont_constrain)
+  NSTRACE (constrainFrameRect);
+
+  if (f->output_data.ns->dont_constrain
+      || ns_menu_bar_should_be_hidden ())
     return frameRect;
 
   f->output_data.ns->dont_constrain = 1;
@@ -6361,6 +6485,11 @@ allowing it to be used at a lower level for accented character entry.");
   staticpro (&last_mouse_motion_frame);
   last_mouse_motion_frame = Qnil;
 
+  DEFVAR_LISP ("ns-auto-hide-menu-bar", ns_auto_hide_menu_bar,
+               doc: /* Non-nil means that the menu bar is hidden, but appears when the mouse is near.
+Only works on OSX 10.6 or later.  */);
+  ns_auto_hide_menu_bar = Qnil;
+
   /* TODO: move to common code */
   DEFVAR_LISP ("x-toolkit-scroll-bars", Vx_toolkit_scroll_bars,
                doc: /* If not nil, Emacs uses toolkit scroll bars.  */);
diff --git a/src/print.c b/src/print.c
index b8266422473..17a896bba8d 100644
--- a/src/print.c
+++ b/src/print.c
@@ -273,7 +273,7 @@ printchar (unsigned int ch, Lisp_Object fun)
 
 static void
 strout (const char *ptr, EMACS_INT size, EMACS_INT size_byte,
-        Lisp_Object printcharfun, int multibyte)
+        Lisp_Object printcharfun)
 {
   if (size < 0)
     size_byte = size = strlen (ptr);
@@ -406,16 +406,13 @@ print_string (Lisp_Object string, Lisp_Object printcharfun)
           SAFE_ALLOCA (buffer, char *, nbytes);
           memcpy (buffer, SDATA (string), nbytes);
 
-          strout (buffer, chars, SBYTES (string),
-                  printcharfun, STRING_MULTIBYTE (string));
+          strout (buffer, chars, SBYTES (string), printcharfun);
 
           SAFE_FREE ();
         }
       else
         /* No need to copy, since output to print_buffer can't GC.  */
-        strout (SSDATA (string),
-                chars, SBYTES (string),
-                printcharfun, STRING_MULTIBYTE (string));
+        strout (SSDATA (string), chars, SBYTES (string), printcharfun);
     }
   else
     {
@@ -472,7 +469,7 @@ write_string (const char *data, int size)
   printcharfun = Vstandard_output;
 
   PRINTPREPARE;
-  strout (data, size, size, printcharfun, 0);
+  strout (data, size, size, printcharfun);
   PRINTFINISH;
 }
 
@@ -486,7 +483,7 @@ write_string_1 (const char *data, int size, Lisp_Object printcharfun)
   PRINTDECLARE;
 
   PRINTPREPARE;
-  strout (data, size, size, printcharfun, 0);
+  strout (data, size, size, printcharfun);
   PRINTFINISH;
 }
 
@@ -1351,7 +1348,7 @@ print_object (Lisp_Object obj, register Lisp_Object printcharfun, int escapeflag
             if (EQ (obj, being_printed[i]))
               {
                 sprintf (buf, "#%d", i);
-                strout (buf, -1, -1, printcharfun, 0);
+                strout (buf, -1, -1, printcharfun);
                 return;
               }
           being_printed[print_depth] = obj;
@@ -1367,7 +1364,7 @@ print_object (Lisp_Object obj, register Lisp_Object printcharfun, int escapeflag
                 { /* Add a prefix #n= if OBJ has not yet been printed;
                      that is, its status field is nil.  */
                   sprintf (buf, "#%d=", -n);
-                  strout (buf, -1, -1, printcharfun, 0);
+                  strout (buf, -1, -1, printcharfun);
                   /* OBJ is going to be printed.  Remember that fact.  */
                   Fputhash (obj, make_number (- n), Vprint_number_table);
                 }
@@ -1375,7 +1372,7 @@ print_object (Lisp_Object obj, register Lisp_Object printcharfun, int escapeflag
                 {
                   /* Just print #n# if OBJ has already been printed.  */
                   sprintf (buf, "#%d#", n);
-                  strout (buf, -1, -1, printcharfun, 0);
+                  strout (buf, -1, -1, printcharfun);
                   return;
                 }
             }
@@ -1393,7 +1390,7 @@ print_object (Lisp_Object obj, register Lisp_Object printcharfun, int escapeflag
         sprintf (buf, "%ld", (long) XINT (obj));
       else
         abort ();
-      strout (buf, -1, -1, printcharfun, 0);
+      strout (buf, -1, -1, printcharfun);
       break;
 
     case Lisp_Float:
@@ -1401,7 +1398,7 @@ print_object (Lisp_Object obj, register Lisp_Object printcharfun, int escapeflag
         char pigbuf[FLOAT_TO_STRING_BUFSIZE];
 
         float_to_string (pigbuf, XFLOAT_DATA (obj));
-        strout (pigbuf, -1, -1, printcharfun, 0);
+        strout (pigbuf, -1, -1, printcharfun);
       }
       break;
 
@@ -1479,7 +1476,7 @@ print_object (Lisp_Object obj, register Lisp_Object printcharfun, int escapeflag
                       sprintf (outbuf, "\\x%04x", c);
                       need_nonhex = 1;
                     }
-                  strout (outbuf, -1, -1, printcharfun, 0);
+                  strout (outbuf, -1, -1, printcharfun);
                 }
               else if (! multibyte
                        && SINGLE_BYTE_CHAR_P (c) && ! ASCII_BYTE_P (c)
@@ -1491,7 +1488,7 @@ print_object (Lisp_Object obj, register Lisp_Object printcharfun, int escapeflag
                      using octal escapes.  */
                   char outbuf[5];
                   sprintf (outbuf, "\\%03o", c);
-                  strout (outbuf, -1, -1, printcharfun, 0);
+                  strout (outbuf, -1, -1, printcharfun);
                 }
               else
                 {
@@ -1504,7 +1501,7 @@ print_object (Lisp_Object obj, register Lisp_Object printcharfun, int escapeflag
                       if ((c >= 'a' && c <= 'f')
                           || (c >= 'A' && c <= 'F')
                           || (c >= '0' && c <= '9'))
-                        strout ("\\ ", -1, -1, printcharfun, 0);
+                        strout ("\\ ", -1, -1, printcharfun);
                     }
 
                   if (c == '\"' || c == '\\')
@@ -1592,7 +1589,7 @@ print_object (Lisp_Object obj, register Lisp_Object printcharfun, int escapeflag
       /* If deeper than spec'd depth, print placeholder.  */
       if (INTEGERP (Vprint_level)
           && print_depth > XINT (Vprint_level))
-        strout ("...", -1, -1, printcharfun, 0);
+        strout ("...", -1, -1, printcharfun);
       else if (print_quoted && CONSP (XCDR (obj)) && NILP (XCDR (XCDR (obj)))
                && (EQ (XCAR (obj), Qquote)))
         {
@@ -1652,7 +1649,7 @@ print_object (Lisp_Object obj, register Lisp_Object printcharfun, int escapeflag
                     if (i != 0 && EQ (obj, halftail))
                       {
                         sprintf (buf, " . #%d", i / 2);
-                        strout (buf, -1, -1, printcharfun, 0);
+                        strout (buf, -1, -1, printcharfun);
                         goto end_of_list;
                       }
                   }
@@ -1664,7 +1661,7 @@ print_object (Lisp_Object obj, register Lisp_Object printcharfun, int escapeflag
                         Lisp_Object num = Fgethash (obj, Vprint_number_table, Qnil);
                         if (INTEGERP (num))
                           {
-                            strout (" . ", 3, 3, printcharfun, 0);
+                            strout (" . ", 3, 3, printcharfun);
                             print_object (obj, printcharfun, escapeflag);
                             goto end_of_list;
                           }
@@ -1676,7 +1673,7 @@ print_object (Lisp_Object obj, register Lisp_Object printcharfun, int escapeflag
 
                 if (print_length && i > print_length)
                   {
-                    strout ("...", 3, 3, printcharfun, 0);
+                    strout ("...", 3, 3, printcharfun);
                     goto end_of_list;
                   }
 
@@ -1691,7 +1688,7 @@ print_object (Lisp_Object obj, register Lisp_Object printcharfun, int escapeflag
           /* OBJ non-nil here means it's the end of a dotted list.  */
           if (!NILP (obj))
             {
-              strout (" . ", 3, 3, printcharfun, 0);
+              strout (" . ", 3, 3, printcharfun);
               print_object (obj, printcharfun, escapeflag);
             }
 
@@ -1705,7 +1702,7 @@ print_object (Lisp_Object obj, register Lisp_Object printcharfun, int escapeflag
         {
           if (escapeflag)
             {
-              strout ("#<process ", -1, -1, printcharfun, 0);
+              strout ("#<process ", -1, -1, printcharfun);
               print_string (XPROCESS (obj)->name, printcharfun);
               PRINTCHAR ('>');
             }
@@ -1726,7 +1723,7 @@ print_object (Lisp_Object obj, register Lisp_Object printcharfun, int escapeflag
           PRINTCHAR ('#');
           PRINTCHAR ('&');
           sprintf (buf, "%ld", (long) XBOOL_VECTOR (obj)->size);
-          strout (buf, -1, -1, printcharfun, 0);
+          strout (buf, -1, -1, printcharfun);
           PRINTCHAR ('\"');
 
           /* Don't print more characters than the specified maximum.
@@ -1771,18 +1768,18 @@ print_object (Lisp_Object obj, register Lisp_Object printcharfun, int escapeflag
         }
       else if (SUBRP (obj))
         {
-          strout ("#<subr ", -1, -1, printcharfun, 0);
-          strout (XSUBR (obj)->symbol_name, -1, -1, printcharfun, 0);
+          strout ("#<subr ", -1, -1, printcharfun);
+          strout (XSUBR (obj)->symbol_name, -1, -1, printcharfun);
           PRINTCHAR ('>');
         }
       else if (WINDOWP (obj))
         {
-          strout ("#<window ", -1, -1, printcharfun, 0);
+          strout ("#<window ", -1, -1, printcharfun);
           sprintf (buf, "%ld", (long) XFASTINT (XWINDOW (obj)->sequence_number));
-          strout (buf, -1, -1, printcharfun, 0);
+          strout (buf, -1, -1, printcharfun);
           if (!NILP (XWINDOW (obj)->buffer))
             {
-              strout (" on ", -1, -1, printcharfun, 0);
+              strout (" on ", -1, -1, printcharfun);
               print_string (BVAR (XBUFFER (XWINDOW (obj)->buffer), name), printcharfun);
             }
           PRINTCHAR ('>');
@@ -1790,13 +1787,13 @@ print_object (Lisp_Object obj, register Lisp_Object printcharfun, int escapeflag
       else if (TERMINALP (obj))
         {
           struct terminal *t = XTERMINAL (obj);
-          strout ("#<terminal ", -1, -1, printcharfun, 0);
+          strout ("#<terminal ", -1, -1, printcharfun);
           sprintf (buf, "%d", t->id);
-          strout (buf, -1, -1, printcharfun, 0);
+          strout (buf, -1, -1, printcharfun);
           if (t->name)
             {
-              strout (" on ", -1, -1, printcharfun, 0);
-              strout (t->name, -1, -1, printcharfun, 0);
+              strout (" on ", -1, -1, printcharfun);
+              strout (t->name, -1, -1, printcharfun);
             }
           PRINTCHAR ('>');
         }
@@ -1806,21 +1803,21 @@ print_object (Lisp_Object obj, register Lisp_Object printcharfun, int escapeflag
           int i;
           EMACS_INT real_size, size;
 #if 0
-          strout ("#<hash-table", -1, -1, printcharfun, 0);
+          strout ("#<hash-table", -1, -1, printcharfun);
           if (SYMBOLP (h->test))
             {
               PRINTCHAR (' ');
               PRINTCHAR ('\'');
-              strout (SDATA (SYMBOL_NAME (h->test)), -1, -1, printcharfun, 0);
+              strout (SDATA (SYMBOL_NAME (h->test)), -1, -1, printcharfun);
               PRINTCHAR (' ');
-              strout (SDATA (SYMBOL_NAME (h->weak)), -1, -1, printcharfun, 0);
+              strout (SDATA (SYMBOL_NAME (h->weak)), -1, -1, printcharfun);
               PRINTCHAR (' ');
               sprintf (buf, "%ld/%ld", (long) h->count,
                        (long) XVECTOR (h->next)->size);
-              strout (buf, -1, -1, printcharfun, 0);
+              strout (buf, -1, -1, printcharfun);
             }
           sprintf (buf, " 0x%lx", (unsigned long) h);
-          strout (buf, -1, -1, printcharfun, 0);
+          strout (buf, -1, -1, printcharfun);
           PRINTCHAR ('>');
 #endif
           /* Implement a readable output, e.g.:
@@ -1828,33 +1825,33 @@ print_object (Lisp_Object obj, register Lisp_Object printcharfun, int escapeflag
           /* Always print the size. */
           sprintf (buf, "#s(hash-table size %ld",
                    (long) XVECTOR (h->next)->size);
-          strout (buf, -1, -1, printcharfun, 0);
+          strout (buf, -1, -1, printcharfun);
 
           if (!NILP (h->test))
             {
-              strout (" test ", -1, -1, printcharfun, 0);
+              strout (" test ", -1, -1, printcharfun);
               print_object (h->test, printcharfun, escapeflag);
             }
 
           if (!NILP (h->weak))
             {
-              strout (" weakness ", -1, -1, printcharfun, 0);
+              strout (" weakness ", -1, -1, printcharfun);
               print_object (h->weak, printcharfun, escapeflag);
             }
 
           if (!NILP (h->rehash_size))
             {
-              strout (" rehash-size ", -1, -1, printcharfun, 0);
+              strout (" rehash-size ", -1, -1, printcharfun);
               print_object (h->rehash_size, printcharfun, escapeflag);
             }
 
           if (!NILP (h->rehash_threshold))
             {
-              strout (" rehash-threshold ", -1, -1, printcharfun, 0);
+              strout (" rehash-threshold ", -1, -1, printcharfun);
               print_object (h->rehash_threshold, printcharfun, escapeflag);
             }
 
-          strout (" data ", -1, -1, printcharfun, 0);
+          strout (" data ", -1, -1, printcharfun);
 
           /* Print the data here as a plist. */
           real_size = HASH_TABLE_SIZE (h);
@@ -1876,7 +1873,7 @@ print_object (Lisp_Object obj, register Lisp_Object printcharfun, int escapeflag
               }
 
           if (size < real_size)
-            strout (" ...", 4, 4, printcharfun, 0);
+            strout (" ...", 4, 4, printcharfun);
 
           PRINTCHAR (')');
           PRINTCHAR (')');
@@ -1885,10 +1882,10 @@ print_object (Lisp_Object obj, register Lisp_Object printcharfun, int escapeflag
       else if (BUFFERP (obj))
         {
           if (NILP (BVAR (XBUFFER (obj), name)))
-            strout ("#<killed buffer>", -1, -1, printcharfun, 0);
+            strout ("#<killed buffer>", -1, -1, printcharfun);
           else if (escapeflag)
             {
-              strout ("#<buffer ", -1, -1, printcharfun, 0);
+              strout ("#<buffer ", -1, -1, printcharfun);
               print_string (BVAR (XBUFFER (obj), name), printcharfun);
               PRINTCHAR ('>');
             }
@@ -1897,16 +1894,16 @@ print_object (Lisp_Object obj, register Lisp_Object printcharfun, int escapeflag
         }
       else if (WINDOW_CONFIGURATIONP (obj))
         {
-          strout ("#<window-configuration>", -1, -1, printcharfun, 0);
+          strout ("#<window-configuration>", -1, -1, printcharfun);
         }
       else if (FRAMEP (obj))
         {
           strout ((FRAME_LIVE_P (XFRAME (obj))
                    ? "#<frame " : "#<dead frame "),
-                  -1, -1, printcharfun, 0);
+                  -1, -1, printcharfun);
           print_string (XFRAME (obj)->name, printcharfun);
           sprintf (buf, " 0x%lx", (unsigned long) (XFRAME (obj)));
-          strout (buf, -1, -1, printcharfun, 0);
+          strout (buf, -1, -1, printcharfun);
           PRINTCHAR ('>');
         }
       else if (FONTP (obj))
@@ -1916,9 +1913,9 @@ print_object (Lisp_Object obj, register Lisp_Object printcharfun, int escapeflag
           if (! FONT_OBJECT_P (obj))
             {
               if (FONT_SPEC_P (obj))
-                strout ("#<font-spec", -1, -1, printcharfun, 0);
+                strout ("#<font-spec", -1, -1, printcharfun);
               else
-                strout ("#<font-entity", -1, -1, printcharfun, 0);
+                strout ("#<font-entity", -1, -1, printcharfun);
               for (i = 0; i < FONT_SPEC_MAX; i++)
                 {
                   PRINTCHAR (' ');
@@ -1931,7 +1928,7 @@ print_object (Lisp_Object obj, register Lisp_Object printcharfun, int escapeflag
             }
           else
             {
-              strout ("#<font-object ", -1, -1, printcharfun, 0);
+              strout ("#<font-object ", -1, -1, printcharfun);
               print_object (AREF (obj, FONT_NAME_INDEX), printcharfun,
                             escapeflag);
             }
@@ -1984,7 +1981,7 @@ print_object (Lisp_Object obj, register Lisp_Object printcharfun, int escapeflag
                 print_object (tem, printcharfun, escapeflag);
               }
             if (size < real_size)
-              strout (" ...", 4, 4, printcharfun, 0);
+              strout (" ...", 4, 4, printcharfun);
           }
           PRINTCHAR (']');
         }
@@ -1994,32 +1991,32 @@ print_object (Lisp_Object obj, register Lisp_Object printcharfun, int escapeflag
       switch (XMISCTYPE (obj))
         {
         case Lisp_Misc_Marker:
-          strout ("#<marker ", -1, -1, printcharfun, 0);
+          strout ("#<marker ", -1, -1, printcharfun);
           /* Do you think this is necessary?  */
           if (XMARKER (obj)->insertion_type != 0)
-            strout ("(moves after insertion) ", -1, -1, printcharfun, 0);
+            strout ("(moves after insertion) ", -1, -1, printcharfun);
           if (! XMARKER (obj)->buffer)
-            strout ("in no buffer", -1, -1, printcharfun, 0);
+            strout ("in no buffer", -1, -1, printcharfun);
           else
             {
               sprintf (buf, "at %ld", (long)marker_position (obj));
-              strout (buf, -1, -1, printcharfun, 0);
-              strout (" in ", -1, -1, printcharfun, 0);
+              strout (buf, -1, -1, printcharfun);
+              strout (" in ", -1, -1, printcharfun);
               print_string (BVAR (XMARKER (obj)->buffer, name), printcharfun);
             }
           PRINTCHAR ('>');
           break;
 
         case Lisp_Misc_Overlay:
-          strout ("#<overlay ", -1, -1, printcharfun, 0);
+          strout ("#<overlay ", -1, -1, printcharfun);
           if (! XMARKER (OVERLAY_START (obj))->buffer)
-            strout ("in no buffer", -1, -1, printcharfun, 0);
+            strout ("in no buffer", -1, -1, printcharfun);
           else
             {
               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);
+              strout (buf, -1, -1, printcharfun);
               print_string (BVAR (XMARKER (OVERLAY_START (obj))->buffer, name),
                             printcharfun);
             }
@@ -2029,15 +2026,15 @@ print_object (Lisp_Object obj, register Lisp_Object printcharfun, int escapeflag
       /* Remaining cases shouldn't happen in normal usage, but let's print
          them anyway for the benefit of the debugger.  */
         case Lisp_Misc_Free:
-          strout ("#<misc free cell>", -1, -1, printcharfun, 0);
+          strout ("#<misc free cell>", -1, -1, printcharfun);
           break;
 
         case Lisp_Misc_Save_Value:
-          strout ("#<save_value ", -1, -1, printcharfun, 0);
+          strout ("#<save_value ", -1, -1, printcharfun);
           sprintf(buf, "ptr=0x%08lx int=%d",
                   (unsigned long) XSAVE_VALUE (obj)->pointer,
                   XSAVE_VALUE (obj)->integer);
-          strout (buf, -1, -1, printcharfun, 0);
+          strout (buf, -1, -1, printcharfun);
           PRINTCHAR ('>');
           break;
 
@@ -2051,16 +2048,16 @@ print_object (Lisp_Object obj, register Lisp_Object printcharfun, int escapeflag
       {
         /* We're in trouble if this happens!
            Probably should just abort () */
-        strout ("#<EMACS BUG: INVALID DATATYPE ", -1, -1, printcharfun, 0);
+        strout ("#<EMACS BUG: INVALID DATATYPE ", -1, -1, printcharfun);
         if (MISCP (obj))
           sprintf (buf, "(MISC 0x%04x)", (int) XMISCTYPE (obj));
         else if (VECTORLIKEP (obj))
           sprintf (buf, "(PVEC 0x%08x)", (int) XVECTOR (obj)->size);
         else
           sprintf (buf, "(0x%02x)", (int) XTYPE (obj));
-        strout (buf, -1, -1, printcharfun, 0);
+        strout (buf, -1, -1, printcharfun);
         strout (" Save your buffers immediately and please report this bug>",
-                -1, -1, printcharfun, 0);
+                -1, -1, printcharfun);
       }
     }
 
diff --git a/src/process.c b/src/process.c
index c9b420ab2ae..1abfbd3f2a4 100644
--- a/src/process.c
+++ b/src/process.c
@@ -159,9 +159,6 @@ extern Lisp_Object QCfilter;
 #define SERIALCONN_P(p) (EQ (XPROCESS (p)->type, Qserial))
 #define SERIALCONN1_P(p) (EQ ((p)->type, Qserial))
 
-/* Define first descriptor number available for subprocesses.  */
-#define FIRST_PROC_DESC 3
-
 #ifndef HAVE_H_ERRNO
 extern int h_errno;
 #endif
@@ -278,10 +275,6 @@ static SELECT_TYPE connect_wait_mask;
 
 /* Number of bits set in connect_wait_mask.  */
 static int num_pending_connects;
-
-#define IF_NON_BLOCKING_CONNECT(s) s
-#else  /* NON_BLOCKING_CONNECT */
-#define IF_NON_BLOCKING_CONNECT(s)
 #endif  /* NON_BLOCKING_CONNECT */
 
 /* The largest descriptor currently in use for a process object.  */
@@ -1250,8 +1243,8 @@ Returns nil if format of ADDRESS is invalid.  */)
 static Lisp_Object
 list_processes_1 (Lisp_Object query_only)
 {
-  register Lisp_Object tail, tem;
-  Lisp_Object proc, minspace, tem1;
+  register Lisp_Object tail;
+  Lisp_Object proc, minspace;
   register struct Lisp_Process *p;
   char tembuf[300];
   int w_proc, w_buffer, w_tty;
@@ -1453,10 +1446,10 @@ list_processes_1 (Lisp_Object query_only)
         }
       else
         {
-          tem = p->command;
+          Lisp_Object tem = p->command;
           while (1)
             {
-              tem1 = Fcar (tem);
+              Lisp_Object tem1 = Fcar (tem);
               if (NILP (tem1))
                 break;
               Finsert (1, &tem1);
@@ -1519,11 +1512,11 @@ the command through a shell and redirect one of them using the shell
 syntax.
 
 usage: (start-process NAME BUFFER PROGRAM &rest PROGRAM-ARGS)  */)
-  (int nargs, register Lisp_Object *args)
+  (size_t nargs, register Lisp_Object *args)
 {
   Lisp_Object buffer, name, program, proc, current_dir, tem;
   register unsigned char **new_argv;
-  register int i;
+  register size_t i;
   int count = SPECPDL_INDEX ();
 
   buffer = args[1];
@@ -1729,7 +1722,7 @@ usage: (start-process NAME BUFFER PROGRAM &rest PROGRAM-ARGS)  */)
       new_argv = (unsigned char **) alloca ((nargs - 1) * sizeof (char *));
       new_argv[nargs - 2] = 0;
 
-      for (i = nargs - 3; i >= 0; i--)
+      for (i = nargs - 2; i-- != 0; )
         {
           new_argv[i] = SDATA (XCAR (tem));
           tem = XCDR (tem);
@@ -1919,8 +1912,7 @@ create_process (Lisp_Object process, char **new_argv, Lisp_Object current_dir)
     /* child_setup must clobber environ on systems with true vfork.
        Protect it from permanent change.  */
     char **save_environ = environ;
-
-    current_dir = ENCODE_FILE (current_dir);
+    volatile Lisp_Object encoded_current_dir = ENCODE_FILE (current_dir);
 
 #ifndef WINDOWSNT
     pid = vfork ();
@@ -2061,13 +2053,13 @@ create_process (Lisp_Object process, char **new_argv, Lisp_Object current_dir)
           child_setup_tty (xforkout);
 #ifdef WINDOWSNT
         pid = child_setup (xforkin, xforkout, xforkout,
-                           new_argv, 1, current_dir);
+                           new_argv, 1, encoded_current_dir);
 #else  /* not WINDOWSNT */
 #ifdef FD_CLOEXEC
         emacs_close (wait_child_setup[0]);
 #endif
         child_setup (xforkin, xforkout, xforkout,
-                     new_argv, 1, current_dir);
+                     new_argv, 1, encoded_current_dir);
 #endif /* not WINDOWSNT */
       }
     environ = save_environ;
@@ -2689,7 +2681,7 @@ Examples:
 \(serial-process-configure :port "\\\\.\\COM13" :bytesize 7)
 
 usage: (serial-process-configure &rest ARGS)  */)
-  (int nargs, Lisp_Object *args)
+  (size_t nargs, Lisp_Object *args)
 {
   struct Lisp_Process *p;
   Lisp_Object contact = Qnil;
@@ -2807,7 +2799,7 @@ Examples:
 \(make-serial-process :port "/dev/tty.BlueConsole-SPP-1" :speed nil)
 
 usage:  (make-serial-process &rest ARGS)  */)
-  (int nargs, Lisp_Object *args)
+  (size_t nargs, Lisp_Object *args)
 {
   int fd = -1;
   Lisp_Object proc, contact, port;
@@ -3085,7 +3077,7 @@ The original argument list, modified with the actual connection
 information, is available via the `process-contact' function.
 
 usage: (make-network-process &rest ARGS)  */)
-  (int nargs, Lisp_Object *args)
+  (size_t nargs, Lisp_Object *args)
 {
   Lisp_Object proc;
   Lisp_Object contact;
@@ -3401,9 +3393,12 @@ usage: (make-network-process &rest ARGS)  */)
 
   for (lres = res; lres; lres = lres->ai_next)
     {
-      int optn, optbits;
+      size_t optn;
+      int optbits;
 
+#ifdef WINDOWSNT
     retry_connect:
+#endif
 
       s = socket (lres->ai_family, lres->ai_socktype, lres->ai_protocol);
       if (s < 0)
@@ -3467,7 +3462,7 @@ usage: (make-network-process &rest ARGS)  */)
           if (EQ (service, Qt))
             {
               struct sockaddr_in sa1;
-              int len1 = sizeof (sa1);
+              socklen_t len1 = sizeof (sa1);
               if (getsockname (s, (struct sockaddr *)&sa1, &len1) == 0)
                 {
                   ((struct sockaddr_in *)(lres->ai_addr))->sin_port = sa1.sin_port;
@@ -3514,7 +3509,8 @@ usage: (make-network-process &rest ARGS)  */)
           /* Unlike most other syscalls connect() cannot be called
              again.  (That would return EALREADY.)  The proper way to
              wait for completion is select(). */
-          int sc, len;
+          int sc;
+          socklen_t len;
           SELECT_TYPE fdset;
         retry_select:
           FD_ZERO (&fdset);
@@ -3587,7 +3583,7 @@ usage: (make-network-process &rest ARGS)  */)
       if (!is_server)
         {
           struct sockaddr_in sa1;
-          int len1 = sizeof (sa1);
+          socklen_t len1 = sizeof (sa1);
           if (getsockname (s, (struct sockaddr *)&sa1, &len1) == 0)
             contact = Fplist_put (contact, QClocal,
                                   conv_sockaddr_to_lisp ((struct sockaddr *)&sa1, len1));
@@ -3705,10 +3701,10 @@ usage: (make-network-process &rest ARGS)  */)
 
   {
     /* Setup coding systems for communicating with the network stream.  */
-    struct gcpro gcpro1;
+    struct gcpro inner_gcpro1;
     /* Qt denotes we have not yet called Ffind_operation_coding_system.  */
     Lisp_Object coding_systems = Qt;
-    Lisp_Object args[5], val;
+    Lisp_Object fargs[5], val;
 
     if (!NILP (tem))
       {
@@ -3731,11 +3727,11 @@ usage: (make-network-process &rest ARGS)  */)
           coding_systems = Qnil;
         else
           {
-            args[0] = Qopen_network_stream, args[1] = name,
-              args[2] = buffer, args[3] = host, args[4] = service;
-            GCPRO1 (proc);
-            coding_systems = Ffind_operation_coding_system (5, args);
-            UNGCPRO;
+            fargs[0] = Qopen_network_stream, fargs[1] = name,
+              fargs[2] = buffer, fargs[3] = host, fargs[4] = service;
+            GCPRO1_VAR (proc, inner_gcpro);
+            coding_systems = Ffind_operation_coding_system (5, fargs);
+            UNGCPRO_VAR (inner_gcpro);
           }
         if (CONSP (coding_systems))
           val = XCAR (coding_systems);
@@ -3764,11 +3760,11 @@ usage: (make-network-process &rest ARGS)  */)
               coding_systems = Qnil;
             else
               {
-                args[0] = Qopen_network_stream, args[1] = name,
-                  args[2] = buffer, args[3] = host, args[4] = service;
-                GCPRO1 (proc);
-                coding_systems = Ffind_operation_coding_system (5, args);
-                UNGCPRO;
+                fargs[0] = Qopen_network_stream, fargs[1] = name,
+                  fargs[2] = buffer, fargs[3] = host, fargs[4] = service;
+                GCPRO1_VAR (proc, inner_gcpro);
+                coding_systems = Ffind_operation_coding_system (5, fargs);
+                UNGCPRO_VAR (inner_gcpro);
               }
           }
         if (CONSP (coding_systems))
@@ -3948,7 +3944,7 @@ FLAGS is the current flags of the interface.  */)
   CHECK_STRING (ifname);
 
   memset (rq.ifr_name, 0, sizeof rq.ifr_name);
-  strncpy (rq.ifr_name, SDATA (ifname), sizeof (rq.ifr_name));
+  strncpy (rq.ifr_name, SSDATA (ifname), sizeof (rq.ifr_name));
 
   s = socket (AF_INET, SOCK_STREAM, 0);
   if (s < 0)
@@ -4192,7 +4188,7 @@ server_accept_connection (Lisp_Object server, int channel)
     struct sockaddr_un un;
 #endif
   } saddr;
-  int len = sizeof saddr;
+  socklen_t len = sizeof saddr;
 
   s = accept (channel, &saddr.sa, &len);
 
@@ -4553,7 +4549,7 @@ wait_reading_process_output (int time_limit, int microsecs, int read_kbd,
               struct buffer *old_buffer = current_buffer;
               Lisp_Object old_window = selected_window;
 
-              timer_delay = timer_check (1);
+              timer_delay = timer_check ();
 
               /* If a timer has run, this might have changed buffers
                  an alike.  Make read_key_sequence aware of that.  */
@@ -4928,8 +4924,6 @@ wait_reading_process_output (int time_limit, int microsecs, int read_kbd,
             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)
@@ -5059,7 +5053,7 @@ wait_reading_process_output (int time_limit, int microsecs, int read_kbd,
               /* getsockopt(,,SO_ERROR,,) is said to hang on some systems.
                  So only use it on systems where it is known to work.  */
               {
-                int xlen = sizeof (xerrno);
+                socklen_t xlen = sizeof (xerrno);
                 if (getsockopt (channel, SOL_SOCKET, SO_ERROR, &xerrno, &xlen))
                   xerrno = errno;
               }
@@ -5128,9 +5122,9 @@ read_process_output_call (Lisp_Object fun_and_args)
 }
 
 static Lisp_Object
-read_process_output_error_handler (Lisp_Object error)
+read_process_output_error_handler (Lisp_Object error_val)
 {
-  cmd_error_internal (error, "error in process filter: ");
+  cmd_error_internal (error_val, "error in process filter: ");
   Vinhibit_quit = Qt;
   update_echo_area ();
   Fsleep_for (make_number (2), Qnil);
@@ -5171,7 +5165,7 @@ read_process_output (Lisp_Object proc, register int channel)
   /* We have a working select, so proc_buffered_char is always -1.  */
   if (DATAGRAM_CHAN_P (channel))
     {
-      int len = datagram_address[channel].len;
+      socklen_t len = datagram_address[channel].len;
       nbytes = recvfrom (channel, chars + carryover, readmax,
                          0, datagram_address[channel].sa, &len);
     }
@@ -5477,7 +5471,7 @@ read_process_output (Lisp_Object proc, register int channel)
 jmp_buf send_process_frame;
 Lisp_Object process_sent_to;
 
-static SIGTYPE
+static void
 send_process_trap (int ignore)
 {
   SIGNAL_THREAD_CHECK (SIGPIPE);
@@ -5504,7 +5498,7 @@ send_process (volatile Lisp_Object proc, const char *volatile buf,
   EMACS_INT rv;
   struct coding_system *coding;
   struct gcpro gcpro1;
-  SIGTYPE (*volatile old_sigpipe) (int);
+  void (*volatile old_sigpipe) (int);
 
   GCPRO1 (object);
 
@@ -5626,7 +5620,7 @@ send_process (volatile Lisp_Object proc, const char *volatile buf,
           while (this > 0)
             {
               int outfd = p->outfd;
-              old_sigpipe = (SIGTYPE (*) (int)) signal (SIGPIPE, send_process_trap);
+              old_sigpipe = (void (*) (int)) signal (SIGPIPE, send_process_trap);
 #ifdef DATAGRAM_SOCKETS
               if (DATAGRAM_CHAN_P (outfd))
                 {
@@ -5925,7 +5919,7 @@ process_send_signal (Lisp_Object process, int signo, Lisp_Object current_group,
 
       if (sig_char && *sig_char != CDISABLE)
         {
-          send_process (proc, sig_char, 1, Qnil);
+          send_process (proc, (char *) sig_char, 1, Qnil);
           return;
         }
       /* If we can't send the signal with a character,
@@ -6386,7 +6380,7 @@ process has been transmitted to the serial port.  */)
    indirectly; if it does, that is a bug  */
 
 #ifdef SIGCHLD
-static SIGTYPE
+static void
 sigchld_handler (int signo)
 {
   int old_errno = errno;
@@ -6534,9 +6528,9 @@ exec_sentinel_unwind (Lisp_Object data)
 }
 
 static Lisp_Object
-exec_sentinel_error_handler (Lisp_Object error)
+exec_sentinel_error_handler (Lisp_Object error_val)
 {
-  cmd_error_internal (error, "error in process sentinel: ");
+  cmd_error_internal (error_val, "error in process sentinel: ");
   Vinhibit_quit = Qt;
   update_echo_area ();
   Fsleep_for (make_number (2), Qnil);
@@ -6953,7 +6947,7 @@ wait_reading_process_output (int time_limit, int microsecs, int read_kbd,
           do
             {
               int old_timers_run = timers_run;
-              timer_delay = timer_check (1);
+              timer_delay = timer_check ();
               if (timers_run != old_timers_run && do_display)
                 /* We must retry, since a timer may have requeued itself
                    and that could alter the time delay.  */
diff --git a/src/region-cache.c b/src/region-cache.c
index 1f9b62da9fa..53ce0e9d802 100644
--- a/src/region-cache.c
+++ b/src/region-cache.c
@@ -290,37 +290,37 @@ move_cache_gap (struct region_cache *c, EMACS_INT pos, EMACS_INT min_size)
 }
 
 
-/* Insert a new boundary in cache C; it will have cache index INDEX,
+/* Insert a new boundary in cache C; it will have cache index I,
    and have the specified POS and VALUE.  */
 static void
-insert_cache_boundary (struct region_cache *c, EMACS_INT index, EMACS_INT pos,
+insert_cache_boundary (struct region_cache *c, EMACS_INT i, EMACS_INT pos,
                        int value)
 {
-  /* index must be a valid cache index.  */
-  if (index < 0 || index > c->cache_len)
+  /* i must be a valid cache index.  */
+  if (i < 0 || i > c->cache_len)
     abort ();
 
   /* We must never want to insert something before the dummy first
      boundary.  */
-  if (index == 0)
+  if (i == 0)
     abort ();
 
   /* We must only be inserting things in order.  */
-  if (! (BOUNDARY_POS (c, index-1) < pos
-         && (index == c->cache_len
-             || pos < BOUNDARY_POS (c, index))))
+  if (! (BOUNDARY_POS (c, i - 1) < pos
+         && (i == c->cache_len
+             || pos < BOUNDARY_POS (c, i))))
     abort ();
 
   /* The value must be different from the ones around it.  However, we
      temporarily create boundaries that establish the same value as
      the subsequent boundary, so we're not going to flag that case.  */
-  if (BOUNDARY_VALUE (c, index-1) == value)
+  if (BOUNDARY_VALUE (c, i - 1) == value)
     abort ();
 
-  move_cache_gap (c, index, 1);
+  move_cache_gap (c, i, 1);
 
-  c->boundaries[index].pos = pos - c->buffer_beg;
-  c->boundaries[index].value = value;
+  c->boundaries[i].pos = pos - c->buffer_beg;
+  c->boundaries[i].value = value;
   c->gap_start++;
   c->gap_len--;
   c->cache_len++;
@@ -808,4 +808,3 @@ pp_cache (struct region_cache *c)
       fprintf (stderr, "%ld : %d\n", (long)pos, BOUNDARY_VALUE (c, i));
     }
 }
-
diff --git a/src/region-cache.h b/src/region-cache.h
index 0da159285e4..8e4336c2885 100644
--- a/src/region-cache.h
+++ b/src/region-cache.h
@@ -111,3 +111,5 @@ extern int region_cache_backward (struct buffer *BUF,
                                   EMACS_INT POS,
                                   EMACS_INT *NEXT);
 
+/* For debugging.  */
+void pp_cache (struct region_cache *);
diff --git a/src/s/template.h b/src/s/template.h
index ee5afa81de4..4e0400e99e3 100644
--- a/src/s/template.h
+++ b/src/s/template.h
@@ -77,15 +77,6 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
    a file that someone else has modified in his Emacs.  */
 #define CLASH_DETECTION
 
-/* Define this if your operating system declares signal handlers to
-   have a type other than the usual.  `The usual' is `void' for ANSI C
-   systems (i.e. when the __STDC__ macro is defined), and `int' for
-   pre-ANSI systems.  If you're using GCC on an older system, __STDC__
-   will be defined, but the system's include files will still say that
-   signal returns int or whatever; in situations like that, define
-   this to be what the system's include files want.  */
-/* #define SIGTYPE int */
-
 /* If the character used to separate elements of the executable path
    is not ':', #define this to be the appropriate character constant.  */
 /* #define SEPCHAR ':' */
diff --git a/src/s/usg5-4-common.h b/src/s/usg5-4-common.h
index aeedd7f4b15..236f71e3007 100644
--- a/src/s/usg5-4-common.h
+++ b/src/s/usg5-4-common.h
@@ -38,9 +38,6 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 /* The docs for system V/386 suggest v.3 has sigpause, so let's try it.  */
 #define HAVE_SYSV_SIGPAUSE
 
-/* On USG systems signal handlers return void.  */
-#define SIGTYPE void
-
 /* Get FIONREAD from <sys/filio.h>.  Get <sys/ttold.h> to get struct tchars.
    But get <termio.h> first to make sure ttold.h doesn't interfere.
    And don't try to use SIGIO yet.  */
diff --git a/src/scroll.c b/src/scroll.c
index 33af18d2090..fcec596daa3 100644
--- a/src/scroll.c
+++ b/src/scroll.c
@@ -239,14 +239,16 @@ calculate_scrolling (FRAME_PTR frame,
    of lines.  */
 
 static void
-do_scrolling (struct frame *frame, struct glyph_matrix *current_matrix, struct matrix_elt *matrix, int window_size, int unchanged_at_top)
+do_scrolling (struct frame *frame, struct glyph_matrix *current_matrix,
+              struct matrix_elt *matrix, int window_size,
+              int unchanged_at_top)
 {
   struct matrix_elt *p;
   int i, j, k;
 
   /* Set to 1 if we have set a terminal window with
-     set_terminal_window.  */
-  int terminal_window_p = 0;
+     set_terminal_window.  It's unsigned to work around GCC bug 48228.  */
+  unsigned int terminal_window_p = 0;
 
   /* A queue for line insertions to be done.  */
   struct queue { int count, pos; };
@@ -831,7 +833,9 @@ scrolling_1 (FRAME_PTR frame, int window_size, int unchanged_at_top,
    such a line will have little weight.  */
 
 int
-scrolling_max_lines_saved (int start, int end, int *oldhash, int *newhash, int *cost)
+scrolling_max_lines_saved (int start, int end,
+                           int *oldhash, int *newhash,
+                           int *cost)
 {
   struct { int hash; int count; } lines[01000];
   register int i, h;
@@ -920,7 +924,8 @@ scroll_cost (FRAME_PTR frame, int from, int to, int amount)
    overhead and multiply factor values */
 
 static void
-line_ins_del (FRAME_PTR frame, int ov1, int pf1, int ovn, int pfn, register int *ov, register int *mf)
+line_ins_del (FRAME_PTR frame, int ov1, int pf1, int ovn, int pfn,
+              register int *ov, register int *mf)
 {
   register EMACS_INT i;
   register EMACS_INT frame_lines = FRAME_LINES (frame);
diff --git a/src/search.c b/src/search.c
index bf93a7fe442..682fa185bbb 100644
--- a/src/search.c
+++ b/src/search.c
@@ -95,10 +95,9 @@ static void save_search_regs (void);
 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 (EMACS_INT, unsigned char *, EMACS_INT, EMACS_INT,
-                              Lisp_Object, Lisp_Object,
-                              EMACS_INT, EMACS_INT,
-                              EMACS_INT, EMACS_INT, int);
+static EMACS_INT boyer_moore (EMACS_INT, unsigned char *, EMACS_INT,
+                              Lisp_Object, Lisp_Object, EMACS_INT,
+                              EMACS_INT, int);
 static EMACS_INT search_buffer (Lisp_Object, EMACS_INT, EMACS_INT,
                                 EMACS_INT, EMACS_INT, EMACS_INT, int,
                                 Lisp_Object, Lisp_Object, int);
@@ -1416,15 +1415,14 @@ search_buffer (Lisp_Object string, EMACS_INT pos, EMACS_INT pos_byte,
         }
 
       len_byte = pat - patbuf;
-      len = raw_pattern_size;
       pat = base_pat = patbuf;
 
       if (boyer_moore_ok)
-        return boyer_moore (n, pat, len, len_byte, trt, inverse_trt,
-                            pos, pos_byte, lim, lim_byte,
+        return boyer_moore (n, pat, len_byte, trt, inverse_trt,
+                            pos_byte, lim_byte,
                             char_base);
       else
-        return simple_search (n, pat, len, len_byte, trt,
+        return simple_search (n, pat, raw_pattern_size, len_byte, trt,
                               pos, pos_byte, lim, lim_byte);
     }
 }
@@ -1636,8 +1634,8 @@ simple_search (EMACS_INT n, unsigned char *pat,
 }
 
 /* Do Boyer-Moore search N times for the string BASE_PAT,
-   whose length is LEN/LEN_BYTE,
-   from buffer position POS/POS_BYTE until LIM/LIM_BYTE.
+   whose length is LEN_BYTE,
+   from buffer position POS_BYTE until LIM_BYTE.
    DIRECTION says which direction we search in.
    TRT and INVERSE_TRT are translation tables.
    Characters in PAT are already translated by TRT.
@@ -1652,10 +1650,10 @@ simple_search (EMACS_INT n, unsigned char *pat,
 
 static EMACS_INT
 boyer_moore (EMACS_INT n, unsigned char *base_pat,
-             EMACS_INT len, EMACS_INT len_byte,
+             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)
+             EMACS_INT pos_byte, EMACS_INT lim_byte,
+             int char_base)
 {
   int direction = ((n > 0) ? 1 : -1);
   register EMACS_INT dirlen;
@@ -1776,8 +1774,8 @@ boyer_moore (EMACS_INT n, unsigned char *base_pat,
             stride_for_teases = BM_tab[j];
 
           BM_tab[j] = dirlen - i;
-          /* A translation table is accompanied by its inverse -- see */
-          /* comment following downcase_table for details */
+          /* A translation table is accompanied by its inverse -- see
+             comment following downcase_table for details.  */
           if (ch >= 0)
             {
               int starting_ch = ch;
@@ -2636,11 +2634,8 @@ since only regular expressions have distinguished subexpressions.  */)
       EMACS_INT substed_alloc_size, substed_len;
       int buf_multibyte = !NILP (BVAR (current_buffer, enable_multibyte_characters));
       int str_multibyte = STRING_MULTIBYTE (newtext);
-      Lisp_Object rev_tbl;
       int really_changed = 0;
 
-      rev_tbl = Qnil;
-
       substed_alloc_size = length * 2 + 100;
       substed = (unsigned char *) xmalloc (substed_alloc_size + 1);
       substed_len = 0;
@@ -2660,7 +2655,7 @@ since only regular expressions have distinguished subexpressions.  */)
             {
               FETCH_STRING_CHAR_ADVANCE_NO_CHECK (c, newtext, pos, pos_byte);
               if (!buf_multibyte)
-                c = multibyte_char_to_unibyte (c, rev_tbl);
+                c = multibyte_char_to_unibyte (c);
             }
           else
             {
@@ -2683,7 +2678,7 @@ since only regular expressions have distinguished subexpressions.  */)
                   FETCH_STRING_CHAR_ADVANCE_NO_CHECK (c, newtext,
                                                       pos, pos_byte);
                   if (!buf_multibyte && !ASCII_CHAR_P (c))
-                    c = multibyte_char_to_unibyte (c, rev_tbl);
+                    c = multibyte_char_to_unibyte (c);
                 }
               else
                 {
diff --git a/src/sound.c b/src/sound.c
index 3a1668e4903..a2fe7ccc8ce 100644
--- a/src/sound.c
+++ b/src/sound.c
@@ -595,12 +595,12 @@ wav_play (struct sound *s, struct sound_device *sd)
      files I found so far.  If someone feels inclined to implement the
      whole RIFF-WAVE spec, please do.  */
   if (STRINGP (s->data))
-    sd->write (sd, SDATA (s->data) + sizeof *header,
+    sd->write (sd, SSDATA (s->data) + sizeof *header,
                SBYTES (s->data) - sizeof *header);
   else
     {
       char *buffer;
-      int nbytes;
+      int nbytes = 0;
       int blksize = sd->period_size ? sd->period_size (sd) : 2048;
       int data_left = header->data_length;
 
@@ -686,7 +686,7 @@ au_play (struct sound *s, struct sound_device *sd)
   sd->configure (sd);
 
   if (STRINGP (s->data))
-    sd->write (sd, SDATA (s->data) + header->data_offset,
+    sd->write (sd, SSDATA (s->data) + header->data_offset,
                SBYTES (s->data) - header->data_offset);
   else
     {
@@ -1104,7 +1104,6 @@ alsa_close (struct sound_device *sd)
 static void
 alsa_choose_format (struct sound_device *sd, struct sound *s)
 {
-  struct alsa_params *p = (struct alsa_params *) sd->data;
   if (s->type == RIFF)
     {
       struct wav_header *h = (struct wav_header *) s->header;
@@ -1410,7 +1409,7 @@ Internal use only, use `play-sound' instead.  */)
     {
       int len = SCHARS (attrs[SOUND_DEVICE]);
       current_sound_device->file = (char *) alloca (len + 1);
-      strcpy (current_sound_device->file, SDATA (attrs[SOUND_DEVICE]));
+      strcpy (current_sound_device->file, SSDATA (attrs[SOUND_DEVICE]));
     }
 
   if (INTEGERP (attrs[SOUND_VOLUME]))
@@ -1498,4 +1497,3 @@ init_sound (void)
 }
 
 #endif /* HAVE_SOUND */
-
diff --git a/src/syntax.c b/src/syntax.c
index c1442c396c1..0a1525b54ea 100644
--- a/src/syntax.c
+++ b/src/syntax.c
@@ -3265,9 +3265,9 @@ do { prev_from = from;				\
     = (curlevel == levelstart) ? -1 : (curlevel - 1)->last;
   state.location = from;
   state.levelstarts = Qnil;
-  while (--curlevel >= levelstart)
-      state.levelstarts = Fcons (make_number (curlevel->last),
-                                 state.levelstarts);
+  while (curlevel > levelstart)
+    state.levelstarts = Fcons (make_number ((--curlevel)->last),
+                               state.levelstarts);
   immediate_quit = 0;
 
   *stateptr = state;
diff --git a/src/sysdep.c b/src/sysdep.c
index 6ef3d88c5c8..1bb400421f0 100644
--- a/src/sysdep.c
+++ b/src/sysdep.c
@@ -449,7 +449,7 @@ child_setup_tty (int out)
 struct save_signal
 {
   int code;
-  SIGTYPE (*handler) (int);
+  void (*handler) (int);
 };
 
 static void save_signal_handlers (struct save_signal *);
@@ -488,7 +488,8 @@ sys_subshell (void)
   int pid;
   struct save_signal saved_handlers[5];
   Lisp_Object dir;
-  unsigned char * IF_LINT (volatile) str = 0;
+  unsigned char *volatile str_volatile = 0;
+  unsigned char *str;
   int len;
 
   saved_handlers[0].code = SIGINT;
@@ -512,7 +513,7 @@ sys_subshell (void)
     goto xyzzy;
 
   dir = expand_and_dir_to_file (Funhandled_file_name_directory (dir), Qnil);
-  str = (unsigned char *) alloca (SCHARS (dir) + 2);
+  str_volatile = str = (unsigned char *) alloca (SCHARS (dir) + 2);
   len = SCHARS (dir);
   memcpy (str, SDATA (dir), len);
   if (str[len - 1] != '/') str[len++] = '/';
@@ -544,6 +545,7 @@ sys_subshell (void)
         sh = "sh";
 
       /* Use our buffer's default directory for the subshell.  */
+      str = str_volatile;
       if (str && chdir ((char *) str) != 0)
         {
 #ifndef DOS_NT
@@ -606,7 +608,7 @@ save_signal_handlers (struct save_signal *saved_handlers)
   while (saved_handlers->code)
     {
       saved_handlers->handler
-        = (SIGTYPE (*) (int)) signal (saved_handlers->code, SIG_IGN);
+        = (void (*) (int)) signal (saved_handlers->code, SIG_IGN);
       saved_handlers++;
     }
 }
diff --git a/src/syssignal.h b/src/syssignal.h
index 7b4070322d6..03768168e20 100644
--- a/src/syssignal.h
+++ b/src/syssignal.h
@@ -69,7 +69,7 @@ extern sigset_t sys_sigmask ();
 
 /* Whether this is what all systems want or not, this is what
    appears to be assumed in the source, for example data.c:arith_error.  */
-typedef RETSIGTYPE (*signal_handler_t) (int);
+typedef void (*signal_handler_t) (int);
 
 signal_handler_t sys_signal (int signal_number, signal_handler_t action);
 sigset_t sys_sigblock   (sigset_t new_mask);
diff --git a/src/term.c b/src/term.c
index e84bbe125f8..fc7726298c5 100644
--- a/src/term.c
+++ b/src/term.c
@@ -1952,7 +1952,7 @@ produce_glyphless_glyph (struct it *it, int for_no_font, Lisp_Object acronym)
 
   it->pixel_width = len;
   it->nglyphs = len;
-  if (len > 0 && it->glyph_row)
+  if (it->glyph_row)
     append_glyphless_glyph (it, face_id, str);
 }
 
@@ -2500,13 +2500,10 @@ A suspended tty may be resumed by calling `resume-tty' on it.  */)
       /* First run `suspend-tty-functions' and then clean up the tty
          state because `suspend-tty-functions' might need to change
          the tty state.  */
-      if (!NILP (Vrun_hooks))
-        {
-          Lisp_Object args[2];
-          args[0] = intern ("suspend-tty-functions");
-          XSETTERMINAL (args[1], t);
-          Frun_hook_with_args (2, args);
-        }
+      Lisp_Object args[2];
+      args[0] = intern ("suspend-tty-functions");
+      XSETTERMINAL (args[1], t);
+      Frun_hook_with_args (2, args);
 
       reset_sys_modes (t->display_info.tty);
       delete_keyboard_wait_descriptor (fileno (f));
@@ -2596,14 +2593,13 @@ frame's terminal). */)
 
       init_sys_modes (t->display_info.tty);
 
-      /* Run `resume-tty-functions'.  */
-      if (!NILP (Vrun_hooks))
-        {
-          Lisp_Object args[2];
-          args[0] = intern ("resume-tty-functions");
-          XSETTERMINAL (args[1], t);
-          Frun_hook_with_args (2, args);
-        }
+      {
+        /* Run `resume-tty-functions'.  */
+        Lisp_Object args[2];
+        args[0] = intern ("resume-tty-functions");
+        XSETTERMINAL (args[1], t);
+        Frun_hook_with_args (2, args);
+      }
     }
 
   set_tty_hooks (t);
diff --git a/src/terminfo.c b/src/terminfo.c
index 905a8edacc7..c0418984efa 100644
--- a/src/terminfo.c
+++ b/src/terminfo.c
@@ -17,6 +17,8 @@ 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 "tparam.h"
+
 #include <setjmp.h>
 #include "lisp.h"
 
@@ -33,18 +35,19 @@ char *UP, *BC, PC;
    format is different too.
 */
 
+extern char *tparm (const char *str, ...);
+
+
 char *
-tparam (char *string, char *outstring,
-        int len, int arg1, int arg2, int arg3, int arg4,
-        int arg5, int arg6, int arg7, int arg8, int arg9)
+tparam (const char *string, char *outstring, int len,
+        int arg1, int arg2, int arg3, int arg4)
 {
   char *temp;
-  extern char *tparm (char *str, ...);
 
-  temp = tparm (string, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
-  if (outstring == 0)
-    outstring = ((char *) (xmalloc ((strlen (temp)) + 1)));
-  strcpy (outstring, temp);
-  return outstring;
-}
+  /* Emacs always should pass a null OUTSTRING and zero LEN.  */
+  if (outstring || len)
+    abort ();
 
+  temp = tparm (string, arg1, arg2, arg3, arg4);
+  return xstrdup (temp);
+}
diff --git a/src/textprop.c b/src/textprop.c
index 5db6033670b..cd89efeb38d 100644
--- a/src/textprop.c
+++ b/src/textprop.c
@@ -974,37 +974,6 @@ past position LIMIT; return LIMIT if nothing is found before LIMIT.  */)
     return make_number (next->position);
 }
 
-/* Return 1 if there's a change in some property between BEG and END.  */
-
-int
-property_change_between_p (EMACS_INT beg, EMACS_INT end)
-{
-  register INTERVAL i, next;
-  Lisp_Object object, pos;
-
-  XSETBUFFER (object, current_buffer);
-  XSETFASTINT (pos, beg);
-
-  i = validate_interval_range (object, &pos, &pos, soft);
-  if (NULL_INTERVAL_P (i))
-    return 0;
-
-  next = next_interval (i);
-  while (! NULL_INTERVAL_P (next) && intervals_equal (i, next))
-    {
-      next = next_interval (next);
-      if (NULL_INTERVAL_P (next))
-        return 0;
-      if (next->position >= end)
-        return 0;
-    }
-
-  if (NULL_INTERVAL_P (next))
-    return 0;
-
-  return 1;
-}
-
 DEFUN ("next-single-property-change", Fnext_single_property_change,
        Snext_single_property_change, 2, 4, 0,
        doc: /* Return the position of next property change for a specific property.
@@ -2331,4 +2300,3 @@ inherits it if NONSTICKINESS is nil.  The `front-sticky' and
 /*  defsubr (&Serase_text_properties); */
 /*  defsubr (&Scopy_text_properties); */
 }
-
diff --git a/src/tparam.h b/src/tparam.h
index 3cd3e6053cc..dc4cdfaa28c 100644
--- a/src/tparam.h
+++ b/src/tparam.h
@@ -29,3 +29,7 @@ char *tgetstr (const char *, char **);
 char *tgoto (const char *, int, int);
 
 char *tparam (const char *, char *, int, int, int, int, int);
+
+extern char PC;
+extern char *BC;
+extern char *UP;
diff --git a/src/unexelf.c b/src/unexelf.c
index b58c78501b8..8b45894f853 100644
--- a/src/unexelf.c
+++ b/src/unexelf.c
@@ -651,7 +651,9 @@ unexec (const char *new_name, const char *old_name)
   int n, nn;
   int old_bss_index, old_sbss_index, old_plt_index;
   int old_data_index, new_data2_index;
+#if defined _SYSTYPE_SYSV || defined __sgi
   int old_mdebug_index;
+#endif
   struct stat stat_buf;
   int old_file_size;
 
@@ -695,8 +697,10 @@ unexec (const char *new_name, const char *old_name)
 
   /* Find the mdebug section, if any.  */
 
+#if defined _SYSTYPE_SYSV || defined __sgi
   old_mdebug_index = find_section (".mdebug", old_section_names,
                                    old_name, old_file_h, old_section_h, 1);
+#endif
 
   /* Find the old .bss section.  Figure out parameters of the new
      data2 and bss sections.  */
diff --git a/src/unexw32.c b/src/unexw32.c
index cd8211d6bee..e03fa6c9b9a 100644
--- a/src/unexw32.c
+++ b/src/unexw32.c
@@ -341,7 +341,6 @@ get_section_info (file_data *p_infile)
 {
   PIMAGE_DOS_HEADER dos_header;
   PIMAGE_NT_HEADERS nt_header;
-  PIMAGE_SECTION_HEADER section;
   int overlap;
 
   dos_header = (PIMAGE_DOS_HEADER) p_infile->file_base;
diff --git a/src/w32.c b/src/w32.c
index 721cea07d20..da403671115 100644
--- a/src/w32.c
+++ b/src/w32.c
@@ -1505,6 +1505,7 @@ w32_get_resource (char *key, LPDWORD lpdwtype)
 }
 
 char *get_emacs_configuration (void);
+
 void
 init_environment (char ** argv)
 {
@@ -1591,25 +1592,25 @@ init_environment (char ** argv)
        If not, then we can try to default to the appdata directory under the
        user's profile, which is more likely to be writable.   */
     if (stat ("C:/.emacs", &ignored) < 0)
-    {
-      HRESULT profile_result;
-      /* Dynamically load ShGetFolderPath, as it won't exist on versions
-         of Windows 95 and NT4 that have not been updated to include
-         MSIE 5.  */
-      ShGetFolderPath_fn get_folder_path;
-      get_folder_path = (ShGetFolderPath_fn)
-        GetProcAddress (GetModuleHandle ("shell32.dll"), "SHGetFolderPathA");
-
-      if (get_folder_path != NULL)
-        {
-          profile_result = get_folder_path (NULL, CSIDL_APPDATA, NULL,
-                                            0, default_home);
+      {
+        HRESULT profile_result;
+        /* Dynamically load ShGetFolderPath, as it won't exist on versions
+           of Windows 95 and NT4 that have not been updated to include
+           MSIE 5.  */
+        ShGetFolderPath_fn get_folder_path;
+        get_folder_path = (ShGetFolderPath_fn)
+          GetProcAddress (GetModuleHandle ("shell32.dll"), "SHGetFolderPathA");
+
+        if (get_folder_path != NULL)
+          {
+            profile_result = get_folder_path (NULL, CSIDL_APPDATA, NULL,
+                                              0, default_home);
 
-          /* If we can't get the appdata dir, revert to old behavior.  */
-          if (profile_result == S_OK)
-            env_vars[0].def_value = default_home;
-        }
-    }
+            /* If we can't get the appdata dir, revert to old behavior.  */
+            if (profile_result == S_OK)
+              env_vars[0].def_value = default_home;
+          }
+      }
 
   /* Get default locale info and use it for LANG.  */
   if (GetLocaleInfo (LOCALE_USER_DEFAULT,
@@ -2082,42 +2083,42 @@ GetCachedVolumeInformation (char * root_dir)
   info = lookup_volume_info (root_dir);
 
   if (info == NULL || ! VOLINFO_STILL_VALID (root_dir, info))
-  {
-    char  name[ 256 ];
-    DWORD serialnum;
-    DWORD maxcomp;
-    DWORD flags;
-    char  type[ 256 ];
-
-    /* Info is not cached, or is stale. */
-    if (!GetVolumeInformation (root_dir,
-                               name, sizeof (name),
-                               &serialnum,
-                               &maxcomp,
-                               &flags,
-                               type, sizeof (type)))
-      return NULL;
+    {
+      char  name[ 256 ];
+      DWORD serialnum;
+      DWORD maxcomp;
+      DWORD flags;
+      char  type[ 256 ];
+
+      /* Info is not cached, or is stale. */
+      if (!GetVolumeInformation (root_dir,
+                                 name, sizeof (name),
+                                 &serialnum,
+                                 &maxcomp,
+                                 &flags,
+                                 type, sizeof (type)))
+        return NULL;
 
-    /* Cache the volume information for future use, overwriting existing
-       entry if present.  */
-    if (info == NULL)
-      {
-        info = (volume_info_data *) xmalloc (sizeof (volume_info_data));
-        add_volume_info (root_dir, info);
-      }
-    else
-      {
-        xfree (info->name);
-        xfree (info->type);
-      }
+      /* Cache the volume information for future use, overwriting existing
+         entry if present.  */
+      if (info == NULL)
+        {
+          info = (volume_info_data *) xmalloc (sizeof (volume_info_data));
+          add_volume_info (root_dir, info);
+        }
+      else
+        {
+          xfree (info->name);
+          xfree (info->type);
+        }
 
-    info->name = xstrdup (name);
-    info->serialnum = serialnum;
-    info->maxcomp = maxcomp;
-    info->flags = flags;
-    info->type = xstrdup (type);
-    info->timestamp = GetTickCount ();
-  }
+      info->name = xstrdup (name);
+      info->serialnum = serialnum;
+      info->maxcomp = maxcomp;
+      info->flags = flags;
+      info->type = xstrdup (type);
+      info->timestamp = GetTickCount ();
+    }
 
   return info;
 }
@@ -2376,8 +2377,8 @@ readdir (DIR *dirp)
   if (wnet_enum_handle != INVALID_HANDLE_VALUE)
     {
       if (!read_unc_volume (wnet_enum_handle,
-                              dir_find_data.cFileName,
-                              MAX_PATH))
+                            dir_find_data.cFileName,
+                            MAX_PATH))
         return NULL;
     }
   /* If we aren't dir_finding, do a find-first, otherwise do a find-next. */
@@ -2487,7 +2488,7 @@ read_unc_volume (HANDLE henum, char *readbuf, int size)
 
   count = 1;
   buffer = alloca (bufsize);
-  result = WNetEnumResource (wnet_enum_handle, &count, buffer, &bufsize);
+  result = WNetEnumResource (henum, &count, buffer, &bufsize);
   if (result != NO_ERROR)
     return NULL;
 
@@ -3250,8 +3251,6 @@ int
 stat (const char * path, struct stat * buf)
 {
   char *name, *r;
-  char drive_root[4];
-  UINT devtype;
   WIN32_FIND_DATA wfd;
   HANDLE fh;
   unsigned __int64 fake_inode;
@@ -4043,7 +4042,6 @@ system_process_attributes (Lisp_Object pid)
   TOKEN_PRIMARY_GROUP group_token;
   unsigned euid;
   unsigned egid;
-  DWORD sess;
   PROCESS_MEMORY_COUNTERS mem;
   PROCESS_MEMORY_COUNTERS_EX mem_ex;
   DWORD minrss, maxrss;
@@ -4520,75 +4518,75 @@ struct {
   int errnum;
   char * msg;
 } _wsa_errlist[] = {
-  WSAEINTR                , "Interrupted function call",
-  WSAEBADF                , "Bad file descriptor",
-  WSAEACCES               , "Permission denied",
-  WSAEFAULT               , "Bad address",
-  WSAEINVAL               , "Invalid argument",
-  WSAEMFILE               , "Too many open files",
-
-  WSAEWOULDBLOCK          , "Resource temporarily unavailable",
-  WSAEINPROGRESS          , "Operation now in progress",
-  WSAEALREADY             , "Operation already in progress",
-  WSAENOTSOCK             , "Socket operation on non-socket",
-  WSAEDESTADDRREQ         , "Destination address required",
-  WSAEMSGSIZE             , "Message too long",
-  WSAEPROTOTYPE           , "Protocol wrong type for socket",
-  WSAENOPROTOOPT          , "Bad protocol option",
-  WSAEPROTONOSUPPORT      , "Protocol not supported",
-  WSAESOCKTNOSUPPORT      , "Socket type not supported",
-  WSAEOPNOTSUPP           , "Operation not supported",
-  WSAEPFNOSUPPORT         , "Protocol family not supported",
-  WSAEAFNOSUPPORT         , "Address family not supported by protocol family",
-  WSAEADDRINUSE           , "Address already in use",
-  WSAEADDRNOTAVAIL        , "Cannot assign requested address",
-  WSAENETDOWN             , "Network is down",
-  WSAENETUNREACH          , "Network is unreachable",
-  WSAENETRESET            , "Network dropped connection on reset",
-  WSAECONNABORTED         , "Software caused connection abort",
-  WSAECONNRESET           , "Connection reset by peer",
-  WSAENOBUFS              , "No buffer space available",
-  WSAEISCONN              , "Socket is already connected",
-  WSAENOTCONN             , "Socket is not connected",
-  WSAESHUTDOWN            , "Cannot send after socket shutdown",
-  WSAETOOMANYREFS         , "Too many references",          /* not sure */
-  WSAETIMEDOUT            , "Connection timed out",
-  WSAECONNREFUSED         , "Connection refused",
-  WSAELOOP                , "Network loop",                 /* not sure */
-  WSAENAMETOOLONG         , "Name is too long",
-  WSAEHOSTDOWN            , "Host is down",
-  WSAEHOSTUNREACH         , "No route to host",
-  WSAENOTEMPTY            , "Buffer not empty",             /* not sure */
-  WSAEPROCLIM             , "Too many processes",
-  WSAEUSERS               , "Too many users",               /* not sure */
-  WSAEDQUOT               , "Double quote in host name",    /* really not sure */
-  WSAESTALE               , "Data is stale",                /* not sure */
-  WSAEREMOTE              , "Remote error",                 /* not sure */
-
-  WSASYSNOTREADY          , "Network subsystem is unavailable",
-  WSAVERNOTSUPPORTED      , "WINSOCK.DLL version out of range",
-  WSANOTINITIALISED       , "Winsock not initialized successfully",
-  WSAEDISCON              , "Graceful shutdown in progress",
+  {WSAEINTR                , "Interrupted function call"},
+  {WSAEBADF                , "Bad file descriptor"},
+  {WSAEACCES               , "Permission denied"},
+  {WSAEFAULT               , "Bad address"},
+  {WSAEINVAL               , "Invalid argument"},
+  {WSAEMFILE               , "Too many open files"},
+
+  {WSAEWOULDBLOCK          , "Resource temporarily unavailable"},
+  {WSAEINPROGRESS          , "Operation now in progress"},
+  {WSAEALREADY             , "Operation already in progress"},
+  {WSAENOTSOCK             , "Socket operation on non-socket"},
+  {WSAEDESTADDRREQ         , "Destination address required"},
+  {WSAEMSGSIZE             , "Message too long"},
+  {WSAEPROTOTYPE           , "Protocol wrong type for socket"},
+  {WSAENOPROTOOPT          , "Bad protocol option"},
+  {WSAEPROTONOSUPPORT      , "Protocol not supported"},
+  {WSAESOCKTNOSUPPORT      , "Socket type not supported"},
+  {WSAEOPNOTSUPP           , "Operation not supported"},
+  {WSAEPFNOSUPPORT         , "Protocol family not supported"},
+  {WSAEAFNOSUPPORT         , "Address family not supported by protocol family"},
+  {WSAEADDRINUSE           , "Address already in use"},
+  {WSAEADDRNOTAVAIL        , "Cannot assign requested address"},
+  {WSAENETDOWN             , "Network is down"},
+  {WSAENETUNREACH          , "Network is unreachable"},
+  {WSAENETRESET            , "Network dropped connection on reset"},
+  {WSAECONNABORTED         , "Software caused connection abort"},
+  {WSAECONNRESET           , "Connection reset by peer"},
+  {WSAENOBUFS              , "No buffer space available"},
+  {WSAEISCONN              , "Socket is already connected"},
+  {WSAENOTCONN             , "Socket is not connected"},
+  {WSAESHUTDOWN            , "Cannot send after socket shutdown"},
+  {WSAETOOMANYREFS         , "Too many references"},        /* not sure */
+  {WSAETIMEDOUT            , "Connection timed out"},
+  {WSAECONNREFUSED         , "Connection refused"},
+  {WSAELOOP                , "Network loop"},               /* not sure */
+  {WSAENAMETOOLONG         , "Name is too long"},
+  {WSAEHOSTDOWN            , "Host is down"},
+  {WSAEHOSTUNREACH         , "No route to host"},
+  {WSAENOTEMPTY            , "Buffer not empty"},           /* not sure */
+  {WSAEPROCLIM             , "Too many processes"},
+  {WSAEUSERS               , "Too many users"},             /* not sure */
+  {WSAEDQUOT               , "Double quote in host name"},  /* really not sure */
+  {WSAESTALE               , "Data is stale"},              /* not sure */
+  {WSAEREMOTE              , "Remote error"},               /* not sure */
+
+  {WSASYSNOTREADY          , "Network subsystem is unavailable"},
+  {WSAVERNOTSUPPORTED      , "WINSOCK.DLL version out of range"},
+  {WSANOTINITIALISED       , "Winsock not initialized successfully"},
+  {WSAEDISCON              , "Graceful shutdown in progress"},
 #ifdef WSAENOMORE
-  WSAENOMORE              , "No more operations allowed",   /* not sure */
-  WSAECANCELLED           , "Operation cancelled",          /* not sure */
-  WSAEINVALIDPROCTABLE    , "Invalid procedure table from service provider",
-  WSAEINVALIDPROVIDER     , "Invalid service provider version number",
-  WSAEPROVIDERFAILEDINIT  , "Unable to initialize a service provider",
-  WSASYSCALLFAILURE       , "System call failure",
-  WSASERVICE_NOT_FOUND    , "Service not found",            /* not sure */
-  WSATYPE_NOT_FOUND       , "Class type not found",
-  WSA_E_NO_MORE           , "No more resources available",  /* really not sure */
-  WSA_E_CANCELLED         , "Operation already cancelled",  /* really not sure */
-  WSAEREFUSED             , "Operation refused",            /* not sure */
+  {WSAENOMORE              , "No more operations allowed"}, /* not sure */
+  {WSAECANCELLED           , "Operation cancelled"},        /* not sure */
+  {WSAEINVALIDPROCTABLE    , "Invalid procedure table from service provider"},
+  {WSAEINVALIDPROVIDER     , "Invalid service provider version number"},
+  {WSAEPROVIDERFAILEDINIT  , "Unable to initialize a service provider"},
+  {WSASYSCALLFAILURE       , "System call failure"},
+  {WSASERVICE_NOT_FOUND    , "Service not found"},          /* not sure */
+  {WSATYPE_NOT_FOUND       , "Class type not found"},
+  {WSA_E_NO_MORE           , "No more resources available"}, /* really not sure */
+  {WSA_E_CANCELLED         , "Operation already cancelled"}, /* really not sure */
+  {WSAEREFUSED             , "Operation refused"},          /* not sure */
 #endif
 
-  WSAHOST_NOT_FOUND       , "Host not found",
-  WSATRY_AGAIN            , "Authoritative host not found during name lookup",
-  WSANO_RECOVERY          , "Non-recoverable error during name lookup",
-  WSANO_DATA              , "Valid name, no data record of requested type",
+  {WSAHOST_NOT_FOUND       , "Host not found"},
+  {WSATRY_AGAIN            , "Authoritative host not found during name lookup"},
+  {WSANO_RECOVERY          , "Non-recoverable error during name lookup"},
+  {WSANO_DATA              , "Valid name, no data record of requested type"},
 
-  -1, NULL
+  {-1, NULL}
 };
 
 char *
@@ -5408,7 +5406,6 @@ sys_read (int fd, char * buffer, unsigned int count)
             {
               HANDLE hnd = fd_info[fd].hnd;
               OVERLAPPED *ovl = &fd_info[fd].cp->ovl_read;
-              DWORD err = 0;
               int rc = 0;
               COMMTIMEOUTS ct;
 
diff --git a/src/w32fns.c b/src/w32fns.c
index 0c899cdceff..821cc671646 100644
--- a/src/w32fns.c
+++ b/src/w32fns.c
@@ -183,7 +183,7 @@ unsigned int msh_mousewheel = 0;
 #define MENU_FREE_DELAY 1000
 static unsigned menu_free_timer = 0;
 
-#ifdef GLYPH_DEBUG
+#if GLYPH_DEBUG
 int image_cache_refcount, dpyinfo_refcount;
 #endif
 
@@ -1527,7 +1527,6 @@ void
 x_set_menu_bar_lines (struct frame *f, Lisp_Object value, Lisp_Object oldval)
 {
   int nlines;
-  int olines = FRAME_MENU_BAR_LINES (f);
 
   /* Right now, menu bars don't work properly in minibuf-only frames;
      most of the commands try to apply themselves to the minibuffer
@@ -2863,7 +2862,6 @@ w32_wnd_proc (HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
                          base character (ie. translating the base key plus
                          shift modifier).  */
                       int add;
-                      int isdead = 0;
                       KEY_EVENT_RECORD key;
 
                       key.bKeyDown = TRUE;
@@ -2951,7 +2949,7 @@ w32_wnd_proc (HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
           HIMC context = get_ime_context_fn (hwnd);
           wmsg.dwModifiers = w32_get_key_modifiers (wParam, lParam);
           /* Get buffer size.  */
-          size = get_composition_string_fn (context, GCS_RESULTSTR, buffer, 0);
+          size = get_composition_string_fn (context, GCS_RESULTSTR, NULL, 0);
           buffer = alloca (size);
           size = get_composition_string_fn (context, GCS_RESULTSTR,
                                             buffer, size);
@@ -3981,7 +3979,7 @@ unwind_create_frame (Lisp_Object frame)
   /* If frame is ``official'', nothing to do.  */
   if (!CONSP (Vframe_list) || !EQ (XCAR (Vframe_list), frame))
     {
-#ifdef GLYPH_DEBUG
+#if GLYPH_DEBUG
       struct w32_display_info *dpyinfo = FRAME_W32_DISPLAY_INFO (f);
 #endif
 
@@ -4522,8 +4520,6 @@ DISPLAY should be either a frame or a display name (a string).
 If omitted or nil, that stands for the selected frame's display.  */)
   (Lisp_Object display)
 {
-  struct w32_display_info *dpyinfo = check_x_display_info (display);
-
   return make_number (1);
 }
 
@@ -4820,7 +4816,6 @@ If DISPLAY is nil, that stands for the selected frame's display.  */)
   (Lisp_Object display)
 {
   struct w32_display_info *dpyinfo = check_x_display_info (display);
-  int i;
 
   if (dpyinfo->reference_count > 0)
     error ("Display still has frames on it");
@@ -5173,7 +5168,7 @@ x_create_tip_frame (struct w32_display_info *dpyinfo,
                     Lisp_Object parms, Lisp_Object text)
 {
   struct frame *f;
-  Lisp_Object frame, tem;
+  Lisp_Object frame;
   Lisp_Object name;
   long window_prompting = 0;
   int width, height;
diff --git a/src/w32font.c b/src/w32font.c
index 40ff0782b88..d86107bc6d5 100644
--- a/src/w32font.c
+++ b/src/w32font.c
@@ -533,6 +533,7 @@ w32font_draw (struct glyph_string *s, int from, int to,
 {
   UINT options;
   HRGN orig_clip = NULL;
+  int len = to - from;
   struct w32font_info *w32font = (struct w32font_info *) s->font;
 
   options = w32font->glyph_idx;
@@ -581,14 +582,14 @@ w32font_draw (struct glyph_string *s, int from, int to,
 
   if (s->padding_p)
     {
-      int len = to - from, i;
+      int i;
 
       for (i = 0; i < len; i++)
         ExtTextOutW (s->hdc, x + i, y, options, NULL,
                      s->char2b + from + i, 1, NULL);
     }
   else
-    ExtTextOutW (s->hdc, x, y, options, NULL, s->char2b + from, to - from, NULL);
+    ExtTextOutW (s->hdc, x, y, options, NULL, s->char2b + from, len, NULL);
 
   /* Restore clip region.  */
   if (s->num_clips > 0)
@@ -596,6 +597,8 @@ w32font_draw (struct glyph_string *s, int from, int to,
 
   if (orig_clip)
     DeleteObject (orig_clip);
+
+  return len;
 }
 
 /* w32 implementation of free_entity for font backend.
@@ -774,7 +777,7 @@ int
 w32font_open_internal (FRAME_PTR f, Lisp_Object font_entity,
                        int pixel_size, Lisp_Object font_object)
 {
-  int len, size, i;
+  int len, size;
   LOGFONT logfont;
   HDC dc;
   HFONT hfont, old_font;
@@ -2418,6 +2421,7 @@ struct font_driver w32font_driver =
     NULL, /* check */
     NULL, /* get_variation_glyphs */
     w32font_filter_properties,
+    NULL, /* cached_font_ok */
   };
 
 
diff --git a/src/w32inevt.c b/src/w32inevt.c
index c4858dea908..465f5ccb70f 100644
--- a/src/w32inevt.c
+++ b/src/w32inevt.c
@@ -677,7 +677,6 @@ w32_console_read_socket (struct terminal *terminal,
                          int expected,
                          struct input_event *hold_quit)
 {
-  BOOL no_events = TRUE;
   int nev, ret = 0, add;
   int isdead;
 
diff --git a/src/w32menu.c b/src/w32menu.c
index a2e62f24f6a..f092ff87bf2 100644
--- a/src/w32menu.c
+++ b/src/w32menu.c
@@ -1320,7 +1320,6 @@ utf8to16 (unsigned char * src, int len, WCHAR * dest)
 {
   while (len > 0)
     {
-      int utf16;
       if (*src < 0x80)
         {
           *dest = (WCHAR) *src;
@@ -1546,8 +1545,6 @@ add_menu_item (HMENU menu, widget_value *wv, HMENU item)
 static int
 fill_in_menu (HMENU menu, widget_value *wv)
 {
-  int items_added = 0;
-
   for ( ; wv != NULL; wv = wv->next)
     {
       if (wv->contents)
@@ -1619,7 +1616,7 @@ w32_menu_display_help (HWND owner, HMENU menu, UINT item, UINT flags)
       else
         /* X version has a loop through frames here, which doesn't
            appear to do anything, unless it has some side effect.  */
-        show_help_echo (help, Qnil, Qnil, Qnil, 1);
+        show_help_echo (help, Qnil, Qnil, Qnil);
     }
 }
 
diff --git a/src/w32term.c b/src/w32term.c
index f31c4e90e77..f6a6ba3e82f 100644
--- a/src/w32term.c
+++ b/src/w32term.c
@@ -160,7 +160,6 @@ int last_scroll_bar_drag_pos;
 /* Where the mouse was last time we reported a mouse event.  */
 static RECT last_mouse_glyph;
 static FRAME_PTR last_mouse_glyph_frame;
-static Lisp_Object last_mouse_press_frame;
 
 /* The scroll bar in which the last motion event occurred.
 
@@ -1069,16 +1068,12 @@ x_set_glyph_string_clipping (struct glyph_string *s)
     w32_set_clip_rectangle (s->hdc, r);
   else if (n > 1)
     {
-      HRGN full_clip, clip1, clip2;
-      clip1 = CreateRectRgnIndirect (r);
-      clip2 = CreateRectRgnIndirect (r + 1);
-      if (CombineRgn (full_clip, clip1, clip2, RGN_OR) != ERROR)
-        {
-          SelectClipRgn (s->hdc, full_clip);
-        }
+      HRGN clip1 = CreateRectRgnIndirect (r);
+      HRGN clip2 = CreateRectRgnIndirect (r + 1);
+      if (CombineRgn (clip1, clip1, clip2, RGN_OR) != ERROR)
+        SelectClipRgn (s->hdc, clip1);
       DeleteObject (clip1);
       DeleteObject (clip2);
-      DeleteObject (full_clip);
     }
     s->num_clips = n;
 }
@@ -1294,7 +1289,6 @@ x_draw_composite_glyph_string_foreground (struct glyph_string *s)
   else if (! s->first_glyph->u.cmp.automatic)
     {
       int y = s->ybase;
-      int width = 0;
       HFONT old_font;
 
       old_font = SelectObject (s->hdc, FONT_HANDLE (font));
@@ -4842,7 +4836,6 @@ w32_read_socket (struct terminal *terminal, int expected,
 static void
 w32_clip_to_row (struct window *w, struct glyph_row *row, int area, HDC hdc)
 {
-  struct frame *f = XFRAME (WINDOW_FRAME (w));
   RECT clip_rect;
   int window_x, window_y, window_width;
 
@@ -6089,7 +6082,6 @@ static void
 x_delete_terminal (struct terminal *terminal)
 {
   struct w32_display_info *dpyinfo = terminal->display_info.w32;
-  int i;
 
   /* Protect against recursive calls.  delete_frame in
      delete_terminal calls us back when it deletes our last frame.  */
diff --git a/src/w32uniscribe.c b/src/w32uniscribe.c
index 39d1ee5c851..f6347bb88f7 100644
--- a/src/w32uniscribe.c
+++ b/src/w32uniscribe.c
@@ -320,7 +320,7 @@ uniscribe_shape (Lisp_Object lgstring)
             }
           if (SUCCEEDED (result))
             {
-              int j, nclusters, from, to;
+              int j, from, to;
 
               from = 0;
               to = from;
@@ -629,8 +629,6 @@ add_opentype_font_name_to_list (ENUMLOGFONTEX *logical_font,
     STR[4] = '\0';                                           \
   } while (0)
 
-static char* NOTHING = "    ";
-
 #define SNAME(VAL) SDATA (SYMBOL_NAME (VAL))
 
 /* Check if font supports the otf script/language/features specified.
@@ -646,7 +644,6 @@ uniscribe_check_otf (LOGFONT *font, Lisp_Object otf_spec)
   struct frame * f;
   HDC context;
   HFONT check_font, old_font;
-  DWORD table;
   int i, retval = 0;
   struct gcpro gcpro1;
 
@@ -936,7 +933,11 @@ struct font_driver uniscribe_font_driver =
     NULL, /* otf_drive - use shape instead.  */
     NULL, /* start_for_frame */
     NULL, /* end_for_frame */
-    uniscribe_shape
+    uniscribe_shape,
+    NULL, /* check */
+    NULL, /* get_variation_glyphs */
+    NULL, /* filter_properties */
+    NULL, /* cached_font_ok */
   };
 
 /* Note that this should be called at every startup, not just when dumping,
diff --git a/src/window.c b/src/window.c
index f35815d757c..4bd533c22ac 100644
--- a/src/window.c
+++ b/src/window.c
@@ -2978,14 +2978,10 @@ shrink_windows (int total, int size, int nchildren, int shrinkable,
   while (total_shrink > total_removed)
     {
       int nonzero_sizes = 0;
-      int nonzero_idx = -1;
 
       for (i = 0; i < nchildren; ++i)
         if (new_sizes[i] > 0)
-          {
-            ++nonzero_sizes;
-            nonzero_idx = i;
-          }
+          ++nonzero_sizes;
 
       for (i = 0; i < nchildren; ++i)
         if (new_sizes[i] > min_sizes[i])
@@ -3689,27 +3685,23 @@ temp_output_buffer_show (register Lisp_Object buf)
 
       /* Run temp-buffer-show-hook, with the chosen window selected
          and its buffer current.  */
-
-      if (!NILP (Vrun_hooks)
-          && !NILP (Fboundp (Qtemp_buffer_show_hook))
-          && !NILP (Fsymbol_value (Qtemp_buffer_show_hook)))
-        {
-          int count = SPECPDL_INDEX ();
-          Lisp_Object prev_window, prev_buffer;
-          prev_window = selected_window;
-          XSETBUFFER (prev_buffer, old);
-
-          /* Select the window that was chosen, for running the hook.
-             Note: Both Fselect_window and select_window_norecord may
-             set-buffer to the buffer displayed in the window,
-             so we need to save the current buffer.  --stef  */
-          record_unwind_protect (Fset_buffer, prev_buffer);
-          record_unwind_protect (select_window_norecord, prev_window);
-          Fselect_window (window, Qt);
-          Fset_buffer (w->buffer);
-          call1 (Vrun_hooks, Qtemp_buffer_show_hook);
-          unbind_to (count, Qnil);
-        }
+      {
+        int count = SPECPDL_INDEX ();
+        Lisp_Object prev_window, prev_buffer;
+        prev_window = selected_window;
+        XSETBUFFER (prev_buffer, old);
+
+        /* Select the window that was chosen, for running the hook.
+           Note: Both Fselect_window and select_window_norecord may
+           set-buffer to the buffer displayed in the window,
+           so we need to save the current buffer.  --stef  */
+        record_unwind_protect (Fset_buffer, prev_buffer);
+        record_unwind_protect (select_window_norecord, prev_window);
+        Fselect_window (window, Qt);
+        Fset_buffer (w->buffer);
+        Frun_hooks (1, &Qtemp_buffer_show_hook);
+        unbind_to (count, Qnil);
+      }
     }
 }
 
diff --git a/src/xdisp.c b/src/xdisp.c
index a7955f41e0c..bbbf37b68ac 100644
--- a/src/xdisp.c
+++ b/src/xdisp.c
@@ -754,7 +754,7 @@ static void setup_for_ellipsis (struct it *, int);
 static void mark_window_display_accurate_1 (struct window *, int);
 static int single_display_spec_string_p (Lisp_Object, Lisp_Object);
 static int display_prop_string_p (Lisp_Object, Lisp_Object);
-static int cursor_row_p (struct window *, struct glyph_row *);
+static int cursor_row_p (struct glyph_row *);
 static int redisplay_mode_lines (Lisp_Object, int);
 static char *decode_mode_spec_coding (Lisp_Object, char *, int);
 
@@ -802,8 +802,8 @@ 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 (EMACS_INT);
-static int message_log_check_duplicate (EMACS_INT, EMACS_INT,
-                                        EMACS_INT, EMACS_INT);
+static unsigned long 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 *);
@@ -823,8 +823,7 @@ static int display_mode_lines (struct window *);
 static int display_mode_line (struct window *, enum face_id, Lisp_Object);
 static int display_mode_element (struct it *, int, int, int, Lisp_Object, Lisp_Object, int);
 static int store_mode_line_string (const char *, Lisp_Object, int, int, int, Lisp_Object);
-static const char *decode_mode_spec (struct window *, int, int, int,
-                                     Lisp_Object *);
+static const char *decode_mode_spec (struct window *, int, int, Lisp_Object *);
 static void display_menu_bar (struct window *);
 static int display_count_lines (EMACS_INT, EMACS_INT, EMACS_INT, int,
                                 EMACS_INT *);
@@ -2181,7 +2180,7 @@ safe_eval_handler (Lisp_Object arg)
    redisplay during the evaluation.  */
 
 Lisp_Object
-safe_call (int nargs, Lisp_Object *args)
+safe_call (size_t nargs, Lisp_Object *args)
 {
   Lisp_Object val;
 
@@ -3164,6 +3163,9 @@ handle_fontified_prop (struct it *it)
     {
       int count = SPECPDL_INDEX ();
       Lisp_Object val;
+      struct buffer *obuf = current_buffer;
+      int begv = BEGV, zv = ZV;
+      int old_clip_changed = current_buffer->clip_changed;
 
       val = Vfontification_functions;
       specbind (Qfontification_functions, Qnil);
@@ -3209,6 +3211,23 @@ handle_fontified_prop (struct it *it)
 
       unbind_to (count, Qnil);
 
+      /* Fontification functions routinely call `save-restriction'.
+         Normally, this tags clip_changed, which can confuse redisplay
+         (see discussion in Bug#6671).  Since we don't perform any
+         special handling of fontification changes in the case where
+         `save-restriction' isn't called, there's no point doing so in
+         this case either.  So, if the buffer's restrictions are
+         actually left unchanged, reset clip_changed.  */
+      if (obuf == current_buffer)
+        {
+          if (begv == BEGV && zv == ZV)
+            current_buffer->clip_changed = old_clip_changed;
+        }
+      /* There isn't much we can reasonably do to protect against
+         misbehaving fontification, but here's a fig leaf.  */
+      else if (!NILP (BVAR (obuf, name)))
+        set_buffer_internal_1 (obuf);
+
       /* The fontification code may have added/removed text.
          It could do even a lot worse, but let's at least protect against
          the most obvious case where only the text past `pos' gets changed',
@@ -4400,20 +4419,18 @@ display_prop_string_p (Lisp_Object prop, Lisp_Object string)
   return 0;
 }
 
-/* Look for STRING in overlays and text properties in W's buffer,
-   between character positions FROM and TO (excluding TO).
+/* Look for STRING in overlays and text properties in the current
+   buffer, between character positions FROM and TO (excluding TO).
    BACK_P non-zero means look back (in this case, TO is supposed to be
    less than FROM).
    Value is the first character position where STRING was found, or
    zero if it wasn't found before hitting TO.
 
-   W's buffer must be current.
-
    This function may only use code that doesn't eval because it is
    called asynchronously from note_mouse_highlight.  */
 
 static EMACS_INT
-string_buffer_position_lim (struct window *w, Lisp_Object string,
+string_buffer_position_lim (Lisp_Object string,
                             EMACS_INT from, EMACS_INT to, int back_p)
 {
   Lisp_Object limit, prop, pos;
@@ -4451,27 +4468,25 @@ string_buffer_position_lim (struct window *w, Lisp_Object string,
   return found ? XINT (pos) : 0;
 }
 
-/* Determine which buffer position in W's buffer STRING comes from.
+/* Determine which buffer position in current buffer STRING comes from.
    AROUND_CHARPOS is an approximate position where it could come from.
    Value is the buffer position or 0 if it couldn't be determined.
 
-   W's buffer must be current.
-
    This function is necessary because we don't record buffer positions
    in glyphs generated from strings (to keep struct glyph small).
    This function may only use code that doesn't eval because it is
    called asynchronously from note_mouse_highlight.  */
 
-EMACS_INT
-string_buffer_position (struct window *w, Lisp_Object string, EMACS_INT around_charpos)
+static EMACS_INT
+string_buffer_position (Lisp_Object string, EMACS_INT around_charpos)
 {
   const int MAX_DISTANCE = 1000;
-  EMACS_INT found = string_buffer_position_lim (w, string, around_charpos,
+  EMACS_INT found = string_buffer_position_lim (string, around_charpos,
                                                 around_charpos + MAX_DISTANCE,
                                                 0);
 
   if (!found)
-    found = string_buffer_position_lim (w, string, around_charpos,
+    found = string_buffer_position_lim (string, around_charpos,
                                         around_charpos - MAX_DISTANCE, 1);
   return found;
 }
@@ -7947,7 +7962,7 @@ message_dolog (const char *m, EMACS_INT nbytes, int nlflag, int multibyte)
               c = string_char_and_length (msg + i, &char_bytes);
               work[0] = (ASCII_CHAR_P (c)
                          ? c
-                         : multibyte_char_to_unibyte (c, Qnil));
+                         : multibyte_char_to_unibyte (c));
               insert_1_both (work, 1, 1, 1, 0, 0);
             }
         }
@@ -7973,7 +7988,7 @@ message_dolog (const char *m, EMACS_INT nbytes, int nlflag, int multibyte)
       if (nlflag)
         {
           EMACS_INT this_bol, this_bol_byte, prev_bol, prev_bol_byte;
-          int dups;
+          unsigned long int dups;
           insert_1 ("\n", 1, 1, 0, 0);
 
           scan_newline (Z, Z_BYTE, BEG, BEG_BYTE, -2, 0);
@@ -8001,7 +8016,7 @@ message_dolog (const char *m, EMACS_INT nbytes, int nlflag, int multibyte)
 
                       /* If you change this format, don't forget to also
                          change message_log_check_duplicate.  */
-                      sprintf (dupstr, " [%d times]", dups);
+                      sprintf (dupstr, " [%lu times]", dups);
                       duplen = strlen (dupstr);
                       TEMP_SET_PT_BOTH (Z - 1, Z_BYTE - 1);
                       insert_1 (dupstr, duplen, 1, 0, 1);
@@ -8063,7 +8078,7 @@ message_dolog (const char *m, EMACS_INT nbytes, int nlflag, int multibyte)
    Return 0 if different, 1 if the new one should just replace it, or a
    value N > 1 if we should also append " [N times]".  */
 
-static int
+static unsigned long int
 message_log_check_duplicate (EMACS_INT prev_bol, EMACS_INT prev_bol_byte,
                              EMACS_INT this_bol, EMACS_INT this_bol_byte)
 {
@@ -8085,10 +8100,9 @@ message_log_check_duplicate (EMACS_INT prev_bol, EMACS_INT prev_bol_byte,
     return 2;
   if (*p1++ == ' ' && *p1++ == '[')
     {
-      int n = 0;
-      while (*p1 >= '0' && *p1 <= '9')
-        n = n * 10 + *p1++ - '0';
-      if (strncmp ((char *) p1, " times]\n", 8) == 0)
+      char *pend;
+      unsigned long int n = strtoul ((char *) p1, &pend, 10);
+      if (strncmp (pend, " times]\n", 8) == 0)
         return n+1;
     }
   return 0;
@@ -9209,7 +9223,7 @@ set_message_1 (EMACS_INT a1, Lisp_Object a2, EMACS_INT nbytes, EMACS_INT multiby
               c = string_char_and_length (msg + i, &n);
               work[0] = (ASCII_CHAR_P (c)
                          ? c
-                         : multibyte_char_to_unibyte (c, Qnil));
+                         : multibyte_char_to_unibyte (c));
               insert_1_both (work, 1, 1, 1, 0, 0);
             }
         }
@@ -12712,7 +12726,7 @@ set_cursor_from_row (struct window *w, struct glyph_row *row,
                   EMACS_INT tem;
 
                   str = glyph->object;
-                  tem = string_buffer_position_lim (w, str, pos, pos_after, 0);
+                  tem = string_buffer_position_lim (str, pos, pos_after, 0);
                   if (tem == 0  /* from overlay */
                       || pos <= tem)
                     {
@@ -13438,7 +13452,7 @@ try_cursor_movement (Lisp_Object window, struct text_pos startp, int *scroll_ste
                      && row < w->current_matrix->rows
                                 + w->current_matrix->nrows - 1
                      && MATRIX_ROW_START_CHARPOS (row+1) == PT
-                     && !cursor_row_p (w, row))
+                     && !cursor_row_p (row))
                 ++row;
 
               /* If within the scroll margin, scroll.  Note that
@@ -13490,7 +13504,7 @@ try_cursor_movement (Lisp_Object window, struct text_pos startp, int *scroll_ste
                  skip forward over overlay strings.  */
               while (MATRIX_ROW_BOTTOM_Y (row) < last_y
                      && MATRIX_ROW_END_CHARPOS (row) == PT
-                     && !cursor_row_p (w, row))
+                     && !cursor_row_p (row))
                 ++row;
 
               /* If within the scroll margin, scroll.  */
@@ -13586,7 +13600,7 @@ try_cursor_movement (Lisp_Object window, struct text_pos startp, int *scroll_ste
                 {
                   if (MATRIX_ROW_START_CHARPOS (row) <= PT
                       && PT <= MATRIX_ROW_END_CHARPOS (row)
-                      && cursor_row_p (w, row))
+                      && cursor_row_p (row))
                     rv |= set_cursor_from_row (w, row, w->current_matrix,
                                                0, 0, 0, 0);
                   /* As soon as we've found the first suitable row
@@ -13625,7 +13639,7 @@ try_cursor_movement (Lisp_Object window, struct text_pos startp, int *scroll_ste
                 }
               while (MATRIX_ROW_BOTTOM_Y (row) < last_y
                      && MATRIX_ROW_START_CHARPOS (row) == PT
-                     && cursor_row_p (w, row));
+                     && cursor_row_p (row));
             }
         }
     }
@@ -14157,7 +14171,6 @@ redisplay_window (Lisp_Object window, int just_this_one_p)
        || temp_scroll_step
        || NUMBERP (BVAR (current_buffer, scroll_up_aggressively))
        || NUMBERP (BVAR (current_buffer, scroll_down_aggressively)))
-      && !current_buffer->clip_changed
       && CHARPOS (startp) >= BEGV
       && CHARPOS (startp) <= ZV)
     {
@@ -14625,8 +14638,6 @@ try_window_reusing_current_matrix (struct window *w)
 
   if (CHARPOS (new_start) <= CHARPOS (start))
     {
-      int first_row_y;
-
       /* Don't use this method if the display starts with an ellipsis
          displayed for invisible text.  It's not easy to handle that case
          below, and it's certainly not worth the effort since this is
@@ -14641,7 +14652,6 @@ try_window_reusing_current_matrix (struct window *w)
          text.  Note that it.vpos == 0 if or if not there is a
          header-line; it's not the same as the MATRIX_ROW_VPOS!  */
       start_display (&it, w, new_start);
-      first_row_y = it.current_y;
       w->cursor.vpos = -1;
       last_text_row = last_reused_text_row = NULL;
 
@@ -16370,7 +16380,7 @@ With ARG, turn tracing on if and only if ARG is positive.  */)
 DEFUN ("trace-to-stderr", Ftrace_to_stderr, Strace_to_stderr, 1, MANY, "",
        doc: /* Like `format', but print result to stderr.
 usage: (trace-to-stderr STRING &rest OBJECTS)  */)
-  (int nargs, Lisp_Object *args)
+  (size_t nargs, Lisp_Object *args)
 {
   Lisp_Object s = Fformat (nargs, args);
   fprintf (stderr, "%s", SDATA (s));
@@ -16953,11 +16963,11 @@ highlight_trailing_whitespace (struct frame *f, struct glyph_row *row)
 }
 
 
-/* Value is non-zero if glyph row ROW in window W should be
+/* Value is non-zero if glyph row ROW should be
    used to hold the cursor.  */
 
 static int
-cursor_row_p (struct window *w, struct glyph_row *row)
+cursor_row_p (struct glyph_row *row)
 {
   int result = 1;
 
@@ -17870,7 +17880,7 @@ display_line (struct it *it)
            && !MATRIX_ROW (it->w->desired_matrix, cvpos)->ends_at_zv_p))
       && PT >= MATRIX_ROW_START_CHARPOS (row)
       && PT <= MATRIX_ROW_END_CHARPOS (row)
-      && cursor_row_p (it->w, row))
+      && cursor_row_p (row))
     set_cursor_from_row (it->w, row, it->w->desired_matrix, 0, 0, 0, 0);
 
   /* Highlight trailing whitespace.  */
@@ -18522,7 +18532,7 @@ display_mode_element (struct it *it, int depth, int field_width, int precision,
                     charpos = (STRING_MULTIBYTE (elt)
                                ? string_byte_to_char (elt, bytepos)
                                : bytepos);
-                    spec = decode_mode_spec (it->w, c, field, prec, &string);
+                    spec = decode_mode_spec (it->w, c, field, &string);
                     multibyte = STRINGP (string) && STRING_MULTIBYTE (string);
 
                     switch (mode_line_target)
@@ -19007,7 +19017,7 @@ pint2str (register char *buf, register int width, register EMACS_INT d)
 
 static const char power_letter[] =
   {
-    0,   /* not used */
+    0,   /* no letter */
     'k', /* kilo */
     'M', /* mega */
     'G', /* giga */
@@ -19089,8 +19099,7 @@ pint2hrstr (char *buf, int width, int d)
   p = psuffix = buf + max (width, length);
 
   /* Print EXPONENT. */
-  if (exponent)
-    *psuffix++ = power_letter[exponent];
+  *psuffix++ = power_letter[exponent];
   *psuffix = '\0';
 
   /* Print TENTHS. */
@@ -19194,9 +19203,8 @@ decode_mode_spec_coding (Lisp_Object coding_system, register char *buf, int eol_
 }
 
 /* Return a string for the output of a mode line %-spec for window W,
-   generated by character C.  PRECISION >= 0 means don't return a
-   string longer than that value.  FIELD_WIDTH > 0 means pad the
-   string returned with spaces to that value.  Return a Lisp string in
+   generated by character C.  FIELD_WIDTH > 0 means pad the string
+   returned with spaces to that value.  Return a Lisp string in
    *STRING if the resulting string is taken from that Lisp string.
 
    Note we operate on the current buffer for most purposes,
@@ -19206,7 +19214,7 @@ static char lots_of_dashes[] = "------------------------------------------------
 
 static const char *
 decode_mode_spec (struct window *w, register int c, int field_width,
-                  int precision, Lisp_Object *string)
+                  Lisp_Object *string)
 {
   Lisp_Object obj;
   struct frame *f = XFRAME (WINDOW_FRAME (w));
@@ -22740,7 +22748,6 @@ x_produce_glyphs (struct it *it)
               int ch = COMPOSITION_GLYPH (cmp, i);
               int face_id;
               struct face *this_face;
-              int this_boff;
 
               if (ch == '\t')
                 ch = ' ';
@@ -22752,9 +22759,6 @@ x_produce_glyphs (struct it *it)
                 pcm = NULL;
               else
                 {
-                  this_boff = font->baseline_offset;
-                  if (font->vertical_centering)
-                    this_boff = VCENTER_BASELINE_OFFSET (font, it->f) - boff;
                   get_char_face_and_encoding (it->f, ch, face_id,
                                               &char2b, it->multibyte_p, 0);
                   pcm = get_per_char_metric (it->f, font, &char2b);
@@ -24307,7 +24311,7 @@ mouse_face_from_buffer_pos (Lisp_Object window,
              END_CHARPOS, or if they come from an overlay.  */
           if (EQ (glyph->object, before_string))
             {
-              pos = string_buffer_position (w, before_string,
+              pos = string_buffer_position (before_string,
                                             start_charpos);
               /* If pos == 0, it means before_string came from an
                  overlay, not from a buffer position.  */
@@ -24316,7 +24320,7 @@ mouse_face_from_buffer_pos (Lisp_Object window,
             }
           else if (EQ (glyph->object, after_string))
             {
-              pos = string_buffer_position (w, after_string, end_charpos);
+              pos = string_buffer_position (after_string, end_charpos);
               if (!pos || (pos >= start_charpos && pos < end_charpos))
                 break;
             }
@@ -24358,7 +24362,7 @@ mouse_face_from_buffer_pos (Lisp_Object window,
              END_CHARPOS, or if they come from an overlay.  */
           if (EQ (glyph->object, before_string))
             {
-              pos = string_buffer_position (w, before_string, start_charpos);
+              pos = string_buffer_position (before_string, start_charpos);
               /* If pos == 0, it means before_string came from an
                  overlay, not from a buffer position.  */
               if (!pos || (pos >= start_charpos && pos < end_charpos))
@@ -24366,7 +24370,7 @@ mouse_face_from_buffer_pos (Lisp_Object window,
             }
           else if (EQ (glyph->object, after_string))
             {
-              pos = string_buffer_position (w, after_string, end_charpos);
+              pos = string_buffer_position (after_string, end_charpos);
               if (!pos || (pos >= start_charpos && pos < end_charpos))
                 break;
             }
@@ -24424,13 +24428,13 @@ mouse_face_from_buffer_pos (Lisp_Object window,
              END_CHARPOS, or if they come from an overlay.  */
           if (EQ (end->object, before_string))
             {
-              pos = string_buffer_position (w, before_string, start_charpos);
+              pos = string_buffer_position (before_string, start_charpos);
               if (!pos || (pos >= start_charpos && pos < end_charpos))
                 break;
             }
           else if (EQ (end->object, after_string))
             {
-              pos = string_buffer_position (w, after_string, end_charpos);
+              pos = string_buffer_position (after_string, end_charpos);
               if (!pos || (pos >= start_charpos && pos < end_charpos))
                 break;
             }
@@ -24474,13 +24478,13 @@ mouse_face_from_buffer_pos (Lisp_Object window,
              END_CHARPOS, or if they come from an overlay.  */
           if (EQ (end->object, before_string))
             {
-              pos = string_buffer_position (w, before_string, start_charpos);
+              pos = string_buffer_position (before_string, start_charpos);
               if (!pos || (pos >= start_charpos && pos < end_charpos))
                 break;
             }
           else if (EQ (end->object, after_string))
             {
-              pos = string_buffer_position (w, after_string, end_charpos);
+              pos = string_buffer_position (after_string, end_charpos);
               if (!pos || (pos >= start_charpos && pos < end_charpos))
                 break;
             }
@@ -24957,10 +24961,9 @@ note_mode_line_or_margin_highlight (Lisp_Object window, int x, int y,
               CONSP (hotspot))
           && (hotspot = XCDR (hotspot), CONSP (hotspot)))
         {
-          Lisp_Object area_id, plist;
+          Lisp_Object plist;
 
-          area_id = XCAR (hotspot);
-          /* Could check AREA_ID to see if we enter/leave this hot-spot.
+          /* Could check XCAR (hotspot) to see if we enter/leave this hot-spot.
              If so, we could look for mouse-enter, mouse-leave
              properties in PLIST (and do something...).  */
           hotspot = XCDR (hotspot);
@@ -25295,10 +25298,10 @@ note_mouse_highlight (struct frame *f, int x, int y)
                       CONSP (hotspot))
                   && (hotspot = XCDR (hotspot), CONSP (hotspot)))
                 {
-                  Lisp_Object area_id, plist;
+                  Lisp_Object plist;
 
-                  area_id = XCAR (hotspot);
-                  /* Could check AREA_ID to see if we enter/leave this hot-spot.
+                  /* Could check XCAR (hotspot) to see if we enter/leave
+                     this hot-spot.
                      If so, we could look for mouse-enter, mouse-leave
                      properties in PLIST (and do something...).  */
                   hotspot = XCDR (hotspot);
@@ -25464,7 +25467,7 @@ note_mouse_highlight (struct frame *f, int x, int y)
                      check if the text under it has one.  */
                   struct glyph_row *r = MATRIX_ROW (w->current_matrix, vpos);
                   EMACS_INT start = MATRIX_ROW_START_CHARPOS (r);
-                  pos = string_buffer_position (w, object, start);
+                  pos = string_buffer_position (object, start);
                   if (pos > 0)
                     {
                       mouse_face = get_char_property_and_overlay
@@ -25574,7 +25577,7 @@ note_mouse_highlight (struct frame *f, int x, int y)
                     struct glyph_row *r
                       = MATRIX_ROW (w->current_matrix, vpos);
                     EMACS_INT start = MATRIX_ROW_START_CHARPOS (r);
-                    EMACS_INT p = string_buffer_position (w, obj, start);
+                    EMACS_INT p = string_buffer_position (obj, start);
                     if (p > 0)
                       {
                         help = Fget_char_property (make_number (p),
@@ -25630,7 +25633,7 @@ note_mouse_highlight (struct frame *f, int x, int y)
                       struct glyph_row *r
                         = MATRIX_ROW (w->current_matrix, vpos);
                       EMACS_INT start = MATRIX_ROW_START_CHARPOS (r);
-                      EMACS_INT p = string_buffer_position (w, obj, start);
+                      EMACS_INT p = string_buffer_position (obj, start);
                       if (p > 0)
                         pointer = Fget_char_property (make_number (p),
                                                       Qpointer, w->buffer);
diff --git a/src/xfont.c b/src/xfont.c
index f8aace3663c..3e0fcd2cd75 100644
--- a/src/xfont.c
+++ b/src/xfont.c
@@ -629,7 +629,7 @@ xfont_list_family (Lisp_Object frame)
   char **names;
   int num_fonts, i;
   Lisp_Object list;
-  char *last_family;
+  char *last_family IF_LINT (= 0);
   int last_len;
 
   BLOCK_INPUT;
diff --git a/src/xftfont.c b/src/xftfont.c
index 695527c4236..c27a4fcf91a 100644
--- a/src/xftfont.c
+++ b/src/xftfont.c
@@ -280,7 +280,7 @@ xftfont_open (FRAME_PTR f, Lisp_Object entity, int pixel_size)
 {
   FcResult result;
   Display *display = FRAME_X_DISPLAY (f);
-  Lisp_Object val, filename, index, font_object;
+  Lisp_Object val, filename, idx, font_object;
   FcPattern *pat = NULL, *match;
   struct xftfont_info *xftfont_info = NULL;
   struct font *font;
@@ -298,7 +298,7 @@ xftfont_open (FRAME_PTR f, Lisp_Object entity, int pixel_size)
     return Qnil;
   val = XCDR (val);
   filename = XCAR (val);
-  index = XCDR (val);
+  idx = XCDR (val);
   size = XINT (AREF (entity, FONT_SIZE_INDEX));
   if (size == 0)
     size = pixel_size;
@@ -335,7 +335,7 @@ xftfont_open (FRAME_PTR f, Lisp_Object entity, int pixel_size)
   xftfont_add_rendering_parameters (pat, entity);
 
   FcPatternAddString (pat, FC_FILE, (FcChar8 *) SDATA (filename));
-  FcPatternAddInteger (pat, FC_INDEX, XINT (index));
+  FcPatternAddInteger (pat, FC_INDEX, XINT (idx));
 
 
   BLOCK_INPUT;
@@ -409,9 +409,9 @@ xftfont_open (FRAME_PTR f, Lisp_Object entity, int pixel_size)
     spacing = FC_PROPORTIONAL;
   if (! ascii_printable[0])
     {
-      int i;
-      for (i = 0; i < 95; i++)
-        ascii_printable[i] = ' ' + i;
+      int ch;
+      for (ch = 0; ch < 95; ch++)
+        ascii_printable[ch] = ' ' + ch;
     }
   BLOCK_INPUT;
   if (spacing != FC_PROPORTIONAL
@@ -672,7 +672,8 @@ xftfont_draw (struct glyph_string *s, int from, int to, int x, int y, int with_b
   return len;
 }
 
-Lisp_Object
+#if defined HAVE_M17N_FLT && defined HAVE_LIBOTF
+static Lisp_Object
 xftfont_shape (Lisp_Object lgstring)
 {
   struct font *font;
@@ -688,6 +689,7 @@ xftfont_shape (Lisp_Object lgstring)
   XftUnlockFace (xftfont_info->xftfont);
   return val;
 }
+#endif
 
 static int
 xftfont_end_for_frame (FRAME_PTR f)
diff --git a/src/xmenu.c b/src/xmenu.c
index eab7bb03f20..8ecef00c88e 100644
--- a/src/xmenu.c
+++ b/src/xmenu.c
@@ -383,7 +383,7 @@ x_menu_wait_for_event (void *data)
 #endif
          )
     {
-      EMACS_TIME next_time = timer_check (1), *ntp;
+      EMACS_TIME next_time = timer_check (), *ntp;
       long secs = EMACS_SECS (next_time);
       long usecs = EMACS_USECS (next_time);
       SELECT_TYPE read_fds;
@@ -712,7 +712,7 @@ show_help_event (FRAME_PTR f, xt_or_gtk_widget widget, Lisp_Object help)
             break;
         }
 #endif
-      show_help_echo (help, Qnil, Qnil, Qnil, 1);
+      show_help_echo (help, Qnil, Qnil, Qnil);
     }
 }
 
@@ -922,7 +922,7 @@ set_frame_menubar (FRAME_PTR f, int first_time, int deep_p)
 #endif
   Lisp_Object items;
   widget_value *wv, *first_wv, *prev_wv = 0;
-  int i, last_i = 0;
+  EMACS_UINT i, last_i = 0;
   int *submenu_start, *submenu_end;
   int *submenu_top_level_items, *submenu_n_panes;
 
@@ -2201,7 +2201,7 @@ menu_help_callback (char *help_string, int pane, int item)
                        Fcons (pane_name,
                               Fcons (make_number (pane), Qnil)));
   show_help_echo (help_string ? build_string (help_string) : Qnil,
-                  Qnil, menu_object, make_number (item), 1);
+                  Qnil, menu_object, make_number (item));
 }
 
 static Lisp_Object
diff --git a/src/xml.c b/src/xml.c
index 12ef14e6b9f..d8e6f8c3faa 100644
--- a/src/xml.c
+++ b/src/xml.c
@@ -28,7 +28,8 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include "lisp.h"
 #include "buffer.h"
 
-Lisp_Object make_dom (xmlNode *node)
+static Lisp_Object
+make_dom (xmlNode *node)
 {
   if (node->type == XML_ELEMENT_NODE)
     {
diff --git a/src/xselect.c b/src/xselect.c
index 5254fa96838..451b2a0b13f 100644
--- a/src/xselect.c
+++ b/src/xselect.c
@@ -2190,7 +2190,8 @@ and t is the same as `SECONDARY'.  */)
 ***********************************************************************/
 /* Check that lisp values are of correct type for x_fill_property_data.
    That is, number, string or a cons with two numbers (low and high 16
-   bit parts of a 32 bit number).  */
+   bit parts of a 32 bit number).  Return the number of items in DATA,
+   or -1 if there is an error.  */
 
 int
 x_check_property_data (Lisp_Object data)
@@ -2198,15 +2199,16 @@ x_check_property_data (Lisp_Object data)
   Lisp_Object iter;
   int size = 0;
 
-  for (iter = data; CONSP (iter) && size != -1; iter = XCDR (iter), ++size)
+  for (iter = data; CONSP (iter); iter = XCDR (iter))
     {
       Lisp_Object o = XCAR (iter);
 
       if (! NUMBERP (o) && ! STRINGP (o) && ! CONSP (o))
-        size = -1;
+        return -1;
       else if (CONSP (o) &&
                (! NUMBERP (XCAR (o)) || ! NUMBERP (XCDR (o))))
-        size = -1;
+        return -1;
+      size++;
     }
 
   return size;
diff --git a/src/xterm.c b/src/xterm.c
index fd7ffd68e62..dc1fd3cbbd1 100644
--- a/src/xterm.c
+++ b/src/xterm.c
@@ -349,7 +349,7 @@ static int handle_one_xevent (struct x_display_info *, XEvent *,
                               int *, struct input_event *);
 /* Don't declare this NO_RETURN because we want no
    interference with debugging failing X calls.  */
-static SIGTYPE x_connection_closed (Display *, const char *);
+static void x_connection_closed (Display *, const char *);
 
 
 /* Flush display of frame F, or of all frames if F is null.  */
@@ -2928,10 +2928,14 @@ x_clear_frame (struct frame *f)
   /* We don't set the output cursor here because there will always
      follow an explicit cursor_to.  */
   BLOCK_INPUT;
-  XClearWindow (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f));
 
-  /* We have to clear the scroll bars, too.  If we have changed
-     colors or something like that, then they should be notified.  */
+  /* The following calls have been commented out because they do not
+     seem to accomplish anything, apart from causing flickering during
+     window resize.  */
+  /* XClearWindow (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f)); */
+
+  /* We have to clear the scroll bars.  If we have changed colors or
+     something like that, then they should be notified.  */
   x_scroll_bar_clear (f);
 
 #if defined (USE_GTK) && defined (USE_TOOLKIT_SCROLL_BARS)
@@ -7646,7 +7650,7 @@ x_trace_wire (void)
    SIGPIPE will fail, causing Xlib to invoke the X IO error handler,
    which will do the appropriate cleanup for us.  */
 
-static SIGTYPE
+static void
 x_connection_signal (int signalnum)     /* If we don't have an argument, */
                                 /* some compilers complain in signal calls.  */
 {
@@ -7669,7 +7673,7 @@ static char *error_msg;
 /* Handle the loss of connection to display DPY.  ERROR_MESSAGE is
    the text of an error message that lead to the connection loss.  */
 
-static SIGTYPE
+static void
 x_connection_closed (Display *dpy, const char *error_message)
 {
   struct x_display_info *dpyinfo = x_display_info_for_display (dpy);
@@ -9117,7 +9121,7 @@ x_make_frame_visible (struct frame *f)
        unknown reason, the call to XtMapWidget is completely ignored.
        Mapping the widget a second time works.  */
 
-    if (!FRAME_VISIBLE_P (f) && --retry_count > 0)
+    if (!FRAME_VISIBLE_P (f) && --retry_count != 0)
       goto retry;
   }
 }
@@ -9722,7 +9726,7 @@ same_x_server (const char *name1, const char *name2)
   for (; *name1 != '\0' && *name1 == *name2; name1++, name2++)
     {
       if (*name1 == ':')
-        seen_colon++;
+        seen_colon = 1;
       if (seen_colon && *name1 == '.')
         return 1;
     }