[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[elpa] externals/vlf 17c6612 130/310: Rename anything vlfi -> vlf.
|
From: |
Stefan Monnier |
|
Subject: |
[elpa] externals/vlf 17c6612 130/310: Rename anything vlfi -> vlf. |
|
Date: |
Sat, 28 Nov 2020 00:33:01 -0500 (EST) |
branch: externals/vlf
commit 17c66122d9795bb96112dd54b40cdc91296fe88c
Author: Andrey Kotlarski <m00naticus@gmail.com>
Commit: Andrey Kotlarski <m00naticus@gmail.com>
Rename anything vlfi -> vlf.
---
README.org | 16 +-
vlf.el | 582 +++++++++++++++++++++++++++++++------------------------------
2 files changed, 300 insertions(+), 298 deletions(-)
diff --git a/README.org b/README.org
index d83962f..5f51108 100644
--- a/README.org
+++ b/README.org
@@ -17,13 +17,13 @@ what it does in a nutshell:
- newly added content is acknowledged if file has changed size
meanwhile
- automatic scrolling of batches
-- VLFI is added as an option when opening large files
+- VLF is added as an option when opening large files
GNU Emacs 23 and 24 are supported.
* Overview and tips
-M-x vlfi PATH-TO-FILE
+M-x vlf PATH-TO-FILE
** Unicode
@@ -35,22 +35,22 @@ editing, search and indexing.
Regular Emacs integers are used, so if you use 32-bit Emacs without
bignum support and have really huge file (with size beyond the maximum
-integer value), VLFI will probably not quite work.
+integer value), VLF will probably not quite work.
** Memory control
-*vlfi-batch-size* bounds the memory used for all operations.
+*vlf-batch-size* bounds the memory used for all operations.
** Special mode
-VLFI is derived from special-mode and keeps all its properties. For
+VLF is derived from special-mode and keeps all its properties. For
example you can directly press digits to enter prefix arguments.
** Change major mode
You can change major mode to whatever you like (for example
hexl-mode). Saving will insert contents as intended. You can return
-to *vlfi-mode* too.
+to *vlf-mode* too.
* Detail usage
@@ -58,7 +58,7 @@ to *vlfi-mode* too.
*+* and *-* control current batch size by factors of 2.
-You can also set by hand local variable *vlfi-batch-size* and then
+You can also set by hand local variable *vlf-batch-size* and then
refresh with *g*.
** Move around
@@ -94,7 +94,7 @@ negative argument, lines are counted from the end of file.
** Edit
-*e* enters VLFI in edit mode. If editing doesn't change size of
+*e* enters VLF in edit mode. If editing doesn't change size of
the chunk, only this chunk is saved. Otherwise the remaining part of
the file is adjusted chunk by chunk, so again you'd better have bigger
current batch size. If chunk has been expanded the memory used is
diff --git a/vlf.el b/vlf.el
index 96f30a3..28b65f1 100644
--- a/vlf.el
+++ b/vlf.el
@@ -1,4 +1,4 @@
-;;; vlfi.el --- View Large Files -*- lexical-binding: t -*-
+;;; vlf.el --- View Large Files -*- lexical-binding: t -*-
;; Copyright (C) 2006, 2012, 2013 Free Software Foundation, Inc.
@@ -27,9 +27,9 @@
;;; Commentary:
-;; This package provides the M-x vlfi command, which visits part of a
+;; This package provides the M-x vlf command, which visits part of a
;; large file without loading the entire file.
-;; The buffer uses VLFI mode, which defines several commands for
+;; The buffer uses VLF mode, which defines several commands for
;; moving around, searching and editing selected part of file.
;; This package was inspired by a snippet posted by Kevin Rodgers,
@@ -38,97 +38,99 @@
;;; Code:
-(defgroup vlfi nil
+(defgroup vlf nil
"View Large Files in Emacs."
- :prefix "vlfi-"
+ :prefix "vlf-"
:group 'files)
-(defcustom vlfi-batch-size 1024
+(defcustom vlf-batch-size 1024
"Defines how large each batch of file data is (in bytes)."
:type 'integer
- :group 'vlfi)
+ :group 'vlf)
+(put 'vlf-batch-size 'permanent-local t)
;;; Keep track of file position.
-(defvar vlfi-start-pos 0
+(defvar vlf-start-pos 0
"Absolute position of the visible chunk start.")
-(defvar vlfi-end-pos 0 "Absolute position of the visible chunk end.")
-(defvar vlfi-file-size 0 "Total size of presented file.")
-(defvar vlfi-encode-size 0 "Size in bytes of current batch decoded.")
+(put 'vlf-start-pos 'permanent-local t)
-(defvar vlfi-mode-map
+(defvar vlf-end-pos 0 "Absolute position of the visible chunk end.")
+(put 'vlf-end-pos 'permanent-local t)
+
+(defvar vlf-file-size 0 "Total size of presented file.")
+(put 'vlf-file-size 'permanent-local t)
+
+(defvar vlf-encode-size 0 "Size in bytes of current batch decoded.")
+(put 'vlf-encode-size 'permanent-local t)
+
+(defvar vlf-mode-map
(let ((map (make-sparse-keymap)))
- (define-key map [M-next] 'vlfi-next-batch)
- (define-key map [M-prior] 'vlfi-prev-batch)
- (define-key map "+" 'vlfi-change-batch-size)
+ (define-key map [M-next] 'vlf-next-batch)
+ (define-key map [M-prior] 'vlf-prev-batch)
+ (define-key map "+" 'vlf-change-batch-size)
(define-key map "-"
- (lambda () "Decrease vlfi batch size by factor of 2."
+ (lambda () "Decrease vlf batch size by factor of 2."
(interactive)
- (vlfi-change-batch-size t)))
- (define-key map "s" 'vlfi-re-search-forward)
- (define-key map "r" 'vlfi-re-search-backward)
- (define-key map "o" 'vlfi-occur)
- (define-key map "[" 'vlfi-beginning-of-file)
- (define-key map "]" 'vlfi-end-of-file)
- (define-key map "e" 'vlfi-edit-mode)
- (define-key map "j" 'vlfi-jump-to-chunk)
- (define-key map "l" 'vlfi-goto-line)
+ (vlf-change-batch-size t)))
+ (define-key map "s" 'vlf-re-search-forward)
+ (define-key map "r" 'vlf-re-search-backward)
+ (define-key map "o" 'vlf-occur)
+ (define-key map "[" 'vlf-beginning-of-file)
+ (define-key map "]" 'vlf-end-of-file)
+ (define-key map "e" 'vlf-edit-mode)
+ (define-key map "j" 'vlf-jump-to-chunk)
+ (define-key map "l" 'vlf-goto-line)
map)
- "Keymap for `vlfi-mode'.")
-
-(put 'vlfi-batch-size 'permanent-local t)
-(put 'vlfi-start-pos 'permanent-local t)
-(put 'vlfi-end-pos 'permanent-local t)
-(put 'vlfi-file-size 'permanent-local t)
-(put 'vlfi-encode-size 'permanent-local t)
+ "Keymap for `vlf-mode'.")
-(define-derived-mode vlfi-mode special-mode "VLFI"
+(define-derived-mode vlf-mode special-mode "VLF"
"Mode to browse large files in."
(setq buffer-read-only t)
(set-buffer-modified-p nil)
(buffer-disable-undo)
- (add-hook 'write-file-functions 'vlfi-write nil t)
+ (add-hook 'write-file-functions 'vlf-write nil t)
(make-local-variable 'revert-buffer-function)
- (setq revert-buffer-function 'vlfi-revert)
- (make-local-variable 'vlfi-batch-size)
- (make-local-variable 'vlfi-start-pos)
- (make-local-variable 'vlfi-end-pos)
- (make-local-variable 'vlfi-file-size)
- (make-local-variable 'vlfi-encode-size))
+ (setq revert-buffer-function 'vlf-revert)
+ (make-local-variable 'vlf-batch-size)
+ (make-local-variable 'vlf-start-pos)
+ (make-local-variable 'vlf-end-pos)
+ (make-local-variable 'vlf-file-size)
+ (make-local-variable 'vlf-encode-size))
;;;###autoload
-(defun vlfi (file)
+(defun vlf (file)
"View Large FILE.
Batches of the file data from FILE will be displayed in a read-only
buffer. You can customize number of bytes displayed by customizing
-`vlfi-batch-size'."
+`vlf-batch-size'."
(interactive "fFile to open: ")
- (with-current-buffer (generate-new-buffer "*vlfi*")
+ (with-current-buffer (generate-new-buffer "*vlf*")
(set-visited-file-name file)
- (vlfi-mode)
- (setq vlfi-file-size (vlfi-get-file-size buffer-file-name))
- (vlfi-insert-file)
+ (vlf-mode)
+ (setq vlf-file-size (vlf-get-file-size buffer-file-name))
+ (vlf-insert-file)
(switch-to-buffer (current-buffer))))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; integration with other packages
;;;###autoload
-(defun dired-vlfi ()
- "In Dired, visit the file on this line in VLFI mode."
+(defun dired-vlf ()
+ "In Dired, visit the file on this line in VLF mode."
(interactive)
- (vlfi (dired-get-file-for-visit)))
+ (vlf (dired-get-file-for-visit)))
;;;###autoload
(eval-after-load "dired"
- '(define-key dired-mode-map "V" 'dired-vlfi))
+ '(define-key dired-mode-map "V" 'dired-vlf))
;;;###autoload
-(defadvice abort-if-file-too-large (around vlfi-if-file-too-large
+(defadvice abort-if-file-too-large (around vlf-if-file-too-large
(size op-type
&optional filename)
compile activate)
"If file SIZE larger than `large-file-warning-threshold', \
-allow user to view file with `vlfi', open it normally, or abort.
+allow user to view file with `vlf', open it normally, or abort.
OP-TYPE specifies the file operation being performed over FILENAME."
(and large-file-warning-threshold size
(> size large-file-warning-threshold)
@@ -138,7 +140,7 @@ OP-TYPE specifies the file operation being performed over
FILENAME."
(propertize
(format
"File %s is large (%s): \
-%s normally (o), %s with vlfi (v) or abort (a)"
+%s normally (o), %s with vlf (v) or abort (a)"
(if filename
(file-name-nondirectory filename)
"")
@@ -148,28 +150,28 @@ OP-TYPE specifies the file operation being performed over
FILENAME."
'(?o ?O ?v ?V ?a ?A))))
(cond ((memq char '(?o ?O)))
((memq char '(?v ?V))
- (vlfi filename)
+ (vlf filename)
(error ""))
((memq char '(?a ?A))
(error "Aborted"))))))
;; scroll auto batching
-(defadvice scroll-up (around vlfi-scroll-up
+(defadvice scroll-up (around vlf-scroll-up
activate compile)
- "Slide to next batch if at end of buffer in `vlfi-mode'."
- (if (and (derived-mode-p 'vlfi-mode)
+ "Slide to next batch if at end of buffer in `vlf-mode'."
+ (if (and (derived-mode-p 'vlf-mode)
(eobp))
- (progn (vlfi-next-batch 1)
+ (progn (vlf-next-batch 1)
(goto-char (point-min)))
ad-do-it))
-(defadvice scroll-down (around vlfi-scroll-down
+(defadvice scroll-down (around vlf-scroll-down
activate compile)
- "Slide to previous batch if at beginning of buffer in `vlfi-mode'."
- (if (and (derived-mode-p 'vlfi-mode)
+ "Slide to previous batch if at beginning of buffer in `vlf-mode'."
+ (if (and (derived-mode-p 'vlf-mode)
(bobp))
- (progn (vlfi-prev-batch 1)
+ (progn (vlf-prev-batch 1)
(goto-char (point-max)))
ad-do-it))
@@ -183,287 +185,287 @@ OP-TYPE specifies the file operation being performed
over FILENAME."
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; utilities
-(defun vlfi-change-batch-size (decrease)
- "Change the buffer-local value of `vlfi-batch-size'.
+(defun vlf-change-batch-size (decrease)
+ "Change the buffer-local value of `vlf-batch-size'.
Normally, the value is doubled;
with the prefix argument DECREASE it is halved."
(interactive "P")
- (setq vlfi-batch-size (if decrease
- (/ vlfi-batch-size 2)
- (* vlfi-batch-size 2)))
- (vlfi-move-to-batch vlfi-start-pos))
+ (setq vlf-batch-size (if decrease
+ (/ vlf-batch-size 2)
+ (* vlf-batch-size 2)))
+ (vlf-move-to-batch vlf-start-pos))
-(defun vlfi-format-buffer-name ()
- "Return format for vlfi buffer name."
+(defun vlf-format-buffer-name ()
+ "Return format for vlf buffer name."
(format "%s(%s)[%d/%d](%d)"
(file-name-nondirectory buffer-file-name)
- (file-size-human-readable vlfi-file-size)
- (/ vlfi-end-pos vlfi-batch-size)
- (/ vlfi-file-size vlfi-batch-size)
- vlfi-batch-size))
+ (file-size-human-readable vlf-file-size)
+ (/ vlf-end-pos vlf-batch-size)
+ (/ vlf-file-size vlf-batch-size)
+ vlf-batch-size))
-(defun vlfi-update-buffer-name ()
+(defun vlf-update-buffer-name ()
"Update the current buffer name."
- (rename-buffer (vlfi-format-buffer-name) t))
+ (rename-buffer (vlf-format-buffer-name) t))
-(defun vlfi-get-file-size (file)
+(defun vlf-get-file-size (file)
"Get size in bytes of FILE."
(nth 7 (file-attributes file)))
-(defun vlfi-verify-size ()
+(defun vlf-verify-size ()
"Update file size information if necessary and visited file time."
(unless (verify-visited-file-modtime (current-buffer))
- (setq vlfi-file-size (vlfi-get-file-size buffer-file-name))
+ (setq vlf-file-size (vlf-get-file-size buffer-file-name))
(set-visited-file-modtime)))
-(defun vlfi-insert-file (&optional from-end)
+(defun vlf-insert-file (&optional from-end)
"Insert first chunk of current file contents in current buffer.
With FROM-END prefix, start from the back."
(if from-end
- (setq vlfi-start-pos (max 0 (- vlfi-file-size vlfi-batch-size))
- vlfi-end-pos vlfi-file-size)
- (setq vlfi-start-pos 0
- vlfi-end-pos (min vlfi-batch-size vlfi-file-size)))
- (vlfi-move-to-chunk vlfi-start-pos vlfi-end-pos))
+ (setq vlf-start-pos (max 0 (- vlf-file-size vlf-batch-size))
+ vlf-end-pos vlf-file-size)
+ (setq vlf-start-pos 0
+ vlf-end-pos (min vlf-batch-size vlf-file-size)))
+ (vlf-move-to-chunk vlf-start-pos vlf-end-pos))
-(defun vlfi-beginning-of-file ()
+(defun vlf-beginning-of-file ()
"Jump to beginning of file content."
(interactive)
- (vlfi-insert-file))
+ (vlf-insert-file))
-(defun vlfi-end-of-file ()
+(defun vlf-end-of-file ()
"Jump to end of file content."
(interactive)
- (vlfi-insert-file t))
+ (vlf-insert-file t))
-(defun vlfi-revert (&optional _ignore-auto noconfirm)
+(defun vlf-revert (&optional _ignore-auto noconfirm)
"Revert current chunk. Ignore _IGNORE-AUTO.
Ask for confirmation if NOCONFIRM is nil."
(if (or noconfirm
(yes-or-no-p (format "Revert buffer from file %s? "
buffer-file-name)))
- (vlfi-move-to-chunk vlfi-start-pos vlfi-end-pos)))
+ (vlf-move-to-chunk vlf-start-pos vlf-end-pos)))
-(defun vlfi-jump-to-chunk (n)
+(defun vlf-jump-to-chunk (n)
"Go to to chunk N."
(interactive "nGoto to chunk: ")
- (vlfi-move-to-batch (* (1- n) vlfi-batch-size)))
+ (vlf-move-to-batch (* (1- n) vlf-batch-size)))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; batch movement
-(defun vlfi-next-batch (append)
+(defun vlf-next-batch (append)
"Display the next batch of file data.
When prefix argument is supplied and positive
jump over APPEND number of batches.
When prefix argument is negative
append next APPEND number of batches to the existing buffer."
(interactive "p")
- (vlfi-verify-size)
- (let ((end (min (+ vlfi-end-pos (* vlfi-batch-size
+ (vlf-verify-size)
+ (let ((end (min (+ vlf-end-pos (* vlf-batch-size
(abs append)))
- vlfi-file-size)))
+ vlf-file-size)))
(let ((inhibit-read-only t)
(do-append (< append 0))
(pos (position-bytes (point))))
(if do-append
(goto-char (point-max))
- (setq vlfi-start-pos (- end vlfi-batch-size))
+ (setq vlf-start-pos (- end vlf-batch-size))
(erase-buffer))
(insert-file-contents buffer-file-name nil (if do-append
- vlfi-end-pos
- vlfi-start-pos)
+ vlf-end-pos
+ vlf-start-pos)
end)
- (setq vlfi-end-pos end)
- (goto-char (or (byte-to-position (+ pos (vlfi-adjust-chunk)))
+ (setq vlf-end-pos end)
+ (goto-char (or (byte-to-position (+ pos (vlf-adjust-chunk)))
(point-max)))))
(set-visited-file-modtime)
(set-buffer-modified-p nil)
- (vlfi-update-buffer-name))
+ (vlf-update-buffer-name))
-(defun vlfi-prev-batch (prepend)
+(defun vlf-prev-batch (prepend)
"Display the previous batch of file data.
When prefix argument is supplied and positive
jump over PREPEND number of batches.
When prefix argument is negative
append previous PREPEND number of batches to the existing buffer."
(interactive "p")
- (if (zerop vlfi-start-pos)
+ (if (zerop vlf-start-pos)
(error "Already at BOF"))
- (vlfi-verify-size)
+ (vlf-verify-size)
(let ((inhibit-read-only t)
- (start (max 0 (- vlfi-start-pos (* vlfi-batch-size
+ (start (max 0 (- vlf-start-pos (* vlf-batch-size
(abs prepend)))))
(do-prepend (< prepend 0))
(pos (- (position-bytes (point-max))
(position-bytes (point)))))
(if do-prepend
(goto-char (point-min))
- (setq vlfi-end-pos (min (+ start vlfi-batch-size)
- vlfi-file-size))
+ (setq vlf-end-pos (min (+ start vlf-batch-size)
+ vlf-file-size))
(erase-buffer))
(insert-file-contents buffer-file-name nil start
(if do-prepend
- vlfi-start-pos
- vlfi-end-pos))
- (setq vlfi-start-pos start
- pos (+ pos (vlfi-adjust-chunk)))
+ vlf-start-pos
+ vlf-end-pos))
+ (setq vlf-start-pos start
+ pos (+ pos (vlf-adjust-chunk)))
(goto-char (or (byte-to-position (- (position-bytes (point-max))
pos))
(point-max))))
(set-visited-file-modtime)
(set-buffer-modified-p nil)
- (vlfi-update-buffer-name))
+ (vlf-update-buffer-name))
-(defun vlfi-move-to-batch (start &optional minimal)
+(defun vlf-move-to-batch (start &optional minimal)
"Move to batch determined by START.
-Adjust according to file start/end and show `vlfi-batch-size' bytes.
+Adjust according to file start/end and show `vlf-batch-size' bytes.
When given MINIMAL flag, skip non important operations."
- (vlfi-verify-size)
- (setq vlfi-start-pos (max 0 start)
- vlfi-end-pos (min (+ vlfi-start-pos vlfi-batch-size)
- vlfi-file-size))
- (if (= vlfi-file-size vlfi-end-pos) ; re-check file size
- (setq vlfi-start-pos (max 0 (- vlfi-end-pos vlfi-batch-size))))
+ (vlf-verify-size)
+ (setq vlf-start-pos (max 0 start)
+ vlf-end-pos (min (+ vlf-start-pos vlf-batch-size)
+ vlf-file-size))
+ (if (= vlf-file-size vlf-end-pos) ; re-check file size
+ (setq vlf-start-pos (max 0 (- vlf-end-pos vlf-batch-size))))
(let ((inhibit-read-only t)
(pos (position-bytes (point))))
(erase-buffer)
(insert-file-contents buffer-file-name nil
- vlfi-start-pos vlfi-end-pos)
- (goto-char (or (byte-to-position (+ pos (vlfi-adjust-chunk)))
+ vlf-start-pos vlf-end-pos)
+ (goto-char (or (byte-to-position (+ pos (vlf-adjust-chunk)))
(point-max))))
(set-buffer-modified-p nil)
(set-visited-file-modtime)
- (or minimal(vlfi-update-buffer-name)))
+ (or minimal(vlf-update-buffer-name)))
-(defun vlfi-move-to-chunk (start end &optional minimal)
+(defun vlf-move-to-chunk (start end &optional minimal)
"Move to chunk determined by START END.
When given MINIMAL flag, skip non important operations."
- (vlfi-verify-size)
- (setq vlfi-start-pos (max 0 start)
- vlfi-end-pos (min end vlfi-file-size))
+ (vlf-verify-size)
+ (setq vlf-start-pos (max 0 start)
+ vlf-end-pos (min end vlf-file-size))
(let ((inhibit-read-only t)
(pos (position-bytes (point))))
(erase-buffer)
(insert-file-contents buffer-file-name nil
- vlfi-start-pos vlfi-end-pos)
- (goto-char (or (byte-to-position (+ pos (vlfi-adjust-chunk)))
+ vlf-start-pos vlf-end-pos)
+ (goto-char (or (byte-to-position (+ pos (vlf-adjust-chunk)))
(point-max))))
(set-buffer-modified-p nil)
(set-visited-file-modtime)
- (or minimal (vlfi-update-buffer-name)))
+ (or minimal (vlf-update-buffer-name)))
-(defun vlfi-adjust-chunk ()
+(defun vlf-adjust-chunk ()
"Adjust chunk beginning until content can be properly decoded.
-Set `vlfi-encode-size' to size of buffer when encoded.
+Set `vlf-encode-size' to size of buffer when encoded.
Return number of bytes moved back for this to happen."
(let ((shift 0)
- (chunk-size (- vlfi-end-pos vlfi-start-pos)))
+ (chunk-size (- vlf-end-pos vlf-start-pos)))
(while (and (< shift 4)
(< 4 (abs (- chunk-size
- (setq vlfi-encode-size
+ (setq vlf-encode-size
(length (encode-coding-region
(point-min) (point-max)
buffer-file-coding-system
t))))))
- (not (zerop vlfi-start-pos)))
+ (not (zerop vlf-start-pos)))
(setq shift (1+ shift)
- vlfi-start-pos (1- vlfi-start-pos)
+ vlf-start-pos (1- vlf-start-pos)
chunk-size (1+ chunk-size))
(let ((inhibit-read-only t))
(erase-buffer)
(insert-file-contents buffer-file-name nil
- vlfi-start-pos vlfi-end-pos)))
+ vlf-start-pos vlf-end-pos)))
(set-buffer-modified-p nil)
shift))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; search
-(defun vlfi-re-search (regexp count backward batch-step)
+(defun vlf-re-search (regexp count backward batch-step)
"Search for REGEXP COUNT number of times forward or BACKWARD.
BATCH-STEP is amount of overlap between successive chunks."
(assert (< 0 count))
- (let* ((match-chunk-start vlfi-start-pos)
- (match-chunk-end vlfi-end-pos)
- (match-start-pos (+ vlfi-start-pos (position-bytes (point))))
+ (let* ((match-chunk-start vlf-start-pos)
+ (match-chunk-end vlf-end-pos)
+ (match-start-pos (+ vlf-start-pos (position-bytes (point))))
(match-end-pos match-start-pos)
(to-find count)
(reporter (make-progress-reporter
(concat "Searching for " regexp "...")
(if backward
- (- vlfi-file-size vlfi-end-pos)
- vlfi-start-pos)
- vlfi-file-size)))
+ (- vlf-file-size vlf-end-pos)
+ vlf-start-pos)
+ vlf-file-size)))
(unwind-protect
(catch 'end-of-file
(if backward
(while (not (zerop to-find))
(cond ((re-search-backward regexp nil t)
(setq to-find (1- to-find)
- match-chunk-start vlfi-start-pos
- match-chunk-end vlfi-end-pos
- match-start-pos (+ vlfi-start-pos
+ match-chunk-start vlf-start-pos
+ match-chunk-end vlf-end-pos
+ match-start-pos (+ vlf-start-pos
(position-bytes
(match-beginning 0)))
- match-end-pos (+ vlfi-start-pos
+ match-end-pos (+ vlf-start-pos
(position-bytes
(match-end 0)))))
- ((zerop vlfi-start-pos)
+ ((zerop vlf-start-pos)
(throw 'end-of-file nil))
- (t (let ((batch-move (- vlfi-start-pos
- (- vlfi-batch-size
+ (t (let ((batch-move (- vlf-start-pos
+ (- vlf-batch-size
batch-step))))
- (vlfi-move-to-batch
+ (vlf-move-to-batch
(if (< match-start-pos batch-move)
- (- match-start-pos vlfi-batch-size)
+ (- match-start-pos vlf-batch-size)
batch-move) t))
(goto-char (if (< match-start-pos
- vlfi-end-pos)
+ vlf-end-pos)
(or (byte-to-position
(- match-start-pos
- vlfi-start-pos))
+ vlf-start-pos))
(point-max))
(point-max)))
(progress-reporter-update
- reporter (- vlfi-file-size
- vlfi-start-pos)))))
+ reporter (- vlf-file-size
+ vlf-start-pos)))))
(while (not (zerop to-find))
(cond ((re-search-forward regexp nil t)
(setq to-find (1- to-find)
- match-chunk-start vlfi-start-pos
- match-chunk-end vlfi-end-pos
- match-start-pos (+ vlfi-start-pos
+ match-chunk-start vlf-start-pos
+ match-chunk-end vlf-end-pos
+ match-start-pos (+ vlf-start-pos
(position-bytes
(match-beginning 0)))
- match-end-pos (+ vlfi-start-pos
+ match-end-pos (+ vlf-start-pos
(position-bytes
(match-end 0)))))
- ((= vlfi-end-pos vlfi-file-size)
+ ((= vlf-end-pos vlf-file-size)
(throw 'end-of-file nil))
- (t (let ((batch-move (- vlfi-end-pos batch-step)))
- (vlfi-move-to-batch
+ (t (let ((batch-move (- vlf-end-pos batch-step)))
+ (vlf-move-to-batch
(if (< batch-move match-end-pos)
match-end-pos
batch-move) t))
- (goto-char (if (< vlfi-start-pos match-end-pos)
+ (goto-char (if (< vlf-start-pos match-end-pos)
(or (byte-to-position
(- match-end-pos
- vlfi-start-pos))
+ vlf-start-pos))
(point-min))
(point-min)))
(progress-reporter-update reporter
- vlfi-end-pos)))))
+ vlf-end-pos)))))
(progress-reporter-done reporter))
(if backward
- (vlfi-goto-match match-chunk-start match-chunk-end
+ (vlf-goto-match match-chunk-start match-chunk-end
match-end-pos match-start-pos
count to-find)
- (vlfi-goto-match match-chunk-start match-chunk-end
+ (vlf-goto-match match-chunk-start match-chunk-end
match-start-pos match-end-pos
count to-find)))))
-(defun vlfi-goto-match (match-chunk-start match-chunk-end
+(defun vlf-goto-match (match-chunk-start match-chunk-end
match-pos-start
match-pos-end
count to-find)
@@ -472,22 +474,22 @@ MATCH-POS-START and MATCH-POS-END.
According to COUNT and left TO-FIND, show if search has been
successful. Return nil if nothing found."
(if (= count to-find)
- (progn (vlfi-move-to-chunk match-chunk-start match-chunk-end)
+ (progn (vlf-move-to-chunk match-chunk-start match-chunk-end)
(goto-char (or (byte-to-position (- match-pos-start
- vlfi-start-pos))
+ vlf-start-pos))
(point-max)))
(message "Not found")
nil)
(let ((success (zerop to-find)))
(if success
- (vlfi-update-buffer-name)
- (vlfi-move-to-chunk match-chunk-start match-chunk-end))
+ (vlf-update-buffer-name)
+ (vlf-move-to-chunk match-chunk-start match-chunk-end))
(let* ((match-end (or (byte-to-position (- match-pos-end
- vlfi-start-pos))
+ vlf-start-pos))
(point-max)))
(overlay (make-overlay (byte-to-position
(- match-pos-start
- vlfi-start-pos))
+ vlf-start-pos))
match-end)))
(overlay-put overlay 'face 'match)
(unless success
@@ -498,62 +500,62 @@ successful. Return nil if nothing found."
(delete-overlay overlay)
t))))
-(defun vlfi-re-search-forward (regexp count)
+(defun vlf-re-search-forward (regexp count)
"Search forward for REGEXP prefix COUNT number of times.
-Search is performed chunk by chunk in `vlfi-batch-size' memory."
+Search is performed chunk by chunk in `vlf-batch-size' memory."
(interactive (list (read-regexp "Search whole file"
(if regexp-history
(car regexp-history)))
(or current-prefix-arg 1)))
- (vlfi-re-search regexp count nil (/ vlfi-batch-size 8)))
+ (vlf-re-search regexp count nil (/ vlf-batch-size 8)))
-(defun vlfi-re-search-backward (regexp count)
+(defun vlf-re-search-backward (regexp count)
"Search backward for REGEXP prefix COUNT number of times.
-Search is performed chunk by chunk in `vlfi-batch-size' memory."
+Search is performed chunk by chunk in `vlf-batch-size' memory."
(interactive (list (read-regexp "Search whole file backward"
(if regexp-history
(car regexp-history)))
(or current-prefix-arg 1)))
- (vlfi-re-search regexp count t (/ vlfi-batch-size 8)))
+ (vlf-re-search regexp count t (/ vlf-batch-size 8)))
-(defun vlfi-goto-line (n)
+(defun vlf-goto-line (n)
"Go to line N. If N is negative, count from the end of file."
(interactive "nGo to line: ")
- (let ((start-pos vlfi-start-pos)
- (end-pos vlfi-end-pos)
+ (let ((start-pos vlf-start-pos)
+ (end-pos vlf-end-pos)
(pos (point))
(success nil))
(unwind-protect
(if (< 0 n)
- (progn (vlfi-beginning-of-file)
+ (progn (vlf-beginning-of-file)
(goto-char (point-min))
- (setq success (vlfi-re-search "[\n\C-m]" (1- n)
+ (setq success (vlf-re-search "[\n\C-m]" (1- n)
nil 0)))
- (vlfi-end-of-file)
+ (vlf-end-of-file)
(goto-char (point-max))
- (setq success (vlfi-re-search "[\n\C-m]" (- n) t 0)))
+ (setq success (vlf-re-search "[\n\C-m]" (- n) t 0)))
(if success
(message "Onto line %s" n)
- (vlfi-move-to-chunk start-pos end-pos)
+ (vlf-move-to-chunk start-pos end-pos)
(goto-char pos)))))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; occur
-(defvar vlfi-occur-mode-map
+(defvar vlf-occur-mode-map
(let ((map (make-sparse-keymap)))
- (define-key map "n" 'vlfi-occur-next-match)
- (define-key map "p" 'vlfi-occur-prev-match)
- (define-key map "\C-m" 'vlfi-occur-visit)
- (define-key map [mouse-1] 'vlfi-occur-visit)
- (define-key map "o" 'vlfi-occur-show)
+ (define-key map "n" 'vlf-occur-next-match)
+ (define-key map "p" 'vlf-occur-prev-match)
+ (define-key map "\C-m" 'vlf-occur-visit)
+ (define-key map [mouse-1] 'vlf-occur-visit)
+ (define-key map "o" 'vlf-occur-show)
map)
- "Keymap for command `vlfi-occur-mode'.")
+ "Keymap for command `vlf-occur-mode'.")
-(define-derived-mode vlfi-occur-mode special-mode "VLFI[occur]"
- "Major mode for showing occur matches of VLFI opened files.")
+(define-derived-mode vlf-occur-mode special-mode "VLF[occur]"
+ "Major mode for showing occur matches of VLF opened files.")
-(defun vlfi-occur-next-match ()
+(defun vlf-occur-next-match ()
"Move cursor to next match."
(interactive)
(if (eq (get-char-property (point) 'face) 'match)
@@ -562,7 +564,7 @@ Search is performed chunk by chunk in `vlfi-batch-size'
memory."
(text-property-any (point-min) (point)
'face 'match))))
-(defun vlfi-occur-prev-match ()
+(defun vlf-occur-prev-match ()
"Move cursor to previous match."
(interactive)
(if (eq (get-char-property (point) 'face) 'match)
@@ -571,23 +573,23 @@ Search is performed chunk by chunk in `vlfi-batch-size'
memory."
(goto-char (or (previous-single-property-change (point) 'face)
(point-max)))))
-(defun vlfi-occur-show (&optional event)
- "Visit current `vlfi-occur' link in a vlfi buffer but stay in the \
-occur buffer. If original VLFI buffer has been killed,
-open new VLFI session each time.
+(defun vlf-occur-show (&optional event)
+ "Visit current `vlf-occur' link in a vlf buffer but stay in the \
+occur buffer. If original VLF buffer has been killed,
+open new VLF session each time.
EVENT may hold details of the invocation."
(interactive (list last-nonmenu-event))
(let ((occur-buffer (if event
(window-buffer (posn-window
(event-end event)))
(current-buffer))))
- (vlfi-occur-visit event)
+ (vlf-occur-visit event)
(pop-to-buffer occur-buffer)))
-(defun vlfi-occur-visit (&optional event)
- "Visit current `vlfi-occur' link in a vlfi buffer.
-If original VLFI buffer has been killed,
-open new VLFI session each time.
+(defun vlf-occur-visit (&optional event)
+ "Visit current `vlf-occur' link in a vlf buffer.
+If original VLF buffer has been killed,
+open new VLF session each time.
EVENT may hold details of the invocation."
(interactive (list last-nonmenu-event))
(when event
@@ -604,68 +606,68 @@ EVENT may hold details of the invocation."
pos-relative)))
(or (buffer-live-p buffer)
(let ((occur-buffer (current-buffer)))
- (setq buffer (vlfi file))
+ (setq buffer (vlf file))
(switch-to-buffer occur-buffer)))
(pop-to-buffer buffer)
(if (buffer-modified-p)
- (cond ((and (= vlfi-start-pos chunk-start)
- (= vlfi-end-pos chunk-end))
+ (cond ((and (= vlf-start-pos chunk-start)
+ (= vlf-end-pos chunk-end))
(goto-char match-pos))
- ((y-or-n-p "VLFI buffer has been modified. \
+ ((y-or-n-p "VLF buffer has been modified. \
Really jump to new chunk? ")
- (vlfi-move-to-chunk chunk-start chunk-end)
+ (vlf-move-to-chunk chunk-start chunk-end)
(goto-char match-pos)))
- (vlfi-move-to-chunk chunk-start chunk-end)
+ (vlf-move-to-chunk chunk-start chunk-end)
(goto-char match-pos))))))
-(defun vlfi-occur (regexp)
+(defun vlf-occur (regexp)
"Make whole file occur style index for REGEXP.
Prematurely ending indexing will still show what's found so far."
(interactive (list (read-regexp "List lines matching regexp"
(if regexp-history
(car regexp-history)))))
- (let ((start-pos vlfi-start-pos)
- (end-pos vlfi-end-pos)
+ (let ((start-pos vlf-start-pos)
+ (end-pos vlf-end-pos)
(pos (point)))
- (vlfi-beginning-of-file)
+ (vlf-beginning-of-file)
(goto-char (point-min))
- (unwind-protect (vlfi-build-occur regexp)
- (vlfi-move-to-chunk start-pos end-pos)
+ (unwind-protect (vlf-build-occur regexp)
+ (vlf-move-to-chunk start-pos end-pos)
(goto-char pos))))
-(defun vlfi-build-occur (regexp)
+(defun vlf-build-occur (regexp)
"Build occur style index for REGEXP."
(let ((line 1)
(last-match-line 0)
(last-line-pos (point-min))
(file buffer-file-name)
(total-matches 0)
- (match-end-pos (+ vlfi-start-pos (position-bytes (point))))
+ (match-end-pos (+ vlf-start-pos (position-bytes (point))))
(occur-buffer (generate-new-buffer
- (concat "*VLFI-occur " (file-name-nondirectory
+ (concat "*VLF-occur " (file-name-nondirectory
buffer-file-name)
"*")))
(line-regexp (concat "\\(?5:[\n\C-m]\\)\\|\\(?10:"
regexp "\\)"))
- (batch-step (/ vlfi-batch-size 8))
+ (batch-step (/ vlf-batch-size 8))
(end-of-file nil)
(reporter (make-progress-reporter
(concat "Building index for " regexp "...")
- vlfi-start-pos vlfi-file-size)))
+ vlf-start-pos vlf-file-size)))
(unwind-protect
(progn
(while (not end-of-file)
(if (re-search-forward line-regexp nil t)
(progn
- (setq match-end-pos (+ vlfi-start-pos
+ (setq match-end-pos (+ vlf-start-pos
(position-bytes
(match-end 0))))
(if (match-string 5)
(setq line (1+ line) ; line detected
last-line-pos (point))
- (let* ((chunk-start vlfi-start-pos)
- (chunk-end vlfi-end-pos)
- (vlfi-buffer (current-buffer))
+ (let* ((chunk-start vlf-start-pos)
+ (chunk-end vlf-end-pos)
+ (vlf-buffer (current-buffer))
(line-pos (line-beginning-position))
(line-text (buffer-substring
line-pos (line-end-position))))
@@ -682,7 +684,7 @@ Prematurely ending indexing will still show what's found so
far."
'face 'shadow)))
(insert (propertize line-text ; insert line
'file file
- 'buffer vlfi-buffer
+ 'buffer vlf-buffer
'chunk-start chunk-start
'chunk-end chunk-end
'mouse-face '(highlight)
@@ -703,20 +705,20 @@ Prematurely ending indexing will still show what's found
so far."
'help-echo
(format "Move to match %d"
total-matches))))))))
- (setq end-of-file (= vlfi-end-pos vlfi-file-size))
+ (setq end-of-file (= vlf-end-pos vlf-file-size))
(unless end-of-file
- (let ((batch-move (- vlfi-end-pos batch-step)))
- (vlfi-move-to-batch (if (< batch-move match-end-pos)
+ (let ((batch-move (- vlf-end-pos batch-step)))
+ (vlf-move-to-batch (if (< batch-move match-end-pos)
match-end-pos
batch-move) t))
- (goto-char (if (< vlfi-start-pos match-end-pos)
+ (goto-char (if (< vlf-start-pos match-end-pos)
(or (byte-to-position (- match-end-pos
- vlfi-start-pos))
+ vlf-start-pos))
(point-min))
(point-min)))
(setq last-match-line 0
last-line-pos (line-beginning-position))
- (progress-reporter-update reporter vlfi-end-pos))))
+ (progress-reporter-update reporter vlf-end-pos))))
(progress-reporter-done reporter))
(if (zerop total-matches)
(progn (with-current-buffer occur-buffer
@@ -731,41 +733,41 @@ in file: %s" total-matches line regexp file)
'face 'underline))
(set-buffer-modified-p nil)
(forward-char 2)
- (vlfi-occur-mode))
+ (vlf-occur-mode))
(display-buffer occur-buffer)))))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; editing
-(defvar vlfi-edit-mode-map
+(defvar vlf-edit-mode-map
(let ((map (make-sparse-keymap)))
(set-keymap-parent map text-mode-map)
- (define-key map "\C-c\C-c" 'vlfi-write)
- (define-key map "\C-c\C-q" 'vlfi-discard-edit)
- (define-key map "\C-v" vlfi-mode-map)
+ (define-key map "\C-c\C-c" 'vlf-write)
+ (define-key map "\C-c\C-q" 'vlf-discard-edit)
+ (define-key map "\C-v" vlf-mode-map)
map)
- "Keymap for command `vlfi-edit-mode'.")
+ "Keymap for command `vlf-edit-mode'.")
-(define-derived-mode vlfi-edit-mode vlfi-mode "VLFI[edit]"
+(define-derived-mode vlf-edit-mode vlf-mode "VLF[edit]"
"Major mode for editing large file chunks."
(setq buffer-read-only nil)
(buffer-enable-undo)
(message (substitute-command-keys
- "Editing: Type \\[vlfi-write] to write chunk \
-or \\[vlfi-discard-edit] to discard changes.")))
+ "Editing: Type \\[vlf-write] to write chunk \
+or \\[vlf-discard-edit] to discard changes.")))
-(defun vlfi-discard-edit ()
+(defun vlf-discard-edit ()
"Discard edit and refresh chunk from file."
(interactive)
(set-buffer-modified-p nil)
- (vlfi-move-to-chunk vlfi-start-pos vlfi-end-pos)
- (vlfi-mode)
- (message "Switched to VLFI mode."))
+ (vlf-move-to-chunk vlf-start-pos vlf-end-pos)
+ (vlf-mode)
+ (message "Switched to VLF mode."))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; saving
-(defun vlfi-write ()
+(defun vlf-write ()
"Write current chunk to file. Always return true to disable save.
If changing size of chunk, shift remaining file content."
(interactive)
@@ -774,89 +776,89 @@ If changing size of chunk, shift remaining file content."
(y-or-n-p "File has changed since visited or saved. \
Save anyway? ")))
(let ((pos (point))
- (size-change (- vlfi-encode-size
- (setq vlfi-encode-size
+ (size-change (- vlf-encode-size
+ (setq vlf-encode-size
(length (encode-coding-region
(point-min) (point-max)
buffer-file-coding-system
t))))))
(cond ((zerop size-change)
- (write-region nil nil buffer-file-name vlfi-start-pos t))
+ (write-region nil nil buffer-file-name vlf-start-pos t))
((< 0 size-change)
- (vlfi-file-shift-back size-change))
- (t (vlfi-file-shift-forward (- size-change))))
- (vlfi-move-to-chunk vlfi-start-pos vlfi-end-pos)
+ (vlf-file-shift-back size-change))
+ (t (vlf-file-shift-forward (- size-change))))
+ (vlf-move-to-chunk vlf-start-pos vlf-end-pos)
(goto-char pos))
- (vlfi-mode))
+ (vlf-mode))
t)
-(defun vlfi-file-shift-back (size-change)
+(defun vlf-file-shift-back (size-change)
"Shift file contents SIZE-CHANGE bytes back."
- (write-region nil nil buffer-file-name vlfi-start-pos t)
+ (write-region nil nil buffer-file-name vlf-start-pos t)
(buffer-disable-undo)
- (let ((read-start-pos vlfi-end-pos)
+ (let ((read-start-pos vlf-end-pos)
(coding-system-for-write 'no-conversion)
(reporter (make-progress-reporter "Adjusting file content..."
- vlfi-end-pos
- vlfi-file-size)))
- (while (vlfi-shift-batch read-start-pos (- read-start-pos
+ vlf-end-pos
+ vlf-file-size)))
+ (while (vlf-shift-batch read-start-pos (- read-start-pos
size-change))
- (setq read-start-pos (+ read-start-pos vlfi-batch-size))
+ (setq read-start-pos (+ read-start-pos vlf-batch-size))
(progress-reporter-update reporter read-start-pos))
;; pad end with space
(erase-buffer)
- (vlfi-verify-size)
+ (vlf-verify-size)
(insert-char 32 size-change)
- (write-region nil nil buffer-file-name (- vlfi-file-size
+ (write-region nil nil buffer-file-name (- vlf-file-size
size-change) t)
(progress-reporter-done reporter)))
-(defun vlfi-shift-batch (read-pos write-pos)
- "Read `vlfi-batch-size' bytes from READ-POS and write them \
+(defun vlf-shift-batch (read-pos write-pos)
+ "Read `vlf-batch-size' bytes from READ-POS and write them \
back at WRITE-POS. Return nil if EOF is reached, t otherwise."
(erase-buffer)
- (vlfi-verify-size)
- (let ((read-end (+ read-pos vlfi-batch-size)))
+ (vlf-verify-size)
+ (let ((read-end (+ read-pos vlf-batch-size)))
(insert-file-contents-literally buffer-file-name nil
read-pos
- (min vlfi-file-size read-end))
+ (min vlf-file-size read-end))
(write-region nil nil buffer-file-name write-pos 0)
- (< read-end vlfi-file-size)))
+ (< read-end vlf-file-size)))
-(defun vlfi-file-shift-forward (size-change)
+(defun vlf-file-shift-forward (size-change)
"Shift file contents SIZE-CHANGE bytes forward.
Done by saving content up front and then writing previous batch."
(buffer-disable-undo)
- (let ((size (+ vlfi-batch-size size-change))
- (read-pos vlfi-end-pos)
- (write-pos vlfi-start-pos)
+ (let ((size (+ vlf-batch-size size-change))
+ (read-pos vlf-end-pos)
+ (write-pos vlf-start-pos)
(reporter (make-progress-reporter "Adjusting file content..."
- vlfi-start-pos
- vlfi-file-size)))
- (when (vlfi-shift-batches size read-pos write-pos t)
+ vlf-start-pos
+ vlf-file-size)))
+ (when (vlf-shift-batches size read-pos write-pos t)
(setq write-pos (+ read-pos size-change)
read-pos (+ read-pos size))
(progress-reporter-update reporter write-pos)
(let ((coding-system-for-write 'no-conversion))
- (while (vlfi-shift-batches size read-pos write-pos nil)
+ (while (vlf-shift-batches size read-pos write-pos nil)
(setq write-pos (+ read-pos size-change)
read-pos (+ read-pos size))
(progress-reporter-update reporter write-pos))))
(progress-reporter-done reporter)))
-(defun vlfi-shift-batches (size read-pos write-pos hide-read)
+(defun vlf-shift-batches (size read-pos write-pos hide-read)
"Append SIZE bytes of file starting at READ-POS.
Then write initial buffer content to file at WRITE-POS.
If HIDE-READ is non nil, temporarily hide literal read content.
Return nil if EOF is reached, t otherwise."
- (vlfi-verify-size)
- (let ((read-more (< read-pos vlfi-file-size))
+ (vlf-verify-size)
+ (let ((read-more (< read-pos vlf-file-size))
(start-write-pos (point-min))
(end-write-pos (point-max)))
(when read-more
(goto-char end-write-pos)
(insert-file-contents-literally buffer-file-name nil read-pos
- (min vlfi-file-size (+ read-pos
+ (min vlf-file-size (+ read-pos
size))))
;; write
(if hide-read ; hide literal region if user has to choose encoding
@@ -867,6 +869,6 @@ Return nil if EOF is reached, t otherwise."
(if hide-read (widen))
read-more))
-(provide 'vlfi)
+(provide 'vlf)
-;;; vlfi.el ends here
+;;; vlf.el ends here
- [elpa] externals/vlf 616d676 114/310: Alters vlfi to respect the default-directory variable when opening, (continued)
- [elpa] externals/vlf 616d676 114/310: Alters vlfi to respect the default-directory variable when opening, Stefan Monnier, 2020/11/28
- [elpa] externals/vlf 3d652fe 103/310: Minor documentation fixes., Stefan Monnier, 2020/11/28
- [elpa] externals/vlf 4589c25 112/310: Return to current position after occur ending with quit., Stefan Monnier, 2020/11/28
- [elpa] externals/vlf ce9441f 120/310: Update info as VLFI is merging back to VLF. Bump version., Stefan Monnier, 2020/11/28
- [elpa] externals/vlf 7cb0474 122/310: Add forgotten vlfi-encode-size local variable creation., Stefan Monnier, 2020/11/28
- [elpa] externals/vlf 02a37c4 123/310: Merge branch 'master' into chunk-opt2, Stefan Monnier, 2020/11/28
- [elpa] externals/vlf 2d71996 125/310: Add end character shift when adjusting chunk. Apply partial chunk, Stefan Monnier, 2020/11/28
- [elpa] externals/vlf 737c1e9 126/310: Remove encode size bookkeeping., Stefan Monnier, 2020/11/28
- [elpa] externals/vlf d1b34dc 127/310: Add autoload cookie for `file-size-human-readable' not to break GNU, Stefan Monnier, 2020/11/28
- [elpa] externals/vlf 4c631bc 129/310: Rename vlfi.el to vlf.el., Stefan Monnier, 2020/11/28
- [elpa] externals/vlf 17c6612 130/310: Rename anything vlfi -> vlf.,
Stefan Monnier <=
- [elpa] externals/vlf bc68eed 131/310: Add dummy vlfi.el that urges move to the vlf package., Stefan Monnier, 2020/11/28
- [elpa] externals/vlf 025399a 133/310: Merge branch 'master' into keep-edit, Stefan Monnier, 2020/11/28
- [elpa] externals/vlf f34986a 142/310: Update README., Stefan Monnier, 2020/11/28
- [elpa] externals/vlf 931ca52 145/310: Stylistic refinements., Stefan Monnier, 2020/11/28
- [elpa] externals/vlf 2ac3e7d 146/310: Fix prematurely ending search/occur not to ask for modified buffer, Stefan Monnier, 2020/11/28
- [elpa] externals/vlf 0080991 154/310: Fix chunk end adjustment and save for trunk Emacs., Stefan Monnier, 2020/11/28
- [elpa] externals/vlf a3901b8 157/310: Fix deletion when moving to partially overlapping chunk and enable more, Stefan Monnier, 2020/11/28
- [elpa] externals/vlf 371c560 158/310: Bump version and remove warning - save is now reliable., Stefan Monnier, 2020/11/28
- [elpa] externals/vlf c68c34e 160/310: Add vlf-application customization which refines control over when, Stefan Monnier, 2020/11/28
- [elpa] externals/vlf a0cafa7 161/310: Explicitly offer vlf-prefix-map so user can easily define another prefix, Stefan Monnier, 2020/11/28