Merge from trunk.

author: Eli Zaretskii 2012-10-12 11:45:45 +0200
committer: Eli Zaretskii 2012-10-12 11:45:45 +0200
commit: 0dc9ee4adad0b566c32036a4c201a1de882ac65b (patch)
tree: a61f585563633f0f38838012771dae63a3cef098 /src
parent: 182b170f7ec712b7f89ada65095aae5bb8fe553e (diff)
parent: 81749a2374c78d656888b462f3b29301e4cbd1c7 (diff)
download: emacs-0dc9ee4adad0b566c32036a4c201a1de882ac65b.tar.gz
emacs-0dc9ee4adad0b566c32036a4c201a1de882ac65b.zip
33 files changed, 592 insertions, 521 deletions
diff --git a/src/ChangeLog b/src/ChangeLog
index 25a4e92a1ca..34e730183de 100644
--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -1,3 +1,134 @@
+2012-10-12  Glenn Morris  <rgm@gnu.org>
+        * buffer.c (Fset_buffer): Doc fix.  (Bug#12624)
+2012-10-11  Stefan Monnier  <monnier@iro.umontreal.ca>
+        * buffer.c (Fkill_buffer): Null out the overlay list(s) as well.
+        * eval.c (Fautoload): Remember previous autoload status in load-history.
+2012-10-11  Paul Eggert  <eggert@cs.ucla.edu>
+        lread.c, macros.c, marker.c, menu.c, minibuf.c: Use bool for booleans.
+        * lread.c (load_each_byte, new_backquote_flag, readchar)
+        (read_filtered_event, lisp_file_lexically_bound_p)
+        (safe_to_load_version, Fload, complete_filename_p, openp)
+        (build_load_history, readevalloop, read_escape, read1)
+        (string_to_number, read_vector, read_list):
+        * macros.c (Fstart_kbd_macro):
+        * marker.c (CONSIDER):
+        * menu.c (parse_single_submenu, digest_single_submenu)
+        (find_and_return_menu_selection, Fx_popup_menu):
+        * minibuf.c (read_minibuf_noninteractive, read_minibuf)
+        (Ftry_completion):
+        * nsmenu.m (ns_update_menubar, runMenuAt:forFrame:keymaps:):
+        (ns_menu_show):
+        * xmenu.c (set_frame_menubar, create_and_show_popup_menu)
+        (xmenu_show, xdialog_show):
+        Use bool for booleans.
+        * lread.c (safe_to_load_version): Rename from safe_to_load_p,
+        as it's not a predicate.  All uses changed.  Omit unnecessary
+        buffer termination.
+2012-10-11  Dmitry Antipov  <dmantipov@yandex.ru>
+        * editfns.c (save_excursion_save): Use nil if mark points to nowhere.
+        (save_excursion_restore): Do not restore mark if it was not saved.
+2012-10-11  Paul Eggert  <eggert@cs.ucla.edu>
+        * marker.c (cached_modiff): EMACS_INT, not int.
+        * w32select.c (waiting_for_input): Declare by including "keyboard.h"
+        instead of having a wrong decl.
+        * nsmenu.m (waiting_for_input): Remove wrong decl.
+2012-10-10  Paul Eggert  <eggert@cs.ucla.edu>
+        keyboard.c, keymap.c: Use bool for booleans.
+        * dispnew.c (sit_for): Distinguish between 3-way display_option
+        and boolean do_display.
+        * keyboard.c (single_kboard, this_command_key_count_reset)
+        (waiting_for_input, echoing, immediate_quit, input_pending)
+        (interrupt_input, interrupts_deferred, pop_kboard)
+        (temporarily_switch_to_single_kboard, ignore_mouse_drag_p)
+        (command_loop_1, adjust_point_for_property)
+        (safe_run_hooks_error, input_polling_used, read_char):
+        (help_char_p, readable_events, kbd_buffer_events_waiting)
+        (kbd_buffer_get_event, timer_check_2, make_lispy_event)
+        (lucid_event_type_list_p, get_input_pending):
+        (gobble_input, menu_separator_name_p, menu_bar_item)
+        (parse_menu_item, parse_tool_bar_item, read_char_x_menu_prompt)
+        (read_char_minibuf_menu_prompt, access_keymap_keyremap)
+        (keyremap_step, test_undefined, read_key_sequence)
+        (detect_input_pending, detect_input_pending_ignore_squeezables)
+        (detect_input_pending_run_timers, requeued_events_pending_p)
+        (quit_throw_to_read_char, Fset_input_interrupt_mode):
+        * keymap.c (get_keymap, keymap_parent, keymap_memberp)
+        (access_keymap_1, access_keymap, map_keymap, get_keyelt)
+        (Fdefine_key, Flookup_key, struct accessible_keymaps_data)
+        (accessible_keymaps_1, Fkey_description, push_key_description):
+        (shadow_lookup, struct where_is_internal_data)
+        (where_is_internal, Fwhere_is_internal, where_is_internal_1)
+        (Fdescribe_buffer_bindings, describe_map_tree, struct describe_map_elt)
+        (describe_map, describe_vector):
+        * menu.c (single_menu_item):
+        * nsmenu.m (ns_update_menubar):
+        * process.c (wait_reading_process_output):
+        * search.c (scan_buffer, scan_newline):
+        Use bool for boolean.
+        * keyboard.c (timers_run, swallow_events)
+        (detect_input_pending_run_timers):
+        * process.c (wait_reading_process_output):
+        Use unsigned for counter where wraparound-on-overflow is desired,
+        since unsigned is guaranteed to have that behavior and signed is not.
+        (read_char): Use ptrdiff_t for string length.
+        (get_input_pending): Remove first argument, since it was always
+        the same pointer-to-int (now pointer-to-boolean) &input_pending,
+        and behave as if it had that value.  Return new value of
+        input_pending.  All callers changed.
+        * keyboard.h (struct kboard): Use unsigned : 1 for boolean member
+        immediate_echo.  Use ptrdiff_t for echo_after_prompt, since it's
+        a string length.
+        * keymap.c (push_key_description): Omit last arg, which was always 1.
+        All callers changed.
+        * regex.c (immediate_quit) [emacs]: Remove duplicate decl.
+2012-10-10  Juanma Barranquero  <lekktu@gmail.com>
+        * makefile.w32-in ($(BLD)/dispnew.$(O), $(BLD)/indent.$(O))
+        ($(BLD)/term.$(O)): Update dependencies.
+2012-10-10  Dmitry Antipov  <dmantipov@yandex.ru>
+        * alloc.c (mark_object): Use meaningful PVEC_NORMAL_VECTOR.
+        * lisp.h (enum pvec_type): Adjust comments and omit explicit
+        initializer for PVEC_NORMAL_VECTOR.
+2012-10-10  Paul Eggert  <eggert@cs.ucla.edu>
+        Clean out old termopts cruft.
+        * termopts.h (flow_control, meta_key): Remove unused decls.
+        * dispnew.c, indent.c, nsterm.m, term.c, xsettings.c, xsmfns.c:
+        Don't include termopts.h.
+2012-10-10  Dmitry Antipov  <dmantipov@yandex.ru>
+        * alloc.c (gc_sweep): Use pointer-to-a-pointer loop for buffers.
+2012-10-10  Paul Eggert  <eggert@cs.ucla.edu>
+        * commands.h (immediate_quit): Remove duplicate decl.
+2012-10-09  Jan Djärv  <jan.h.d@swipnet.se>
+        * nsfont.m (Vfonts_in_cache): Remove, not needed as font.c handles
+        caching.
+        (nsfont_open): Remove setting of Vfonts_in_cache.
+        (syms_of_nsfont): Remove initialization of Vfonts_in_cache
 2012-10-09  Eli Zaretskii  <eliz@gnu.org>
        * w32fns.c (w32_last_error): Change the return value to DWORD, to
diff --git a/src/alloc.c b/src/alloc.c
index dd3a93ae019..4fd659bd001 100644
--- a/src/alloc.c
+++ b/src/alloc.c
@@ -5689,7 +5689,7 @@ mark_object (Lisp_Object arg)
          pvectype = ((ptr->header.size & PVEC_TYPE_MASK)
                      >> PSEUDOVECTOR_SIZE_BITS);
        else
-          pvectype = 0;
+          pvectype = PVEC_NORMAL_VECTOR;
        if (pvectype != PVEC_SUBR && pvectype != PVEC_BUFFER)
          CHECK_LIVE (live_vector_p);
@@ -6311,19 +6311,14 @@ gc_sweep (void)
  /* Free all unmarked buffers */
  {
-    register struct buffer *buffer = all_buffers, *prev = 0, *next;
+    register struct buffer *buffer, **bprev = &all_buffers;
    total_buffers = 0;
-    while (buffer)
+    for (buffer = all_buffers; buffer; buffer = *bprev)
      if (!VECTOR_MARKED_P (buffer))
        {
-          if (prev)
+          *bprev = buffer->header.next.buffer;
-            prev->header.next = buffer->header.next;
-          else
-            all_buffers = buffer->header.next.buffer;
-          next = buffer->header.next.buffer;
          lisp_free (buffer);
-          buffer = next;
        }
      else
        {
@@ -6331,7 +6326,7 @@ gc_sweep (void)
          /* Do not use buffer_(set|get)_intervals here.  */
          buffer->text->intervals = balance_intervals (buffer->text->intervals);
          total_buffers++;
-          prev = buffer, buffer = buffer->header.next.buffer;
+          bprev = &buffer->header.next.buffer;
        }
  }
diff --git a/src/buffer.c b/src/buffer.c
index 425d05ca790..861a89b5a0f 100644
--- a/src/buffer.c
+++ b/src/buffer.c
@@ -897,6 +897,8 @@ delete_all_overlays (struct buffer *b)
 {
  struct Lisp_Overlay *ov, *next;
+  /* FIXME: Since each drop_overlay will scan BUF_MARKERS to unlink its
+     markers, we have an unneeded O(N^2) behavior here.  */
  for (ov = b->overlays_before; ov; ov = next)
    {
      drop_overlay (b, ov);
@@ -1886,16 +1888,19 @@ cleaning up all windows currently displaying the buffer to be killed. */)
  if (b->base_buffer)
    {
-      /* Unchain all markers that belong to this indirect buffer.
+      { /* Unchain all markers that belong to this indirect buffer.
-         Don't unchain the markers that belong to the base buffer
+           Don't unchain the markers that belong to the base buffer
-         or its other indirect buffers.  */
+           or its other indirect buffers.  */
-      for (m = BUF_MARKERS (b); m; )
+        struct Lisp_Marker **mp;
-        {
+        for (mp = &BUF_MARKERS (b); *mp; )
-          struct Lisp_Marker *next = m->next;
+          {
-          if (m->buffer == b)
+            struct Lisp_Marker *m = *mp;
-            unchain_marker (m);
+            if (m->buffer == b)
-          m = next;
+              *mp = m->next;
-        }
+            else
+              mp = &m->next;
+          }
+      }
    }
  else
    {
@@ -1911,8 +1916,12 @@ cleaning up all windows currently displaying the buffer to be killed. */)
      BUF_MARKERS (b) = NULL;
      set_buffer_intervals (b, NULL);
-      /* Perhaps we should explicitly free the interval tree here... */
+      /* Perhaps we should explicitly free the interval tree here...  */
    }
+  /* Since we've unlinked the markers, the overlays can't be here any more
+     either.  */
+  b->overlays_before = NULL;
+  b->overlays_after = NULL;
  /* Reset the local variables, so that this buffer's local values
     won't be protected from GC.  They would be protected
@@ -2176,7 +2185,7 @@ set_buffer_temp (struct buffer *b)
 DEFUN ("set-buffer", Fset_buffer, Sset_buffer, 1, 1, 0,
       doc: /* Make buffer BUFFER-OR-NAME current for editing operations.
 BUFFER-OR-NAME may be a buffer or the name of an existing buffer.  See
-also `save-excursion' when you want to make a buffer current
+also `with-current-buffer' when you want to make a buffer current
 temporarily.  This function does not display the buffer, so its effect
 ends when the current command terminates.  Use `switch-to-buffer' or
 `pop-to-buffer' to switch buffers permanently.  */)
diff --git a/src/commands.h b/src/commands.h
index 36f600cee01..510fce0e182 100644
--- a/src/commands.h
+++ b/src/commands.h
@@ -36,9 +36,6 @@ extern Lisp_Object control_x_map;
   events until a non-ASCII event is acceptable as input.  */
 extern Lisp_Object unread_switch_frame;
-/* Nonzero means ^G can quit instantly */
-extern int immediate_quit;
 /* Nonzero if input is coming from the keyboard */
 #define INTERACTIVE (NILP (Vexecuting_kbd_macro) && !noninteractive)
diff --git a/src/dispnew.c b/src/dispnew.c
index 6f8fb10b41d..0956e3f2905 100644
--- a/src/dispnew.c
+++ b/src/dispnew.c
@@ -26,7 +26,6 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include "lisp.h"
 #include "termchar.h"
-#include "termopts.h"
 /* cm.h must come after dispextern.h on Windows.  */
 #include "dispextern.h"
 #include "cm.h"
@@ -5919,15 +5918,16 @@ additional wait period, in milliseconds; this is for backwards compatibility.
   TIMEOUT is number of seconds to wait (float or integer),
   or t to wait forever.
   READING is true if reading input.
-   If DO_DISPLAY is >0 display process output while waiting.
+   If DISPLAY_OPTION is >0 display process output while waiting.
-   If DO_DISPLAY is >1 perform an initial redisplay before waiting.
+   If DISPLAY_OPTION is >1 perform an initial redisplay before waiting.
 */
 Lisp_Object
-sit_for (Lisp_Object timeout, bool reading, int do_display)
+sit_for (Lisp_Object timeout, bool reading, int display_option)
 {
  intmax_t sec;
  int nsec;
+  bool do_display = display_option > 0;
  swallow_events (do_display);
@@ -5935,7 +5935,7 @@ sit_for (Lisp_Object timeout, bool reading, int do_display)
      || !NILP (Vexecuting_kbd_macro))
    return Qnil;
-  if (do_display >= 2)
+  if (display_option > 1)
    redisplay_preserve_echo_area (2);
  if (INTEGERP (timeout))
diff --git a/src/editfns.c b/src/editfns.c
index fc6465a3d46..19fad7130a7 100644
--- a/src/editfns.c
+++ b/src/editfns.c
@@ -819,9 +819,13 @@ save_excursion_save (void)
 {
  bool visible = (XBUFFER (XWINDOW (selected_window)->buffer)
                  == current_buffer);
+  /* Do not copy the mark if it points to nowhere.  */
+  Lisp_Object mark = (XMARKER (BVAR (current_buffer, mark))->buffer
+                      ? Fcopy_marker (BVAR (current_buffer, mark), Qnil)
+                      : Qnil);
  return Fcons (Fpoint_marker (),
-                Fcons (Fcopy_marker (BVAR (current_buffer, mark), Qnil),
+                Fcons (mark,
                       Fcons (visible ? Qt : Qnil,
                              Fcons (BVAR (current_buffer, mark_active),
                                     selected_window))));
@@ -856,9 +860,14 @@ save_excursion_restore (Lisp_Object info)
  info = XCDR (info);
  tem = XCAR (info);
  omark = Fmarker_position (BVAR (current_buffer, mark));
-  Fset_marker (BVAR (current_buffer, mark), tem, Fcurrent_buffer ());
+  if (NILP (tem))
-  nmark = Fmarker_position (tem);
+    unchain_marker (XMARKER (BVAR (current_buffer, mark)));
-  unchain_marker (XMARKER (tem));
+  else
+    {
+      Fset_marker (BVAR (current_buffer, mark), tem, Fcurrent_buffer ());
+      nmark = Fmarker_position (tem);
+      unchain_marker (XMARKER (tem));
+    }
  /* visible */
  info = XCDR (info);
diff --git a/src/eval.c b/src/eval.c
index 4d200fbc2bd..975204da017 100644
--- a/src/eval.c
+++ b/src/eval.c
@@ -1876,9 +1876,11 @@ this does nothing and returns nil.  */)
  CHECK_STRING (file);
  /* If function is defined and not as an autoload, don't override.  */
-  if (!EQ (XSYMBOL (function)->function, Qunbound)
+  if ((CONSP (XSYMBOL (function)->function)
-      && !(CONSP (XSYMBOL (function)->function)
+       && EQ (XCAR (XSYMBOL (function)->function), Qautoload)))
-           && EQ (XCAR (XSYMBOL (function)->function), Qautoload)))
+    /* Remember that the function was already an autoload.  */
+    LOADHIST_ATTACH (Fcons (Qt, function));
+  else if (!EQ (XSYMBOL (function)->function, Qunbound))
    return Qnil;
  if (NILP (Vpurify_flag))
diff --git a/src/indent.c b/src/indent.c
index b368a7aeb09..81a63455ecb 100644
--- a/src/indent.c
+++ b/src/indent.c
@@ -30,7 +30,6 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include "frame.h"
 #include "window.h"
 #include "termchar.h"
-#include "termopts.h"
 #include "disptab.h"
 #include "intervals.h"
 #include "dispextern.h"
diff --git a/src/keyboard.c b/src/keyboard.c
index 2a37e510ba4..68656d527e8 100644
--- a/src/keyboard.c
+++ b/src/keyboard.c
@@ -86,8 +86,8 @@ KBOARD *initial_kboard;
 KBOARD *current_kboard;
 KBOARD *all_kboards;
-/* Nonzero in the single-kboard state, 0 in the any-kboard state.  */
+/* True in the single-kboard state, false in the any-kboard state.  */
-static int single_kboard;
+static bool single_kboard;
 /* Non-nil disable property on a command means
   do not execute it; call disabled-command-function's value instead.  */
@@ -113,9 +113,9 @@ static Lisp_Object recent_keys;
 Lisp_Object this_command_keys;
 ptrdiff_t this_command_key_count;
-/* 1 after calling Freset_this_command_lengths.
+/* True after calling Freset_this_command_lengths.
-   Usually it is 0.  */
+   Usually it is false.  */
-static int this_command_key_count_reset;
+static bool this_command_key_count_reset;
 /* This vector is used as a buffer to record the events that were actually read
   by read_key_sequence.  */
@@ -140,11 +140,11 @@ static ptrdiff_t before_command_echo_length;
 static sys_jmp_buf getcjmp;
 /* True while doing kbd input.  */
-int waiting_for_input;
+bool waiting_for_input;
 /* True while displaying for echoing.   Delays C-g throwing.  */
-static int echoing;
+static bool echoing;
 /* Non-null means we can start echoing at the next input pause even
   though there is something in the echo area.  */
@@ -163,8 +163,8 @@ struct kboard *echo_kboard;
 Lisp_Object echo_message_buffer;
-/* Nonzero means C-g should cause immediate error-signal.  */
+/* True means C-g should cause immediate error-signal.  */
-int immediate_quit;
+bool immediate_quit;
 /* Character that causes a quit.  Normally C-g.
@@ -270,7 +270,7 @@ static Lisp_Object Qhelp_form_show;
 static FILE *dribble;
 /* Nonzero if input is available.  */
-int input_pending;
+bool input_pending;
 /* Circular buffer for pre-read keyboard input.  */
@@ -375,18 +375,18 @@ static ptrdiff_t echo_length (void);
 static Lisp_Object Qpolling_period;
 /* Incremented whenever a timer is run.  */
-int timers_run;
+unsigned timers_run;
 /* Address (if not 0) of EMACS_TIME to zero out if a SIGIO interrupt
   happens.  */
 EMACS_TIME *input_available_clear_time;
-/* Nonzero means use SIGIO interrupts; zero means use CBREAK mode.
+/* True means use SIGIO interrupts; false means use CBREAK mode.
-   Default is 1 if INTERRUPT_INPUT is defined.  */
+   Default is true if INTERRUPT_INPUT is defined.  */
-int interrupt_input;
+bool interrupt_input;
 /* Nonzero while interrupts are temporarily deferred during redisplay.  */
-int interrupts_deferred;
+bool interrupts_deferred;
 /* If we support a window system, turn on the code to poll periodically
   to detect C-g.  It isn't actually used when doing interrupt input.  */
@@ -414,10 +414,10 @@ static EMACS_TIME timer_last_idleness_start_time;
 /* Function for init_keyboard to call with no args (if nonzero).  */
 static void (*keyboard_init_hook) (void);
-static void get_input_pending (int *, int);
+static bool get_input_pending (int);
-static int readable_events (int);
+static bool readable_events (int);
 static Lisp_Object read_char_x_menu_prompt (ptrdiff_t, Lisp_Object *,
-                                            Lisp_Object, int *);
+                                            Lisp_Object, bool *);
 static Lisp_Object read_char_minibuf_menu_prompt (int, ptrdiff_t,
                                                  Lisp_Object *);
 static Lisp_Object make_lispy_event (struct input_event *);
@@ -431,7 +431,7 @@ static Lisp_Object modify_event_symbol (ptrdiff_t, int, Lisp_Object,
                                        Lisp_Object, const char *const *,
                                        Lisp_Object *, ptrdiff_t);
 static Lisp_Object make_lispy_switch_frame (Lisp_Object);
-static int help_char_p (Lisp_Object);
+static bool help_char_p (Lisp_Object);
 static void save_getcjmp (sys_jmp_buf);
 static void restore_getcjmp (sys_jmp_buf);
 static Lisp_Object apply_modifiers (int, Lisp_Object);
@@ -441,7 +441,7 @@ static Lisp_Object restore_kboard_configuration (Lisp_Object);
 static void deliver_input_available_signal (int signo);
 #endif
 static void handle_interrupt (bool);
-static _Noreturn void quit_throw_to_read_char (int);
+static _Noreturn void quit_throw_to_read_char (bool);
 static void process_special_events (void);
 static void timer_start_idle (void);
 static void timer_stop_idle (void);
@@ -519,7 +519,7 @@ echo_char (Lisp_Object c)
      if (INTEGERP (c))
        {
-          ptr = push_key_description (XINT (c), ptr, 1);
+          ptr = push_key_description (XINT (c), ptr);
        }
      else if (SYMBOLP (c))
        {
@@ -928,7 +928,7 @@ pop_kboard (void)
 {
  struct terminal *t;
  struct kboard_stack *p = kboard_stack;
-  int found = 0;
+  bool found = 0;
  for (t = terminal_list; t; t = t->next_terminal)
    {
      if (t->kboard == p->kboard)
@@ -961,7 +961,7 @@ pop_kboard (void)
 void
 temporarily_switch_to_single_kboard (struct frame *f)
 {
-  int was_locked = single_kboard;
+  bool was_locked = single_kboard;
  if (was_locked)
    {
      if (f != NULL && FRAME_KBOARD (f) != current_kboard)
@@ -1060,12 +1060,7 @@ cmd_error (Lisp_Object data)
  Vprint_length = old_length;
  Vquit_flag = Qnil;
  Vinhibit_quit = Qnil;
-#if 0 /* This shouldn't be necessary anymore.  --lorentey  */
-  if (command_loop_level == 0 && minibuf_level == 0)
-    any_kboard_state ();
-#endif
  return make_number (0);
 }
@@ -1152,12 +1147,6 @@ command_loop (void)
    while (1)
      {
        internal_catch (Qtop_level, top_level_1, Qnil);
-#if 0 /* This shouldn't be necessary anymore.  --lorentey  */
-        /* Reset single_kboard in case top-level set it while
-           evaluating an -f option, or we are stuck there for some
-           other reason.  */
-        any_kboard_state ();
-#endif
        internal_catch (Qtop_level, command_loop_2, Qnil);
        executing_kbd_macro = Qnil;
@@ -1268,8 +1257,7 @@ tracking_off (Lisp_Object old_value)
      if (!readable_events (READABLE_EVENTS_DO_TIMERS_NOW))
        {
          redisplay_preserve_echo_area (6);
-          get_input_pending (&input_pending,
+          get_input_pending (READABLE_EVENTS_DO_TIMERS_NOW);
-                             READABLE_EVENTS_DO_TIMERS_NOW);
        }
    }
  return Qnil;
@@ -1304,7 +1292,7 @@ usage: (track-mouse BODY...)  */)
 #if !defined HAVE_WINDOW_SYSTEM || defined USE_GTK || defined HAVE_NS
 static
 #endif
-int ignore_mouse_drag_p;
+bool ignore_mouse_drag_p;
 static FRAME_PTR
 some_mouse_moved (void)
@@ -1332,9 +1320,9 @@ some_mouse_moved (void)
   sans error-handling encapsulation.  */
 static int read_key_sequence (Lisp_Object *, int, Lisp_Object,
-                              int, int, int);
+                              bool, bool, bool);
 void safe_run_hooks (Lisp_Object);
-static void adjust_point_for_property (ptrdiff_t, int);
+static void adjust_point_for_property (ptrdiff_t, bool);
 /* Cancel hourglass from protect_unwind.
   ARG is not used.  */
@@ -1362,10 +1350,7 @@ command_loop_1 (void)
  int i;
  EMACS_INT prev_modiff = 0;
  struct buffer *prev_buffer = NULL;
-#if 0 /* This shouldn't be necessary anymore.  --lorentey  */
+  bool already_adjusted = 0;
-  int was_locked = single_kboard;
-#endif
-  int already_adjusted = 0;
  kset_prefix_arg (current_kboard, Qnil);
  kset_last_prefix_arg (current_kboard, Qnil);
@@ -1734,10 +1719,6 @@ command_loop_1 (void)
      if (!NILP (KVAR (current_kboard, defining_kbd_macro))
          && NILP (KVAR (current_kboard, Vprefix_arg)))
        finalize_kbd_macro_chars ();
-#if 0 /* This shouldn't be necessary anymore.  --lorentey  */
-      if (!was_locked)
-        any_kboard_state ();
-#endif
    }
 }
@@ -1747,7 +1728,7 @@ command_loop_1 (void)
   LAST_PT is the last position of point.  */
 static void
-adjust_point_for_property (ptrdiff_t last_pt, int modified)
+adjust_point_for_property (ptrdiff_t last_pt, bool modified)
 {
  ptrdiff_t beg, end;
  Lisp_Object val, overlay, tmp;
@@ -1755,7 +1736,7 @@ adjust_point_for_property (ptrdiff_t last_pt, int modified)
     suppress the point adjustment for automatic composition so that a
     user can keep inserting another character at point or keep
     deleting characters around point.  */
-  int check_composition = ! modified, check_display = 1, check_invisible = 1;
+  bool check_composition = ! modified, check_display = 1, check_invisible = 1;
  ptrdiff_t orig_pt = PT;
  /* FIXME: cycling is probably not necessary because these properties
@@ -1794,7 +1775,8 @@ adjust_point_for_property (ptrdiff_t last_pt, int modified)
      check_display = 0;
      if (check_invisible && PT > BEGV && PT < ZV)
        {
-          int inv, ellipsis = 0;
+          int inv;
+          bool ellipsis = 0;
          beg = end = PT;
          /* Find boundaries `beg' and `end' of the invisible area, if any.  */
@@ -1923,7 +1905,7 @@ safe_run_hooks_error (Lisp_Object error_data)
  if (SYMBOLP (hook))
    {
      Lisp_Object val;
-      int found = 0;
+      bool found = 0;
      Lisp_Object newval = Qnil;
      for (val = find_symbol_value (hook); CONSP (val); val = XCDR (val))
        if (EQ (fun, XCAR (val)))
@@ -2053,9 +2035,9 @@ start_polling (void)
 #endif
 }
-/* Nonzero if we are using polling to handle input asynchronously.  */
+/* True if we are using polling to handle input asynchronously.  */
-int
+bool
 input_polling_used (void)
 {
 #ifdef POLL_FOR_INPUT
@@ -2231,7 +2213,7 @@ show_help_echo (Lisp_Object help, Lisp_Object window, Lisp_Object object,
 /* Input of single characters from keyboard */
-static Lisp_Object kbd_buffer_get_event (KBOARD **kbp, int *used_mouse_menu,
+static Lisp_Object kbd_buffer_get_event (KBOARD **kbp, bool *used_mouse_menu,
                                         EMACS_TIME *end_time);
 static void record_char (Lisp_Object c);
@@ -2268,9 +2250,9 @@ do { if (polling_stopped_here) start_polling ();	\
   not to run input methods, but in other respects to act as if
   not reading a key sequence.
-   If USED_MOUSE_MENU is non-null, then we set *USED_MOUSE_MENU to 1
+   If USED_MOUSE_MENU is non-null, then set *USED_MOUSE_MENU to true
-   if we used a mouse menu to read the input, or zero otherwise.  If
+   if we used a mouse menu to read the input, or false otherwise.  If
-   USED_MOUSE_MENU is null, we don't dereference it.
+   USED_MOUSE_MENU is null, don't dereference it.
   Value is -2 when we find input on another keyboard.  A second call
   to read_char will read it.
@@ -2284,7 +2266,7 @@ do { if (polling_stopped_here) start_polling ();	\
 Lisp_Object
 read_char (int commandflag, ptrdiff_t nmaps, Lisp_Object *maps,
           Lisp_Object prev_event,
-           int *used_mouse_menu, EMACS_TIME *end_time)
+           bool *used_mouse_menu, EMACS_TIME *end_time)
 {
  Lisp_Object c;
  ptrdiff_t jmpcount;
@@ -2293,9 +2275,9 @@ read_char (int commandflag, ptrdiff_t nmaps, Lisp_Object *maps,
  Lisp_Object tem, save;
  volatile Lisp_Object previous_echo_area_message;
  volatile Lisp_Object also_record;
-  volatile int reread;
+  volatile bool reread;
  struct gcpro gcpro1, gcpro2;
-  int volatile polling_stopped_here = 0;
+  bool volatile polling_stopped_here = 0;
  struct kboard *orig_kboard = current_kboard;
  also_record = Qnil;
@@ -2331,7 +2313,7 @@ read_char (int commandflag, ptrdiff_t nmaps, Lisp_Object *maps,
  if (CONSP (Vunread_command_events))
    {
-      int was_disabled = 0;
+      bool was_disabled = 0;
      c = XCAR (Vunread_command_events);
      Vunread_command_events = XCDR (Vunread_command_events);
@@ -2433,7 +2415,7 @@ read_char (int commandflag, ptrdiff_t nmaps, Lisp_Object *maps,
  /* if redisplay was requested */
  if (commandflag >= 0)
    {
-      int echo_current = EQ (echo_message_buffer, echo_area_buffer[0]);
+      bool echo_current = EQ (echo_message_buffer, echo_area_buffer[0]);
        /* If there is pending input, process any events which are not
           user-visible, such as X selection_request events.  */
@@ -2865,12 +2847,6 @@ read_char (int commandflag, ptrdiff_t nmaps, Lisp_Object *maps,
  if (!NILP (tem))
    {
      struct buffer *prev_buffer = current_buffer;
-#if 0 /* This shouldn't be necessary anymore. --lorentey  */
-      int was_locked = single_kboard;
-      ptrdiff_t count = SPECPDL_INDEX ();
-      record_single_kboard_state ();
-#endif
      last_input_event = c;
      Fcommand_execute (tem, Qnil, Fvector (1, &last_input_event), Qt);
@@ -2881,13 +2857,6 @@ read_char (int commandflag, ptrdiff_t nmaps, Lisp_Object *maps,
           example banishing the mouse under mouse-avoidance-mode.  */
        timer_resume_idle ();
-#if 0 /* This shouldn't be necessary anymore. --lorentey  */
-      /* Resume allowing input from any kboard, if that was true before.  */
-      if (!was_locked)
-        any_kboard_state ();
-      unbind_to (count, Qnil);
-#endif
      if (current_buffer != prev_buffer)
        {
          /* The command may have changed the keymaps.  Pretend there
@@ -2995,15 +2964,15 @@ read_char (int commandflag, ptrdiff_t nmaps, Lisp_Object *maps,
    {
      Lisp_Object keys;
      ptrdiff_t key_count;
-      int key_count_reset;
+      bool key_count_reset;
      struct gcpro gcpro1;
      ptrdiff_t count = SPECPDL_INDEX ();
      /* Save the echo status.  */
-      int saved_immediate_echo = current_kboard->immediate_echo;
+      bool saved_immediate_echo = current_kboard->immediate_echo;
      struct kboard *saved_ok_to_echo = ok_to_echo_at_next_pause;
      Lisp_Object saved_echo_string = KVAR (current_kboard, echo_string);
-      int saved_echo_after_prompt = current_kboard->echo_after_prompt;
+      ptrdiff_t saved_echo_after_prompt = current_kboard->echo_after_prompt;
 #if 0
      if (before_command_restore_flag)
@@ -3204,9 +3173,9 @@ record_menu_key (Lisp_Object c)
  num_input_events++;
 }
-/* Return 1 if should recognize C as "the help character".  */
+/* Return true if should recognize C as "the help character".  */
-static int
+static bool
 help_char_p (Lisp_Object c)
 {
  Lisp_Object tail;
@@ -3378,7 +3347,7 @@ restore_getcjmp (sys_jmp_buf temp)
 /* Return true if there are any events in the queue that read-char
   would return.  If this returns false, a read-char would block.  */
-static int
+static bool
 readable_events (int flags)
 {
  if (flags & READABLE_EVENTS_DO_TIMERS_NOW)
@@ -3717,15 +3686,14 @@ discard_mouse_events (void)
 }
-/* Return non-zero if there are any real events waiting in the event
+/* Return true if there are any real events waiting in the event
   buffer, not counting `NO_EVENT's.
-   If DISCARD is non-zero, discard NO_EVENT events at the front of
+   Discard NO_EVENT events at the front of the input queue, possibly
-   the input queue, possibly leaving the input queue empty if there
+   leaving the input queue empty if there are no real input events.  */
-   are no real input events.  */
-int
+bool
-kbd_buffer_events_waiting (int discard)
+kbd_buffer_events_waiting (void)
 {
  struct input_event *sp;
@@ -3737,9 +3705,7 @@ kbd_buffer_events_waiting (int discard)
        sp = kbd_buffer;
    }
-  if (discard)
+  kbd_fetch_ptr = sp;
-    kbd_fetch_ptr = sp;
  return sp != kbd_store_ptr && sp->kind != NO_EVENT;
 }
@@ -3761,7 +3727,7 @@ clear_event (struct input_event *event)
 static Lisp_Object
 kbd_buffer_get_event (KBOARD **kbp,
-                      int *used_mouse_menu,
+                      bool *used_mouse_menu,
                      EMACS_TIME *end_time)
 {
  Lisp_Object obj;
@@ -4216,14 +4182,14 @@ process_special_events (void)
   are ripe, and return, without reading any user-visible events.  */
 void
-swallow_events (int do_display)
+swallow_events (bool do_display)
 {
-  int old_timers_run;
+  unsigned old_timers_run;
  process_special_events ();
  old_timers_run = timers_run;
-  get_input_pending (&input_pending, READABLE_EVENTS_DO_TIMERS_NOW);
+  get_input_pending (READABLE_EVENTS_DO_TIMERS_NOW);
  if (timers_run != old_timers_run && do_display)
    redisplay_preserve_echo_area (7);
@@ -4350,7 +4316,7 @@ timer_check_2 (Lisp_Object timers, Lisp_Object idle_timers)
      EMACS_TIME difference;
      EMACS_TIME timer_difference = invalid_emacs_time ();
      EMACS_TIME idle_timer_difference = invalid_emacs_time ();
-      int ripe, timer_ripe = 0, idle_timer_ripe = 0;
+      bool ripe, timer_ripe = 0, idle_timer_ripe = 0;
      /* Set TIMER and TIMER_DIFFERENCE
         based on the next ordinary timer.
@@ -5454,7 +5420,7 @@ make_lispy_event (struct input_event *event)
 #endif
      {
        int button = event->code;
-        int is_double;
+        bool is_double;
        Lisp_Object position;
        Lisp_Object *start_pos_ptr;
        Lisp_Object start_pos;
@@ -5735,7 +5701,7 @@ make_lispy_event (struct input_event *event)
          struct frame *fr;
          int fuzz;
          int symbol_num;
-          int is_double;
+          bool is_double;
          if (WINDOWP (event->frame_or_window))
            fr = XFRAME (XWINDOW (event->frame_or_window)->frame);
@@ -6677,11 +6643,11 @@ parse_solitary_modifier (Lisp_Object symbol)
  return 0;
 }
-/* Return 1 if EVENT is a list whose elements are all integers or symbols.
+/* Return true if EVENT is a list whose elements are all integers or symbols.
   Such a list is not valid as an event,
   but it can be a Lucid-style event type list.  */
-int
+bool
 lucid_event_type_list_p (Lisp_Object object)
 {
  Lisp_Object tail;
@@ -6706,8 +6672,10 @@ lucid_event_type_list_p (Lisp_Object object)
  return NILP (tail);
 }
-/* Store into *addr a value nonzero if terminal input chars are available.
+/* Return true if terminal input chars are available.
-   Serves the purpose of ioctl (0, FIONREAD, addr)
+   Also, store the return value into INPUT_PENDING.
+   Serves the purpose of ioctl (0, FIONREAD, ...)
   but works even if FIONREAD does not exist.
   (In fact, this may actually read some input.)
@@ -6718,19 +6686,21 @@ lucid_event_type_list_p (Lisp_Object object)
   If READABLE_EVENTS_IGNORE_SQUEEZABLES is set in FLAGS, ignore mouse
   movements and toolkit scroll bar thumb drags.  */
-static void
+static bool
-get_input_pending (int *addr, int flags)
+get_input_pending (int flags)
 {
  /* First of all, have we already counted some input?  */
-  *addr = (!NILP (Vquit_flag) || readable_events (flags));
+  input_pending = (!NILP (Vquit_flag) || readable_events (flags));
  /* If input is being read as it arrives, and we have none, there is none.  */
-  if (*addr > 0 || (interrupt_input && ! interrupts_deferred))
+  if (!input_pending && (!interrupt_input || interrupts_deferred))
-    return;
+    {
+      /* Try to read some input and see how much we get.  */
+      gobble_input ();
+      input_pending = (!NILP (Vquit_flag) || readable_events (flags));
+    }
-  /* Try to read some input and see how much we get.  */
+  return input_pending;
-  gobble_input ();
-  *addr = (!NILP (Vquit_flag) || readable_events (flags));
 }
 /* Put a BUFFER_SWITCH_EVENT in the buffer
@@ -6780,7 +6750,7 @@ int
 gobble_input (void)
 {
  int nread = 0;
-  int err = 0;
+  bool err = 0;
  struct terminal *t;
  /* Store pending user signal events, if any.  */
@@ -7350,9 +7320,9 @@ static const char* separator_names[] = {
  0,
 };
-/* Return non-zero if LABEL specifies a separator.  */
+/* Return true if LABEL specifies a separator.  */
-int
+bool
 menu_separator_name_p (const char *label)
 {
  if (!label)
@@ -7527,6 +7497,7 @@ menu_bar_item (Lisp_Object key, Lisp_Object item, Lisp_Object dummy1, void *dumm
 {
  struct gcpro gcpro1;
  int i;
+  bool parsed;
  Lisp_Object tem;
  if (EQ (item, Qundefined))
@@ -7558,9 +7529,9 @@ menu_bar_item (Lisp_Object key, Lisp_Object item, Lisp_Object dummy1, void *dumm
     parse_menu_item, so that if it turns out it wasn't a menu item,
     it still correctly hides any further menu item.  */
  GCPRO1 (key);
-  i = parse_menu_item (item, 1);
+  parsed = parse_menu_item (item, 1);
  UNGCPRO;
-  if (!i)
+  if (!parsed)
    return;
  item = AREF (item_properties, ITEM_PROPERTY_DEF);
@@ -7636,7 +7607,7 @@ menu_item_eval_property (Lisp_Object sexpr)
   parse_menu_item returns true if the item is a menu item and false
   otherwise.  */
-int
+bool
 parse_menu_item (Lisp_Object item, int inmenubar)
 {
  Lisp_Object def, tem, item_string, start;
@@ -7936,7 +7907,7 @@ static Lisp_Object QCrtl;
 static void init_tool_bar_items (Lisp_Object);
 static void process_tool_bar_item (Lisp_Object, Lisp_Object, Lisp_Object, void*);
-static int parse_tool_bar_item (Lisp_Object, Lisp_Object);
+static bool parse_tool_bar_item (Lisp_Object, Lisp_Object);
 static void append_tool_bar_item (void);
@@ -8069,7 +8040,7 @@ set_prop (ptrdiff_t idx, Lisp_Object val)
 /* Parse a tool bar item specification ITEM for key KEY and return the
-   result in tool_bar_item_properties.  Value is zero if ITEM is
+   result in tool_bar_item_properties.  Value is false if ITEM is
   invalid.
   ITEM is a list `(menu-item CAPTION BINDING PROPS...)'.
@@ -8114,12 +8085,13 @@ set_prop (ptrdiff_t idx, Lisp_Object val)
   A text label to show with the tool bar button if labels are enabled.  */
-static int
+static bool
 parse_tool_bar_item (Lisp_Object key, Lisp_Object item)
 {
  Lisp_Object filter = Qnil;
  Lisp_Object caption;
-  int i, have_label = 0;
+  int i;
+  bool have_label = 0;
  /* Definition looks like `(menu-item CAPTION BINDING PROPS...)'.
     Rule out items that aren't lists, don't start with
@@ -8376,9 +8348,9 @@ append_tool_bar_item (void)
   PREV_EVENT is the previous input event, or nil if we are reading
   the first event of a key sequence.
-   If USED_MOUSE_MENU is non-null, then we set *USED_MOUSE_MENU to 1
+   If USED_MOUSE_MENU is non-null, set *USED_MOUSE_MENU to true
-   if we used a mouse menu to read the input, or zero otherwise.  If
+   if we used a mouse menu to read the input, or false otherwise.  If
-   USED_MOUSE_MENU is null, we don't dereference it.
+   USED_MOUSE_MENU is null, don't dereference it.
   The prompting is done based on the prompt-string of the map
   and the strings associated with various map elements.
@@ -8391,7 +8363,7 @@ append_tool_bar_item (void)
 static Lisp_Object
 read_char_x_menu_prompt (ptrdiff_t nmaps, Lisp_Object *maps,
-                         Lisp_Object prev_event, int *used_mouse_menu)
+                         Lisp_Object prev_event, bool *used_mouse_menu)
 {
 #ifdef HAVE_MENUS
  ptrdiff_t mapno;
@@ -8485,7 +8457,7 @@ read_char_minibuf_menu_prompt (int commandflag,
  /* FIXME: Use the minibuffer's frame width.  */
  ptrdiff_t width = FRAME_COLS (SELECTED_FRAME ()) - 4;
  ptrdiff_t idx = -1;
-  int nobindings = 1;
+  bool nobindings = 1;
  Lisp_Object rest, vector;
  char *menu;
@@ -8533,7 +8505,7 @@ read_char_minibuf_menu_prompt (int commandflag,
  /* Present the documented bindings, a line at a time.  */
  while (1)
    {
-      int notfirst = 0;
+      bool notfirst = 0;
      ptrdiff_t i = nlength;
      Lisp_Object obj;
      Lisp_Object orig_defn_macro;
@@ -8589,8 +8561,8 @@ read_char_minibuf_menu_prompt (int commandflag,
              /* Ignore the element if it has no prompt string.  */
              if (INTEGERP (event) && parse_menu_item (elt, -1))
                {
-                  /* 1 if the char to type matches the string.  */
+                  /* True if the char to type matches the string.  */
-                  int char_matches;
+                  bool char_matches;
                  Lisp_Object upcased_event, downcased_event;
                  Lisp_Object desc = Qnil;
                  Lisp_Object s
@@ -8642,7 +8614,7 @@ read_char_minibuf_menu_prompt (int commandflag,
                          i += 2;
                        }
                      notfirst = 1;
-                      nobindings = 0 ;
+                      nobindings = 0;
                      /* If the char to type doesn't match the string's
                         first char, explicitly show what char to type.  */
@@ -8776,14 +8748,14 @@ typedef struct keyremap
 /* Lookup KEY in MAP.
   MAP is a keymap mapping keys to key vectors or functions.
-   If the mapping is a function and DO_FUNCTION is non-zero, then
+   If the mapping is a function and DO_FUNCALL is true,
   the function is called with PROMPT as parameter and its return
   value is used as the return value of this function (after checking
   that it is indeed a vector).  */
 static Lisp_Object
 access_keymap_keyremap (Lisp_Object map, Lisp_Object key, Lisp_Object prompt,
-                        int do_funcall)
+                        bool do_funcall)
 {
  Lisp_Object next;
@@ -8822,15 +8794,15 @@ access_keymap_keyremap (Lisp_Object map, Lisp_Object key, Lisp_Object prompt,
   BUFSIZE is its maximum size.
   FKEY is a pointer to the keyremap structure to use.
   INPUT is the index of the last element in KEYBUF.
-   DOIT if non-zero says that the remapping can actually take place.
+   DOIT if true says that the remapping can actually take place.
   DIFF is used to return the number of keys added/removed by the remapping.
   PARENT is the root of the keymap.
   PROMPT is the prompt to use if the remapping happens through a function.
-   The return value is non-zero if the remapping actually took place.  */
+   Return true if the remapping actually took place.  */
-static int
+static bool
 keyremap_step (Lisp_Object *keybuf, int bufsize, volatile keyremap *fkey,
-               int input, int doit, int *diff, Lisp_Object prompt)
+               int input, bool doit, int *diff, Lisp_Object prompt)
 {
  Lisp_Object next, key;
@@ -8884,7 +8856,7 @@ keyremap_step (Lisp_Object *keybuf, int bufsize, volatile keyremap *fkey,
  return 0;
 }
-static int
+static bool
 test_undefined (Lisp_Object binding)
 {
  return (EQ (binding, Qundefined)
@@ -8926,13 +8898,13 @@ test_undefined (Lisp_Object binding)
   off the switch-frame event until later; the next call to
   read_char will return it.
-   If FIX_CURRENT_BUFFER is nonzero, we restore current_buffer
+   If FIX_CURRENT_BUFFER, we restore current_buffer
   from the selected window's buffer.  */
 static int
 read_key_sequence (Lisp_Object *keybuf, int bufsize, Lisp_Object prompt,
-                   int dont_downcase_last, int can_return_switch_frame,
+                   bool dont_downcase_last, bool can_return_switch_frame,
-                   int fix_current_buffer)
+                   bool fix_current_buffer)
 {
  Lisp_Object from_string;
  ptrdiff_t count = SPECPDL_INDEX ();
@@ -8965,7 +8937,7 @@ read_key_sequence (Lisp_Object *keybuf, int bufsize, Lisp_Object prompt,
     key sequence.  */
  Lisp_Object orig_keymap;
-  /* 1 if we have already considered switching to the local-map property
+  /* Positive if we have already considered switching to the local-map property
     of the place where a mouse click occurred.  */
  int localized_local_map = 0;
@@ -9005,10 +8977,10 @@ read_key_sequence (Lisp_Object *keybuf, int bufsize, Lisp_Object prompt,
  /* Likewise, for key_translation_map and input-decode-map.  */
  keyremap keytran, indec;
-  /* Non-zero if we are trying to map a key by changing an upper-case
+  /* True if we are trying to map a key by changing an upper-case
     letter to lower case, or a shifted function key to an unshifted
     one.  */
-  int shift_translated = 0;
+  bool shift_translated = 0;
  /* If we receive a `switch-frame' or `select-window' event in the middle of
     a key sequence, we put it off for later.
@@ -9024,7 +8996,7 @@ read_key_sequence (Lisp_Object *keybuf, int bufsize, Lisp_Object prompt,
  int original_uppercase_position = -1;
  /* Gets around Microsoft compiler limitations.  */
-  int dummyflag = 0;
+  bool dummyflag = 0;
  struct buffer *starting_buffer;
@@ -9186,7 +9158,7 @@ read_key_sequence (Lisp_Object *keybuf, int bufsize, Lisp_Object prompt,
         : (/* indec.start < t || fkey.start < t || */ keytran.start < t))
    {
      Lisp_Object key;
-      int used_mouse_menu = 0;
+      bool used_mouse_menu = 0;
      /* Where the last real key started.  If we need to throw away a
         key that has expanded into more than one element of keybuf
@@ -9280,7 +9252,7 @@ read_key_sequence (Lisp_Object *keybuf, int bufsize, Lisp_Object prompt,
                   return.  Any better way to fix this? -- cyd  */
                || (interrupted_kboard != current_kboard))
              {
-                int found = 0;
+                bool found = 0;
                struct kboard *k;
                for (k = all_kboards; k; k = k->next_kboard)
@@ -9834,7 +9806,8 @@ read_key_sequence (Lisp_Object *keybuf, int bufsize, Lisp_Object prompt,
      while (indec.end < t)
        {
          struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
-          int done, diff;
+          bool done;
+          int diff;
          GCPRO4 (indec.map, fkey.map, keytran.map, delayed_switch_frame);
          done = keyremap_step (keybuf, bufsize, &indec, max (t, mock_input),
@@ -9868,7 +9841,8 @@ read_key_sequence (Lisp_Object *keybuf, int bufsize, Lisp_Object prompt,
        while (fkey.end < indec.start)
          {
            struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
-            int done, diff;
+            bool done;
+            int diff;
            GCPRO4 (indec.map, fkey.map, keytran.map, delayed_switch_frame);
            done = keyremap_step (keybuf, bufsize, &fkey,
@@ -9897,7 +9871,8 @@ read_key_sequence (Lisp_Object *keybuf, int bufsize, Lisp_Object prompt,
      while (keytran.end < fkey.start)
        {
          struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
-          int done, diff;
+          bool done;
+          int diff;
          GCPRO4 (indec.map, fkey.map, keytran.map, delayed_switch_frame);
          done = keyremap_step (keybuf, bufsize, &keytran, max (t, mock_input),
@@ -10283,38 +10258,32 @@ a special event, so ignore the prefix argument and don't clear it.  */)
-/* Return nonzero if input events are pending.  */
+/* Return true if input events are pending.  */
-int
+bool
 detect_input_pending (void)
 {
-  if (!input_pending)
+  return input_pending || get_input_pending (0);
-    get_input_pending (&input_pending, 0);
-  return input_pending;
 }
-/* Return nonzero if input events other than mouse movements are
+/* Return true if input events other than mouse movements are
   pending.  */
-int
+bool
 detect_input_pending_ignore_squeezables (void)
 {
-  if (!input_pending)
+  return input_pending || get_input_pending (READABLE_EVENTS_IGNORE_SQUEEZABLES);
-    get_input_pending (&input_pending, READABLE_EVENTS_IGNORE_SQUEEZABLES);
-  return input_pending;
 }
-/* Return nonzero if input events are pending, and run any pending timers.  */
+/* Return true if input events are pending, and run any pending timers.  */
-int
+bool
-detect_input_pending_run_timers (int do_display)
+detect_input_pending_run_timers (bool do_display)
 {
-  int old_timers_run = timers_run;
+  unsigned old_timers_run = timers_run;
  if (!input_pending)
-    get_input_pending (&input_pending, READABLE_EVENTS_DO_TIMERS_NOW);
+    get_input_pending (READABLE_EVENTS_DO_TIMERS_NOW);
  if (old_timers_run != timers_run && do_display)
    {
@@ -10345,13 +10314,13 @@ clear_input_pending (void)
  input_pending = 0;
 }
-/* Return nonzero if there are pending requeued events.
+/* Return true if there are pending requeued events.
   This isn't used yet.  The hope is to make wait_reading_process_output
   call it, and return if it runs Lisp code that unreads something.
   The problem is, kbd_buffer_get_event needs to be fixed to know what
   to do in that case.  It isn't trivial.  */
-int
+bool
 requeued_events_pending_p (void)
 {
  return (!NILP (Vunread_command_events));
@@ -10372,10 +10341,9 @@ if there is a doubt, the value is t.  */)
  /* Process non-user-visible events (Bug#10195).  */
  process_special_events ();
-  get_input_pending (&input_pending,
+  return (get_input_pending (READABLE_EVENTS_DO_TIMERS_NOW
-                     READABLE_EVENTS_DO_TIMERS_NOW
+                             | READABLE_EVENTS_FILTER_EVENTS)
-                     | READABLE_EVENTS_FILTER_EVENTS);
+          ? Qt : Qnil);
-  return input_pending > 0 ? Qt : Qnil;
 }
 DEFUN ("recent-keys", Frecent_keys, Srecent_keys, 0, 0, 0,
@@ -10881,7 +10849,7 @@ handle_interrupt (bool in_signal_handler)
 /* Handle a C-g by making read_char return C-g.  */
 static void
-quit_throw_to_read_char (int from_signal)
+quit_throw_to_read_char (bool from_signal)
 {
  /* When not called from a signal handler it is safe to call
     Lisp.  */
@@ -10911,7 +10879,7 @@ otherwise Emacs uses CBREAK mode.
 See also `current-input-mode'.  */)
  (Lisp_Object interrupt)
 {
-  int new_interrupt_input;
+  bool new_interrupt_input;
 #ifdef USABLE_SIGIO
 #ifdef HAVE_X_WINDOWS
  if (x_display_list != NULL)
diff --git a/src/keyboard.h b/src/keyboard.h
index d78c27fbf9b..e57c8cc7193 100644
--- a/src/keyboard.h
+++ b/src/keyboard.h
@@ -169,12 +169,12 @@ struct kboard
       reading from this KBOARD again until more input arrives.  */
    char kbd_queue_has_data;
-    /* Nonzero means echo each character as typed.  */
+    /* True means echo each character as typed.  */
-    char immediate_echo;
+    unsigned immediate_echo : 1;
    /* If we have echoed a prompt string specified by the user,
       this is its length in characters.  Otherwise this is -1.  */
-    char echo_after_prompt;
+    ptrdiff_t echo_after_prompt;
  };
 KEYBOARD_INLINE void
@@ -463,14 +463,14 @@ extern Lisp_Object Qhelp_echo;
 extern Lisp_Object Qmode_line, Qvertical_line, Qheader_line;
 /* True while doing kbd input.  */
-extern int waiting_for_input;
+extern bool waiting_for_input;
 /* Address (if not 0) of EMACS_TIME to zero out if a SIGIO interrupt
   happens.  */
 extern EMACS_TIME *input_available_clear_time;
 #if defined HAVE_WINDOW_SYSTEM && !defined USE_GTK && !defined HAVE_NS
-extern int ignore_mouse_drag_p;
+extern bool ignore_mouse_drag_p;
 #endif
 /* The primary selection.  */
@@ -482,7 +482,7 @@ struct input_event;
 extern Lisp_Object parse_modifiers (Lisp_Object);
 extern Lisp_Object reorder_modifiers (Lisp_Object);
 extern Lisp_Object read_char (int, ptrdiff_t, Lisp_Object *, Lisp_Object,
-                              int *, EMACS_TIME *);
+                              bool *, EMACS_TIME *);
 extern int parse_solitary_modifier (Lisp_Object symbol);
@@ -506,10 +506,10 @@ extern Time last_event_timestamp;
 extern int quit_char;
-extern int timers_run;
+extern unsigned int timers_run;
-extern int menu_separator_name_p (const char *);
+extern bool menu_separator_name_p (const char *);
-extern int parse_menu_item (Lisp_Object, int);
+extern bool parse_menu_item (Lisp_Object, int);
 extern void init_kboard (KBOARD *);
 extern void delete_kboard (KBOARD *);
@@ -524,15 +524,15 @@ extern void start_polling (void);
 extern void stop_polling (void);
 extern void set_poll_suppress_count (int);
 extern int gobble_input (void);
-extern int input_polling_used (void);
+extern bool input_polling_used (void);
 extern void clear_input_pending (void);
-extern int requeued_events_pending_p (void);
+extern bool requeued_events_pending_p (void);
 extern void bind_polling_period (int);
 extern int make_ctrl_char (int) ATTRIBUTE_CONST;
 extern void stuff_buffered_input (Lisp_Object);
 extern void clear_waiting_for_input (void);
-extern void swallow_events (int);
+extern void swallow_events (bool);
-extern int lucid_event_type_list_p (Lisp_Object);
+extern bool lucid_event_type_list_p (Lisp_Object);
 extern void kbd_buffer_store_event (struct input_event *);
 extern void kbd_buffer_store_event_hold (struct input_event *,
                                         struct input_event *);
@@ -544,7 +544,7 @@ extern void gen_help_event (Lisp_Object, Lisp_Object, Lisp_Object,
                            Lisp_Object, ptrdiff_t);
 extern void kbd_buffer_store_help_event (Lisp_Object, Lisp_Object);
 extern Lisp_Object menu_item_eval_property (Lisp_Object);
-extern int  kbd_buffer_events_waiting (int);
+extern bool kbd_buffer_events_waiting (void);
 extern void add_user_signal (int, const char *);
 extern int tty_read_avail_input (struct terminal *, struct input_event *);
diff --git a/src/keymap.c b/src/keymap.c
index 6ea142651bf..fbdd31e0de3 100644
--- a/src/keymap.c
+++ b/src/keymap.c
@@ -99,12 +99,12 @@ static void describe_command (Lisp_Object, Lisp_Object);
 static void describe_translation (Lisp_Object, Lisp_Object);
 static void describe_map (Lisp_Object, Lisp_Object,
                          void (*) (Lisp_Object, Lisp_Object),
-                          int, Lisp_Object, Lisp_Object*, int, int);
+                          bool, Lisp_Object, Lisp_Object*, bool, bool);
 static void describe_vector (Lisp_Object, Lisp_Object, Lisp_Object,
-                             void (*) (Lisp_Object, Lisp_Object), int,
+                             void (*) (Lisp_Object, Lisp_Object), bool,
-                             Lisp_Object, Lisp_Object, int, int);
+                             Lisp_Object, Lisp_Object, bool, bool);
 static void silly_event_symbol_error (Lisp_Object);
-static Lisp_Object get_keyelt (Lisp_Object, int);
+static Lisp_Object get_keyelt (Lisp_Object, bool);
 /* Keymap object support - constructors and predicates.                 */
@@ -207,15 +207,12 @@ when reading a key-sequence to be looked-up in this keymap.  */)
 /* Check that OBJECT is a keymap (after dereferencing through any
   symbols).  If it is, return it.
-   If AUTOLOAD is non-zero and OBJECT is a symbol whose function value
+   If AUTOLOAD and if OBJECT is a symbol whose function value
   is an autoload form, do the autoload and try again.
-   If AUTOLOAD is nonzero, callers must assume GC is possible.
+   If AUTOLOAD, callers must assume GC is possible.
-   If the map needs to be autoloaded, but AUTOLOAD is zero (and ERROR
-   is zero as well), return Qt.
   ERROR_IF_NOT_KEYMAP controls how we respond if OBJECT isn't a keymap.
-   If ERROR_IF_NOT_KEYMAP is non-zero, signal an error; otherwise,
+   If ERROR_IF_NOT_KEYMAP, signal an error; otherwise,
   just return Qnil.
   Note that most of the time, we don't want to pursue autoloads.
@@ -224,11 +221,11 @@ when reading a key-sequence to be looked-up in this keymap.  */)
   but it seems to me that only read_key_sequence, Flookup_key, and
   Fdefine_key should cause keymaps to be autoloaded.
-   This function can GC when AUTOLOAD is non-zero, because it calls
+   This function can GC when AUTOLOAD is true, because it calls
   Fautoload_do_load which can GC.  */
 Lisp_Object
-get_keymap (Lisp_Object object, int error_if_not_keymap, int autoload)
+get_keymap (Lisp_Object object, bool error_if_not_keymap, bool autoload)
 {
  Lisp_Object tem;
@@ -280,7 +277,7 @@ get_keymap (Lisp_Object object, int error_if_not_keymap, int autoload)
   We assume that KEYMAP is a valid keymap.  */
 static Lisp_Object
-keymap_parent (Lisp_Object keymap, int autoload)
+keymap_parent (Lisp_Object keymap, bool autoload)
 {
  Lisp_Object list;
@@ -307,7 +304,7 @@ If KEYMAP has no parent, return nil.  */)
 }
 /* Check whether MAP is one of MAPS parents.  */
-static int
+static bool
 keymap_memberp (Lisp_Object map, Lisp_Object maps)
 {
  if (NILP (map)) return 0;
@@ -365,19 +362,20 @@ Return PARENT.  PARENT should be nil or another keymap.  */)
   MAP must be a keymap or a list of keymaps.
-   If T_OK is non-zero, bindings for Qt are treated as default
+   If T_OK, bindings for Qt are treated as default
   bindings; any key left unmentioned by other tables and bindings is
   given the binding of Qt.
-   If T_OK is zero, bindings for Qt are not treated specially.
+   If not T_OK, bindings for Qt are not treated specially.
   If NOINHERIT, don't accept a subkeymap found in an inherited keymap.
-   Returns Qunbound if no binding was found (and returns Qnil if a nil
+   Return Qunbound if no binding was found (and return Qnil if a nil
   binding was found).  */
 static Lisp_Object
-access_keymap_1 (Lisp_Object map, Lisp_Object idx, int t_ok, int noinherit, int autoload)
+access_keymap_1 (Lisp_Object map, Lisp_Object idx,
+                 bool t_ok, bool noinherit, bool autoload)
 {
  /* If idx is a list (some sort of mouse click, perhaps?),
     the index we want to use is the car of the list, which
@@ -547,7 +545,7 @@ access_keymap_1 (Lisp_Object map, Lisp_Object idx, int t_ok, int noinherit, int
 Lisp_Object
 access_keymap (Lisp_Object map, Lisp_Object idx,
-               int t_ok, int noinherit, int autoload)
+               bool t_ok, bool noinherit, bool autoload)
 {
  Lisp_Object val = access_keymap_1 (map, idx, t_ok, noinherit, autoload);
  return EQ (val, Qunbound) ? Qnil : val;
@@ -630,9 +628,10 @@ map_keymap_call (Lisp_Object key, Lisp_Object val, Lisp_Object fun, void *dummy)
 }
 /* Same as map_keymap_internal, but traverses parent keymaps as well.
-   A non-zero AUTOLOAD indicates that autoloaded keymaps should be loaded.  */
+   AUTOLOAD indicates that autoloaded keymaps should be loaded.  */
 void
-map_keymap (Lisp_Object map, map_keymap_function_t fun, Lisp_Object args, void *data, int autoload)
+map_keymap (Lisp_Object map, map_keymap_function_t fun, Lisp_Object args,
+            void *data, bool autoload)
 {
  struct gcpro gcpro1;
  GCPRO1 (args);
@@ -711,13 +710,13 @@ usage: (map-keymap FUNCTION KEYMAP)  */)
   Also if OBJECT has a menu string as the first element,
   remove that.  Also remove a menu help string as second element.
-   If AUTOLOAD is nonzero, load autoloadable keymaps
+   If AUTOLOAD, load autoloadable keymaps
   that are referred to with indirection.
   This can GC because menu_item_eval_property calls Feval.  */
 static Lisp_Object
-get_keyelt (Lisp_Object object, int autoload)
+get_keyelt (Lisp_Object object, bool autoload)
 {
  while (1)
    {
@@ -1114,10 +1113,10 @@ binding is altered.  If there is no binding for KEY, the new pair
 binding KEY to DEF is added at the front of KEYMAP.  */)
  (Lisp_Object keymap, Lisp_Object key, Lisp_Object def)
 {
-  register ptrdiff_t idx;
+  ptrdiff_t idx;
-  register Lisp_Object c;
+  Lisp_Object c;
-  register Lisp_Object cmd;
+  Lisp_Object cmd;
-  int metized = 0;
+  bool metized = 0;
  int meta_bit;
  ptrdiff_t length;
  struct gcpro gcpro1, gcpro2, gcpro3;
@@ -1271,11 +1270,11 @@ third optional argument ACCEPT-DEFAULT is non-nil, `lookup-key' will
 recognize the default bindings, just as `read-key-sequence' does.  */)
  (Lisp_Object keymap, Lisp_Object key, Lisp_Object accept_default)
 {
-  register ptrdiff_t idx;
+  ptrdiff_t idx;
-  register Lisp_Object cmd;
+  Lisp_Object cmd;
-  register Lisp_Object c;
+  Lisp_Object c;
  ptrdiff_t length;
-  int t_ok = !NILP (accept_default);
+  bool t_ok = !NILP (accept_default);
  struct gcpro gcpro1, gcpro2;
  GCPRO2 (keymap, key);
@@ -1887,7 +1886,7 @@ DEFUN ("current-minor-mode-maps", Fcurrent_minor_mode_maps, Scurrent_minor_mode_
 struct accessible_keymaps_data {
  Lisp_Object maps, tail, thisseq;
  /* Does the current sequence end in the meta-prefix-char?  */
-  int is_metized;
+  bool is_metized;
 };
 static void
@@ -1898,7 +1897,7 @@ accessible_keymaps_1 (Lisp_Object key, Lisp_Object cmd, Lisp_Object args, void *
  Lisp_Object maps = d->maps;
  Lisp_Object tail = d->tail;
  Lisp_Object thisseq = d->thisseq;
-  int is_metized = d->is_metized && INTEGERP (key);
+  bool is_metized = d->is_metized && INTEGERP (key);
  Lisp_Object tem;
  cmd = get_keymap (get_keyelt (cmd, 0), 0, 0);
@@ -2060,7 +2059,7 @@ The `kbd' macro is an approximate inverse of this.  */)
  Lisp_Object sep = build_string (" ");
  Lisp_Object key;
  Lisp_Object result;
-  int add_meta = 0;
+  bool add_meta = 0;
  USE_SAFE_ALLOCA;
  if (!NILP (prefix))
@@ -2155,9 +2154,10 @@ The `kbd' macro is an approximate inverse of this.  */)
 char *
-push_key_description (EMACS_INT ch, char *p, int force_multibyte)
+push_key_description (EMACS_INT ch, char *p)
 {
-  int c, c2, tab_as_ci;
+  int c, c2;
+  bool tab_as_ci;
  /* Clear all the meaningless bits above the meta bit.  */
  c = ch & (meta_modifier | ~ - meta_modifier);
@@ -2256,21 +2256,12 @@ push_key_description (EMACS_INT ch, char *p, int force_multibyte)
      *p++ = 'P';
      *p++ = 'C';
    }
-  else if (c < 128
+  else if (c < 128)
-           || (NILP (BVAR (current_buffer, enable_multibyte_characters))
+    *p++ = c;
-               && SINGLE_BYTE_CHAR_P (c)
-               && !force_multibyte))
-    {
-      *p++ = c;
-    }
  else
    {
      /* Now we are sure that C is a valid character code.  */
-      if (NILP (BVAR (current_buffer, enable_multibyte_characters))
+      p += CHAR_STRING (c, (unsigned char *) p);
-          && ! force_multibyte)
-        *p++ = multibyte_char_to_unibyte (c);
-      else
-        p += CHAR_STRING (c, (unsigned char *) p);
    }
  return p;
@@ -2299,9 +2290,8 @@ around function keys and event symbols.  */)
  if (INTEGERP (key))           /* Normal character.  */
    {
-      char tem[KEY_DESCRIPTION_SIZE], *p;
+      char tem[KEY_DESCRIPTION_SIZE];
+      char *p = push_key_description (XINT (key), tem);
-      p = push_key_description (XINT (key), tem, 1);
      *p = 0;
      return make_specified_string (tem, -1, p - tem, 1);
    }
@@ -2429,7 +2419,7 @@ static void where_is_internal_1 (Lisp_Object key, Lisp_Object binding,
 static Lisp_Object
 shadow_lookup (Lisp_Object shadow, Lisp_Object key, Lisp_Object flag,
-               int remap)
+               bool remap)
 {
  Lisp_Object tail, value;
@@ -2461,7 +2451,7 @@ static Lisp_Object Vmouse_events;
 struct where_is_internal_data {
  Lisp_Object definition, this, last;
-  int last_is_meta, noindirect;
+  bool last_is_meta, noindirect;
  Lisp_Object sequences;
 };
@@ -2474,7 +2464,7 @@ struct where_is_internal_data {
 static Lisp_Object
 where_is_internal (Lisp_Object definition, Lisp_Object keymaps,
-                   int noindirect, int nomenus)
+                   bool noindirect, bool nomenus)
 {
  Lisp_Object maps = Qnil;
  Lisp_Object found;
@@ -2523,7 +2513,7 @@ where_is_internal (Lisp_Object definition, Lisp_Object keymaps,
         [M-CHAR] sequences, check if last character of the sequence
         is the meta-prefix char.  */
      Lisp_Object last;
-      int last_is_meta;
+      bool last_is_meta;
      this = Fcar (XCAR (maps));
      map  = Fcdr (XCAR (maps));
@@ -2606,7 +2596,7 @@ The optional 5th arg NO-REMAP alters how command remapping is handled:
    /* Actually relevant bindings.  */
  Lisp_Object found = Qnil;
  /* 1 means ignore all menu bindings entirely.  */
-  int nomenus = !NILP (firstonly) && !EQ (firstonly, Qnon_ascii);
+  bool nomenus = !NILP (firstonly) && !EQ (firstonly, Qnon_ascii);
  struct gcpro gcpro1, gcpro2, gcpro3, gcpro4, gcpro5, gcpro6;
  /* List of sequences found via remapping.  Keep them in a separate
     variable, so as to push them later, since we prefer
@@ -2615,7 +2605,7 @@ The optional 5th arg NO-REMAP alters how command remapping is handled:
  /* Whether or not we're handling remapped sequences.  This is needed
     because remapping is not done recursively by Fcommand_remapping: you
     can't remap a remapped command.  */
-  int remapped = 0;
+  bool remapped = 0;
  Lisp_Object tem = Qnil;
  /* Refresh the C version of the modifier preference.  */
@@ -2767,10 +2757,10 @@ where_is_internal_1 (Lisp_Object key, Lisp_Object binding, Lisp_Object args, voi
 {
  struct where_is_internal_data *d = data; /* Cast! */
  Lisp_Object definition = d->definition;
-  int noindirect = d->noindirect;
+  bool noindirect = d->noindirect;
  Lisp_Object this = d->this;
  Lisp_Object last = d->last;
-  int last_is_meta = d->last_is_meta;
+  bool last_is_meta = d->last_is_meta;
  Lisp_Object sequence;
  /* Search through indirections unless that's not wanted.  */
@@ -2821,8 +2811,8 @@ The optional argument MENUS, if non-nil, says to mention menu bindings.
  (Lisp_Object buffer, Lisp_Object prefix, Lisp_Object menus)
 {
  Lisp_Object outbuf, shadow;
-  int nomenu = NILP (menus);
+  bool nomenu = NILP (menus);
-  register Lisp_Object start1;
+  Lisp_Object start1;
  struct gcpro gcpro1;
  const char *alternate_heading
@@ -2857,10 +2847,10 @@ You type        Translation\n\
                alternate_heading = 0;
              }
-            bufend = push_key_description (translate[c], buf, 1);
+            bufend = push_key_description (translate[c], buf);
            insert (buf, bufend - buf);
            Findent_to (make_number (16), make_number (1));
-            bufend = push_key_description (c, buf, 1);
+            bufend = push_key_description (c, buf);
            insert (buf, bufend - buf);
            insert ("\n", 1);
@@ -2977,34 +2967,34 @@ You type        Translation\n\
 /* Insert a description of the key bindings in STARTMAP,
    followed by those of all maps reachable through STARTMAP.
-   If PARTIAL is nonzero, omit certain "uninteresting" commands
+   If PARTIAL, omit certain "uninteresting" commands
    (such as `undefined').
   If SHADOW is non-nil, it is a list of maps;
    don't mention keys which would be shadowed by any of them.
   PREFIX, if non-nil, says mention only keys that start with PREFIX.
   TITLE, if not 0, is a string to insert at the beginning.
   TITLE should not end with a colon or a newline; we supply that.
-   If NOMENU is not 0, then omit menu-bar commands.
+   If NOMENU, then omit menu-bar commands.
-   If TRANSL is nonzero, the definitions are actually key translations
+   If TRANSL, the definitions are actually key translations
   so print strings and vectors differently.
-   If ALWAYS_TITLE is nonzero, print the title even if there are no maps
+   If ALWAYS_TITLE, print the title even if there are no maps
   to look through.
-   If MENTION_SHADOW is nonzero, then when something is shadowed by SHADOW,
+   If MENTION_SHADOW, then when something is shadowed by SHADOW,
   don't omit it; instead, mention it but say it is shadowed.
   Any inserted text ends in two newlines (used by `help-make-xrefs').  */
 void
-describe_map_tree (Lisp_Object startmap, int partial, Lisp_Object shadow,
+describe_map_tree (Lisp_Object startmap, bool partial, Lisp_Object shadow,
-                   Lisp_Object prefix, const char *title, int nomenu, int transl,
+                   Lisp_Object prefix, const char *title, bool nomenu,
-                   int always_title, int mention_shadow)
+                   bool transl, bool always_title, bool mention_shadow)
 {
  Lisp_Object maps, orig_maps, seen, sub_shadows;
  struct gcpro gcpro1, gcpro2, gcpro3;
-  int something = 0;
+  bool something = 0;
  const char *key_heading
    = "\
 key             binding\n\
@@ -3179,7 +3169,12 @@ describe_translation (Lisp_Object definition, Lisp_Object args)
   into an array of `struct describe_map_elt',
   then sorts them by the events.  */
-struct describe_map_elt { Lisp_Object event; Lisp_Object definition; int shadowed; };
+struct describe_map_elt
+{
+  Lisp_Object event;
+  Lisp_Object definition;
+  bool shadowed;
+};
 /* qsort comparison function for sorting `struct describe_map_elt' by
   the event field.  */
@@ -3209,14 +3204,14 @@ describe_map_compare (const void *aa, const void *bb)
 static void
 describe_map (Lisp_Object map, Lisp_Object prefix,
              void (*elt_describer) (Lisp_Object, Lisp_Object),
-              int partial, Lisp_Object shadow,
+              bool partial, Lisp_Object shadow,
-              Lisp_Object *seen, int nomenu, int mention_shadow)
+              Lisp_Object *seen, bool nomenu, bool mention_shadow)
 {
  Lisp_Object tail, definition, event;
  Lisp_Object tem;
  Lisp_Object suppress;
  Lisp_Object kludge;
-  int first = 1;
+  bool first = 1;
  struct gcpro gcpro1, gcpro2, gcpro3;
  /* These accumulate the values from sparse keymap bindings,
@@ -3258,7 +3253,7 @@ describe_map (Lisp_Object map, Lisp_Object prefix,
                         1, mention_shadow);
      else if (CONSP (XCAR (tail)))
        {
-          int this_shadowed = 0;
+          bool this_shadowed = 0;
          event = XCAR (XCAR (tail));
@@ -3428,7 +3423,7 @@ DESCRIBER is the output function used; nil means use `princ'.  */)
   of bytes that lead to the character set or portion of a character
   set described by this chartable.
-   If PARTIAL is nonzero, it means do not mention suppressed commands
+   If PARTIAL, it means do not mention suppressed commands
   (that assumes the vector is in a keymap).
   SHADOW is a list of keymaps that shadow this map.
@@ -3448,8 +3443,8 @@ DESCRIBER is the output function used; nil means use `princ'.  */)
 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,
+                 bool partial, Lisp_Object shadow, Lisp_Object entire_map,
-                 int keymap_p, int mention_shadow)
+                 bool keymap_p, bool mention_shadow)
 {
  Lisp_Object definition;
  Lisp_Object tem2;
@@ -3457,7 +3452,7 @@ describe_vector (Lisp_Object vector, Lisp_Object prefix, Lisp_Object args,
  int i;
  Lisp_Object suppress;
  Lisp_Object kludge;
-  int first = 1;
+  bool first = 1;
  struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
  /* Range of elements to be handled.  */
  int from, to, stop;
@@ -3497,7 +3492,7 @@ describe_vector (Lisp_Object vector, Lisp_Object prefix, Lisp_Object args,
  for (i = from; ; i++)
    {
-      int this_shadowed = 0;
+      bool this_shadowed = 0;
      int range_beg, range_end;
      Lisp_Object val;
diff --git a/src/keymap.h b/src/keymap.h
index 5ed70c67b85..c704ee0b050 100644
--- a/src/keymap.h
+++ b/src/keymap.h
@@ -34,11 +34,11 @@ extern Lisp_Object Qkeymap, Qmenu_bar;
 extern Lisp_Object Qremap;
 extern Lisp_Object Qmenu_item;
 extern Lisp_Object current_global_map;
-extern char *push_key_description (EMACS_INT, char *, int);
+extern char *push_key_description (EMACS_INT, char *);
-extern Lisp_Object access_keymap (Lisp_Object, Lisp_Object, int, int, int);
+extern Lisp_Object access_keymap (Lisp_Object, Lisp_Object, bool, bool, bool);
-extern Lisp_Object get_keymap (Lisp_Object, int, int);
+extern Lisp_Object get_keymap (Lisp_Object, bool, bool);
-extern void describe_map_tree (Lisp_Object, int, Lisp_Object, Lisp_Object,
+extern void describe_map_tree (Lisp_Object, bool, Lisp_Object, Lisp_Object,
-                              const char *, int, int, int, int);
+                               const char *, bool, bool, bool, bool);
 extern ptrdiff_t current_minor_maps (Lisp_Object **, Lisp_Object **);
 extern void initial_define_key (Lisp_Object, int, const char *);
 extern void initial_define_lispy_key (Lisp_Object, const char *, const char *);
@@ -47,7 +47,8 @@ extern void keys_of_keymap (void);
 typedef void (*map_keymap_function_t)
     (Lisp_Object key, Lisp_Object val, Lisp_Object args, void* data);
-extern void map_keymap (Lisp_Object map, map_keymap_function_t fun, Lisp_Object largs, void* cargs, int autoload);
+extern void map_keymap (Lisp_Object, map_keymap_function_t, Lisp_Object,
+                        void *, bool);
 extern void map_keymap_canonical (Lisp_Object map,
                                  map_keymap_function_t fun,
                                  Lisp_Object args, void *data);
diff --git a/src/lisp.h b/src/lisp.h
index 7812e58782b..756d08fda33 100644
--- a/src/lisp.h
+++ b/src/lisp.h
@@ -345,15 +345,11 @@ static ptrdiff_t const PSEUDOVECTOR_FLAG
      = PSEUDOVECTOR_FLAG;
 /* In a pseudovector, the size field actually contains a word with one
-   PSEUDOVECTOR_FLAG bit set, and exactly one of the following bits to
+   PSEUDOVECTOR_FLAG bit set, and one of the following values extracted
-   indicate the actual type.
+   with PVEC_TYPE_MASK to indicate the actual type.  */
-   We use a bitset, even tho only one of the bits can be set at any
-   particular time just so as to be able to use micro-optimizations such as
-   testing membership of a particular subset of pseudovectors in Fequal.
-   It is not crucial, but there are plenty of bits here, so why not do it?  */
 enum pvec_type
 {
-  PVEC_NORMAL_VECTOR = 0,       /* Unused!  */
+  PVEC_NORMAL_VECTOR,
  PVEC_FREE,
  PVEC_PROCESS,
  PVEC_FRAME,
@@ -3031,7 +3027,7 @@ extern Lisp_Object oblookup (Lisp_Object, const char *, ptrdiff_t, ptrdiff_t);
  } while (0)
 extern int openp (Lisp_Object, Lisp_Object, Lisp_Object,
                  Lisp_Object *, Lisp_Object);
-Lisp_Object string_to_number (char const *, int, int);
+extern Lisp_Object string_to_number (char const *, int, bool);
 extern void map_obarray (Lisp_Object, void (*) (Lisp_Object, Lisp_Object),
                         Lisp_Object);
 extern void dir_warning (const char *, Lisp_Object);
@@ -3202,9 +3198,9 @@ extern ptrdiff_t fast_string_match_ignore_case (Lisp_Object, Lisp_Object);
 extern ptrdiff_t fast_looking_at (Lisp_Object, ptrdiff_t, ptrdiff_t,
                                  ptrdiff_t, ptrdiff_t, Lisp_Object);
 extern ptrdiff_t scan_buffer (int, ptrdiff_t, ptrdiff_t, ptrdiff_t,
-                              ptrdiff_t *, int);
+                              ptrdiff_t *, bool);
 extern EMACS_INT scan_newline (ptrdiff_t, ptrdiff_t, ptrdiff_t, ptrdiff_t,
-                               EMACS_INT, int);
+                               EMACS_INT, bool);
 extern ptrdiff_t find_next_newline (ptrdiff_t, int);
 extern ptrdiff_t find_next_newline_no_quit (ptrdiff_t, ptrdiff_t);
 extern ptrdiff_t find_before_next_newline (ptrdiff_t, ptrdiff_t, ptrdiff_t);
@@ -3247,7 +3243,7 @@ extern Lisp_Object Qdisabled, QCfilter;
 extern Lisp_Object Qup, Qdown, Qbottom;
 extern Lisp_Object Qtop;
 extern Lisp_Object last_undo_boundary;
-extern int input_pending;
+extern bool input_pending;
 extern Lisp_Object menu_bar_items (Lisp_Object);
 extern Lisp_Object tool_bar_items (Lisp_Object, int *);
 extern void discard_mouse_events (void);
@@ -3255,9 +3251,9 @@ extern void discard_mouse_events (void);
 void handle_input_available_signal (int);
 #endif
 extern Lisp_Object pending_funcalls;
-extern int detect_input_pending (void);
+extern bool detect_input_pending (void);
-extern int detect_input_pending_ignore_squeezables (void);
+extern bool detect_input_pending_ignore_squeezables (void);
-extern int detect_input_pending_run_timers (int);
+extern bool detect_input_pending_run_timers (bool);
 extern void safe_run_hooks (Lisp_Object);
 extern void cmd_error_internal (Lisp_Object, const char *);
 extern Lisp_Object command_loop_1 (void);
@@ -3336,7 +3332,7 @@ extern bool running_asynch_code;
 extern Lisp_Object QCtype, Qlocal;
 extern Lisp_Object Qprocessp;
 extern void kill_buffer_processes (Lisp_Object);
-extern int wait_reading_process_output (intmax_t, int, int, int,
+extern int wait_reading_process_output (intmax_t, int, int, bool,
                                        Lisp_Object,
                                        struct Lisp_Process *,
                                        int);
@@ -3568,7 +3564,8 @@ extern char *emacs_root_dir (void);
   Used during startup to detect startup of dumped Emacs.  */
 extern bool initialized;
-extern int immediate_quit;          /* Nonzero means ^G can quit instantly.  */
+/* True means ^G can quit instantly.  */
+extern bool immediate_quit;
 extern void *xmalloc (size_t);
 extern void *xzalloc (size_t);
diff --git a/src/lread.c b/src/lread.c
index a2b6d1f26d9..dbbde694cf6 100644
--- a/src/lread.c
+++ b/src/lread.c
@@ -95,10 +95,10 @@ static Lisp_Object Qload_in_progress;
   It must be set to nil before all top-level calls to read0.  */
 static Lisp_Object read_objects;
-/* Nonzero means READCHAR should read bytes one by one (not character)
+/* True means READCHAR should read bytes one by one (not character)
   when READCHARFUN is Qget_file_char or Qget_emacs_mule_file_char.
-   This is set to 1 by read1 temporarily while handling #@NUMBER.  */
+   This is set by read1 temporarily while handling #@NUMBER.  */
-static int load_each_byte;
+static bool load_each_byte;
 /* List of descriptors now open for Fload.  */
 static Lisp_Object load_descriptor_list;
@@ -135,11 +135,11 @@ static ptrdiff_t prev_saved_doc_string_length;
 /* This is the file position that string came from.  */
 static file_offset prev_saved_doc_string_position;
-/* Nonzero means inside a new-style backquote
+/* True means inside a new-style backquote
   with no surrounding parentheses.
-   Fread initializes this to zero, so we need not specbind it
+   Fread initializes this to false, so we need not specbind it
   or worry about what happens to it when there is an error.  */
-static int new_backquote_flag;
+static bool new_backquote_flag;
 static Lisp_Object Qold_style_backquotes;
 /* A list of file names for files being loaded in Fload.  Used to
@@ -150,7 +150,7 @@ static Lisp_Object Vloads_in_progress;
 static int read_emacs_mule_char (int, int (*) (int, Lisp_Object),
                                 Lisp_Object);
-static void readevalloop (Lisp_Object, FILE*, Lisp_Object, int,
+static void readevalloop (Lisp_Object, FILE *, Lisp_Object, bool,
                          Lisp_Object, Lisp_Object,
                          Lisp_Object, Lisp_Object);
 static Lisp_Object load_unwind (Lisp_Object);
@@ -192,7 +192,7 @@ readchar (Lisp_Object readcharfun, bool *multibyte)
  int (*readbyte) (int, Lisp_Object);
  unsigned char buf[MAX_MULTIBYTE_LENGTH];
  int i, len;
-  int emacs_mule_encoding = 0;
+  bool emacs_mule_encoding = 0;
  if (multibyte)
    *multibyte = 0;
@@ -546,10 +546,10 @@ read_emacs_mule_char (int c, int (*readbyte) (int, Lisp_Object), Lisp_Object rea
 static Lisp_Object read_internal_start (Lisp_Object, Lisp_Object,
                                        Lisp_Object);
 static Lisp_Object read0 (Lisp_Object);
-static Lisp_Object read1 (Lisp_Object, int *, int);
+static Lisp_Object read1 (Lisp_Object, int *, bool);
-static Lisp_Object read_list (int, Lisp_Object);
+static Lisp_Object read_list (bool, Lisp_Object);
-static Lisp_Object read_vector (Lisp_Object, int);
+static Lisp_Object read_vector (Lisp_Object, bool);
 static Lisp_Object substitute_object_recurse (Lisp_Object, Lisp_Object,
                                              Lisp_Object);
@@ -562,28 +562,28 @@ static void substitute_in_interval (INTERVAL, Lisp_Object);
 /* Read input events until we get one that's acceptable for our purposes.
-   If NO_SWITCH_FRAME is non-zero, switch-frame events are stashed
+   If NO_SWITCH_FRAME, switch-frame events are stashed
   until we get a character we like, and then stuffed into
   unread_switch_frame.
-   If ASCII_REQUIRED is non-zero, we check function key events to see
+   If ASCII_REQUIRED, check function key events to see
   if the unmodified version of the symbol has a Qascii_character
   property, and use that character, if present.
-   If ERROR_NONASCII is non-zero, we signal an error if the input we
+   If ERROR_NONASCII, signal an error if the input we
-   get isn't an ASCII character with modifiers.  If it's zero but
+   get isn't an ASCII character with modifiers.  If it's false but
-   ASCII_REQUIRED is non-zero, we just re-read until we get an ASCII
+   ASCII_REQUIRED is true, just re-read until we get an ASCII
   character.
-   If INPUT_METHOD is nonzero, we invoke the current input method
+   If INPUT_METHOD, invoke the current input method
   if the character warrants that.
-   If SECONDS is a number, we wait that many seconds for input, and
+   If SECONDS is a number, wait that many seconds for input, and
   return Qnil if no input arrives within that time.  */
 static Lisp_Object
-read_filtered_event (int no_switch_frame, int ascii_required,
+read_filtered_event (bool no_switch_frame, bool ascii_required,
-                     int error_nonascii, int input_method, Lisp_Object seconds)
+                     bool error_nonascii, bool input_method, Lisp_Object seconds)
 {
  Lisp_Object val, delayed_switch_frame;
  EMACS_TIME end_time;
@@ -767,7 +767,7 @@ DEFUN ("get-file-char", Fget_file_char, Sget_file_char, 0, 0, 0,
   positioned following the first line, if it is a comment or #! line,
   otherwise nothing is read.  */
-static int
+static bool
 lisp_file_lexically_bound_p (Lisp_Object readcharfun)
 {
  int ch = READCHAR;
@@ -797,11 +797,11 @@ lisp_file_lexically_bound_p (Lisp_Object readcharfun)
  else
    /* Look for an appropriate file-variable in the first line.  */
    {
-      int rv = 0;
+      bool rv = 0;
      enum {
        NOMINAL, AFTER_FIRST_DASH, AFTER_ASTERIX,
      } beg_end_state = NOMINAL;
-      int in_file_vars = 0;
+      bool in_file_vars = 0;
 #define UPDATE_BEG_END_STATE(ch)                                \
  if (beg_end_state == NOMINAL)                                 \
@@ -897,20 +897,17 @@ lisp_file_lexically_bound_p (Lisp_Object readcharfun)
   because of an incompatible change in the byte compiler.  */
 static int
-safe_to_load_p (int fd)
+safe_to_load_version (int fd)
 {
  char buf[512];
  int nbytes, i;
-  int safe_p = 1;
  int version = 1;
  /* Read the first few bytes from the file, and look for a line
     specifying the byte compiler version used.  */
-  nbytes = emacs_read (fd, buf, sizeof buf - 1);
+  nbytes = emacs_read (fd, buf, sizeof buf);
  if (nbytes > 0)
    {
-      buf[nbytes] = '\0';
      /* Skip to the next newline, skipping over the initial `ELC'
         with NUL bytes following it, but note the version.  */
      for (i = 0; i < nbytes && buf[i] != '\n'; ++i)
@@ -920,13 +917,11 @@ safe_to_load_p (int fd)
      if (i >= nbytes
          || fast_c_string_match_ignore_case (Vbytecomp_version_regexp,
                                              buf + i, nbytes - i) < 0)
-        safe_p = 0;
+        version = 0;
    }
-  if (safe_p)
-    safe_p = version;
  lseek (fd, 0, SEEK_SET);
-  return safe_p;
+  return version;
 }
@@ -1030,12 +1025,12 @@ Return t if the file exists and loads successfully.  */)
  ptrdiff_t count = SPECPDL_INDEX ();
  struct gcpro gcpro1, gcpro2, gcpro3;
  Lisp_Object found, efound, hist_file_name;
-  /* 1 means we printed the ".el is newer" message.  */
+  /* True means we printed the ".el is newer" message.  */
-  int newer = 0;
+  bool newer = 0;
-  /* 1 means we are loading a compiled file.  */
+  /* True means we are loading a compiled file.  */
-  int compiled = 0;
+  bool compiled = 0;
  Lisp_Object handler;
-  int safe_p = 1;
+  bool safe_p = 1;
  const char *fmode = "r";
  Lisp_Object tmp[2];
  int version;
@@ -1190,7 +1185,7 @@ Return t if the file exists and loads successfully.  */)
  record_unwind_protect (load_warn_old_style_backquotes, file);
  if (!memcmp (SDATA (found) + SBYTES (found) - 4, ".elc", 4)
-      || (fd >= 0 && (version = safe_to_load_p (fd)) > 0))
+      || (fd >= 0 && (version = safe_to_load_version (fd)) > 0))
    /* Load .elc files directly, but not when they are
       remote and have no handler!  */
    {
@@ -1202,7 +1197,7 @@ Return t if the file exists and loads successfully.  */)
          GCPRO3 (file, found, hist_file_name);
          if (version < 0
-              && ! (version = safe_to_load_p (fd)))
+              && ! (version = safe_to_load_version (fd)))
            {
              safe_p = 0;
              if (!load_dangerous_libraries)
@@ -1394,10 +1389,10 @@ close_load_descs (void)
 #endif
 }
-static int
+static bool
 complete_filename_p (Lisp_Object pathname)
 {
-  register const unsigned char *s = SDATA (pathname);
+  const unsigned char *s = SDATA (pathname);
  return (IS_DIRECTORY_SEP (s[0])
          || (SCHARS (pathname) > 2
              && IS_DEVICE_SEP (s[1]) && IS_DIRECTORY_SEP (s[2])));
@@ -1447,11 +1442,11 @@ static Lisp_Object Qdir_ok;
 int
 openp (Lisp_Object path, Lisp_Object str, Lisp_Object suffixes, Lisp_Object *storeptr, Lisp_Object predicate)
 {
-  register int fd;
+  int fd;
  ptrdiff_t fn_size = 100;
  char buf[100];
-  register char *fn = buf;
+  char *fn = buf;
-  int absolute = 0;
+  bool absolute = 0;
  ptrdiff_t want_length;
  Lisp_Object filename;
  struct stat st;
@@ -1503,7 +1498,7 @@ openp (Lisp_Object path, Lisp_Object str, Lisp_Object suffixes, Lisp_Object *sto
        {
          ptrdiff_t fnlen, lsuffix = SBYTES (XCAR (tail));
          Lisp_Object handler;
-          int exists;
+          bool exists;
          /* Concatenate path element/specified name with the suffix.
             If the directory starts with /:, remove that.  */
@@ -1588,14 +1583,16 @@ openp (Lisp_Object path, Lisp_Object str, Lisp_Object suffixes, Lisp_Object *sto
   the source has an associated file name or not.
   FILENAME is the file name that we are loading from.
-   ENTIRE is 1 if loading that entire file, 0 if evaluating part of it.  */
+   ENTIRE is true if loading that entire file, false if evaluating
+   part of it.  */
 static void
-build_load_history (Lisp_Object filename, int entire)
+build_load_history (Lisp_Object filename, bool entire)
 {
-  register Lisp_Object tail, prev, newelt;
+  Lisp_Object tail, prev, newelt;
-  register Lisp_Object tem, tem2;
+  Lisp_Object tem, tem2;
-  register int foundit = 0;
+  bool foundit = 0;
  tail = Vload_history;
  prev = Qnil;
@@ -1680,7 +1677,7 @@ static void
 readevalloop (Lisp_Object readcharfun,
              FILE *stream,
              Lisp_Object sourcename,
-              int printflag,
+              bool printflag,
              Lisp_Object unibyte, Lisp_Object readfun,
              Lisp_Object start, Lisp_Object end)
 {
@@ -1689,12 +1686,12 @@ readevalloop (Lisp_Object readcharfun,
  ptrdiff_t count = SPECPDL_INDEX ();
  struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
  struct buffer *b = 0;
-  int continue_reading_p;
+  bool continue_reading_p;
  Lisp_Object lex_bound;
-  /* Nonzero if reading an entire buffer.  */
+  /* True if reading an entire buffer.  */
-  int whole_buffer = 0;
+  bool whole_buffer = 0;
-  /* 1 on the first time around.  */
+  /* True on the first time around.  */
-  int first_sexp = 1;
+  bool first_sexp = 1;
  Lisp_Object macroexpand = intern ("internal-macroexpand-for-load");
  if (NILP (Ffboundp (macroexpand))
@@ -2072,9 +2069,9 @@ static char *read_buffer;
   If the escape sequence forces unibyte, return eight-bit char.  */
 static int
-read_escape (Lisp_Object readcharfun, int stringp)
+read_escape (Lisp_Object readcharfun, bool stringp)
 {
-  register int c = READCHAR;
+  int c = READCHAR;
  /* \u allows up to four hex digits, \U up to eight.  Default to the
     behavior for \u, and change this value in the case that \U is seen.  */
  int unicode_hex_count = 4;
@@ -2375,10 +2372,10 @@ read_integer (Lisp_Object readcharfun, EMACS_INT radix)
   in *PCH and the return value is not interesting.  Else, we store
   zero in *PCH and we read and return one lisp object.
-   FIRST_IN_LIST is nonzero if this is the first element of a list.  */
+   FIRST_IN_LIST is true if this is the first element of a list.  */
 static Lisp_Object
-read1 (register Lisp_Object readcharfun, int *pch, int first_in_list)
+read1 (Lisp_Object readcharfun, int *pch, bool first_in_list)
 {
  int c;
  bool uninterned_symbol = 0;
@@ -2803,10 +2800,11 @@ read1 (register Lisp_Object readcharfun, int *pch, int first_in_list)
        else
          {
            Lisp_Object value;
+            bool saved_new_backquote_flag = new_backquote_flag;
-            new_backquote_flag++;
+            new_backquote_flag = 1;
            value = read0 (readcharfun);
-            new_backquote_flag--;
+            new_backquote_flag = saved_new_backquote_flag;
            return Fcons (Qbackquote, Fcons (value, Qnil));
          }
@@ -2858,7 +2856,7 @@ read1 (register Lisp_Object readcharfun, int *pch, int first_in_list)
      {
        int modifiers;
        int next_char;
-        int ok;
+        bool ok;
        c = READCHAR;
        if (c < 0)
@@ -2894,14 +2892,14 @@ read1 (register Lisp_Object readcharfun, int *pch, int first_in_list)
      {
        char *p = read_buffer;
        char *end = read_buffer + read_buffer_size;
-        register int ch;
+        int ch;
-        /* Nonzero if we saw an escape sequence specifying
+        /* True if we saw an escape sequence specifying
           a multibyte character.  */
-        int force_multibyte = 0;
+        bool force_multibyte = 0;
-        /* Nonzero if we saw an escape sequence specifying
+        /* True if we saw an escape sequence specifying
           a single-byte character.  */
-        int force_singlebyte = 0;
+        bool force_singlebyte = 0;
-        int cancel = 0;
+        bool cancel = 0;
        ptrdiff_t nchars = 0;
        while ((ch = READCHAR) >= 0
@@ -3033,7 +3031,7 @@ read1 (register Lisp_Object readcharfun, int *pch, int first_in_list)
    read_symbol:
      {
        char *p = read_buffer;
-        int quoted = 0;
+        bool quoted = 0;
        EMACS_INT start_position = readchar_count - 1;
        {
@@ -3250,17 +3248,17 @@ substitute_in_interval (INTERVAL interval, Lisp_Object arg)
 /* Convert STRING to a number, assuming base BASE.  Return a fixnum if CP has
   integer syntax and fits in a fixnum, else return the nearest float if CP has
   either floating point or integer syntax and BASE is 10, else return nil.  If
-   IGNORE_TRAILING is nonzero, consider just the longest prefix of CP that has
+   IGNORE_TRAILING, consider just the longest prefix of CP that has
   valid floating point syntax.  Signal an overflow if BASE is not 10 and the
   number has integer syntax but does not fit.  */
 Lisp_Object
-string_to_number (char const *string, int base, int ignore_trailing)
+string_to_number (char const *string, int base, bool ignore_trailing)
 {
  int state;
  char const *cp = string;
  int leading_digit;
-  int float_syntax = 0;
+  bool float_syntax = 0;
  double value = 0;
  /* Compute NaN and infinities using a variable, to cope with compilers that
@@ -3270,9 +3268,9 @@ string_to_number (char const *string, int base, int ignore_trailing)
  /* Negate the value ourselves.  This treats 0, NaNs, and infinity properly on
     IEEE floating point hosts, and works around a formerly-common bug where
     atof ("-0.0") drops the sign.  */
-  int negative = *cp == '-';
+  bool negative = *cp == '-';
-  int signedp = negative || *cp == '+';
+  bool signedp = negative || *cp == '+';
  cp += signedp;
  state = 0;
@@ -3365,7 +3363,7 @@ string_to_number (char const *string, int base, int ignore_trailing)
      uintmax_t n;
      /* Fast special case for single-digit integers.  This also avoids a
-         glitch when BASE is 16 and IGNORE_TRAILING is nonzero, because in that
+         glitch when BASE is 16 and IGNORE_TRAILING, because in that
         case some versions of strtoumax accept numbers like "0x1" that Emacs
         does not allow.  */
      if (digit_to_number (string[signedp + 1], base) < 0)
@@ -3401,12 +3399,12 @@ string_to_number (char const *string, int base, int ignore_trailing)
 static Lisp_Object
-read_vector (Lisp_Object readcharfun, int bytecodeflag)
+read_vector (Lisp_Object readcharfun, bool bytecodeflag)
 {
  ptrdiff_t i, size;
-  register Lisp_Object *ptr;
+  Lisp_Object *ptr;
-  register Lisp_Object tem, item, vector;
+  Lisp_Object tem, item, vector;
-  register struct Lisp_Cons *otem;
+  struct Lisp_Cons *otem;
  Lisp_Object len;
  tem = read_list (1, readcharfun);
@@ -3478,13 +3476,13 @@ read_vector (Lisp_Object readcharfun, int bytecodeflag)
  return vector;
 }
-/* FLAG = 1 means check for ] to terminate rather than ) and .  */
+/* FLAG means check for ] to terminate rather than ) and .  */
 static Lisp_Object
-read_list (int flag, register Lisp_Object readcharfun)
+read_list (bool flag, Lisp_Object readcharfun)
 {
  Lisp_Object val, tail;
-  register Lisp_Object elt, tem;
+  Lisp_Object elt, tem;
  struct gcpro gcpro1, gcpro2;
  /* 0 is the normal case.
     1 means this list is a doc reference; replace it with the number 0.
@@ -3492,7 +3490,7 @@ read_list (int flag, register Lisp_Object readcharfun)
  int doc_reference = 0;
  /* Initialize this to 1 if we are reading a list.  */
-  int first_in_list = flag <= 0;
+  bool first_in_list = flag <= 0;
  val = Qnil;
  tail = Qnil;
diff --git a/src/macros.c b/src/macros.c
index a507f12e343..632c851ee8c 100644
--- a/src/macros.c
+++ b/src/macros.c
@@ -84,7 +84,7 @@ macro before appending to it. */)
    {
      ptrdiff_t i;
      EMACS_INT len;
-      int cvt;
+      bool cvt;
      /* Check the type of last-kbd-macro in case Lisp code changed it.  */
      CHECK_VECTOR_OR_STRING (KVAR (current_kboard, Vlast_kbd_macro));
diff --git a/src/makefile.w32-in b/src/makefile.w32-in
index f96f765a7fa..e4a77cc87a3 100644
--- a/src/makefile.w32-in
+++ b/src/makefile.w32-in
@@ -736,7 +736,6 @@ $(BLD)/dispnew.$(O) : \
        $(SRC)/disptab.h \
        $(SRC)/indent.h \
        $(SRC)/termchar.h \
-        $(SRC)/termopts.h \
        $(NT_INC)/unistd.h \
        $(BUFFER_H) \
        $(CHARACTER_H) \
@@ -1016,7 +1015,6 @@ $(BLD)/indent.$(O) : \
        $(SRC)/indent.h \
        $(SRC)/region-cache.h \
        $(SRC)/termchar.h \
-        $(SRC)/termopts.h \
        $(BUFFER_H) \
        $(CHARACTER_H) \
        $(CONFIG_H) \
@@ -1413,7 +1411,6 @@ $(BLD)/term.$(O) : \
        $(SRC)/disptab.h \
        $(SRC)/keymap.h \
        $(SRC)/termchar.h \
-        $(SRC)/termopts.h \
        $(SRC)/tparam.h \
        $(NT_INC)/sys/file.h \
        $(NT_INC)/sys/time.h \
diff --git a/src/marker.c b/src/marker.c
index e01647bdb2a..69be4faec3a 100644
--- a/src/marker.c
+++ b/src/marker.c
@@ -29,7 +29,7 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 static ptrdiff_t cached_charpos;
 static ptrdiff_t cached_bytepos;
 static struct buffer *cached_buffer;
-static int cached_modiff;
+static EMACS_INT cached_modiff;
 /* Juanma Barranquero <lekktu@gmail.com> reported ~3x increased
   bootstrap time when byte_char_debug_check is enabled; so this
@@ -91,7 +91,7 @@ clear_charpos_cache (struct buffer *b)
 #define CONSIDER(CHARPOS, BYTEPOS)                                      \
 {                                                                       \
  ptrdiff_t this_charpos = (CHARPOS);                                   \
-  int changed = 0;                                                      \
+  bool changed = 0;                                                     \
                                                                        \
  if (this_charpos == charpos)                                          \
    {                                                                   \
@@ -190,7 +190,7 @@ buf_charpos_to_bytepos (struct buffer *b, ptrdiff_t charpos)
  if (charpos - best_below < best_above - charpos)
    {
-      int record = charpos - best_below > 5000;
+      bool record = charpos - best_below > 5000;
      while (best_below != charpos)
        {
@@ -215,7 +215,7 @@ buf_charpos_to_bytepos (struct buffer *b, ptrdiff_t charpos)
    }
  else
    {
-      int record = best_above - charpos > 5000;
+      bool record = best_above - charpos > 5000;
      while (best_above != charpos)
        {
@@ -335,7 +335,7 @@ buf_bytepos_to_charpos (struct buffer *b, ptrdiff_t bytepos)
  if (bytepos - best_below_byte < best_above_byte - bytepos)
    {
-      int record = bytepos - best_below_byte > 5000;
+      bool record = bytepos - best_below_byte > 5000;
      while (best_below_byte < bytepos)
        {
@@ -362,7 +362,7 @@ buf_bytepos_to_charpos (struct buffer *b, ptrdiff_t bytepos)
    }
  else
    {
-      int record = best_above_byte - bytepos > 5000;
+      bool record = best_above_byte - bytepos > 5000;
      while (best_above_byte > bytepos)
        {
@@ -479,10 +479,10 @@ live_buffer (Lisp_Object buffer)
 static Lisp_Object
 set_marker_internal (Lisp_Object marker, Lisp_Object position,
-                     Lisp_Object buffer, int restricted)
+                     Lisp_Object buffer, bool restricted)
 {
-  register struct Lisp_Marker *m;
+  struct Lisp_Marker *m;
-  register struct buffer *b = live_buffer (buffer);
+  struct buffer *b = live_buffer (buffer);
  CHECK_MARKER (marker);
  m = XMARKER (marker);
diff --git a/src/menu.c b/src/menu.c
index 835267b2f0c..7cc110ce7e2 100644
--- a/src/menu.c
+++ b/src/menu.c
@@ -331,7 +331,7 @@ single_menu_item (Lisp_Object key, Lisp_Object item, Lisp_Object dummy, void *sk
 {
  Lisp_Object map, item_string, enabled;
  struct gcpro gcpro1, gcpro2;
-  int res;
+  bool res;
  struct skp *skp = skp_v;
  /* Parse the menu item and leave the result in item_properties.  */
@@ -519,14 +519,15 @@ list_of_panes (Lisp_Object menu)
 /* Set up data in menu_items for a menu bar item
   whose event type is ITEM_KEY (with string ITEM_NAME)
   and whose contents come from the list of keymaps MAPS.  */
-int
+bool
-parse_single_submenu (Lisp_Object item_key, Lisp_Object item_name, Lisp_Object maps)
+parse_single_submenu (Lisp_Object item_key, Lisp_Object item_name,
+                      Lisp_Object maps)
 {
  Lisp_Object length;
  EMACS_INT len;
  Lisp_Object *mapvec;
  ptrdiff_t i;
-  int top_level_items = 0;
+  bool top_level_items = 0;
  USE_SAFE_ALLOCA;
  length = Flength (maps);
@@ -616,13 +617,13 @@ free_menubar_widget_value_tree (widget_value *wv)
   in menu_items starting at index START, up to index END.  */
 widget_value *
-digest_single_submenu (int start, int end, int top_level_items)
+digest_single_submenu (int start, int end, bool top_level_items)
 {
  widget_value *wv, *prev_wv, *save_wv, *first_wv;
  int i;
  int submenu_depth = 0;
  widget_value **submenu_stack;
-  int panes_seen = 0;
+  bool panes_seen = 0;
  submenu_stack = alloca (menu_items_used * sizeof *submenu_stack);
  wv = xmalloc_widget_value ();
@@ -668,7 +669,7 @@ digest_single_submenu (int start, int end, int top_level_items)
          Lisp_Object pane_name;
          const char *pane_string;
-          panes_seen++;
+          panes_seen = 1;
          pane_name = AREF (menu_items, i + MENU_ITEMS_PANE_NAME);
@@ -735,7 +736,7 @@ digest_single_submenu (int start, int end, int top_level_items)
          Lisp_Object help;
          /* All items should be contained in panes.  */
-          if (panes_seen == 0)
+          if (! panes_seen)
            emacs_abort ();
          item_name = AREF (menu_items, i + MENU_ITEMS_ITEM_NAME);
@@ -957,9 +958,9 @@ find_and_call_menu_selection (FRAME_PTR f, int menu_bar_items_used, Lisp_Object
 #ifdef HAVE_NS
 /* As above, but return the menu selection instead of storing in kb buffer.
-   If keymaps==1, return full prefixes to selection. */
+   If KEYMAPS, return full prefixes to selection. */
 Lisp_Object
-find_and_return_menu_selection (FRAME_PTR f, int keymaps, void *client_data)
+find_and_return_menu_selection (FRAME_PTR f, bool keymaps, void *client_data)
 {
  Lisp_Object prefix, entry;
  int i;
@@ -999,7 +1000,7 @@ find_and_return_menu_selection (FRAME_PTR f, int keymaps, void *client_data)
            = AREF (menu_items, i + MENU_ITEMS_ITEM_VALUE);
          if (aref_addr (menu_items, i) == client_data)
            {
-              if (keymaps != 0)
+              if (keymaps)
                {
                  int j;
@@ -1071,8 +1072,8 @@ no quit occurs and `x-popup-menu' returns nil.  */)
  Lisp_Object selection = Qnil;
  FRAME_PTR f = NULL;
  Lisp_Object x, y, window;
-  int keymaps = 0;
+  bool keymaps = 0;
-  int for_click = 0;
+  bool for_click = 0;
  ptrdiff_t specpdl_count = SPECPDL_INDEX ();
  struct gcpro gcpro1;
@@ -1083,7 +1084,7 @@ no quit occurs and `x-popup-menu' returns nil.  */)
 #ifdef HAVE_MENUS
  {
-    int get_current_pos_p = 0;
+    bool get_current_pos_p = 0;
    /* FIXME!!  check_w32 (); or check_x (); or check_ns (); */
    /* Decode the first argument: find the window and the coordinates.  */
diff --git a/src/menu.h b/src/menu.h
index 3406928a8d5..67934c42d76 100644
--- a/src/menu.h
+++ b/src/menu.h
@@ -29,7 +29,7 @@ extern void init_menu_items (void);
 extern void finish_menu_items (void) ATTRIBUTE_CONST;
 extern void discard_menu_items (void);
 extern void save_menu_items (void);
-extern int parse_single_submenu (Lisp_Object, Lisp_Object, Lisp_Object);
+extern bool parse_single_submenu (Lisp_Object, Lisp_Object, Lisp_Object);
 extern void list_of_panes (Lisp_Object);
 #if defined (USE_X_TOOLKIT) || defined (USE_GTK) || defined (HAVE_NTGUI) \
  || defined (HAVE_NS)
@@ -38,7 +38,7 @@ extern void update_submenu_strings (widget_value *);
 extern void find_and_call_menu_selection (FRAME_PTR, int,
                                          Lisp_Object, void *);
 extern widget_value *xmalloc_widget_value (void);
-extern widget_value *digest_single_submenu (int, int, int);
+extern widget_value *digest_single_submenu (int, int, bool);
 #endif
 #ifdef HAVE_X_WINDOWS
@@ -47,8 +47,8 @@ extern void mouse_position_for_popup (FRAME_PTR f, int *x, int *y);
 extern Lisp_Object w32_menu_show (FRAME_PTR, int, int, int, int,
                                  Lisp_Object, const char **);
-extern Lisp_Object ns_menu_show (FRAME_PTR, int, int, int, int,
+extern Lisp_Object ns_menu_show (FRAME_PTR, int, int, bool, bool,
                                 Lisp_Object, const char **);
-extern Lisp_Object xmenu_show (FRAME_PTR, int, int, int, int,
+extern Lisp_Object xmenu_show (FRAME_PTR, int, int, bool, bool,
                               Lisp_Object, const char **, Time);
 #endif /* MENU_H */
diff --git a/src/minibuf.c b/src/minibuf.c
index dd4ca34c3fb..2cc89e75680 100644
--- a/src/minibuf.c
+++ b/src/minibuf.c
@@ -173,17 +173,6 @@ without invoking the usual minibuffer commands.  */)
 static Lisp_Object read_minibuf_unwind (Lisp_Object);
 static Lisp_Object run_exit_minibuf_hook (Lisp_Object);
-static Lisp_Object read_minibuf (Lisp_Object, Lisp_Object,
-                                 Lisp_Object,
-                                 int, Lisp_Object,
-                                 Lisp_Object, Lisp_Object,
-                                 int, int);
-static Lisp_Object read_minibuf_noninteractive (Lisp_Object, Lisp_Object,
-                                                Lisp_Object, Lisp_Object,
-                                                int, Lisp_Object,
-                                                Lisp_Object, Lisp_Object,
-                                                int, int);
-static Lisp_Object string_to_object (Lisp_Object, Lisp_Object);
 /* Read a Lisp object from VAL and return it.  If VAL is an empty
@@ -233,10 +222,10 @@ string_to_object (Lisp_Object val, Lisp_Object defalt)
 static Lisp_Object
 read_minibuf_noninteractive (Lisp_Object map, Lisp_Object initial,
                             Lisp_Object prompt, Lisp_Object backup_n,
-                             int expflag,
+                             bool expflag,
                             Lisp_Object histvar, Lisp_Object histpos,
                             Lisp_Object defalt,
-                             int allow_props, int inherit_input_method)
+                             bool allow_props, bool inherit_input_method)
 {
  ptrdiff_t size, len;
  char *line;
@@ -376,23 +365,23 @@ If the current buffer is not a minibuffer, return its entire contents.  */)
   beginning of INITIAL if N <= 0.
   Normally return the result as a string (the text that was read),
-   but if EXPFLAG is nonzero, read it and return the object read.
+   but if EXPFLAG, read it and return the object read.
   If HISTVAR is given, save the value read on that history only if it doesn't
   match the front of that history list exactly.  The value is pushed onto
   the list as the string that was read.
   DEFALT specifies the default value for the sake of history commands.
-   If ALLOW_PROPS is nonzero, we do not throw away text properties.
+   If ALLOW_PROPS, do not throw away text properties.
-   if INHERIT_INPUT_METHOD is nonzero, the minibuffer inherits the
+   if INHERIT_INPUT_METHOD, the minibuffer inherits the
   current input method.  */
 static Lisp_Object
 read_minibuf (Lisp_Object map, Lisp_Object initial, Lisp_Object prompt,
-              int expflag,
+              bool expflag,
              Lisp_Object histvar, Lisp_Object histpos, Lisp_Object defalt,
-              int allow_props, int inherit_input_method)
+              bool allow_props, bool inherit_input_method)
 {
  Lisp_Object val;
  ptrdiff_t count = SPECPDL_INDEX ();
@@ -1447,7 +1436,7 @@ is used to further constrain the set of candidates.  */)
              if (bestmatchsize != SCHARS (eltstring)
                  || bestmatchsize != matchsize)
                /* Don't count the same string multiple times.  */
-                matchcount++;
+                matchcount += matchcount <= 1;
              bestmatchsize = matchsize;
              if (matchsize <= SCHARS (string)
                  /* If completion-ignore-case is non-nil, don't
diff --git a/src/nsfont.m b/src/nsfont.m
index 20a8f5d4028..a820b60ac58 100644
--- a/src/nsfont.m
+++ b/src/nsfont.m
@@ -53,8 +53,6 @@ extern float ns_antialias_threshold;
 extern int ns_tmp_flags;
 extern struct nsfont_info *ns_tmp_font;
-static Lisp_Object Vfonts_in_cache;
 /* font glyph and metrics caching functions, implemented at end */
 static void ns_uni_to_glyphs (struct nsfont_info *font_info,
@@ -815,7 +813,6 @@ nsfont_open (FRAME_PTR f, Lisp_Object font_entity, int pixel_size)
                                  numberWithUnsignedLongLong:
                                    (unsigned long long) XHASH (font_object)]
                        forKey: nsfont];
-          Vfonts_in_cache = Fcons (font_object, Vfonts_in_cache);
        }
    }
@@ -1535,7 +1532,4 @@ syms_of_nsfont (void)
               doc: /* Internal use: maps font registry to Unicode script. */);
  ascii_printable = NULL;
-  Vfonts_in_cache = Qnil;
-  staticpro (&Vfonts_in_cache);
 }
diff --git a/src/nsmenu.m b/src/nsmenu.m
index 9af732c6c45..d0ea8f5a47a 100644
--- a/src/nsmenu.m
+++ b/src/nsmenu.m
@@ -128,8 +128,7 @@ ns_update_menubar (struct frame *f, bool deep_p, EmacsMenu *submenu)
  static EmacsMenu *last_submenu = nil;
  BOOL needsSet = NO;
  const char *submenuTitle = [[submenu title] UTF8String];
-  extern int waiting_for_input;
+  bool owfi;
-  int owfi;
  Lisp_Object items;
  widget_value *wv, *first_wv, *prev_wv = 0;
  int i;
@@ -182,7 +181,8 @@ ns_update_menubar (struct frame *f, bool deep_p, EmacsMenu *submenu)
      /* Fully parse one or more of the submenus. */
      int n = 0;
      int *submenu_start, *submenu_end;
-      int *submenu_top_level_items, *submenu_n_panes;
+      bool *submenu_top_level_items;
+      int *submenu_n_panes;
      struct buffer *prev = current_buffer;
      Lisp_Object buffer;
      ptrdiff_t specpdl_count = SPECPDL_INDEX ();
@@ -741,7 +741,7 @@ extern NSString *NSMenuDidBeginTrackingNotification;
 /* run a menu in popup mode */
 - (Lisp_Object)runMenuAt: (NSPoint)p forFrame: (struct frame *)f
-                 keymaps: (int)keymaps
+                 keymaps: (bool)keymaps
 {
  EmacsView *view = FRAME_NS_VIEW (f);
  NSEvent *e, *event;
@@ -780,7 +780,7 @@ extern NSString *NSMenuDidBeginTrackingNotification;
   ========================================================================== */
 Lisp_Object
-ns_menu_show (FRAME_PTR f, int x, int y, int for_click, int keymaps,
+ns_menu_show (FRAME_PTR f, int x, int y, bool for_click, bool keymaps,
              Lisp_Object title, const char **error)
 {
  EmacsMenu *pmenu;
@@ -802,7 +802,7 @@ ns_menu_show (FRAME_PTR f, int x, int y, int for_click, int keymaps,
 #if 0
  /* FIXME: a couple of one-line differences prevent reuse */
-  wv = digest_single_submenu (0, menu_items_used, Qnil);
+  wv = digest_single_submenu (0, menu_items_used, 0);
 #else
  {
  widget_value *save_wv = 0, *prev_wv = 0;
diff --git a/src/nsterm.h b/src/nsterm.h
index 958d1ce7853..2e868b86caf 100644
--- a/src/nsterm.h
+++ b/src/nsterm.h
@@ -161,7 +161,7 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 - (EmacsMenu *)addSubmenuWithTitle: (const char *)title forFrame: (struct frame *)f;
 - (void) clear;
 - (Lisp_Object)runMenuAt: (NSPoint)p forFrame: (struct frame *)f
-                 keymaps: (int)keymaps;
+                 keymaps: (bool)keymaps;
 @end
@@ -792,7 +792,7 @@ extern void free_frame_tool_bar (FRAME_PTR f);
 extern void find_and_call_menu_selection (FRAME_PTR f,
    int menu_bar_items_used, Lisp_Object vector, void *client_data);
 extern Lisp_Object find_and_return_menu_selection (FRAME_PTR f,
-                                                   int keymaps,
+                                                   bool keymaps,
                                                   void *client_data);
 extern Lisp_Object ns_popup_dialog (Lisp_Object position, Lisp_Object contents,
                                    Lisp_Object header);
diff --git a/src/nsterm.m b/src/nsterm.m
index 6b739befeeb..1d935fc76de 100644
--- a/src/nsterm.m
+++ b/src/nsterm.m
@@ -55,7 +55,6 @@ GNUstep port and post-20 update by Adrian Robert (arobert@cogsci.ucsd.edu)
 #include "ccl.h"
 #include "termhooks.h"
-#include "termopts.h"
 #include "termchar.h"
 #include "window.h"
@@ -1315,7 +1314,7 @@ static void
 ns_fullscreen_hook (FRAME_PTR f)
 {
  EmacsView *view = (EmacsView *)FRAME_NS_VIEW (f);
-  
  if (! f->async_visible) return;
 #ifndef NEW_STYLE_FS
  if (f->want_fullscreen == FULLSCREEN_BOTH)
@@ -5942,7 +5941,7 @@ not_in_argv (NSString *arg)
      [w setBackgroundColor: col];
      if ([col alphaComponent] != 1.0)
        [w setOpaque: NO];
-      
      f->border_width = bwidth;
      FRAME_NS_TITLEBAR_HEIGHT (f) = tibar_height;
      FRAME_TOOLBAR_HEIGHT (f) = tobar_height;
@@ -5995,7 +5994,7 @@ not_in_argv (NSString *arg)
            }
          break;
        }
-  
      emacsframe->want_fullscreen = FULLSCREEN_NONE;
    }
diff --git a/src/process.c b/src/process.c
index c941a196539..2cbce9d28ea 100644
--- a/src/process.c
+++ b/src/process.c
@@ -4302,7 +4302,7 @@ wait_reading_process_output_1 (void)
     -1 meaning caller will actually read the input, so don't throw to
       the quit handler, or
-   DO_DISPLAY != 0 means redisplay should be done to show subprocess
+   DO_DISPLAY means redisplay should be done to show subprocess
     output that arrives.
   If WAIT_FOR_CELL is a cons cell, wait until its car is non-nil
@@ -4322,7 +4322,7 @@ wait_reading_process_output_1 (void)
 int
 wait_reading_process_output (intmax_t time_limit, int nsecs, int read_kbd,
-                             int do_display,
+                             bool do_display,
                             Lisp_Object wait_for_cell,
                             struct Lisp_Process *wait_proc, int just_wait_proc)
 {
@@ -4419,7 +4419,7 @@ wait_reading_process_output (intmax_t time_limit, int nsecs, int read_kbd,
          do
            {
-              int old_timers_run = timers_run;
+              unsigned old_timers_run = timers_run;
              struct buffer *old_buffer = current_buffer;
              Lisp_Object old_window = selected_window;
@@ -4753,7 +4753,7 @@ wait_reading_process_output (intmax_t time_limit, int nsecs, int read_kbd,
      if (read_kbd != 0)
        {
-          int old_timers_run = timers_run;
+          unsigned old_timers_run = timers_run;
          struct buffer *old_buffer = current_buffer;
          Lisp_Object old_window = selected_window;
          int leave = 0;
@@ -6821,14 +6821,14 @@ extern int sys_select (int, SELECT_TYPE *, SELECT_TYPE *, SELECT_TYPE *,
   see full version for other parameters. We know that wait_proc will
     always be NULL, since `subprocesses' isn't defined.
-   DO_DISPLAY != 0 means redisplay should be done to show subprocess
+   DO_DISPLAY means redisplay should be done to show subprocess
   output that arrives.
   Return true if we received input from any process.  */
 int
 wait_reading_process_output (intmax_t time_limit, int nsecs, int read_kbd,
-                             int do_display,
+                             bool do_display,
                             Lisp_Object wait_for_cell,
                             struct Lisp_Process *wait_proc, int just_wait_proc)
 {
@@ -6904,7 +6904,7 @@ wait_reading_process_output (intmax_t time_limit, int nsecs, int read_kbd,
          do
            {
-              int old_timers_run = timers_run;
+              unsigned old_timers_run = timers_run;
              timer_delay = timer_check ();
              if (timers_run != old_timers_run && do_display)
                /* We must retry, since a timer may have requeued itself
diff --git a/src/regex.c b/src/regex.c
index 17562043df1..7443eff3977 100644
--- a/src/regex.c
+++ b/src/regex.c
@@ -1834,7 +1834,6 @@ typedef struct
 /* Explicit quit checking is needed for Emacs, which uses polling to
   process input events.  */
 #ifdef emacs
-extern int immediate_quit;
 # define IMMEDIATE_QUIT_CHECK                   \
    do {                                        \
      if (immediate_quit) QUIT;                 \
diff --git a/src/search.c b/src/search.c
index 7c084c62e28..aacdbe33eef 100644
--- a/src/search.c
+++ b/src/search.c
@@ -636,12 +636,12 @@ newline_cache_on_off (struct buffer *buf)
   If we don't find COUNT instances before reaching END, set *SHORTAGE
   to the number of TARGETs left unfound, and return END.
-   If ALLOW_QUIT is non-zero, set immediate_quit.  That's good to do
+   If ALLOW_QUIT, set immediate_quit.  That's good to do
   except when inside redisplay.  */
 ptrdiff_t
-scan_buffer (register int target, ptrdiff_t start, ptrdiff_t end,
+scan_buffer (int target, ptrdiff_t start, ptrdiff_t end,
-             ptrdiff_t count, ptrdiff_t *shortage, int allow_quit)
+             ptrdiff_t count, ptrdiff_t *shortage, bool allow_quit)
 {
  struct region_cache *newline_cache;
  int direction;
@@ -837,23 +837,23 @@ scan_buffer (register int target, ptrdiff_t start, ptrdiff_t end,
   the number of line boundaries left unfound, and position at
   the limit we bumped up against.
-   If ALLOW_QUIT is non-zero, set immediate_quit.  That's good to do
+   If ALLOW_QUIT, set immediate_quit.  That's good to do
   except in special cases.  */
 EMACS_INT
 scan_newline (ptrdiff_t start, ptrdiff_t start_byte,
              ptrdiff_t limit, ptrdiff_t limit_byte,
-              register EMACS_INT count, int allow_quit)
+              EMACS_INT count, bool allow_quit)
 {
  int direction = ((count > 0) ? 1 : -1);
-  register unsigned char *cursor;
+  unsigned char *cursor;
  unsigned char *base;
  ptrdiff_t ceiling;
-  register unsigned char *ceiling_addr;
+  unsigned char *ceiling_addr;
-  int old_immediate_quit = immediate_quit;
+  bool old_immediate_quit = immediate_quit;
  /* The code that follows is like scan_buffer
     but checks for either newline or carriage return.  */
diff --git a/src/term.c b/src/term.c
index 189fb783cbc..acce9c0548c 100644
--- a/src/term.c
+++ b/src/term.c
@@ -28,7 +28,6 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include "lisp.h"
 #include "termchar.h"
-#include "termopts.h"
 #include "tparam.h"
 #include "character.h"
 #include "buffer.h"
diff --git a/src/termopts.h b/src/termopts.h
index 7bf71aeefe7..05fa0a52eee 100644
--- a/src/termopts.h
+++ b/src/termopts.h
@@ -17,15 +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/>.  */
-/* Nonzero means use ^S/^Q as cretinous flow control.  */
-extern int flow_control;
 /* Nonzero means use interrupt-driven input.  */
-extern int interrupt_input;
+extern bool interrupt_input;
 /* Nonzero while interrupts are temporarily deferred during redisplay.  */
-extern int interrupts_deferred;
+extern bool interrupts_deferred;
-/* Terminal has meta key */
-extern int meta_key;
diff --git a/src/w32select.c b/src/w32select.c
index ee0e6d16b11..1b10c74cfe9 100644
--- a/src/w32select.c
+++ b/src/w32select.c
@@ -76,6 +76,7 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include "lisp.h"
 #include "w32term.h"    /* for all of the w32 includes */
 #include "w32common.h"  /* os_subtype */
+#include "keyboard.h"
 #include "blockinput.h"
 #include "charset.h"
 #include "coding.h"
@@ -393,7 +394,6 @@ run_protected (Lisp_Object (*code) (Lisp_Object), Lisp_Object arg)
     with global variables and calling strange looking functions.  Is
     this really the right way to run Lisp callbacks?  */
-  extern int waiting_for_input; /* from keyboard.c */
  int owfi;
  block_input ();
diff --git a/src/xmenu.c b/src/xmenu.c
index 96a1ae87fdc..01d932cf8d8 100644
--- a/src/xmenu.c
+++ b/src/xmenu.c
@@ -111,7 +111,7 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 static Lisp_Object Qdebug_on_next_call;
 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
-static Lisp_Object xdialog_show (FRAME_PTR, int, Lisp_Object, Lisp_Object,
+static Lisp_Object xdialog_show (FRAME_PTR, bool, Lisp_Object, Lisp_Object,
                                 const char **);
 #endif
@@ -930,7 +930,8 @@ set_frame_menubar (FRAME_PTR f, bool first_time, bool deep_p)
  widget_value *wv, *first_wv, *prev_wv = 0;
  int i;
  int *submenu_start, *submenu_end;
-  int *submenu_top_level_items, *submenu_n_panes;
+  bool *submenu_top_level_items;
+  int *submenu_n_panes;
  if (! FRAME_X_P (f))
    emacs_abort ();
@@ -1346,8 +1347,8 @@ free_frame_menubar (FRAME_PTR f)
 /* F is the frame the menu is for.
   X and Y are the frame-relative specified position,
   relative to the inside upper left corner of the frame F.
-   FOR_CLICK is nonzero if this menu was invoked for a mouse click.
+   FOR_CLICK is true if this menu was invoked for a mouse click.
-   KEYMAPS is 1 if this menu was specified with keymaps;
+   KEYMAPS is true if this menu was specified with keymaps;
    in that case, we return a list containing the chosen item's value
    and perhaps also the pane's prefix.
   TITLE is the specified menu title.
@@ -1427,14 +1428,14 @@ pop_down_menu (Lisp_Object arg)
   menu_item_selection will be set to the selection.  */
 static void
 create_and_show_popup_menu (FRAME_PTR f, widget_value *first_wv, int x, int y,
-                            int for_click, Time timestamp)
+                            bool for_click, Time timestamp)
 {
  int i;
  GtkWidget *menu;
  GtkMenuPositionFunc pos_func = 0;  /* Pop up at pointer.  */
  struct next_popup_x_y popup_x_y;
  ptrdiff_t specpdl_count = SPECPDL_INDEX ();
-  int use_pos_func = ! for_click;
+  bool use_pos_func = ! for_click;
 #ifdef HAVE_GTK3
  /* Always use position function for Gtk3.  Otherwise menus may become
@@ -1539,7 +1540,7 @@ pop_down_menu (Lisp_Object arg)
   menu_item_selection will be set to the selection.  */
 static void
 create_and_show_popup_menu (FRAME_PTR f, widget_value *first_wv,
-                            int x, int y, int for_click, Time timestamp)
+                            int x, int y, bool for_click, Time timestamp)
 {
  int i;
  Arg av[2];
@@ -1623,7 +1624,7 @@ cleanup_widget_value_tree (Lisp_Object arg)
 }
 Lisp_Object
-xmenu_show (FRAME_PTR f, int x, int y, int for_click, int keymaps,
+xmenu_show (FRAME_PTR f, int x, int y, bool for_click, bool keymaps,
            Lisp_Object title, const char **error_name, Time timestamp)
 {
  int i;
@@ -1878,7 +1879,7 @@ xmenu_show (FRAME_PTR f, int x, int y, int for_click, int keymaps,
                = AREF (menu_items, i + MENU_ITEMS_ITEM_VALUE);
              if (menu_item_selection == aref_addr (menu_items, i))
                {
-                  if (keymaps != 0)
+                  if (keymaps)
                    {
                      int j;
@@ -2011,7 +2012,7 @@ static const char * button_names [] = {
 static Lisp_Object
 xdialog_show (FRAME_PTR f,
-              int keymaps,
+              bool keymaps,
              Lisp_Object title,
              Lisp_Object header,
              const char **error_name)
@@ -2277,7 +2278,7 @@ pop_down_menu (Lisp_Object arg)
 Lisp_Object
-xmenu_show (FRAME_PTR f, int x, int y, int for_click, int keymaps,
+xmenu_show (FRAME_PTR f, int x, int y, bool for_click, bool keymaps,
            Lisp_Object title, const char **error_name, Time timestamp)
 {
  Window root;
@@ -2528,7 +2529,7 @@ xmenu_show (FRAME_PTR f, int x, int y, int for_click, int keymaps,
                    {
                      entry
                        = AREF (menu_items, i + MENU_ITEMS_ITEM_VALUE);
-                      if (keymaps != 0)
+                      if (keymaps)
                        {
                          entry = Fcons (entry, Qnil);
                          if (!NILP (pane_prefix))
diff --git a/src/xsettings.c b/src/xsettings.c
index 7c68ff295cf..d23070791d8 100644
--- a/src/xsettings.c
+++ b/src/xsettings.c
@@ -29,7 +29,6 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include "keyboard.h"
 #include "blockinput.h"
 #include "termhooks.h"
-#include "termopts.h"
 #include <X11/Xproto.h>
diff --git a/src/xsmfns.c b/src/xsmfns.c
index 8067899f931..289aac8492b 100644
--- a/src/xsmfns.c
+++ b/src/xsmfns.c
@@ -35,7 +35,6 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include "sysselect.h"
 #include "frame.h"
 #include "termhooks.h"
-#include "termopts.h"
 #include "xterm.h"
 #include "process.h"
 #include "keyboard.h"
author	Eli Zaretskii	2012-10-12 11:45:45 +0200
committer	Eli Zaretskii	2012-10-12 11:45:45 +0200
commit	0dc9ee4adad0b566c32036a4c201a1de882ac65b (patch)
tree	a61f585563633f0f38838012771dae63a3cef098 /src
parent	182b170f7ec712b7f89ada65095aae5bb8fe553e (diff)
parent	81749a2374c78d656888b462f3b29301e4cbd1c7 (diff)
download	emacs-0dc9ee4adad0b566c32036a4c201a1de882ac65b.tar.gz emacs-0dc9ee4adad0b566c32036a4c201a1de882ac65b.zip