auto upstream

22 files changed, 351 insertions, 205 deletions

diff --git a/doc/misc/ChangeLog b/doc/misc/ChangeLog
index 12230bfb374..44a0b7b3211 100644
--- a/doc/misc/ChangeLog
+++ b/doc/misc/ChangeLog
@@ -1,3 +1,13 @@
+2013-03-08  Glenn Morris  <rgm@gnu.org>
+
+        * faq.texi (Top): Don't say this was updated @today.
+        That's irrelevant and leads to spurious diffs.
+
+2013-03-08  Jay Belanger  <jay.p.belanger@gmail.com>
+
+        * calc.texi (Basic Operations on Units): Fix
+        cross-reference.
+
 2013-03-07  Katsumi Yamaoka  <yamaoka@jpl.org>
 
         * gnus-faq.texi (FAQ 3-11): Now Gnus supports POP3 UIDL.
diff --git a/doc/misc/calc.texi b/doc/misc/calc.texi
index 2d1f59cfa68..0bf7833ec34 100644
--- a/doc/misc/calc.texi
+++ b/doc/misc/calc.texi
@@ -27918,8 +27918,8 @@ simplified so that it doesn't contain any units, like @samp{ft/in} can
 be simplified to 12, then @kbd{u c} will still prompt for both old
 units and new units. You can ignore the prompt for old units with
 @key{RET}, or turn off the prompt by setting the customizable variable
-@code{calc-allow-units-as-numbers} to @code{nil}. 
-@pxref{Customizing Calc})  Assuming the old and new units you give are
+@code{calc-allow-units-as-numbers} to @code{nil};
+@pxref{Customizing Calc}.)  Assuming the old and new units you give are
 consistent with each other, the result also will not contain any
 units.  For example, @kbd{@w{u c} cm @key{RET} in @key{RET}} converts
 the number 2 on the stack to 5.08.
diff --git a/doc/misc/faq.texi b/doc/misc/faq.texi
index 39b4a9037bd..18e3340a474 100644
--- a/doc/misc/faq.texi
+++ b/doc/misc/faq.texi
@@ -58,8 +58,7 @@ distribution.]
 @node Top, FAQ notation, (dir), (dir)
 @top The GNU Emacs FAQ
 
-@c FIXME @today is just the day we ran `makeinfo'.
-This is the GNU Emacs FAQ, last updated on @today{}.
+This is the GNU Emacs FAQ.
 
 This FAQ is maintained as a part of GNU Emacs.  If you find any errors,
 or have any suggestions, please use @kbd{M-x report-emacs-bug} to report
diff --git a/lisp/ChangeLog b/lisp/ChangeLog
index 4f24f5b2c8c..9dc7f06e02c 100644
--- a/lisp/ChangeLog
+++ b/lisp/ChangeLog
@@ -1,23 +1,36 @@
-2013-03-07  Karl Fogel  <kfogel@red-bean.com>
+2013-03-08  Jambunathan K  <kjambunathan@gmail.com>
+
+        * hi-lock.el (hi-lock-read-regexp-defaults-function): New var.
+        (hi-lock-read-regexp-defaults):  New defun.
+        (hi-lock-line-face-buffer, hi-lock-face-buffer)
+        (hi-lock-face-phrase-buffer): Propagate above change.  Update
+        docstring (bug#13892).
+
+        * subr.el (find-tag-default-as-regexp): New defun.
+        * replace.el (read-regexp): Propagate above change.
+
+2013-03-08  Jay Belanger  <jay.p.belanger@gmail.com>
+
+        * calc/calc-units.el (calc-convert-units): Fix the way that default
+        new units are stored.
+
+2013-03-07  Matthias Meulien  <orontee@gmail.com>
 
         * bookmark.el: Define a face to highlight bookmark names in
         bookmark menu buffers, where the default is a bold face similarly
-        to buffer names in buffer menu buffers.  Patch by Matthias Meulien
-        <orontee {_AT_} gmail.com>.
-
+        to buffer names in buffer menu buffers.
         (bookmark-menu-bookmark): New face to highlight bookmark names.
         (bookmark-insert-location): Remove duplicated text property to
         conform to buffer list (see `list-buffers').
         (bookmark-bmenu-list, bookmark-bmenu-hide-filenames): Apply face
         `bookmark-menu-bookmark' to bookmark names.
 
-2013-03-07  Karl Fogel  <kfogel@red-bean.com>
+2013-03-07  Matthias Meulien  <orontee@gmail.com>
+            Karl Fogel  <kfogel@red-bean.com>
 
         * bookmark.el: Display the bookmark list header similarly to the
         buffer list header (see `list-buffers'), where the default is now
-        an immovable/immutable header line.  Patch by Matthias Meulien
-        <orontee {_AT_} gmail.com> with a few tweaks by me.
-
+        an immovable/immutable header line.
         (bookmark-bmenu-use-header-line): New variable.
         (bookmark-bmenu-inline-header-height): New name for
         `bookmark-bmenu-header-height', to avoid confusion with the code
diff --git a/lisp/calc/calc-units.el b/lisp/calc/calc-units.el
index b334d7b3b45..335980af4dd 100644
--- a/lisp/calc/calc-units.el
+++ b/lisp/calc/calc-units.el
@@ -503,11 +503,13 @@ If COMP or STD is non-nil, put that in the units table instead."
            (comp (eq (car-safe units) '+)))
        (unless (or unew std)
          (error "No units specified"))
-       (let ((res
-              (if std
-                  (math-simplify-units (math-to-standard-units expr (nth 1 std)))
-                (math-convert-units expr units (and uoldname (not (equal uoldname "1")))))))
-         (math-put-default-units res (if comp units))
+       (let* ((noold (and uoldname (not (equal uoldname "1"))))
+              (res
+               (if std
+                   (math-simplify-units (math-to-standard-units expr (nth 1 std)))
+                 (math-convert-units expr units noold))))
+         (unless std
+           (math-put-default-units (if noold units res) (if comp units)))
          (calc-enter-result 1 "cvun" res))))))
 
 (defun calc-autorange-units (arg)
diff --git a/lisp/hi-lock.el b/lisp/hi-lock.el
index cbd8ac5ebad..38e5e8acb15 100644
--- a/lisp/hi-lock.el
+++ b/lisp/hi-lock.el
@@ -279,6 +279,26 @@ a library is being loaded.")
     map)
   "Key map for hi-lock.")
 
+(defvar hi-lock-read-regexp-defaults-function
+  'hi-lock-read-regexp-defaults
+  "Function that provides default regexp(s) for highlighting commands.
+This function should take no arguments and return one of nil, a
+regexp or a list of regexps for use with highlighting commands -
+`hi-lock-face-phrase-buffer', `hi-lock-line-face-buffer' and
+`hi-lock-face-buffer'.  The return value of this function is used
+as DEFAULTS param of `read-regexp' while executing the
+highlighting command.  This function is called only during
+interactive use.  
+
+For example, to highlight at symbol at point use
+
+    \(setq hi-lock-read-regexp-defaults-function 
+          'find-tag-default-as-regexp\)
+
+If you need different defaults for different highlighting
+operations, use `this-command' to identify the command under
+execution.")
+
 ;; Visible Functions
 
 ;;;###autoload
@@ -399,17 +419,18 @@ versions before 22 use the following in your init file:
 ;;;###autoload
 (defun hi-lock-line-face-buffer (regexp &optional face)
   "Set face of all lines containing a match of REGEXP to FACE.
-Interactively, prompt for REGEXP then FACE, using a buffer-local
-history list for REGEXP and a global history list for FACE.
+Interactively, prompt for REGEXP then FACE.  Use
+`hi-lock-read-regexp-defaults-function' to retrieve default
+value(s) of REGEXP.  Use the global history list for FACE.
 
-If Font Lock mode is enabled in the buffer, it is used to
-highlight REGEXP.  If Font Lock mode is disabled, overlays are
-used for highlighting; in this case, the highlighting will not be
-updated as you type."
+Use Font lock mode, if enabled, to highlight REGEXP.  Otherwise,
+use overlays for highlighting.  If overlays are used, the
+highlighting will not update as you type."
   (interactive
    (list
     (hi-lock-regexp-okay
-     (read-regexp "Regexp to highlight line" (car regexp-history)))
+     (read-regexp "Regexp to highlight line"
+                  (funcall hi-lock-read-regexp-defaults-function)))
     (hi-lock-read-face-name)))
   (or (facep face) (setq face 'hi-yellow))
   (unless hi-lock-mode (hi-lock-mode 1))
@@ -424,17 +445,18 @@ updated as you type."
 ;;;###autoload
 (defun hi-lock-face-buffer (regexp &optional face)
   "Set face of each match of REGEXP to FACE.
-Interactively, prompt for REGEXP then FACE, using a buffer-local
-history list for REGEXP and a global history list for FACE.
+Interactively, prompt for REGEXP then FACE.  Use
+`hi-lock-read-regexp-defaults-function' to retrieve default
+value(s) REGEXP.  Use the global history list for FACE.
 
-If Font Lock mode is enabled in the buffer, it is used to
-highlight REGEXP.  If Font Lock mode is disabled, overlays are
-used for highlighting; in this case, the highlighting will not be
-updated as you type."
+Use Font lock mode, if enabled, to highlight REGEXP.  Otherwise,
+use overlays for highlighting.  If overlays are used, the
+highlighting will not update as you type."
   (interactive
    (list
     (hi-lock-regexp-okay
-     (read-regexp "Regexp to highlight" (car regexp-history)))
+     (read-regexp "Regexp to highlight"
+                  (funcall hi-lock-read-regexp-defaults-function)))
     (hi-lock-read-face-name)))
   (or (facep face) (setq face 'hi-yellow))
   (unless hi-lock-mode (hi-lock-mode 1))
@@ -445,18 +467,22 @@ updated as you type."
 ;;;###autoload
 (defun hi-lock-face-phrase-buffer (regexp &optional face)
   "Set face of each match of phrase REGEXP to FACE.
-If called interactively, replaces whitespace in REGEXP with
-arbitrary whitespace and makes initial lower-case letters case-insensitive.
-
-If Font Lock mode is enabled in the buffer, it is used to
-highlight REGEXP.  If Font Lock mode is disabled, overlays are
-used for highlighting; in this case, the highlighting will not be
-updated as you type."
+Interactively, prompt for REGEXP then FACE.  Use
+`hi-lock-read-regexp-defaults-function' to retrieve default
+value(s) of REGEXP.  Use the global history list for FACE.  When
+called interactively, replace whitespace in user provided regexp
+with arbitrary whitespace and make initial lower-case letters
+case-insensitive before highlighting with `hi-lock-set-pattern'.
+
+Use Font lock mode, if enabled, to highlight REGEXP.  Otherwise,
+use overlays for highlighting.  If overlays are used, the
+highlighting will not update as you type."
   (interactive
    (list
     (hi-lock-regexp-okay
      (hi-lock-process-phrase
-      (read-regexp "Phrase to highlight" (car regexp-history))))
+      (read-regexp "Phrase to highlight"
+                   (funcall hi-lock-read-regexp-defaults-function))))
     (hi-lock-read-face-name)))
   (or (facep face) (setq face 'hi-yellow))
   (unless hi-lock-mode (hi-lock-mode 1))
@@ -622,6 +648,11 @@ not suitable."
       (error "Regexp cannot match an empty string")
     regexp))
 
+(defun hi-lock-read-regexp-defaults ()
+  "Return the latest regexp from `regexp-history'.
+See `hi-lock-read-regexp-defaults-function' for details."
+  (car regexp-history))
+
 (defun hi-lock-read-face-name ()
   "Return face for interactive highlighting.
 When `hi-lock-auto-select-face' is non-nil, just return the next face.
diff --git a/lisp/org/ChangeLog b/lisp/org/ChangeLog
index 5626b611f0d..1bf6fe315c1 100644
--- a/lisp/org/ChangeLog
+++ b/lisp/org/ChangeLog
@@ -1,3 +1,9 @@
+2013-03-08  Bastien Guerry  <bzg@gnu.org>
+
+        * org-exp.el (org-export-normalize-links): Fix critical bug: do
+        not rely on `org-context' to guess where to prevent links
+        normalization.
+
 2013-02-28  Achim Gratz  <Stromeko@Stromeko.DE>
 
         * org.el (org-org-menu): Use correct key "C-u C-c C-x !" to do
diff --git a/lisp/org/org-exp.el b/lisp/org/org-exp.el
index 5ccaec3e67f..82b9003e4fd 100644
--- a/lisp/org/org-exp.el
+++ b/lisp/org/org-exp.el
@@ -2113,8 +2113,7 @@ Also, store forced alignment information found in such lines."
       (put-text-property (match-beginning 0) (match-end 0) 'org-normalized-link t))
     (goto-char (point-min))
     (while (re-search-forward re-plain-link nil t)
-      (unless (or (get-text-property (match-beginning 0) 'org-normalized-link)
-                  (assoc :tags (org-context)))
+      (unless (get-text-property (match-beginning 0) 'org-normalized-link)
         (goto-char (1- (match-end 0)))
         (org-if-unprotected-at (1+ (match-beginning 0))
           (let* ((s (concat (match-string 1)
diff --git a/lisp/replace.el b/lisp/replace.el
index 86b1aa27069..ceb0fe4a63e 100644
--- a/lisp/replace.el
+++ b/lisp/replace.el
@@ -603,15 +603,7 @@ If HISTORY is nil, `regexp-history' is used."
           (append
            suggestions
            (list
-            ;; Regexp for tag at point.
-            (let* ((tagf (or find-tag-default-function
-                             (get major-mode 'find-tag-default-function)
-                             'find-tag-default))
-                   (tag (funcall tagf)))
-              (cond ((not tag) "")
-                    ((eq tagf 'find-tag-default)
-                     (format "\\_<%s\\_>" (regexp-quote tag)))
-                    (t (regexp-quote tag))))
+            (find-tag-default-as-regexp)
             (car regexp-search-ring)
             (regexp-quote (or (car search-ring) ""))
             (car (symbol-value query-replace-from-history-variable)))))
diff --git a/lisp/subr.el b/lisp/subr.el
index db2b6a8eaad..9a7b94208fe 100644
--- a/lisp/subr.el
+++ b/lisp/subr.el
@@ -2697,6 +2697,22 @@ If there is no plausible default, return nil."
                      (setq to (point)))))
       (buffer-substring-no-properties from to))))
 
+(defun find-tag-default-as-regexp ()
+  "Return regexp that matches the default tag at point.
+If there is no tag at point, return nil.
+
+When in a major mode that does not provide its own
+`find-tag-default-function', return a regexp that matches the
+symbol at point exactly."
+  (let* ((tagf (or find-tag-default-function
+                   (get major-mode 'find-tag-default-function)
+                   'find-tag-default))
+         (tag (funcall tagf)))
+    (cond ((not tag))
+          ((eq tagf 'find-tag-default)
+           (format "\\_<%s\\_>" (regexp-quote tag)))
+          (t (regexp-quote tag)))))
+
 (defun play-sound (sound)
   "SOUND is a list of the form `(sound KEYWORD VALUE...)'.
 The following keywords are recognized:
diff --git a/src/ChangeLog b/src/ChangeLog
index 54b1fd04503..69e8303111a 100644
--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -1,3 +1,61 @@
+2013-03-08  Paul Eggert  <eggert@cs.ucla.edu>
+
+        region-cache.c, scroll.c, search.c: Use bool for booleans.
+        * lisp.h (compile_pattern):
+        * scroll.c (do_scrolling, do_direct_scrolling):
+        * search.c (struct regexp_cache, compile_pattern_1)
+        (compile_pattern, string_match_1, search_command)
+        (trivial_regexp_p, search_buffer, Freplace_match, match_limit)
+        (search_regs_saved, Fregexp_quote):
+        Use bool for boolean.
+        * region-cache.c (region_cache_forward, region_cache_backward):
+        Fix comments to match code: these functions return int, not boolean.
+
+2013-03-08  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        * search.c (find_newline): Accept start and end byte positions
+        as arguments and allow -1 if not known.
+        (find_newline_no_quit): Likewise for start position.
+        * lisp.h (find_newline, find_newline_no_quit): Adjust prototype.
+        * bidi.c (bidi_find_paragraph_start): Pass byte position to
+        find_newline_no_quit, thus eliminating CHAR_TO_BYTE.
+        * editfns.c (Fconstrain_to_field): Break long line.  Adjust
+        call to find_newline.
+        * indent.c (vmotion): Adjust calls to find_newline_no_quit.
+        Use DEC_BOTH to start next search from the previous buffer
+        position, where appropriate.
+        * xdisp.c (back_to_previous_line_start, forward_to_next_line_start)
+        (get_visually_first_element, move_it_vertically_backward): Likewise.
+        Obtain byte position from the display iterator, where appropriate.
+
+2013-03-08  Paul Eggert  <eggert@cs.ucla.edu>
+
+        print.c, process.c: Use bool for booleans.
+        * lisp.h (wait_reading_process_output):
+        * print.c (print_output_debug_flag, PRINTDECLARE, printchar)
+        (strout, debug_output_compilation_hack, float_to_string, print)
+        (print_object):
+        * process.c (kbd_is_on_hold, inhibit_sentinels, process_output_skip)
+        (decode_status, status_message, create_process, create_pty)
+        (Fmake_network_process, Fnetwork_interface_info)
+        (wait_reading_process_output, read_process_output)
+        (write_queue_push, write_queue_pop, process_send_signal)
+        (handle_child_signal, keyboard_bit_set, kbd_on_hold_p):
+        * process.h (struct Lisp_Process, inhibit_sentinels, kbd_on_hold_p):
+        Use bool for booleans.
+        * process.c (Fnetwork_interface_list): Remove unused local.
+        (connect_counter): Now EMACS_INT, not int.
+
+2013-03-08  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        * bidi.c (bidi_fetch_char): Swap first and second arguments
+        to match other functions accepting character and byte positions.
+        Adjust comment.
+        (bidi_resolve_explicit_1, bidi_level_of_next_char): Adjust users.
+        (bidi_paragraph_init): Likewise.  Use DEC_BOTH which is faster
+        when you need just to move to the previous buffer position.
+        * xdisp.c (Fcurrent_bidi_paragraph_direction): Use DEC_BOTH.
+
 2013-03-07  Eli Zaretskii  <eliz@gnu.org>
 
         * .gdbinit (prowlims): Display the enabled_p flag of the row.
diff --git a/src/bidi.c b/src/bidi.c
index cf5e580cd8f..c6bea62f67b 100644
--- a/src/bidi.c
+++ b/src/bidi.c
@@ -910,7 +910,7 @@ bidi_char_at_pos (ptrdiff_t bytepos, const unsigned char *s, bool unibyte)
   return STRING_CHAR (s);
 }
 
-/* Fetch and return the character at BYTEPOS/CHARPOS.  If that
+/* Fetch and return the character at CHARPOS/BYTEPOS.  If that
    character is covered by a display string, treat the entire run of
    covered characters as a single character, either u+2029 or u+FFFC,
    and return their combined length in CH_LEN and NCHARS.  DISP_POS
@@ -925,7 +925,7 @@ bidi_char_at_pos (ptrdiff_t bytepos, const unsigned char *s, bool unibyte)
    string to iterate, or NULL if iterating over a buffer or a Lisp
    string; in the latter case, STRING->lstring is the Lisp string.  */
 static int
-bidi_fetch_char (ptrdiff_t bytepos, ptrdiff_t charpos, ptrdiff_t *disp_pos,
+bidi_fetch_char (ptrdiff_t charpos, ptrdiff_t bytepos, ptrdiff_t *disp_pos,
                  int *disp_prop, struct bidi_string_data *string,
                  bool frame_window_p, ptrdiff_t *ch_len, ptrdiff_t *nchars)
 {
@@ -1104,11 +1104,14 @@ bidi_find_paragraph_start (ptrdiff_t pos, ptrdiff_t pos_byte)
   while (pos_byte > BEGV_BYTE
          && n++ < MAX_PARAGRAPH_SEARCH
          && fast_looking_at (re, pos, pos_byte, limit, limit_byte, Qnil) < 0)
-    /* FIXME: What if the paragraph beginning is covered by a
-       display string?  And what if a display string covering some
-       of the text over which we scan back includes
-       paragraph_start_re?  */
-    pos = find_newline_no_quit (pos - 1, -1, &pos_byte);
+    {
+      /* FIXME: What if the paragraph beginning is covered by a
+         display string?  And what if a display string covering some
+         of the text over which we scan back includes
+         paragraph_start_re?  */
+      DEC_BOTH (pos, pos_byte);
+      pos = find_newline_no_quit (pos, pos_byte, -1, &pos_byte);
+    }
   if (n >= MAX_PARAGRAPH_SEARCH)
     pos_byte = BEGV_BYTE;
   return pos_byte;
@@ -1220,7 +1223,7 @@ bidi_paragraph_init (bidi_dir_t dir, struct bidi_it *bidi_it, bool no_default_p)
         bytepos = pstartbyte;
         if (!string_p)
           pos = BYTE_TO_CHAR (bytepos);
-        ch = bidi_fetch_char (bytepos, pos, &disp_pos, &disp_prop,
+        ch = bidi_fetch_char (pos, bytepos, &disp_pos, &disp_prop,
                               &bidi_it->string,
                               bidi_it->frame_window_p, &ch_len, &nchars);
         type = bidi_get_type (ch, NEUTRAL_DIR);
@@ -1248,7 +1251,7 @@ bidi_paragraph_init (bidi_dir_t dir, struct bidi_it *bidi_it, bool no_default_p)
                 && bidi_at_paragraph_end (pos, bytepos) >= -1)
               break;
             /* Fetch next character and advance to get past it.  */
-            ch = bidi_fetch_char (bytepos, pos, &disp_pos,
+            ch = bidi_fetch_char (pos, bytepos, &disp_pos,
                                   &disp_prop, &bidi_it->string,
                                   bidi_it->frame_window_p, &ch_len, &nchars);
             pos += nchars;
@@ -1279,8 +1282,7 @@ bidi_paragraph_init (bidi_dir_t dir, struct bidi_it *bidi_it, bool no_default_p)
                     /* FXIME: What if p is covered by a display
                        string?  See also a FIXME inside
                        bidi_find_paragraph_start.  */
-                    p--;
-                    pbyte = CHAR_TO_BYTE (p);
+                    DEC_BOTH (p, pbyte);
                     prevpbyte = bidi_find_paragraph_start (p, pbyte);
                   }
                 pstartbyte = prevpbyte;
@@ -1398,7 +1400,7 @@ bidi_resolve_explicit_1 (struct bidi_it *bidi_it)
       /* Fetch the character at BYTEPOS.  If it is covered by a
          display string, treat the entire run of covered characters as
          a single character u+FFFC.  */
-      curchar = bidi_fetch_char (bidi_it->bytepos, bidi_it->charpos,
+      curchar = bidi_fetch_char (bidi_it->charpos, bidi_it->bytepos,
                                  &bidi_it->disp_pos, &bidi_it->disp_prop,
                                  &bidi_it->string, bidi_it->frame_window_p,
                                  &bidi_it->ch_len, &bidi_it->nchars);
@@ -2191,7 +2193,7 @@ bidi_level_of_next_char (struct bidi_it *bidi_it)
       if (bidi_it->nchars <= 0)
         emacs_abort ();
       do {
-        ch = bidi_fetch_char (bpos += clen, cpos += nc, &disp_pos, &dpp, &bs,
+        ch = bidi_fetch_char (cpos += nc, bpos += clen, &disp_pos, &dpp, &bs,
                               fwp, &clen, &nc);
         if (ch == '\n' || ch == BIDI_EOB)
           chtype = NEUTRAL_B;
diff --git a/src/editfns.c b/src/editfns.c
index e1813dc65a1..f34c574cae3 100644
--- a/src/editfns.c
+++ b/src/editfns.c
@@ -669,7 +669,8 @@ If the optional argument INHIBIT-CAPTURE-PROPERTY is non-nil, and OLD-POS has
 a non-nil property of that name, then any field boundaries are ignored.
 
 Field boundaries are not noticed if `inhibit-field-text-motion' is non-nil.  */)
-  (Lisp_Object new_pos, Lisp_Object old_pos, Lisp_Object escape_from_edge, Lisp_Object only_in_line, Lisp_Object inhibit_capture_property)
+  (Lisp_Object new_pos, Lisp_Object old_pos, Lisp_Object escape_from_edge,
+   Lisp_Object only_in_line, Lisp_Object inhibit_capture_property)
 {
   /* If non-zero, then the original point, before re-positioning.  */
   ptrdiff_t orig_point = 0;
@@ -735,7 +736,8 @@ Field boundaries are not noticed if `inhibit-field-text-motion' is non-nil.  */)
               /* This is the ONLY_IN_LINE case, check that NEW_POS and
                  FIELD_BOUND are on the same line by seeing whether
                  there's an intervening newline or not.  */
-              || (find_newline (XFASTINT (new_pos), XFASTINT (field_bound),
+              || (find_newline (XFASTINT (new_pos), -1,
+                                XFASTINT (field_bound), -1,
                                 fwd ? -1 : 1, &shortage, NULL, 1),
                   shortage != 0)))
         /* Constrain NEW_POS to FIELD_BOUND.  */
diff --git a/src/indent.c b/src/indent.c
index fd692f0b149..d1f95da6bcf 100644
--- a/src/indent.c
+++ b/src/indent.c
@@ -1840,10 +1840,13 @@ vmotion (register ptrdiff_t from, register ptrdiff_t from_byte,
 
       while ((vpos > vtarget || first) && from > BEGV)
         {
-          ptrdiff_t bytepos;
+          ptrdiff_t bytepos = from_byte;
           Lisp_Object propval;
 
-          prevline = find_newline_no_quit (from - 1, -1, &bytepos);
+          prevline = from;
+          DEC_BOTH (prevline, bytepos);
+          prevline = find_newline_no_quit (prevline, bytepos, -1, &bytepos);
+
           while (prevline > BEGV
                  && ((selective > 0
                       && indented_beyond_p (prevline, bytepos, selective))
@@ -1853,7 +1856,10 @@ vmotion (register ptrdiff_t from, register ptrdiff_t from_byte,
                                                        Qinvisible,
                                                        text_prop_object),
                          TEXT_PROP_MEANS_INVISIBLE (propval))))
-            prevline = find_newline_no_quit (prevline - 1, -1, &bytepos);
+            {
+              DEC_BOTH (prevline, bytepos);
+              prevline = find_newline_no_quit (prevline, bytepos, -1, &bytepos);
+            }
           pos = *compute_motion (prevline, bytepos, 0, lmargin, 0, from,
                                  /* Don't care for VPOS...  */
                                  1 << (BITS_PER_SHORT - 1),
@@ -1890,7 +1896,7 @@ vmotion (register ptrdiff_t from, register ptrdiff_t from_byte,
       ptrdiff_t bytepos;
       Lisp_Object propval;
 
-      prevline = find_newline_no_quit (from, -1, &bytepos);
+      prevline = find_newline_no_quit (from, from_byte, -1, &bytepos);
       while (prevline > BEGV
              && ((selective > 0
                   && indented_beyond_p (prevline, bytepos, selective))
@@ -1900,7 +1906,10 @@ vmotion (register ptrdiff_t from, register ptrdiff_t from_byte,
                                                    Qinvisible,
                                                    text_prop_object),
                      TEXT_PROP_MEANS_INVISIBLE (propval))))
-        prevline = find_newline_no_quit (prevline - 1, -1, &bytepos);
+        {
+          DEC_BOTH (prevline, bytepos);
+          prevline = find_newline_no_quit (prevline, bytepos, -1, &bytepos);
+        }
       pos = *compute_motion (prevline, bytepos, 0, lmargin, 0, from,
                              /* Don't care for VPOS...  */
                              1 << (BITS_PER_SHORT - 1),
diff --git a/src/lisp.h b/src/lisp.h
index 85cf981d9b2..b46f466406b 100644
--- a/src/lisp.h
+++ b/src/lisp.h
@@ -3362,18 +3362,19 @@ extern void record_unwind_save_match_data (void);
 struct re_registers;
 extern struct re_pattern_buffer *compile_pattern (Lisp_Object,
                                                   struct re_registers *,
-                                                  Lisp_Object, int, bool);
+                                                  Lisp_Object, bool, bool);
 extern ptrdiff_t fast_string_match (Lisp_Object, Lisp_Object);
 extern ptrdiff_t fast_c_string_match_ignore_case (Lisp_Object, const char *,
                                                   ptrdiff_t);
 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 find_newline (ptrdiff_t, ptrdiff_t, ptrdiff_t,
-                               ptrdiff_t *, ptrdiff_t *, bool);
+extern ptrdiff_t find_newline (ptrdiff_t, ptrdiff_t, ptrdiff_t, ptrdiff_t,
+                               ptrdiff_t, ptrdiff_t *, ptrdiff_t *, bool);
 extern EMACS_INT scan_newline (ptrdiff_t, ptrdiff_t, ptrdiff_t, ptrdiff_t,
                                EMACS_INT, bool);
-extern ptrdiff_t find_newline_no_quit (ptrdiff_t, ptrdiff_t, ptrdiff_t *);
+extern ptrdiff_t find_newline_no_quit (ptrdiff_t, ptrdiff_t,
+                                       ptrdiff_t, ptrdiff_t *);
 extern ptrdiff_t find_before_next_newline (ptrdiff_t, ptrdiff_t,
                                            ptrdiff_t, ptrdiff_t *);
 extern void syms_of_search (void);
@@ -3503,10 +3504,10 @@ 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, bool,
-                                        Lisp_Object,
-                                        struct Lisp_Process *,
-                                        int);
+extern bool wait_reading_process_output (intmax_t, int, int, bool,
+                                         Lisp_Object,
+                                         struct Lisp_Process *,
+                                         int);
 /* Max value for the first argument of wait_reading_process_output.  */
 #if __GNUC__ == 3 || (__GNUC__ == 4 && __GNUC_MINOR__ <= 5)
 /* Work around a bug in GCC 3.4.2, known to be fixed in GCC 4.6.3.
diff --git a/src/print.c b/src/print.c
index 9a84903e306..cc451d2e395 100644
--- a/src/print.c
+++ b/src/print.c
@@ -86,7 +86,7 @@ static ptrdiff_t print_number_index;
 static void print_interval (INTERVAL interval, Lisp_Object printcharfun);
 
 /* GDB resets this to zero on W32 to disable OutputDebugString calls.  */
-int print_output_debug_flag EXTERNALLY_VISIBLE = 1;
+bool print_output_debug_flag EXTERNALLY_VISIBLE = 1;
 
 
 /* Low level output routines for characters and strings.  */
@@ -103,7 +103,7 @@ int print_output_debug_flag EXTERNALLY_VISIBLE = 1;
    ptrdiff_t old_point = -1, start_point = -1;                          \
    ptrdiff_t old_point_byte = -1, start_point_byte = -1;                \
    ptrdiff_t specpdl_count = SPECPDL_INDEX ();                          \
-   int free_print_buffer = 0;                                           \
+   bool free_print_buffer = 0;                                          \
    bool multibyte                                                       \
      = !NILP (BVAR (current_buffer, enable_multibyte_characters));      \
    Lisp_Object original
@@ -243,7 +243,7 @@ printchar (unsigned int ch, Lisp_Object fun)
         }
       else
         {
-          int multibyte_p
+          bool multibyte_p
             = !NILP (BVAR (current_buffer, enable_multibyte_characters));
 
           setup_echo_area_for_printing (multibyte_p);
@@ -292,7 +292,7 @@ strout (const char *ptr, ptrdiff_t size, ptrdiff_t size_byte,
          here, that's the reason we don't call printchar to do the
          job.  */
       int i;
-      int multibyte_p
+      bool multibyte_p
         = !NILP (BVAR (current_buffer, enable_multibyte_characters));
 
       setup_echo_area_for_printing (multibyte_p);
@@ -510,10 +510,10 @@ temp_output_buffer_setup (const char *bufname)
   specbind (Qstandard_output, buf);
 }
 
-static void print (Lisp_Object obj, register Lisp_Object printcharfun, int escapeflag);
-static void print_preprocess (Lisp_Object obj);
-static void print_preprocess_string (INTERVAL interval, Lisp_Object arg);
-static void print_object (Lisp_Object obj, register Lisp_Object printcharfun, int escapeflag);
+static void print (Lisp_Object, Lisp_Object, bool);
+static void print_preprocess (Lisp_Object);
+static void print_preprocess_string (INTERVAL, Lisp_Object);
+static void print_object (Lisp_Object, Lisp_Object, bool);
 
 DEFUN ("terpri", Fterpri, Sterpri, 0, 1, 0,
        doc: /* Output a newline to stream PRINTCHARFUN.
@@ -729,9 +729,9 @@ to make it write to the debugging output.  */)
 /* This function is never called.  Its purpose is to prevent
    print_output_debug_flag from being optimized away.  */
 
-extern void debug_output_compilation_hack (int) EXTERNALLY_VISIBLE;
+extern void debug_output_compilation_hack (bool) EXTERNALLY_VISIBLE;
 void
-debug_output_compilation_hack (int x)
+debug_output_compilation_hack (bool x)
 {
   print_output_debug_flag = x;
 }
@@ -969,7 +969,7 @@ float_to_string (char *buf, double data)
       static char const NaN_string[] = "0.0e+NaN";
       int i;
       union { double d; char c[sizeof (double)]; } u_data, u_minus_zero;
-      int negative = 0;
+      bool negative = 0;
       u_data.d = data;
       u_minus_zero.d = - 0.0;
       for (i = 0; i < sizeof (double); i++)
@@ -1066,7 +1066,7 @@ float_to_string (char *buf, double data)
 
 
 static void
-print (Lisp_Object obj, register Lisp_Object printcharfun, int escapeflag)
+print (Lisp_Object obj, Lisp_Object printcharfun, bool escapeflag)
 {
   new_backquote_output = 0;
 
@@ -1316,7 +1316,7 @@ print_prune_string_charset (Lisp_Object string)
 }
 
 static void
-print_object (Lisp_Object obj, register Lisp_Object printcharfun, int escapeflag)
+print_object (Lisp_Object obj, Lisp_Object printcharfun, bool escapeflag)
 {
   char buf[max (sizeof "from..to..in " + 2 * INT_STRLEN_BOUND (EMACS_INT),
                 max (sizeof " . #" + INT_STRLEN_BOUND (printmax_t),
@@ -1398,7 +1398,7 @@ print_object (Lisp_Object obj, register Lisp_Object printcharfun, int escapeflag
           ptrdiff_t size_byte;
           /* 1 means we must ensure that the next character we output
              cannot be taken as part of a hex character escape.  */
-          int need_nonhex = 0;
+          bool need_nonhex = 0;
           bool multibyte = STRING_MULTIBYTE (obj);
 
           GCPRO1 (obj);
@@ -1510,10 +1510,10 @@ print_object (Lisp_Object obj, register Lisp_Object printcharfun, int escapeflag
 
     case Lisp_Symbol:
       {
-        register int confusing;
-        register unsigned char *p = SDATA (SYMBOL_NAME (obj));
-        register unsigned char *end = p + SBYTES (SYMBOL_NAME (obj));
-        register int c;
+        bool confusing;
+        unsigned char *p = SDATA (SYMBOL_NAME (obj));
+        unsigned char *end = p + SBYTES (SYMBOL_NAME (obj));
+        int c;
         ptrdiff_t i, i_byte;
         ptrdiff_t size_byte;
         Lisp_Object name;
diff --git a/src/process.c b/src/process.c
index 5b15ade1122..bafdca9bd63 100644
--- a/src/process.c
+++ b/src/process.c
@@ -146,13 +146,13 @@ Lisp_Object Qcutime, Qpri, Qnice, Qthcount, Qstart, Qvsize, Qrss, Qargs;
 Lisp_Object Quser, Qgroup, Qetime, Qpcpu, Qpmem, Qtime, Qctime;
 Lisp_Object QCname, QCtype;
 
-/* Non-zero if keyboard input is on hold, zero otherwise.  */
+/* True if keyboard input is on hold, zero otherwise.  */
 
-static int kbd_is_on_hold;
+static bool kbd_is_on_hold;
 
 /* Nonzero means don't run process sentinels.  This is used
    when exiting.  */
-int inhibit_sentinels;
+bool inhibit_sentinels;
 
 #ifdef subprocesses
 
@@ -234,9 +234,9 @@ static EMACS_INT update_tick;
 
 static int process_output_delay_count;
 
-/* Non-zero if any process has non-nil read_output_skip.  */
+/* True if any process has non-nil read_output_skip.  */
 
-static int process_output_skip;
+static bool process_output_skip;
 
 #else
 #define process_output_delay_count 0
@@ -244,7 +244,7 @@ static int process_output_skip;
 
 static void create_process (Lisp_Object, char **, Lisp_Object);
 #ifdef USABLE_SIGIO
-static int keyboard_bit_set (SELECT_TYPE *);
+static bool keyboard_bit_set (SELECT_TYPE *);
 #endif
 static void deactivate_process (Lisp_Object);
 static void status_notify (struct Lisp_Process *);
@@ -527,7 +527,7 @@ status_convert (int w)
    and store them individually through the three pointers.  */
 
 static void
-decode_status (Lisp_Object l, Lisp_Object *symbol, int *code, int *coredump)
+decode_status (Lisp_Object l, Lisp_Object *symbol, int *code, bool *coredump)
 {
   Lisp_Object tem;
 
@@ -554,7 +554,8 @@ status_message (struct Lisp_Process *p)
 {
   Lisp_Object status = p->status;
   Lisp_Object symbol;
-  int code, coredump;
+  int code;
+  bool coredump;
   Lisp_Object string, string2;
 
   decode_status (status, &symbol, &code, &coredump);
@@ -1579,7 +1580,7 @@ create_process (Lisp_Object process, char **new_argv, Lisp_Object current_dir)
   sigset_t blocked;
   /* Use volatile to protect variables from being clobbered by vfork.  */
   volatile int forkin, forkout;
-  volatile int pty_flag = 0;
+  volatile bool pty_flag = 0;
   volatile Lisp_Object lisp_pty_name = Qnil;
   volatile Lisp_Object encoded_current_dir;
 
@@ -1871,7 +1872,7 @@ void
 create_pty (Lisp_Object process)
 {
   int inchannel, outchannel;
-  int pty_flag = 0;
+  bool pty_flag = 0;
 
   inchannel = outchannel = -1;
 
@@ -2819,8 +2820,9 @@ usage: (make-network-process &rest ARGS)  */)
   Lisp_Object tem;
   Lisp_Object name, buffer, host, service, address;
   Lisp_Object filter, sentinel;
-  int is_non_blocking_client = 0;
-  int is_server = 0, backlog = 5;
+  bool is_non_blocking_client = 0;
+  bool is_server = 0;
+  int backlog = 5;
   int socktype;
   int family = -1;
 
@@ -3497,7 +3499,7 @@ format; see the description of ADDRESS in `make-network-process'.  */)
   struct ifreq *ifreq;
   void *buf = NULL;
   ptrdiff_t buf_size = 512;
-  int s, i;
+  int s;
   Lisp_Object res;
 
   s = socket (AF_INET, SOCK_STREAM, 0);
@@ -3535,7 +3537,6 @@ format; see the description of ADDRESS in `make-network-process'.  */)
       int len = sizeof (*ifreq);
 #endif
       char namebuf[sizeof (ifq->ifr_name) + 1];
-      i += len;
       ifreq = (struct ifreq *) ((char *) ifreq + len);
 
       if (ifq->ifr_addr.sa_family != AF_INET)
@@ -3645,7 +3646,7 @@ FLAGS is the current flags of the interface.  */)
   Lisp_Object res = Qnil;
   Lisp_Object elt;
   int s;
-  int any = 0;
+  bool any = 0;
 #if (! (defined SIOCGIFHWADDR && defined HAVE_STRUCT_IFREQ_IFR_HWADDR)  \
      && defined HAVE_GETIFADDRS && defined LLADDR)
   struct ifaddrs *ifap;
@@ -3931,7 +3932,7 @@ Return non-nil if we received any output before the timeout expired.  */)
 
 /* Accept a connection for server process SERVER on CHANNEL.  */
 
-static int connect_counter = 0;
+static EMACS_INT connect_counter = 0;
 
 static void
 server_accept_connection (Lisp_Object server, int channel)
@@ -4186,7 +4187,7 @@ wait_reading_process_output_1 (void)
      process.  The return value is true if we read some input from
      that process.
 
-   If JUST_WAIT_PROC is non-nil, handle only output from WAIT_PROC
+   If JUST_WAIT_PROC is nonzero, handle only output from WAIT_PROC
      (suspending output from other processes).  A negative value
      means don't run any timers either.
 
@@ -4194,22 +4195,23 @@ wait_reading_process_output_1 (void)
      received input from that process before the timeout elapsed.
    Otherwise, return true if we received input from any process.  */
 
-int
+bool
 wait_reading_process_output (intmax_t time_limit, int nsecs, int read_kbd,
                              bool do_display,
                              Lisp_Object wait_for_cell,
                              struct Lisp_Process *wait_proc, int just_wait_proc)
 {
-  register int channel, nfds;
+  int channel, nfds;
   SELECT_TYPE Available;
   SELECT_TYPE Writeok;
-  int check_write;
-  int check_delay, no_avail;
+  bool check_write;
+  int check_delay;
+  bool no_avail;
   int xerrno;
   Lisp_Object proc;
   EMACS_TIME timeout, end_time;
   int wait_channel = -1;
-  int got_some_input = 0;
+  bool got_some_input = 0;
   ptrdiff_t count = SPECPDL_INDEX ();
 
   FD_ZERO (&Available);
@@ -4246,7 +4248,7 @@ wait_reading_process_output (intmax_t time_limit, int nsecs, int read_kbd,
 
   while (1)
     {
-      int timeout_reduced_for_timers = 0;
+      bool timeout_reduced_for_timers = 0;
 
       /* If calling from keyboard input, do not quit
          since we want to return C-g as an input character.
@@ -4624,7 +4626,7 @@ wait_reading_process_output (intmax_t time_limit, int nsecs, int read_kbd,
           unsigned old_timers_run = timers_run;
           struct buffer *old_buffer = current_buffer;
           Lisp_Object old_window = selected_window;
-          int leave = 0;
+          bool leave = 0;
 
           if (detect_input_pending_run_timers (do_display))
             {
@@ -4945,7 +4947,7 @@ read_process_output (Lisp_Object proc, register int channel)
   else
 #endif
     {
-      int buffered = 0 <= proc_buffered_char[channel];
+      bool buffered = 0 <= proc_buffered_char[channel];
       if (buffered)
         {
           chars[carryover] = proc_buffered_char[channel];
@@ -5261,7 +5263,7 @@ read_process_output (Lisp_Object proc, register int channel)
 
 static void
 write_queue_push (struct Lisp_Process *p, Lisp_Object input_obj,
-                  const char *buf, ptrdiff_t len, int front)
+                  const char *buf, ptrdiff_t len, bool front)
 {
   ptrdiff_t offset;
   Lisp_Object entry, obj;
@@ -5286,10 +5288,10 @@ write_queue_push (struct Lisp_Process *p, Lisp_Object input_obj,
 }
 
 /* Remove the first element in the write_queue of process P, put its
-   contents in OBJ, BUF and LEN, and return non-zero.  If the
-   write_queue is empty, return zero.  */
+   contents in OBJ, BUF and LEN, and return true.  If the
+   write_queue is empty, return false.  */
 
-static int
+static bool
 write_queue_pop (struct Lisp_Process *p, Lisp_Object *obj,
                  const char **buf, ptrdiff_t *len)
 {
@@ -5650,7 +5652,7 @@ return t unconditionally.  */)
    If CURRENT_GROUP is lambda, that means send to the process group
    that currently owns the terminal, but only if it is NOT the shell itself.
 
-   If NOMSG is zero, insert signal-announcements into process's buffers
+   If NOMSG is false, insert signal-announcements into process's buffers
    right away.
 
    If we can, we try to signal PROCESS by sending control characters
@@ -5659,12 +5661,12 @@ return t unconditionally.  */)
 
 static void
 process_send_signal (Lisp_Object process, int signo, Lisp_Object current_group,
-                     int nomsg)
+                     bool nomsg)
 {
   Lisp_Object proc;
-  register struct Lisp_Process *p;
+  struct Lisp_Process *p;
   pid_t gid;
-  int no_pgrp = 0;
+  bool no_pgrp = 0;
 
   proc = get_process (process);
   p = XPROCESS (proc);
@@ -6161,7 +6163,7 @@ handle_child_signal (int sig)
           /* If process has terminated, stop waiting for its output.  */
           if (WIFSIGNALED (status) || WIFEXITED (status))
             {
-              int clear_desc_flag = 0;
+              bool clear_desc_flag = 0;
               p->alive = 0;
               if (p->infd >= 0)
                 clear_desc_flag = 1;
@@ -6504,10 +6506,10 @@ delete_gpm_wait_descriptor (int desc)
 
 # ifdef USABLE_SIGIO
 
-/* Return nonzero if *MASK has a bit set
+/* Return true if *MASK has a bit set
    that corresponds to one of the keyboard input descriptors.  */
 
-static int
+static bool
 keyboard_bit_set (fd_set *mask)
 {
   int fd;
@@ -6557,7 +6559,7 @@ extern int sys_select (int, SELECT_TYPE *, SELECT_TYPE *, SELECT_TYPE *,
 
    Return true if we received input from any process.  */
 
-int
+bool
 wait_reading_process_output (intmax_t time_limit, int nsecs, int read_kbd,
                              bool do_display,
                              Lisp_Object wait_for_cell,
@@ -6589,7 +6591,7 @@ wait_reading_process_output (intmax_t time_limit, int nsecs, int read_kbd,
 
   while (1)
     {
-      int timeout_reduced_for_timers = 0;
+      bool timeout_reduced_for_timers = 0;
       SELECT_TYPE waitchannels;
       int xerrno;
 
@@ -6940,9 +6942,9 @@ unhold_keyboard_input (void)
   kbd_is_on_hold = 0;
 }
 
-/* Return non-zero if keyboard input is on hold, zero otherwise.  */
+/* Return true if keyboard input is on hold, zero otherwise.  */
 
-int
+bool
 kbd_on_hold_p (void)
 {
   return kbd_is_on_hold;
diff --git a/src/process.h b/src/process.h
index a003ffa147f..765e5d82567 100644
--- a/src/process.h
+++ b/src/process.h
@@ -159,7 +159,7 @@ struct Lisp_Process
     gnutls_anon_client_credentials_t gnutls_anon_cred;
     int gnutls_log_level;
     int gnutls_handshakes_tried;
-    int gnutls_p;
+    unsigned int gnutls_p : 1;
 #endif
 };
 
@@ -185,9 +185,9 @@ pset_gnutls_cred_type (struct Lisp_Process *p, Lisp_Object val)
 }
 #endif
 
-/* Nonzero means don't run process sentinels.  This is used
+/* True means don't run process sentinels.  This is used
    when exiting.  */
-extern int inhibit_sentinels;
+extern bool inhibit_sentinels;
 
 extern Lisp_Object Qeuid, Qegid, Qcomm, Qstate, Qppid, Qpgrp, Qsess, Qttname;
 extern Lisp_Object Qminflt, Qmajflt, Qcminflt, Qcmajflt, Qutime, Qstime;
@@ -209,7 +209,7 @@ extern Lisp_Object system_process_attributes (Lisp_Object);
 
 extern void hold_keyboard_input (void);
 extern void unhold_keyboard_input (void);
-extern int kbd_on_hold_p (void);
+extern bool kbd_on_hold_p (void);
 
 typedef void (*fd_callback) (int fd, void *data);
 
diff --git a/src/region-cache.c b/src/region-cache.c
index 14e6982cd9a..452a5b3a065 100644
--- a/src/region-cache.c
+++ b/src/region-cache.c
@@ -695,8 +695,9 @@ know_region_cache (struct buffer *buf, struct region_cache *c,
 
 /* Interface: using the cache.  */
 
-/* Return true if the text immediately after POS in BUF is known, for
-   the purposes of CACHE.  If NEXT is non-zero, set *NEXT to the nearest
+/* Return the value for the text immediately after POS in BUF if the value
+   is known, for the purposes of CACHE, and return zero otherwise.
+   If NEXT is non-zero, set *NEXT to the nearest
    position after POS where the knowledge changes.  */
 int
 region_cache_forward (struct buffer *buf, struct region_cache *c,
@@ -732,8 +733,9 @@ region_cache_forward (struct buffer *buf, struct region_cache *c,
   }
 }
 
-/* Return true if the text immediately before POS in BUF is known, for
-   the purposes of CACHE.  If NEXT is non-zero, set *NEXT to the nearest
+/* Return the value for the text immediately before POS in BUF if the
+   value is known, for the purposes of CACHE, and return zero
+   otherwise.  If NEXT is non-zero, set *NEXT to the nearest
    position before POS where the knowledge changes.  */
 int region_cache_backward (struct buffer *buf, struct region_cache *c,
                            ptrdiff_t pos, ptrdiff_t *next)
diff --git a/src/scroll.c b/src/scroll.c
index 9e11feb64d4..037e338c696 100644
--- a/src/scroll.c
+++ b/src/scroll.c
@@ -246,9 +246,8 @@ do_scrolling (struct frame *frame, struct glyph_matrix *current_matrix,
   struct matrix_elt *p;
   int i, j, k;
 
-  /* Set to 1 if we have set a terminal window with
-     set_terminal_window.  It's unsigned to work around GCC bug 48228.  */
-  unsigned int terminal_window_p = 0;
+  /* True if we have set a terminal window with set_terminal_window.  */
+  bool terminal_window_p = 0;
 
   /* A queue for line insertions to be done.  */
   struct queue { int count, pos; };
@@ -657,18 +656,16 @@ do_direct_scrolling (struct frame *frame, struct glyph_matrix *current_matrix,
     alloca (window_size * sizeof *queue_start);
   struct alt_queue *queue = queue_start;
 
-  /* Set to 1 if a terminal window has been set with
-     set_terminal_window: */
-  int terminal_window_p = 0;
+  /* True if a terminal window has been set with set_terminal_window.  */
+  bool terminal_window_p = 0;
 
-  /* A nonzero value of write_follows indicates that a write has been
-     selected, allowing either an insert or a delete to be selected
-     next.  When write_follows is zero, a delete cannot be selected
+  /* If true, a write has been selected, allowing either an insert or a
+     delete to be selected next.  If false, a delete cannot be selected
      unless j < i, and an insert cannot be selected unless i < j.
      This corresponds to a similar restriction (with the ordering
      reversed) in calculate_direct_scrolling, which is intended to
      ensure that lines marked as inserted will be blank. */
-  int write_follows_p = 1;
+  bool write_follows_p = 1;
 
   /* For each row in the new matrix what row of the old matrix it is.  */
   int *copy_from = alloca (window_size * sizeof *copy_from);
diff --git a/src/search.c b/src/search.c
index 090965ead3b..c5ac7d494dc 100644
--- a/src/search.c
+++ b/src/search.c
@@ -49,8 +49,8 @@ struct regexp_cache
   Lisp_Object syntax_table;
   struct re_pattern_buffer buf;
   char fastmap[0400];
-  /* Nonzero means regexp was compiled to do full POSIX backtracking.  */
-  char posix;
+  /* True means regexp was compiled to do full POSIX backtracking.  */
+  bool posix;
 };
 
 /* The instances of that struct.  */
@@ -100,7 +100,7 @@ static EMACS_INT boyer_moore (EMACS_INT, unsigned char *, ptrdiff_t,
                               ptrdiff_t, int);
 static EMACS_INT search_buffer (Lisp_Object, ptrdiff_t, ptrdiff_t,
                                 ptrdiff_t, ptrdiff_t, EMACS_INT, int,
-                                Lisp_Object, Lisp_Object, int);
+                                Lisp_Object, Lisp_Object, bool);
 
 static _Noreturn void
 matcher_overflow (void)
@@ -112,13 +112,14 @@ matcher_overflow (void)
    PATTERN is the pattern to compile.
    CP is the place to put the result.
    TRANSLATE is a translation table for ignoring case, or nil for none.
-   POSIX is nonzero if we want full backtracking (POSIX style)
-   for this pattern.  0 means backtrack only enough to get a valid match.
+   POSIX is true if we want full backtracking (POSIX style) for this pattern.
+   False means backtrack only enough to get a valid match.
 
    The behavior also depends on Vsearch_spaces_regexp.  */
 
 static void
-compile_pattern_1 (struct regexp_cache *cp, Lisp_Object pattern, Lisp_Object translate, int posix)
+compile_pattern_1 (struct regexp_cache *cp, Lisp_Object pattern,
+                   Lisp_Object translate, bool posix)
 {
   char *val;
   reg_syntax_t old;
@@ -205,12 +206,12 @@ clear_regexp_cache (void)
    values that will result from matching this pattern.
    If it is 0, we should compile the pattern not to record any
    subexpression bounds.
-   POSIX is nonzero if we want full backtracking (POSIX style)
-   for this pattern.  0 means backtrack only enough to get a valid match.  */
+   POSIX is true if we want full backtracking (POSIX style) for this pattern.
+   False means backtrack only enough to get a valid match.  */
 
 struct re_pattern_buffer *
 compile_pattern (Lisp_Object pattern, struct re_registers *regp,
-                 Lisp_Object translate, int posix, bool multibyte)
+                 Lisp_Object translate, bool posix, bool multibyte)
 {
   struct regexp_cache *cp, **cpp;
 
@@ -267,7 +268,7 @@ compile_pattern (Lisp_Object pattern, struct re_registers *regp,
 
 
 static Lisp_Object
-looking_at_1 (Lisp_Object string, int posix)
+looking_at_1 (Lisp_Object string, bool posix)
 {
   Lisp_Object val;
   unsigned char *p1, *p2;
@@ -365,7 +366,8 @@ data if you want to preserve them.  */)
 }
 
 static Lisp_Object
-string_match_1 (Lisp_Object regexp, Lisp_Object string, Lisp_Object start, int posix)
+string_match_1 (Lisp_Object regexp, Lisp_Object string, Lisp_Object start,
+                bool posix)
 {
   ptrdiff_t val;
   struct re_pattern_buffer *bufp;
@@ -621,7 +623,7 @@ newline_cache_on_off (struct buffer *buf)
 }
 
 
-/* Search for COUNT newlines between START and END.
+/* Search for COUNT newlines between START/START_BYTE and END/END_BYTE.
 
    If COUNT is positive, search forwards; END must be >= START.
    If COUNT is negative, search backwards for the -COUNTth instance;
@@ -645,11 +647,11 @@ newline_cache_on_off (struct buffer *buf)
    except when inside redisplay.  */
 
 ptrdiff_t
-find_newline (ptrdiff_t start, ptrdiff_t end, ptrdiff_t count,
-              ptrdiff_t *shortage, ptrdiff_t *bytepos, bool allow_quit)
+find_newline (ptrdiff_t start, ptrdiff_t start_byte, ptrdiff_t end,
+              ptrdiff_t end_byte, ptrdiff_t count, ptrdiff_t *shortage,
+              ptrdiff_t *bytepos, bool allow_quit)
 {
   struct region_cache *newline_cache;
-  ptrdiff_t start_byte = -1, end_byte = -1;
   int direction;
 
   if (count > 0)
@@ -706,7 +708,7 @@ find_newline (ptrdiff_t start, ptrdiff_t end, ptrdiff_t count,
                next_change is the position of the next known region. */
             ceiling_byte = min (CHAR_TO_BYTE (next_change) - 1, ceiling_byte);
           }
-        else
+        else if (start_byte == -1)
           start_byte = CHAR_TO_BYTE (start);
 
         /* The dumb loop can only scan text stored in contiguous
@@ -783,7 +785,7 @@ find_newline (ptrdiff_t start, ptrdiff_t end, ptrdiff_t count,
                next_change is the position of the next known region. */
             ceiling_byte = max (CHAR_TO_BYTE (next_change), ceiling_byte);
           }
-        else
+        else if (start_byte == -1)
           start_byte = CHAR_TO_BYTE (start);
 
         /* Stop scanning before the gap.  */
@@ -944,9 +946,10 @@ scan_newline (ptrdiff_t start, ptrdiff_t start_byte,
 /* Like find_newline, but doesn't allow QUITting and doesn't return
    SHORTAGE.  */
 ptrdiff_t
-find_newline_no_quit (ptrdiff_t from, ptrdiff_t cnt, ptrdiff_t *bytepos)
+find_newline_no_quit (ptrdiff_t from, ptrdiff_t frombyte,
+                      ptrdiff_t cnt, ptrdiff_t *bytepos)
 {
-  return find_newline (from, 0, cnt, NULL, bytepos, 0);
+  return find_newline (from, frombyte, 0, -1, cnt, NULL, bytepos, 0);
 }
 
 /* Like find_newline, but returns position before the newline, not
@@ -958,7 +961,7 @@ find_before_next_newline (ptrdiff_t from, ptrdiff_t to,
                           ptrdiff_t cnt, ptrdiff_t *bytepos)
 {
   ptrdiff_t shortage;
-  ptrdiff_t pos = find_newline (from, to, cnt, &shortage, bytepos, 1);
+  ptrdiff_t pos = find_newline (from, -1, to, -1, cnt, &shortage, bytepos, 1);
 
   if (shortage == 0)
     {
@@ -974,9 +977,9 @@ find_before_next_newline (ptrdiff_t from, ptrdiff_t to,
 
 static Lisp_Object
 search_command (Lisp_Object string, Lisp_Object bound, Lisp_Object noerror,
-                Lisp_Object count, int direction, int RE, int posix)
+                Lisp_Object count, int direction, int RE, bool posix)
 {
-  register EMACS_INT np;
+  EMACS_INT np;
   EMACS_INT lim;
   ptrdiff_t lim_byte;
   EMACS_INT n = direction;
@@ -1046,9 +1049,9 @@ search_command (Lisp_Object string, Lisp_Object bound, Lisp_Object noerror,
   return make_number (np);
 }
 
-/* Return 1 if REGEXP it matches just one constant string.  */
+/* Return true if REGEXP it matches just one constant string.  */
 
-static int
+static bool
 trivial_regexp_p (Lisp_Object regexp)
 {
   ptrdiff_t len = SBYTES (regexp);
@@ -1117,7 +1120,7 @@ static struct re_registers search_regs_1;
 static EMACS_INT
 search_buffer (Lisp_Object string, ptrdiff_t pos, ptrdiff_t pos_byte,
                ptrdiff_t lim, ptrdiff_t lim_byte, EMACS_INT n,
-               int RE, Lisp_Object trt, Lisp_Object inverse_trt, int posix)
+               int RE, Lisp_Object trt, Lisp_Object inverse_trt, bool posix)
 {
   ptrdiff_t len = SCHARS (string);
   ptrdiff_t len_byte = SBYTES (string);
@@ -1272,7 +1275,7 @@ search_buffer (Lisp_Object string, ptrdiff_t pos, ptrdiff_t pos_byte,
       /* Set to positive if we find a non-ASCII char that need
          translation.  Otherwise set to zero later.  */
       int char_base = -1;
-      int boyer_moore_ok = 1;
+      bool boyer_moore_ok = 1;
 
       /* MULTIBYTE says whether the text to be searched is multibyte.
          We must convert PATTERN to match that, or we will not really
@@ -2281,12 +2284,12 @@ since only regular expressions have distinguished subexpressions.  */)
   (Lisp_Object newtext, Lisp_Object fixedcase, Lisp_Object literal, Lisp_Object string, Lisp_Object subexp)
 {
   enum { nochange, all_caps, cap_initial } case_action;
-  register ptrdiff_t pos, pos_byte;
-  int some_multiletter_word;
-  int some_lowercase;
-  int some_uppercase;
-  int some_nonuppercase_initial;
-  register int c, prevc;
+  ptrdiff_t pos, pos_byte;
+  bool some_multiletter_word;
+  bool some_lowercase;
+  bool some_uppercase;
+  bool some_nonuppercase_initial;
+  int c, prevc;
   ptrdiff_t sub;
   ptrdiff_t opoint, newpoint;
 
@@ -2431,7 +2434,7 @@ since only regular expressions have distinguished subexpressions.  */)
             {
               ptrdiff_t substart = -1;
               ptrdiff_t subend = 0;
-              int delbackslash = 0;
+              bool delbackslash = 0;
 
               FETCH_STRING_CHAR_ADVANCE (c, newtext, pos, pos_byte);
 
@@ -2528,7 +2531,7 @@ since only regular expressions have distinguished subexpressions.  */)
       ptrdiff_t substed_alloc_size, substed_len;
       bool buf_multibyte = !NILP (BVAR (current_buffer, enable_multibyte_characters));
       bool str_multibyte = STRING_MULTIBYTE (newtext);
-      int really_changed = 0;
+      bool really_changed = 0;
 
       substed_alloc_size = ((STRING_BYTES_BOUND - 100) / 2 < length
                             ? STRING_BYTES_BOUND
@@ -2694,7 +2697,7 @@ since only regular expressions have distinguished subexpressions.  */)
 }
 
 static Lisp_Object
-match_limit (Lisp_Object num, int beginningp)
+match_limit (Lisp_Object num, bool beginningp)
 {
   EMACS_INT n;
 
@@ -2967,9 +2970,9 @@ If optional arg RESEAT is non-nil, make markers on LIST point nowhere.  */)
   return Qnil;
 }
 
-/* If non-zero the match data have been saved in saved_search_regs
+/* If true the match data have been saved in saved_search_regs
    during the execution of a sentinel or filter. */
-static int search_regs_saved;
+static bool search_regs_saved;
 static struct re_registers saved_search_regs;
 static Lisp_Object saved_last_thing_searched;
 
@@ -3034,9 +3037,9 @@ DEFUN ("regexp-quote", Fregexp_quote, Sregexp_quote, 1, 1, 0,
        doc: /* Return a regexp string which matches exactly STRING and nothing else.  */)
   (Lisp_Object string)
 {
-  register char *in, *out, *end;
-  register char *temp;
-  int backslashes_added = 0;
+  char *in, *out, *end;
+  char *temp;
+  ptrdiff_t backslashes_added = 0;
 
   CHECK_STRING (string);
 
diff --git a/src/xdisp.c b/src/xdisp.c
index 28acbbdb8c0..48fc95a9a34 100644
--- a/src/xdisp.c
+++ b/src/xdisp.c
@@ -5940,8 +5940,10 @@ pop_it (struct it *it)
 static void
 back_to_previous_line_start (struct it *it)
 {
-  IT_CHARPOS (*it) = find_newline_no_quit (IT_CHARPOS (*it) - 1, -1,
-                                           &IT_BYTEPOS (*it));
+  ptrdiff_t cp = IT_CHARPOS (*it), bp = IT_BYTEPOS (*it);
+
+  DEC_BOTH (cp, bp);
+  IT_CHARPOS (*it) = find_newline_no_quit (cp, bp, -1, &IT_BYTEPOS (*it));
 }
 
 
@@ -6013,7 +6015,8 @@ forward_to_next_line_start (struct it *it, int *skipped_p,
   if (!newline_found_p)
     {
       ptrdiff_t bytepos, start = IT_CHARPOS (*it);
-      ptrdiff_t limit = find_newline_no_quit (start, 1, &bytepos);
+      ptrdiff_t limit = find_newline_no_quit (start, IT_BYTEPOS (*it),
+                                              1, &bytepos);
       Lisp_Object pos;
 
       eassert (!STRINGP (it->string));
@@ -7473,7 +7476,8 @@ get_visually_first_element (struct it *it)
       if (string_p)
         it->bidi_it.charpos = it->bidi_it.bytepos = 0;
       else
-        it->bidi_it.charpos = find_newline_no_quit (IT_CHARPOS (*it), -1,
+        it->bidi_it.charpos = find_newline_no_quit (IT_CHARPOS (*it),
+                                                    IT_BYTEPOS (*it), -1,
                                                     &it->bidi_it.bytepos);
       bidi_paragraph_init (it->paragraph_embedding, &it->bidi_it, 1);
       do
@@ -9121,10 +9125,11 @@ move_it_vertically_backward (struct it *it, int dy)
           && IT_CHARPOS (*it) > BEGV
           && FETCH_BYTE (IT_BYTEPOS (*it) - 1) != '\n')
         {
-          ptrdiff_t nl_pos = find_newline_no_quit (IT_CHARPOS (*it) - 1, -1,
-                                                   NULL);
+          ptrdiff_t cp = IT_CHARPOS (*it), bp = IT_BYTEPOS (*it);
 
-          move_it_to (it, nl_pos, -1, -1, -1, MOVE_TO_POS);
+          DEC_BOTH (cp, bp);
+          cp = find_newline_no_quit (cp, bp, -1, NULL);
+          move_it_to (it, cp, -1, -1, -1, MOVE_TO_POS);
         }
       bidi_unshelve_cache (it3data, 1);
     }
@@ -20015,10 +20020,7 @@ See also `bidi-paragraph-direction'.  */)
          to make sure we are within that paragraph.  To that end, find
          the previous non-empty line.  */
       if (pos >= ZV && pos > BEGV)
-        {
-          pos--;
-          bytepos = CHAR_TO_BYTE (pos);
-        }
+        DEC_BOTH (pos, bytepos);
       if (fast_looking_at (build_string ("[\f\t ]*\n"),
                            pos, bytepos, ZV, ZV_BYTE, Qnil) > 0)
         {