From fed107327ce38c5416ae52b70edd673d37e68695 Mon Sep 17 00:00:00 2001 From: Gregory Heytings Date: Tue, 5 Jul 2022 08:44:04 +0000 Subject: [PATCH] Actually fix the long lines display bug. * lisp/files.el (auto-narrow-mode): New minor mode. (auto-narrow-pre-command-function, auto-narrow-post-command-function): New auxiliary functions for the minor mode. (auto-narrow-display-length, auto-narrow-widen-automatically): New defcustoms for the minor mode. (auto-narrow--widen-automatically, auto-narrow--isearch-widen-automatically, auto-narrow--initialized): New internal variables for the minor mode. * src/buffer.h (struct buffer): New internal variable for the minor mode. * src/buffer.c (init_buffer_once, syms_of_buffer): New internal variable for the minor mode. * src/fileio.c (Finsert_file_contents): Automatically enter the minor mode when appropriate. (syms_of_fileio): New defcustom for the minor mode. * src/keyboard.c (syms_of_keyboard): New hook functions for the minor mode. (command_loop_1): Execute the hook functions. * src/search.c (find_newline1): Make it externally visible. * src/lisp.h: Make find_newline1 externally visible. * src/xdisp.c (decode_mode_spec): Indicate when the minor mode is active in the modeline. * lisp/isearch.el (isearch-widen-automatically): New defcustom. (isearch-search): Use the new defcustom. * lisp/bindings.el (mode-line-modes): Do not propertize the indication in the modeline when the new minor mode is active. * etc/NEWS: Announce the new minor mode, and remove the unobsoletion indication for 'longlines-mode'. * lisp/longlines.el: Reobsolete longlines-mode. * doc/emacs/display.texi (Auto-Narrowing): New section, describing the new minor mode. (Display): Entry for the new section. * doc/emacs/trouble.texi (Long Lines): Remove the section. (Lossage): Remove the entry for the Long Lines section. * doc/emacs/emacs.texi (Top): Remove the entry for the Long Lines section. --- doc/emacs/display.texi | 25 ++ doc/emacs/emacs.texi | 1 - doc/emacs/trouble.texi | 59 ----- etc/NEWS | 15 +- lisp/bindings.el | 12 +- lisp/files.el | 92 ++++++++ lisp/isearch.el | 32 ++- lisp/longlines.el | 502 ----------------------------------------- src/buffer.c | 5 + src/buffer.h | 3 + src/fileio.c | 25 ++ src/keyboard.c | 28 +++ src/lisp.h | 2 + src/search.c | 2 +- src/xdisp.c | 7 +- 15 files changed, 228 insertions(+), 582 deletions(-) delete mode 100644 lisp/longlines.el diff --git a/doc/emacs/display.texi b/doc/emacs/display.texi index cadac7e453..9fe9533e88 100644 --- a/doc/emacs/display.texi +++ b/doc/emacs/display.texi @@ -19,6 +19,8 @@ Display * Horizontal Scrolling:: Moving text left and right in a window. * Narrowing:: Restricting display and editing to a portion of the buffer. +* Auto-Narrowing:: Automatically restrict display to a portion of + the buffer. * View Mode:: Viewing read-only buffers. * Follow Mode:: Follow mode lets two windows scroll as one. * Faces:: How to change the display style using faces. @@ -467,6 +469,29 @@ Narrowing if you enable the command, confirmation will no longer be required for it. @xref{Disabling}. +@node Auto-Narrowing +@findex auto-narrow-mode +@vindex auto-narrow-long-line-threshold +@vindex auto-narrow-display-length +@vindex auto-narrow-widen-automatically + + When a file with extremely long lines is opened or inserted in a +buffer, Emacs automatically enters auto-narrow mode, and the word +@samp{Auto-Narrow} appears in the mode line. This means that Emacs +restricts display, but not editing, to a portion of the buffer above +and below point. All editing commands, including narrowing commands, +remain available, and they act on the whole buffer. For example, +@kbd{M->} moves point to the end of the buffer, and not, as would +happen with ordinary narrowing, to the end of the portion of the +buffer to which display is currently restricted. + + The behavior of auto-narrow mode is controlled by three variables: +@code{auto-narrow-long-line-threshold} is the line length above which +auto-narrow move is entered, @code{auto-narrow-display-length} is the +number of characters to which display is restricted, and +@code{auto-narrow-widen-automatically} is a list of commands for which +display is widened before they are executed. + @node View Mode @section View Mode @cindex View mode diff --git a/doc/emacs/emacs.texi b/doc/emacs/emacs.texi index 5e72699bbe..b43c966f87 100644 --- a/doc/emacs/emacs.texi +++ b/doc/emacs/emacs.texi @@ -1190,7 +1190,6 @@ Top * Crashing:: What Emacs does when it crashes. * After a Crash:: Recovering editing in an Emacs session that crashed. * Emergency Escape:: What to do if Emacs stops responding. -* Long Lines:: Mitigating slowness due to extremely long lines. * DEL Does Not Delete:: What to do if @key{DEL} doesn't delete. Reporting Bugs diff --git a/doc/emacs/trouble.texi b/doc/emacs/trouble.texi index f06b93759d..887e5c6170 100644 --- a/doc/emacs/trouble.texi +++ b/doc/emacs/trouble.texi @@ -158,7 +158,6 @@ Lossage * Crashing:: What Emacs does when it crashes. * After a Crash:: Recovering editing in an Emacs session that crashed. * Emergency Escape:: What to do if Emacs stops responding. -* Long Lines:: Mitigating slowness due to extremely long lines. * DEL Does Not Delete:: What to do if @key{DEL} doesn't delete. @end menu @@ -433,64 +432,6 @@ Emergency Escape emergency escape---but there are cases where it won't work, when a system call hangs or when Emacs is stuck in a tight loop in C code. -@node Long Lines -@subsection Long Lines -@cindex long lines - - For a variety of reasons (some of which are fundamental to the Emacs -redisplay code and the complex range of possibilities it handles; -others of which are due to modes and features which do not scale well -in unusual circumstances), Emacs can perform poorly when extremely -long lines are present (where ``extremely long'' usually means at -least many thousands of characters). - -@cindex @code{so-long} mode -@findex global-so-long-mode -@vindex so-long-action - A particular problem is that Emacs may ``hang'' for a long time at -the point of visiting a file with extremely long lines. This can be -mitigated by enabling the @file{so-long} library, which detects when a -visited file contains abnormally long lines, and takes steps to -disable features which are liable to cause slowness in that situation. -To enable this library, type @kbd{M-x global-so-long-mode @key{RET}}, -or turn on the @code{global-so-long-mode} in your init file -(@pxref{Init File}), or customize the @code{global-so-long-mode} -option. You can tailor this mode's operation by customizing the -variable @code{so-long-action}. - - The @file{so-long} library can also significantly improve -performance when moving and editing in a buffer with long lines. -Performance is still likely to degrade as you get deeper into the long -lines, but the improvements from using this library can nevertheless -be substantial. - -@findex so-long-commentary - Use @kbd{M-x so-long-commentary} to view the documentation for this -library and learn more about how to enable and configure it. - -@vindex max-redisplay-ticks - If even @code{so-long-mode} doesn't help making Emacs responsive -enough, or if you'd rather not disable the display-related features -that @code{so-long-mode} turns off, you can instead customize the -variable @code{max-redisplay-ticks} to a non-zero value. Then Emacs -will abort redisplay of a window and commands, like @kbd{C-n} and -@kbd{M-v}, which use the display code to do their job, if processing a -window needs more low-level display operations than the value of this -variable. The display of the offending window will then remain -outdated, and possibly incomplete, on the screen, but Emacs should -otherwise be responsive, and you could then switch to another buffer, -or kill the problematic buffer, or turn on @code{so-long-mode} or -@code{so-long-minor-mode} in that buffer. When the display of a -window is aborted due to this reason, the buffer shown in that window -will not have any of its windows redisplayed until the buffer is -modified or until you type @kbd{C-l} (@pxref{Recentering}) in one of -that buffer's windows. - - If you decide to customize this variable to a non-zero value, we -recommend to use a value between 100,000 and 1,000,000, depending on -your patience and the speed of your system. The default value is -zero, which disables this feature. - @node DEL Does Not Delete @subsection If @key{DEL} Fails to Delete @cindex @key{DEL} vs @key{BACKSPACE} diff --git a/etc/NEWS b/etc/NEWS index 7967190c6e..30c71e7f0c 100644 --- a/etc/NEWS +++ b/etc/NEWS @@ -324,9 +324,6 @@ startup. Previously, these functions ignored * Changes in Emacs 29.1 ---- -** 'longlines-mode' is no longer obsolete. - +++ ** New command to change the font size globally. To increase the font size, type 'C-x C-M-+' or 'C-x C-M-='; to @@ -901,6 +898,18 @@ Formerly it invoked 'just-one-space'. The actions performed by 'cycle-spacing' and their order can now be customized via the user option 'cycle-spacing-actions'. ++++ +** Emacs is now capable of editing files with arbitarily long lines. +When a file with long lines is opened or inserted in a buffer, Emacs +automatically enters auto-narrow mode. This means that Emacs +restricts display, but not editing, to a portion of the buffer above +and below point. All editing commands, including narrowing commands, +remain available, and they act on the whole buffer. The behavior of +that mode is controlled by three variables: +auto-narrow-long-line-threshold, auto-narrow-display-length and +auto-narrow-widen-automatically. To disable that feature, set +auto-narrow-long-line-threshold to nil in your init file. + --- ** 'zap-to-char' and 'zap-up-to-char' are case-sensitive for upper-case chars. These commands now behave as case-sensitive for interactive calls when diff --git a/lisp/bindings.el b/lisp/bindings.el index 0cf1834a4f..fa5040776d 100644 --- a/lisp/bindings.el +++ b/lisp/bindings.el @@ -400,10 +400,14 @@ mode-line-modes mouse-2: Show help for minor mode\n\ mouse-3: Toggle minor modes" local-map ,mode-line-minor-mode-keymap) - (propertize "%n" 'help-echo "mouse-2: Remove narrowing from buffer" - 'mouse-face 'mode-line-highlight - 'local-map (make-mode-line-mouse-map - 'mouse-2 #'mode-line-widen)) + '(:eval + (if (not (eq auto-narrow--narrowing 'auto)) + (propertize "%n" + 'help-echo "mouse-2: Remove narrowing from buffer" + 'mouse-face 'mode-line-highlight + 'local-map (make-mode-line-mouse-map + 'mouse-2 #'mode-line-widen)) + "%n")) ")" (propertize "%]" 'help-echo recursive-edit-help-echo) " ")) diff --git a/lisp/files.el b/lisp/files.el index 8812175014..abdeea7a80 100644 --- a/lisp/files.el +++ b/lisp/files.el @@ -2648,6 +2648,98 @@ find-file-literally (confirm-nonexistent-file-or-buffer)))) (switch-to-buffer (find-file-noselect filename nil t))) +(defcustom auto-narrow-display-length 30000 + "Number of characters to which display is restricted in `auto-narrow-mode'." + :group 'files + :group 'find-file + :version "29.1" + :type 'integer) + +(defcustom auto-narrow-widen-automatically + '( move-beginning-of-line move-end-of-line backward-sentence forward-sentence + backward-sexp forward-sexp beginning-of-defun end-of-defun + beginning-of-buffer end-of-buffer goto-char goto-line + mark-sexp mark-defun mark-paragraph mark-whole-buffer mark-page + exchange-point-and-mark pop-global-mark set-mark-command jump-to-register + bookmark-jump) + "Commands for which display is automatically widened in `auto-narrow-mode'." + :group 'files + :group 'find-file + :version "29.1" + :type '(repeat function)) + +(defvar-local auto-narrow--widen-automatically nil + "Internal variable used by `auto-narrow-mode'.") + +(defvar-local auto-narrow--isearch-widen-automatically nil + "Internal variable used by `auto-narrow-mode'.") + +(defvar-local auto-narrow--initialized nil + "Internal variable used by `auto-narrow-mode'.") + +(defun auto-narrow-pre-command-function () + "Conditionally widen display when `auto-narrow-mode' is in effect." + (when auto-narrow-mode + (unless auto-narrow--initialized + (setq auto-narrow--widen-automatically widen-automatically + auto-narrow--isearch-widen-automatically isearch-widen-automatically + auto-narrow--narrowing 'auto + auto-narrow--initialized t)) + (setq-local widen-automatically t + isearch-widen-automatically t) + (if (memq this-command '(narrow-to-region narrow-to-defun narrow-to-page)) + (setq auto-narrow--narrowing 'explicit + widen-automatically auto-narrow--widen-automatically + isearch-widen-automatically auto-narrow--isearch-widen-automatically)) + (if (eq this-command 'widen) + (setq auto-narrow--narrowing 'auto)) + (when (and (not (eq auto-narrow--narrowing 'explicit)) + (memq this-command auto-narrow-widen-automatically)) + (widen)))) + +(defun auto-narrow-post-command-function () + "Update display narrowing when `auto-narrow-mode' is in effect." + (when (and auto-narrow-mode + (not (eq auto-narrow--narrowing 'explicit))) + (unless auto-narrow--initialized + (setq auto-narrow--narrowing 'auto)) + (let (point cur-point-min buf-point-min buf-point-max size) + (setq point (point) cur-point-min (point-min) + size (/ auto-narrow-display-length 3)) + (save-restriction + (widen) + (setq buf-point-min (point-min) buf-point-max (point-max))) + (let* ((pos (* (min (max (/ point size) 1) + (1- (/ buf-point-max size))) + size)) + (begin (max (- pos size) buf-point-min)) + (end (min (+ begin (* 3 size)) buf-point-max))) + (when (or (not (buffer-narrowed-p)) + (not (= begin cur-point-min))) + (narrow-to-region begin end)))))) + +(setq auto-narrow-long-line-threshold 30000 + auto-narrow-pre-command-function #'auto-narrow-pre-command-function + auto-narrow-post-command-function #'auto-narrow-post-command-function) + +(define-minor-mode auto-narrow-mode + "Automatically narrow the display of a buffer above and below point. + +This mode is automatically entered when a file with one or more lines +longer than `auto-narrow-long-line-threshold' is opened or inserted +in a buffer. It restricts display, but not editing, to +`auto-narrow-display-length' characters. Display is widened before +executing any of the commands listed in `auto-narrow-widen-automatically'." + :group 'files + :version "29.1" + :after-hook (progn (put 'auto-narrow-mode 'permanent-local t) + (put 'auto-narrow--narrowing 'permanent-local t)) + (if auto-narrow-mode + (auto-narrow-post-command-function) + (when (not (eq auto-narrow--narrowing 'explicit)) + (widen)) + (setq auto-narrow--narrowing nil))) + (defun after-find-file (&optional error warn noauto _after-find-file-from-revert-buffer nomodes) diff --git a/lisp/isearch.el b/lisp/isearch.el index db7b53c014..a6e034df6b 100644 --- a/lisp/isearch.el +++ b/lisp/isearch.el @@ -3037,6 +3037,13 @@ isearch-allow-prefix :type 'boolean :group 'isearch) +(defcustom isearch-widen-automatically nil + "Whether a narrowed buffer can be widened when isearch fails. +This option has no effect when `widen-automatically' is nil." + :version "29.1" + :type 'boolean + :group 'isearch) + (defun isearch-string-out-of-window (isearch-point) "Test whether the search string is currently outside of the window. Return nil if it's completely visible, or if point is visible, @@ -3649,17 +3656,20 @@ isearch-search (while retry (setq isearch-success (isearch-search-string isearch-string nil t)) - ;; Clear RETRY unless the search predicate says - ;; to skip this search hit. - (if (or (not isearch-success) - (funcall isearch-filter-predicate - (match-beginning 0) (match-end 0))) - (setq retry nil) - ;; Advance point on empty matches before retrying - (when (= (match-beginning 0) (match-end 0)) - (if (if isearch-forward (eobp) (bobp)) - (setq retry nil isearch-success nil) - (forward-char (if isearch-forward 1 -1)))))) + (if (and (not isearch-success) (buffer-narrowed-p) + isearch-widen-automatically widen-automatically) + (widen) + ;; Clear RETRY unless the search predicate says + ;; to skip this search hit. + (if (or (not isearch-success) + (funcall isearch-filter-predicate + (match-beginning 0) (match-end 0))) + (setq retry nil) + ;; Advance point on empty matches before retrying + (when (= (match-beginning 0) (match-end 0)) + (if (if isearch-forward (eobp) (bobp)) + (setq retry nil isearch-success nil) + (forward-char (if isearch-forward 1 -1))))))) (setq isearch-just-started nil) (when isearch-success (setq isearch-other-end diff --git a/lisp/longlines.el b/lisp/longlines.el deleted file mode 100644 index a6cf93a039..0000000000 --- a/lisp/longlines.el +++ /dev/null @@ -1,502 +0,0 @@ -;;; longlines.el --- automatically wrap long lines -*- lexical-binding: t; -*- - -;; Copyright (C) 2000-2001, 2004-2022 Free Software Foundation, Inc. - -;; Authors: Kai Grossjohann -;; Alex Schroeder -;; Chong Yidong -;; Maintainer: emacs-devel@gnu.org -;; Keywords: convenience, wp - -;; This file is part of GNU Emacs. - -;; GNU Emacs is free software: you can redistribute it and/or modify -;; it under the terms of the GNU General Public License as published by -;; the Free Software Foundation, either version 3 of the License, or -;; (at your option) any later version. - -;; GNU Emacs is distributed in the hope that it will be useful, -;; but WITHOUT ANY WARRANTY; without even the implied warranty of -;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -;; GNU General Public License for more details. - -;; You should have received a copy of the GNU General Public License -;; along with GNU Emacs. If not, see . - -;;; Commentary: - -;; Some text editors save text files with long lines, and they -;; automatically break these lines at whitespace, without actually -;; inserting any newline characters. When doing `M-q' in Emacs, you -;; are inserting newline characters. Longlines mode provides a file -;; format which wraps the long lines when reading a file and unwraps -;; the lines when saving the file. It can also wrap and unwrap -;; automatically as editing takes place. - -;; Special thanks to Rod Smith for many useful bug reports. - -;;; Code: -;;; Options - -(defgroup longlines nil - "Automatic wrapping of long lines when loading files." - :group 'fill) - -(defcustom longlines-auto-wrap t - "Non-nil means long lines are automatically wrapped after each command. -Otherwise, you can perform filling using `fill-paragraph' or -`auto-fill-mode'. In any case, the soft newlines will be removed -when the file is saved to disk." - :type 'boolean) - -(defcustom longlines-wrap-follows-window-size nil - "Non-nil means wrapping and filling happen at the edge of the window. -Otherwise, `fill-column' is used, regardless of the window size. This -does not work well when the buffer is displayed in multiple windows -with differing widths. - -If the value is an integer, that specifies the distance from the -right edge of the window at which wrapping occurs. For any other -non-nil value, wrapping occurs 2 characters from the right edge." - :type 'boolean) - -(defcustom longlines-show-hard-newlines nil - "Non-nil means each hard newline is marked on the screen. -\(The variable `longlines-show-effect' controls what they look like.) -You can also enable the display temporarily, using the command -`longlines-show-hard-newlines'." - :type 'boolean) - -(defcustom longlines-show-effect (propertize "¶\n" 'face 'escape-glyph) - "A string to display when showing hard newlines. -This is used when `longlines-show-hard-newlines' is on." - :type 'string) - -(defcustom longlines-breakpoint-chars " ;,|" - "A bag of separator chars for longlines." - :type 'string) - -;;; Internal variables - -(defvar longlines-wrap-beg nil) -(defvar longlines-wrap-end nil) -(defvar longlines-wrap-point nil) -(defvar longlines-showing nil) -(defvar longlines-decoded nil) - -(make-variable-buffer-local 'longlines-wrap-beg) -(make-variable-buffer-local 'longlines-wrap-end) -(make-variable-buffer-local 'longlines-wrap-point) -(make-variable-buffer-local 'longlines-showing) -(make-variable-buffer-local 'longlines-decoded) - -;;; Mode - -(defvar message-indent-citation-function) - -;;;###autoload -(define-minor-mode longlines-mode - "Toggle Long Lines mode in this buffer. - -When Long Lines mode is enabled, long lines are wrapped if they -extend beyond `fill-column'. The soft newlines used for line -wrapping will not show up when the text is yanked or saved to -disk. - -If the variable `longlines-auto-wrap' is non-nil, lines are -automatically wrapped whenever the buffer is changed. You can -always call `fill-paragraph' to fill individual paragraphs. - -If the variable `longlines-show-hard-newlines' is non-nil, hard -newlines are indicated with a symbol." - :lighter " ll" - (if longlines-mode - ;; Turn on longlines mode - (progn - (use-hard-newlines 1 'never) - (set (make-local-variable 'require-final-newline) nil) - (add-to-list 'buffer-file-format 'longlines) - (add-hook 'change-major-mode-hook #'longlines-mode-off nil t) - (add-hook 'before-revert-hook #'longlines-before-revert-hook nil t) - (make-local-variable 'buffer-substring-filters) - (make-local-variable 'longlines-auto-wrap) - (set (make-local-variable 'isearch-search-fun-function) - #'longlines-search-function) - (set (make-local-variable 'replace-search-function) - #'longlines-search-forward) - (set (make-local-variable 'replace-re-search-function) - #'longlines-re-search-forward) - (add-to-list 'buffer-substring-filters 'longlines-encode-string) - (when longlines-wrap-follows-window-size - (let ((dw (if (and (integerp longlines-wrap-follows-window-size) - (>= longlines-wrap-follows-window-size 0) - (< longlines-wrap-follows-window-size - (window-width))) - longlines-wrap-follows-window-size - 2))) - (set (make-local-variable 'fill-column) - (- (window-width) dw))) - (add-hook 'window-configuration-change-hook - #'longlines-window-change-function nil t)) - (let ((buffer-undo-list t) - (inhibit-read-only t) - (inhibit-modification-hooks t) - (mod (buffer-modified-p)) - buffer-file-name buffer-file-truename) - ;; Turning off undo is OK since (spaces + newlines) is - ;; conserved, except for a corner case in - ;; longlines-wrap-lines that we'll never encounter from here - (save-restriction - (widen) - (unless longlines-decoded - (longlines-decode-buffer) - (setq longlines-decoded t)) - (longlines-wrap-region (point-min) (point-max))) - (set-buffer-modified-p mod)) - (when (and longlines-show-hard-newlines - (not longlines-showing)) - (longlines-show-hard-newlines)) - - ;; Hacks to make longlines play nice with various modes. - (cond ((eq major-mode 'mail-mode) - (declare-function mail-indent-citation "sendmail" ()) - (add-hook 'mail-setup-hook #'longlines-decode-buffer nil t) - (or mail-citation-hook - (add-hook 'mail-citation-hook #'mail-indent-citation nil t)) - (add-hook 'mail-citation-hook #'longlines-decode-region nil t)) - ((eq major-mode 'message-mode) - (add-hook 'message-setup-hook #'longlines-decode-buffer nil t) - (make-local-variable 'message-indent-citation-function) - (if (not (listp message-indent-citation-function)) - (setq message-indent-citation-function - (list message-indent-citation-function))) - (add-hook 'message-indent-citation-function - #'longlines-decode-region t t))) - - (add-hook 'after-change-functions #'longlines-after-change-function nil t) - (add-hook 'post-command-hook #'longlines-post-command-function nil t) - (when longlines-auto-wrap - (auto-fill-mode 0))) - ;; Turn off longlines mode - (setq buffer-file-format (delete 'longlines buffer-file-format)) - (if longlines-showing - (longlines-unshow-hard-newlines)) - (let ((buffer-undo-list t) - (inhibit-modification-hooks t) - (inhibit-read-only t) - buffer-file-name buffer-file-truename) - (if longlines-decoded - (save-restriction - (widen) - (longlines-encode-region (point-min) (point-max)) - (setq longlines-decoded nil)))) - (remove-hook 'change-major-mode-hook #'longlines-mode-off t) - (remove-hook 'after-change-functions #'longlines-after-change-function t) - (remove-hook 'post-command-hook #'longlines-post-command-function t) - (remove-hook 'before-revert-hook #'longlines-before-revert-hook t) - (remove-hook 'window-configuration-change-hook - #'longlines-window-change-function t) - (when longlines-wrap-follows-window-size - (kill-local-variable 'fill-column)) - (kill-local-variable 'isearch-search-fun-function) - (kill-local-variable 'replace-search-function) - (kill-local-variable 'replace-re-search-function) - (kill-local-variable 'require-final-newline) - (kill-local-variable 'buffer-substring-filters) - (kill-local-variable 'use-hard-newlines))) - -(defun longlines-mode-off () - "Turn off longlines mode. -This function exists to be called by `change-major-mode-hook' when the -major mode changes." - (longlines-mode 0)) - -;;; Showing the effect of hard newlines in the buffer - -(defun longlines-show-hard-newlines (&optional arg) - "Make hard newlines visible by adding a face. -With optional argument ARG, make the hard newlines invisible again." - (interactive "P") - (if arg - (longlines-unshow-hard-newlines) - (setq longlines-showing t) - (longlines-show-region (point-min) (point-max)))) - -(defun longlines-show-region (beg end) - "Make hard newlines between BEG and END visible." - (let* ((pmin (min beg end)) - (pmax (max beg end)) - (pos (text-property-not-all pmin pmax 'hard nil)) - (mod (buffer-modified-p)) - (buffer-undo-list t) - (inhibit-read-only t) - (inhibit-modification-hooks t) - buffer-file-name buffer-file-truename) - (while pos - (put-text-property pos (1+ pos) 'display - (copy-sequence longlines-show-effect)) - (setq pos (text-property-not-all (1+ pos) pmax 'hard nil))) - (restore-buffer-modified-p mod))) - -(defun longlines-unshow-hard-newlines () - "Make hard newlines invisible again." - (interactive) - (setq longlines-showing nil) - (let ((pos (text-property-not-all (point-min) (point-max) 'hard nil)) - (mod (buffer-modified-p)) - (buffer-undo-list t) - (inhibit-read-only t) - (inhibit-modification-hooks t) - buffer-file-name buffer-file-truename) - (while pos - (remove-text-properties pos (1+ pos) '(display nil)) - (setq pos (text-property-not-all (1+ pos) (point-max) 'hard nil))) - (restore-buffer-modified-p mod))) - -;;; Wrapping the paragraphs - -(defun longlines-wrap-region (beg end) - "Wrap each successive line, starting with the line before BEG. -Stop when we reach lines after END that don't need wrapping, or the -end of the buffer." - (let ((mod (buffer-modified-p))) - (setq longlines-wrap-point (point)) - (goto-char beg) - (forward-line -1) - ;; Two successful longlines-wrap-line's in a row mean successive - ;; lines don't need wrapping. - (while (null (and (longlines-wrap-line) - (or (eobp) - (and (>= (point) end) - (longlines-wrap-line)))))) - (goto-char longlines-wrap-point) - (set-buffer-modified-p mod))) - -(defun longlines-wrap-line () - "If the current line needs to be wrapped, wrap it and return nil. -If wrapping is performed, point remains on the line. If the line does -not need to be wrapped, move point to the next line and return t." - (if (longlines-set-breakpoint fill-column) - (progn (insert-before-markers-and-inherit ?\n) - nil) - (if (longlines-merge-lines-p) - (progn (end-of-line) - ;; After certain commands (e.g. kill-line), there may be two - ;; successive soft newlines in the buffer. In this case, we - ;; replace these two newlines by a single space. Unfortunately, - ;; this breaks the conservation of (spaces + newlines), so we - ;; have to fiddle with longlines-wrap-point. - (if (or (prog1 (bolp) (forward-char 1)) (eolp)) - (progn - (delete-char -1) - (if (> longlines-wrap-point (point)) - (setq longlines-wrap-point - (1- longlines-wrap-point)))) - (delete-char -1)) - nil) - (forward-line 1) - t))) - -(defun longlines-set-breakpoint (target-column) - "Place point where we should break the current line, and return t. -If the line should not be broken, return nil; point remains on the -line." - (move-to-column target-column) - (let ((non-breakpoint-re (format "[^%s]" longlines-breakpoint-chars))) - (if (and (re-search-forward non-breakpoint-re (line-end-position) t 1) - (> (current-column) target-column)) - ;; This line is too long. Can we break it? - (or (longlines-find-break-backward) - (progn (move-to-column target-column) - (longlines-find-break-forward)))))) - -(defun longlines-find-break-backward () - "Move point backward to the first available breakpoint and return t. -If no breakpoint is found, return nil." - (let ((breakpoint-re (format "[%s]" longlines-breakpoint-chars))) - (when (and (re-search-backward breakpoint-re (line-beginning-position) t 1) - (save-excursion - (skip-chars-backward longlines-breakpoint-chars - (line-beginning-position)) - (null (bolp)))) - (forward-char 1) - (if (and fill-nobreak-predicate - (run-hook-with-args-until-success 'fill-nobreak-predicate)) - (progn - (skip-chars-backward longlines-breakpoint-chars - (line-beginning-position)) - (longlines-find-break-backward)) - t)))) - -(defun longlines-find-break-forward () - "Move point forward to the first available breakpoint and return t. -If no break point is found, return nil." - (let ((breakpoint-re (format "[%s]" longlines-breakpoint-chars))) - (and (re-search-forward breakpoint-re (line-end-position) t 1) - (progn - (skip-chars-forward longlines-breakpoint-chars (line-end-position)) - (null (eolp))) - (if (and fill-nobreak-predicate - (run-hook-with-args-until-success 'fill-nobreak-predicate)) - (longlines-find-break-forward) - t)))) - -(defun longlines-merge-lines-p () - "Return t if part of the next line can fit onto the current line. -Otherwise, return nil. Text cannot be moved across hard newlines." - (save-excursion - (end-of-line) - (and (null (eobp)) - (null (get-text-property (point) 'hard)) - (let ((space (- fill-column (current-column)))) - (forward-line 1) - (longlines-set-breakpoint (max 0 (1- space))))))) - -(defun longlines-decode-region (&optional beg end) - "Turn all newlines between BEG and END into hard newlines. -If BEG and END are nil, the point and mark are used." - (if (null beg) (setq beg (point))) - (if (null end) (setq end (mark t))) - (save-excursion - (let ((reg-max (max beg end))) - (goto-char (min beg end)) - (while (search-forward "\n" reg-max t) - (set-hard-newline-properties - (match-beginning 0) (match-end 0)))))) - -(defun longlines-decode-buffer () - "Turn all newlines in the buffer into hard newlines." - (longlines-decode-region (point-min) (point-max))) - -(defun longlines-encode-region (beg end &optional _buffer) - "Remove each soft newline between BEG and END. -Hard newlines are left intact. The optional argument BUFFER exists for -compatibility with `format-alist', and is ignored." - (save-excursion - (let ((reg-max (max beg end)) - (mod (buffer-modified-p))) - (goto-char (min beg end)) - (while (search-forward "\n" reg-max t) - (let ((pos (match-beginning 0))) - (unless (get-text-property pos 'hard) - (remove-text-properties pos (1+ pos) '(hard nil)) - (delete-region pos (1+ pos))))) - (set-buffer-modified-p mod) - end))) - -(defun longlines-encode-string (string) - "Return a copy of STRING with each soft newline replaced by a space. -Hard newlines are left intact." - (let* ((str (copy-sequence string)) - (pos (string-search "\n" str))) - (while pos - (if (null (get-text-property pos 'hard str)) - (aset str pos ? )) - (setq pos (string-search "\n" str (1+ pos)))) - str)) - -;;; Auto wrap - -(defun longlines-auto-wrap (&optional arg) - "Toggle automatic line wrapping. -With optional argument ARG, turn on line wrapping if and only if -ARG is positive. -If automatic line wrapping is turned on, wrap the entire buffer." - (interactive "P") - (setq arg (if arg - (> (prefix-numeric-value arg) 0) - (not longlines-auto-wrap))) - (if arg - (progn - (setq longlines-auto-wrap t) - (longlines-wrap-region (point-min) (point-max)) - (message "Auto wrap enabled.")) - (setq longlines-auto-wrap nil) - (message "Auto wrap disabled."))) - -(defun longlines-after-change-function (beg end _len) - "Update `longlines-wrap-beg' and `longlines-wrap-end'. -This is called by `after-change-functions' to keep track of the region -that has changed." - (when (and longlines-auto-wrap (not undo-in-progress)) - (setq longlines-wrap-beg - (if longlines-wrap-beg (min longlines-wrap-beg beg) beg)) - (setq longlines-wrap-end - (if longlines-wrap-end (max longlines-wrap-end end) end)))) - -(defun longlines-post-command-function () - "Perform line wrapping on the parts of the buffer that have changed. -This is called by `post-command-hook' after each command." - (when (and longlines-auto-wrap longlines-wrap-beg) - (if (or (eq this-command 'yank) - (eq this-command 'yank-pop)) - (longlines-decode-region (point) (mark t))) - (if longlines-showing - (longlines-show-region longlines-wrap-beg longlines-wrap-end)) - (unless (or (eq this-command 'fill-paragraph) - (eq this-command 'fill-region)) - (longlines-wrap-region longlines-wrap-beg longlines-wrap-end)) - (setq longlines-wrap-beg nil) - (setq longlines-wrap-end nil))) - -(defun longlines-window-change-function () - "Re-wrap the buffer if the window width has changed. -This is called by `window-configuration-change-hook'." - (let ((dw (if (and (integerp longlines-wrap-follows-window-size) - (>= longlines-wrap-follows-window-size 0) - (< longlines-wrap-follows-window-size (window-width))) - longlines-wrap-follows-window-size - 2))) - (when (/= fill-column (- (window-width) dw)) - (setq fill-column (- (window-width) dw)) - (longlines-wrap-region (point-min) (point-max))))) - -;;; Isearch - -(defun longlines-search-function () - (cond - ((or isearch-regexp-function isearch-regexp) (isearch-search-fun-default)) - (isearch-forward #'longlines-search-forward) - (t #'longlines-search-backward))) - -(defun longlines-search-forward (string &optional bound noerror count) - (let ((search-spaces-regexp " *[ \n]")) - (re-search-forward (regexp-quote string) bound noerror count))) - -(defun longlines-search-backward (string &optional bound noerror count) - (let ((search-spaces-regexp " *[ \n]")) - (re-search-backward (regexp-quote string) bound noerror count))) - -(defun longlines-re-search-forward (string &optional bound noerror count) - (let ((search-spaces-regexp " *[ \n]")) - (re-search-forward string bound noerror count))) - -;;; Loading and saving - -(defun longlines-before-revert-hook () - (add-hook 'after-revert-hook #'longlines-after-revert-hook nil t) - (longlines-mode 0)) - -(defun longlines-after-revert-hook () - (remove-hook 'after-revert-hook #'longlines-after-revert-hook t) - (longlines-mode 1)) - -(add-to-list - 'format-alist - (list 'longlines "Automatically wrap long lines." nil nil - #'longlines-encode-region t nil)) - -;;; Unloading - -(defun longlines-unload-function () - "Unload the longlines library." - (save-current-buffer - (dolist (buffer (buffer-list)) - (set-buffer buffer) - (longlines-mode-off))) - ;; continue standard unloading - nil) - -(provide 'longlines) - -;;; longlines.el ends here diff --git a/src/buffer.c b/src/buffer.c index 509ce51b55..cbc246067d 100644 --- a/src/buffer.c +++ b/src/buffer.c @@ -5276,6 +5276,7 @@ init_buffer_once (void) XSETFASTINT (BVAR (&buffer_local_flags, tab_line_format), idx); ++idx; XSETFASTINT (BVAR (&buffer_local_flags, cursor_type), idx); ++idx; XSETFASTINT (BVAR (&buffer_local_flags, extra_line_spacing), idx); ++idx; + XSETFASTINT (BVAR (&buffer_local_flags, auto_narrow__narrowing), idx); ++idx; XSETFASTINT (BVAR (&buffer_local_flags, cursor_in_non_selected_windows), idx); ++idx; /* buffer_local_flags contains no pointers, so it's safe to treat it @@ -6363,6 +6364,10 @@ from (abs POSITION). If POSITION is positive, point was at the front If value is a floating point number, it specifies the spacing relative to the default frame line height. A value of nil means add no extra space. */); + DEFVAR_PER_BUFFER ("auto-narrow--narrowing", + &BVAR (current_buffer, auto_narrow__narrowing), Qnil, + doc: /* Internal variable used by `auto-narrow-mode'. */); + DEFVAR_PER_BUFFER ("cursor-in-non-selected-windows", &BVAR (current_buffer, cursor_in_non_selected_windows), Qnil, doc: /* Non-nil means show a cursor in non-selected windows. diff --git a/src/buffer.h b/src/buffer.h index 135eaf72d3..a6abc6ece8 100644 --- a/src/buffer.h +++ b/src/buffer.h @@ -561,6 +561,9 @@ #define BVAR(buf, field) ((buf)->field ## _) in the display of this buffer. */ Lisp_Object extra_line_spacing_; + /* Narrowing type when auto-narrow mode is in effect. */ + Lisp_Object auto_narrow__narrowing_; + /* Cursor type to display in non-selected windows. t means to use hollow box cursor. See `cursor-type' for other values. */ diff --git a/src/fileio.c b/src/fileio.c index 10d4b8bc15..9d2cf2ae00 100644 --- a/src/fileio.c +++ b/src/fileio.c @@ -4997,6 +4997,20 @@ because (1) it preserves some marker positions (in unchanged portions Otherwise start with an empty undo_list. */ bset_undo_list (current_buffer, EQ (old_undo, Qt) ? Qt : Qnil); + if (!noninteractive && !NILP (Vauto_narrow_long_line_threshold)) + { + ptrdiff_t cur, next, found, max = 0; + for (cur = PT; cur < PT + inserted; cur = next) + { + next = find_newline1 (cur, CHAR_TO_BYTE (cur), 0, -1, 1, + &found, NULL, true); + if (next - cur > max) max = next - cur; + if (!found) break; + } + if (max > XFIXNUM (Vauto_narrow_long_line_threshold)) + safe_call (1, Qauto_narrow_mode); + } + unbind_to (count1, Qnil); } @@ -6638,6 +6652,17 @@ do (file-exists-p FILENAME) and FILENAME is handled by HANDLER, then /* Lisp function for recursively deleting directories. */ DEFSYM (Qdelete_directory, "delete-directory"); + DEFVAR_LISP ("auto-narrow-long-line-threshold", + Vauto_narrow_long_line_threshold, + doc: /* Line length above which `auto-narrow-mode' is entered. +When non-nil, and when a file with one or more lines longer than +`auto-narrow-long-line-threshold' is opened or inserted in a buffer, +`auto-narrow-mode' is automatically enabled. +When nil, `auto-narrow-mode' is not entered automatically. */); + Vauto_narrow_long_line_threshold = Qnil; + + DEFSYM (Qauto_narrow_mode, "auto-narrow-mode"); + DEFSYM (Qsubstitute_env_in_file_name, "substitute-env-in-file-name"); DEFSYM (Qget_buffer_window_list, "get-buffer-window-list"); diff --git a/src/keyboard.c b/src/keyboard.c index bed8307b6f..38aa64774d 100644 --- a/src/keyboard.c +++ b/src/keyboard.c @@ -1290,6 +1290,9 @@ command_loop_1 (void) if (NILP (Vmemory_full)) { + if (!NILP (Vauto_narrow_post_command_function) && !NILP (Vrun_hooks)) + safe_run_hooks (Qauto_narrow_post_command_function); + /* Make sure this hook runs after commands that get errors and throw to top level. */ /* Note that the value cell will never directly contain nil @@ -1472,6 +1475,8 @@ command_loop_1 (void) Vreal_this_command = cmd; safe_run_hooks (Qpre_command_hook); + safe_run_hooks (Qauto_narrow_pre_command_function); + already_adjusted = 0; if (NILP (Vthis_command)) @@ -1522,6 +1527,8 @@ command_loop_1 (void) } kset_last_prefix_arg (current_kboard, Vcurrent_prefix_arg); + safe_run_hooks (Qauto_narrow_post_command_function); + safe_run_hooks (Qpost_command_hook); /* If displaying a message, resize the echo area window to fit @@ -12040,6 +12047,11 @@ syms_of_keyboard (void) DEFSYM (Qpre_command_hook, "pre-command-hook"); DEFSYM (Qpost_command_hook, "post-command-hook"); + DEFSYM (Qauto_narrow_pre_command_function, + "auto-narrow-pre-command-function"); + DEFSYM (Qauto_narrow_post_command_function, + "auto-narrow-post-command-function"); + DEFSYM (Qundo_auto__add_boundary, "undo-auto--add-boundary"); DEFSYM (Qundo_auto__undoably_changed_buffers, "undo-auto--undoably-changed-buffers"); @@ -12604,6 +12616,22 @@ syms_of_keyboard (void) See also `pre-command-hook'. */); Vpost_command_hook = Qnil; + DEFVAR_LISP ("auto-narrow-pre-command-function", + Vauto_narrow_pre_command_function, + doc: /* Function executed before each command is executed in `auto-narrow-mode'. +If non-nil, and `auto-narrow-mode' is enabled, the function is +called before each command is executed, after `pre-command-hook'. +It is called without arguments. */); + Vauto_narrow_pre_command_function = Qnil; + + DEFVAR_LISP ("auto-narrow-post-command-function", + Vauto_narrow_post_command_function, + doc: /* Function executed after each command is executed in `auto-narrow-mode'. +If non-nil, and `auto-narrow-mode' is enabled, the function is +called after each command is executed, before `post-command-hook'. +It is called without arguments. */); + Vauto_narrow_post_command_function = Qnil; + #if 0 DEFVAR_LISP ("echo-area-clear-hook", ..., doc: /* Normal hook run when clearing the echo area. */); diff --git a/src/lisp.h b/src/lisp.h index e4a49b8ef9..289141296c 100644 --- a/src/lisp.h +++ b/src/lisp.h @@ -4761,6 +4761,8 @@ fast_string_match_ignore_case (Lisp_Object regexp, Lisp_Object string) ptrdiff_t); extern ptrdiff_t fast_looking_at (Lisp_Object, ptrdiff_t, ptrdiff_t, ptrdiff_t, ptrdiff_t, Lisp_Object); +extern ptrdiff_t find_newline1 (ptrdiff_t, ptrdiff_t, 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 void scan_newline (ptrdiff_t, ptrdiff_t, ptrdiff_t, ptrdiff_t, diff --git a/src/search.c b/src/search.c index 9d6bd074e1..b5d6a442c0 100644 --- a/src/search.c +++ b/src/search.c @@ -3192,7 +3192,7 @@ DEFUN ("regexp-quote", Fregexp_quote, Sregexp_quote, 1, 1, 0, } /* Like find_newline, but doesn't use the cache, and only searches forward. */ -static ptrdiff_t +ptrdiff_t find_newline1 (ptrdiff_t start, ptrdiff_t start_byte, ptrdiff_t end, ptrdiff_t end_byte, ptrdiff_t count, ptrdiff_t *counted, ptrdiff_t *bytepos, bool allow_quit) diff --git a/src/xdisp.c b/src/xdisp.c index 4089525e10..d782659b92 100644 --- a/src/xdisp.c +++ b/src/xdisp.c @@ -27667,7 +27667,12 @@ decode_mode_spec (struct window *w, register int c, int field_width, case 'n': if (BUF_BEGV (b) > BUF_BEG (b) || BUF_ZV (b) < BUF_Z (b)) - return " Narrow"; + { + if (EQ (BVAR (current_buffer, auto_narrow__narrowing), intern ("auto"))) + return " Auto-Narrow"; + else + return " Narrow"; + } break; /* Display the "degree of travel" of the window through the buffer. */ -- 2.35.1