;;; tar-mode.el --- simple editing of tar files from GNU emacs
-;;; Copyright (C) 1990, 1991, 1993 Free Software Foundation, Inc.
+;;; Copyright (C) 1990, 1991, 1993, 1994 Free Software Foundation, Inc.
;; Author: Jamie Zawinski <jwz@lucid.com>
;; Created: 04 Apr 1990
;;; o Block files, sparse files, continuation files, and the various header
;;; types aren't editable. Actually I don't know that they work at all.
+;;; Rationale:
+
+;;; Why does tar-mode edit the file itself instead of using tar?
+
+;;; That means that you can edit tar files which you don't have room for
+;;; on your local disk.
+
+;;; I don't know about recent features in gnu tar, but old versions of tar
+;;; can't replace a file in the middle of a tar file with a new version.
+;;; Tar-mode can. I don't think tar can do things like chmod the subfiles.
+;;; An implementation which involved unpacking and repacking the file into
+;;; some scratch directory would be very wasteful, and wouldn't be able to
+;;; preserve the file owners.
+
;;; Code:
(defvar tar-anal-blocksize 20
(defconst tar-dmin-offset (+ tar-dmaj-offset 8))
(defconst tar-end-offset (+ tar-dmin-offset 8))
-(defun tokenize-tar-header-block (string)
+(defun tar-header-block-tokenize (string)
"Return a `tar-header' structure.
This is a list of name, mode, uid, gid, size,
write-date, checksum, link-type, and link-name."
(tar-dotimes (i L)
(if (or (< (aref string i) ?0)
(> (aref string i) ?7))
- (error "'%c' is not an octal digit."))))
+ (error "'%c' is not an octal digit"))))
(tar-parse-octal-integer string))
-(defun checksum-tar-header-block (string)
+(defun tar-header-block-checksum (string)
"Compute and return a tar-acceptable checksum for this block."
(let* ((chk-field-start tar-chk-offset)
(chk-field-end (+ chk-field-start 8))
i (1+ i)))
(+ sum (* 32 8))))
-(defun check-tar-header-block-checksum (hblock desired-checksum file-name)
+(defun tar-header-block-check-checksum (hblock desired-checksum file-name)
"Beep and print a warning if the checksum doesn't match."
- (if (not (= desired-checksum (checksum-tar-header-block hblock)))
+ (if (not (= desired-checksum (tar-header-block-checksum hblock)))
(progn (beep) (message "Invalid checksum for file %s!" file-name))))
-(defun recompute-tar-header-block-checksum (hblock)
+(defun tar-header-block-recompute-checksum (hblock)
"Modifies the given string to have a valid checksum field."
- (let* ((chk (checksum-tar-header-block hblock))
+ (let* ((chk (tar-header-block-checksum hblock))
(chk-string (format "%6o" chk))
(l (length chk-string)))
(aset hblock 154 0)
(if (zerop (logand 2048 mode)) nil (aset string (+ start 5) ?s))
string)
-(defun summarize-tar-header-block (tar-hblock &optional mod-p)
+(defun tar-header-block-summarize (tar-hblock &optional mod-p)
"Returns a line similar to the output of `tar -vtf'."
(let ((name (tar-header-name tar-hblock))
(mode (tar-header-mode tar-hblock))
(progn
(tar-dotimes (i 3) (aset string (+ namestart 1 (length name) i) (aref (if (= link-p 1) "==>" "-->") i)))
(tar-dotimes (i (length link-name)) (aset string (+ namestart 5 (length name) i) (aref link-name i)))))
+ (put-text-property namestart (length string)
+ 'mouse-face 'highlight string)
string)))
(tokens nil))
(while (not (eq tokens 'empty-tar-block))
(let* ((hblock (buffer-substring pos (+ pos 512))))
- (setq tokens (tokenize-tar-header-block hblock))
+ (setq tokens (tar-header-block-tokenize hblock))
(setq pos (+ pos 512))
(message "parsing tar file...%s%%"
;(/ (* pos 100) bs) ; this gets round-off lossage
)
(if (eq tokens 'empty-tar-block)
nil
- (if (null tokens) (error "premature EOF parsing tar file."))
+ (if (null tokens) (error "premature EOF parsing tar file"))
(if (eq (tar-header-link-type tokens) 20)
;; Foo. There's an extra empty block after these.
(setq pos (+ pos 512)))
(let ((size (tar-header-size tokens)))
(if (< size 0)
- (error "%s has size %s - corrupted."
+ (error "%s has size %s - corrupted"
(tar-header-name tokens) size))
;
; This is just too slow. Don't really need it anyway....
- ;(check-tar-header-block-checksum
- ; hblock (checksum-tar-header-block hblock)
+ ;(tar-header-block-check-checksum
+ ; hblock (tar-header-block-checksum hblock)
; (tar-header-name tokens))
(setq result (cons (make-tar-desc pos tokens) result))
(let ((buffer-read-only nil))
(tar-dolist (tar-desc tar-parse-info)
(insert-string
- (summarize-tar-header-block (tar-desc-tokens tar-desc)))
+ (tar-header-block-summarize (tar-desc-tokens tar-desc)))
(insert-string "\n"))
(make-local-variable 'tar-header-offset)
(setq tar-header-offset (point))
(set-buffer-modified-p nil)))
(message "parsing tar file...done."))
\f
-(defvar tar-mode-map nil "*Local keymap for tar-mode listings.")
+(defvar tar-mode-map nil "*Local keymap for Tar mode listings.")
(if tar-mode-map
nil
(define-key tar-mode-map "\^D" 'tar-flag-deleted)
(define-key tar-mode-map "e" 'tar-extract)
(define-key tar-mode-map "f" 'tar-extract)
+ (define-key tar-mode-map [mouse-2] 'tar-mouse-extract)
(define-key tar-mode-map "g" 'revert-buffer)
(define-key tar-mode-map "h" 'describe-mode)
(define-key tar-mode-map "n" 'tar-next-line)
"Major mode for viewing a tar file as a dired-like listing of its contents.
You can move around using the usual cursor motion commands.
Letters no longer insert themselves.
-Type `e' to pull a file out of the tar file and into its own buffer.
+Type `e' to pull a file out of the tar file and into its own buffer;
+or click mouse-2 on the file's line in the Tar mode buffer.
Type `c' to copy an entry from the tar file into another file on disk.
If you edit a sub-file of this archive (as with the `e' command) and
(interactive "P")
(or (and (boundp 'tar-superior-buffer) tar-superior-buffer)
(error "This buffer is not an element of a tar file"))
- (or (assq 'tar-subfile-mode minor-mode-alist)
- (setq minor-mode-alist (append minor-mode-alist
- (list '(tar-subfile-mode
- " TarFile")))))
+;;; Don't do this, because it is redundant and wastes mode line space.
+;;; (or (assq 'tar-subfile-mode minor-mode-alist)
+;;; (setq minor-mode-alist (append minor-mode-alist
+;;; (list '(tar-subfile-mode " TarFile")))))
(make-local-variable 'tar-subfile-mode)
(setq tar-subfile-mode
(if (null p)
tar-parse-info)
(if noerror
nil
- (error "This line does not describe a tar-file entry."))))
-
+ (error "This line does not describe a tar-file entry"))))
-(defun tar-extract (&optional other-window-p)
- "*In Tar mode, extract this entry of the tar file into its own buffer."
- (interactive)
- (let* ((view-p (eq other-window-p 'view))
- (descriptor (tar-current-descriptor))
+(defun tar-get-descriptor ()
+ (let* ((descriptor (tar-current-descriptor))
(tokens (tar-desc-tokens descriptor))
- (name (tar-header-name tokens))
(size (tar-header-size tokens))
- (link-p (tar-header-link-type tokens))
- (start (+ (tar-desc-data-start descriptor) tar-header-offset -1))
- (end (+ start size)))
+ (link-p (tar-header-link-type tokens)))
(if link-p
- (error "This is a %s, not a real file."
+ (error "This is a %s, not a real file"
(cond ((eq link-p 5) "directory")
((eq link-p 20) "tar directory header")
((eq link-p 29) "multivolume-continuation")
((eq link-p 35) "sparse entry")
((eq link-p 38) "volume header")
(t "link"))))
- (if (zerop size) (error "This is a zero-length file."))
+ (if (zerop size) (error "This is a zero-length file"))
+ descriptor))
+
+(defun tar-mouse-extract (event)
+ "Extract a file whose tar directory line you click on."
+ (interactive "e")
+ (save-excursion
+ (set-buffer (window-buffer (posn-window (event-end event))))
+ (save-excursion
+ (goto-char (posn-point (event-end event)))
+ ;; Just make sure this doesn't get an error.
+ (tar-get-descriptor)))
+ (select-window (posn-window (event-end event)))
+ (goto-char (posn-point (event-end event)))
+ (tar-extract))
+
+(defun tar-extract (&optional other-window-p)
+ "In Tar mode, extract this entry of the tar file into its own buffer."
+ (interactive)
+ (let* ((view-p (eq other-window-p 'view))
+ (descriptor (tar-get-descriptor))
+ (tokens (tar-desc-tokens descriptor))
+ (name (tar-header-name tokens))
+ (size (tar-header-size tokens))
+ (start (+ (tar-desc-data-start descriptor) tar-header-offset -1))
+ (end (+ start size)))
(let* ((tar-buffer (current-buffer))
+ (tarname (file-name-nondirectory (buffer-file-name)))
(bufname (concat (file-name-nondirectory name)
- " (" name " in "
- (file-name-nondirectory (buffer-file-name))
+ " ("
+ tarname
")"))
(read-only-p (or buffer-read-only view-p))
(buffer (get-buffer bufname))
(set-buffer buffer)
(insert-buffer-substring tar-buffer start end)
(goto-char 0)
- (set-visited-file-name name) ; give it a name to decide mode.
+ ;; Give it a name for list-buffers and to decide mode.
+ ;; Set buffer-file-name by hand first
+ ;; so that set-visited-file-name won't lock the filename.
+ (setq buffer-file-name
+ (expand-file-name (concat tarname ":" name)))
+ (set-visited-file-name buffer-file-name)
(normal-mode) ; pick a mode.
- (set-visited-file-name nil) ; nuke the name - not meaningful.
+;;; Without a file name, save-buffer doesn't work.
+;;; (set-visited-file-name nil) ; nuke the name - not meaningful.
(rename-buffer bufname)
(make-local-variable 'tar-superior-buffer)
(make-local-variable 'tar-superior-descriptor)
(setq tar-superior-buffer tar-buffer)
(setq tar-superior-descriptor descriptor)
+
(tar-subfile-mode 1)
(setq buffer-read-only read-only-p)
If TO-FILE is not supplied, it is prompted for, defaulting to the name of
the current tar-entry."
(interactive (list (tar-read-file-name)))
- (let* ((descriptor (tar-current-descriptor))
+ (let* ((descriptor (tar-get-descriptor))
(tokens (tar-desc-tokens descriptor))
(name (tar-header-name tokens))
(size (tar-header-size tokens))
- (link-p (tar-header-link-type tokens))
(start (+ (tar-desc-data-start descriptor) tar-header-offset -1))
(end (+ start size)))
- (if link-p (error "This is a link, not a real file."))
- (if (zerop size) (error "This is a zero-length file."))
- (let* ((tar-buffer (current-buffer))
- buffer)
- (unwind-protect
- (progn
- (setq buffer (generate-new-buffer "*tar-copy-tmp*"))
- (widen)
- (save-excursion
- (set-buffer buffer)
- (insert-buffer-substring tar-buffer start end)
- (set-buffer-modified-p nil) ; in case we abort
- (write-file to-file)
- (message "Copied tar entry %s to %s" name to-file)
- (set-buffer tar-buffer)))
- (narrow-to-region 1 tar-header-offset)
- (if buffer (kill-buffer buffer)))
- )))
-
+ (save-restriction
+ (widen)
+ (write-region start end to-file))
+ (message "Copied tar entry %s to %s" name to-file)))
(defun tar-flag-deleted (p &optional unflag)
"*In Tar mode, mark this sub-file to be deleted from the tar file.
(interactive
(list (read-string "New name: "
(tar-header-name (tar-desc-tokens (tar-current-descriptor))))))
- (if (string= "" new-name) (error "zero length name."))
- (if (> (length new-name) 98) (error "name too long."))
+ (if (string= "" new-name) (error "zero length name"))
+ (if (> (length new-name) 98) (error "name too long"))
(tar-setf (tar-header-name (tar-desc-tokens (tar-current-descriptor)))
new-name)
(tar-alter-one-field 0
(let ((p (point)))
(forward-line 1)
(delete-region p (point))
- (insert (summarize-tar-header-block tokens) "\n")
+ (insert (tar-header-block-summarize tokens) "\n")
(setq tar-header-offset (point-max)))
(widen)
(insert new-data-string) ; <--
;;
;; compute a new checksum and insert it.
- (let ((chk (checksum-tar-header-block
+ (let ((chk (tar-header-block-checksum
(buffer-substring start (+ start 512)))))
(goto-char (+ start tar-chk-offset))
(delete-region (point) (+ (point) 8))
(tar-setf (tar-header-checksum tokens) chk)
;;
;; ok, make sure we didn't botch it.
- (check-tar-header-block-checksum
+ (tar-header-block-check-checksum
(buffer-substring start (+ start 512))
chk (tar-header-name tokens))
)))
to make your changes permanent."
(interactive)
(if (not (and (boundp 'tar-superior-buffer) tar-superior-buffer))
- (error "this buffer has no superior tar file buffer."))
+ (error "This buffer has no superior tar file buffer"))
(if (not (and (boundp 'tar-superior-descriptor) tar-superior-descriptor))
- (error "this buffer doesn't have an index into its superior tar file!"))
+ (error "This buffer doesn't have an index into its superior tar file!"))
(save-excursion
(let ((subfile (current-buffer))
(subfile-size (buffer-size))
(insert ? ))
;;
;; compute a new checksum and insert it.
- (let ((chk (checksum-tar-header-block
+ (let ((chk (tar-header-block-checksum
(buffer-substring header-start data-start))))
(goto-char (+ header-start tar-chk-offset))
(delete-region (point) (+ (point) 8))
(next-line position)
(beginning-of-line)
(let ((p (point))
+ after
(m (set-marker (make-marker) tar-header-offset)))
(forward-line 1)
- (delete-region p (point))
- (insert-before-markers (summarize-tar-header-block tokens t) "\n")
+ (setq after (point))
+ ;; Insert the new text after the old, before deleting,
+ ;; to preserve the window start.
+ (insert-before-markers (tar-header-block-summarize tokens t) "\n")
+ (delete-region p after)
(setq tar-header-offset (marker-position m)))
)))
;; after doing the insertion, add any final padding that may be necessary.
(set-buffer-modified-p t) ; mark the tar file as modified
(set-buffer subfile)
(set-buffer-modified-p nil) ; mark the tar subfile as unmodified
- (message "saved into tar-buffer \"%s\" - remember to save that buffer!"
+ (message "saved into tar-buffer `%s' -- remember to save that buffer!"
(buffer-name tar-superior-buffer))
;; Prevent ordinary saving from happening.
t)))
(data-end (+ start size))
(bbytes (ash tar-anal-blocksize 9))
(pad-to (+ bbytes (* bbytes (/ (1- data-end) bbytes))))
- (buffer-read-only nil) ; ##
+ (inhibit-read-only t) ; ##
)
;; If the padding after the last data is too long, delete some;
;; else insert some until we are padded out to the right number of blocks.
)))
-(defun maybe-write-tar-file ()
- "Used as a write-file-hook to write tar-files out correctly."
+;; Used in write-file-hook to write tar-files out correctly.
+(defun tar-mode-maybe-write-tar-file ()
;;
;; If the current buffer is in Tar mode and has its header-offset set,
;; only write out the part of the file after the header-offset.
\f
;;; Patch it in.
-(or (memq 'maybe-write-tar-file write-file-hooks)
+(or (memq 'tar-mode-maybe-write-tar-file write-file-hooks)
(setq write-file-hooks
- (cons 'maybe-write-tar-file write-file-hooks)))
+ (cons 'tar-mode-maybe-write-tar-file write-file-hooks)))
(provide 'tar-mode)
HCoop / bpt / emacs.git / blobdiff