;;; tar-mode.el --- simple editing of tar files from GNU emacs
-;; Copyright (C) 1990, 1991, 1993, 1994, 1995 Free Software Foundation, Inc.
+;; Copyright (C) 1990,91,93,94,95,96,97,98,99,2000,2001
+;; Free Software Foundation, Inc.
;; Author: Jamie Zawinski <jwz@lucid.com>
;; Maintainer: FSF
;; This code now understands the extra fields that GNU tar adds to tar files.
;; This interacts correctly with "uncompress.el" in the Emacs library,
-;; which you get with
+;; which you get with
;;
;; (autoload 'uncompress-while-visiting "uncompress")
;; (setq auto-mode-alist (cons '("\\.Z$" . uncompress-while-visiting)
;;
;; Do not attempt to use tar-mode.el with crypt.el, you will lose.
-;; *************** TO DO ***************
+;; *************** TO DO ***************
;;
;; o chmod should understand "a+x,og-w".
;;
-;; o It's not possible to add a NEW file to a tar archive; not that
+;; o It's not possible to add a NEW file to a tar archive; not that
;; important, but still...
;;
;; o The code is less efficient that it could be - in a lot of places, I
;; of an archive, where <esc> would leave you in a subfile-edit buffer.
;; (Like the Meta-R command of the Zmacs mail reader.)
;;
-;; o Sometimes (but not always) reverting the tar-file buffer does not
+;; o Sometimes (but not always) reverting the tar-file buffer does not
;; re-grind the listing, and you are staring at the binary tar data.
;; Typing 'g' again immediately after that will always revert and re-grind
;; it, though. I have no idea why this happens.
;; might be a problem if the tar write-file-hook does not come *first* on
;; the list.
;;
-;; o Block files, sparse files, continuation files, and the various header
+;; 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:
(defcustom tar-anal-blocksize 20
"*The blocksize of tar files written by Emacs, or nil, meaning don't care.
The blocksize of a tar file is not really the size of the blocks; rather, it is
-the number of blocks written with one system call. When tarring to a tape,
+the number of blocks written with one system call. When tarring to a tape,
this is the size of the *tape* blocks, but when writing to a file, it doesn't
matter much. The only noticeable difference is that if a tar file does not
have a blocksize of 20, tar will tell you that; all this really controls is
tar file will update its datestamp. If false, the datestamp is unchanged.
You may or may not want this - it is good in that you can tell when a file
in a tar archive has been changed, but it is bad for the same reason that
-editing a file in the tar archive at all is bad - the changed version of
+editing a file in the tar archive at all is bad - the changed version of
the file never exists on disk."
:type 'boolean
:group 'tar)
:group 'tar)
(defvar tar-parse-info nil)
-;; Be sure that this variable holds byte position, not char position.
(defvar tar-header-offset nil)
(defvar tar-superior-buffer nil)
(defvar tar-superior-descriptor nil)
(defvar tar-subfile-mode nil)
+(defvar tar-file-name-coding-system nil)
(put 'tar-parse-info 'permanent-local t)
(put 'tar-header-offset 'permanent-local t)
(put 'tar-superior-buffer 'permanent-local t)
(put 'tar-superior-descriptor 'permanent-local t)
+(put 'tar-file-name-coding-system 'permanent-local t)
\f
(defmacro tar-setf (form val)
"A mind-numbingly simple implementation of setf."
(defun tar-header-block-tokenize (string)
"Return a `tar-header' structure.
-This is a list of name, mode, uid, gid, size,
+This is a list of name, mode, uid, gid, size,
write-date, checksum, link-type, and link-name."
+ (setq string (string-as-unibyte string))
(cond ((< (length string) 512) nil)
(;(some 'plusp string) ; <-- oops, massive cycle hog!
(or (not (= 0 (aref string 0))) ; This will do.
(setq linkname (substring string tar-link-offset link-end))
(if default-enable-multibyte-characters
(setq name
- (decode-coding-string name (or file-name-coding-system
- 'undecided))
+ (decode-coding-string name tar-file-name-coding-system)
linkname
- (decode-coding-string linkname (or file-name-coding-system
- 'undecided))))
+ (decode-coding-string linkname
+ tar-file-name-coding-system)))
(if (and (null link-p) (string-match "/$" name)) (setq link-p 5)) ; directory
(make-tar-header
name
(defun tar-header-block-checksum (string)
"Compute and return a tar-acceptable checksum for this block."
+ (setq string (string-as-unibyte string))
(let* ((chk-field-start tar-chk-offset)
(chk-field-end (+ chk-field-start 8))
(sum 0)
(format "%c%c%s%8s/%-8s%7s%s %s%s"
(if mod-p ?* ? )
(cond ((or (eq type nil) (eq type 0)) ?-)
- ((eq type 1) ?l) ; link
- ((eq type 2) ?s) ; symlink
+ ((eq type 1) ?h) ; link
+ ((eq type 2) ?l) ; symlink
((eq type 3) ?c) ; char special
((eq type 4) ?b) ; block special
((eq type 5) ?d) ; directory
((eq type 6) ?p) ; FIFO/pipe
((eq type 20) ?*) ; directory listing
+ ((eq type 28) ?L) ; next has longname
((eq type 29) ?M) ; multivolume continuation
((eq type 35) ?S) ; sparse
((eq type 38) ?V) ; volume header
(if (= 0 (length gname)) gid gname)
size
(if tar-mode-show-date (tar-clip-time-string time) "")
- (propertize name 'mouse-face 'highlight)
+ (propertize name
+ 'mouse-face 'highlight
+ 'help-echo "mouse-2: extract this file into a buffer")
(if (or (eq type 1) (eq type 2))
(concat (if (= type 1) " ==> " " --> ") link-name)
""))))
+(defun tar-untar-buffer ()
+ "Extract all archive members in the tar-file into the current directory."
+ (interactive)
+ (let ((multibyte enable-multibyte-characters))
+ (unwind-protect
+ (save-restriction
+ (widen)
+ (set-buffer-multibyte nil)
+ (dolist (descriptor tar-parse-info)
+ (let* ((tokens (tar-desc-tokens descriptor))
+ (name (tar-header-name tokens))
+ (dir (file-name-directory name))
+ (start (+ (tar-desc-data-start descriptor)
+ (- tar-header-offset (point-min))))
+ (end (+ start (tar-header-size tokens))))
+ (unless (file-directory-p name)
+ (message "Extracting %s" name)
+ (if (and dir (not (file-exists-p dir)))
+ (make-directory dir t))
+ (unless (file-directory-p name)
+ (write-region start end name))
+ (set-file-modes name (tar-header-mode tokens))))))
+ (set-buffer-multibyte multibyte))))
+
(defun tar-summarize-buffer ()
"Parse the contents of the tar file in the current buffer.
Place a dired-like listing on the front;
then narrow to it, so that only that listing
is visible (and the real data of the buffer is hidden)."
- (set-buffer-multibyte nil)
(message "Parsing tar file...")
(let* ((result '())
- (pos 1)
+ (pos (point-min))
(bs (max 1 (- (buffer-size) 1024))) ; always 2+ empty blocks at end.
(bs100 (max 1 (/ bs 100)))
tokens)
(cons "\n"
summaries))))
(let ((total-summaries (apply 'concat summaries)))
- (if (multibyte-string-p total-summaries)
- (set-buffer-multibyte t))
(insert total-summaries))
(make-local-variable 'tar-header-offset)
(setq tar-header-offset (point))
- (narrow-to-region 1 tar-header-offset)
- (if enable-multibyte-characters
- (setq tar-header-offset (position-bytes tar-header-offset)))
+ (narrow-to-region (point-min) tar-header-offset)
(set-buffer-modified-p nil))))
\f
(defvar tar-mode-map nil "*Local keymap for Tar mode listings.")
(put 'tar-subfile-mode 'mode-class 'special)
;;;###autoload
-(defun tar-mode ()
+(define-derived-mode tar-mode nil "Tar"
"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.
+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;
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
-save it with Control-x Control-s, the contents of that buffer will be
-saved back into the tar-file buffer; in this way you can edit a file
+If you edit a sub-file of this archive (as with the `e' command) and
+save it with Control-x Control-s, the contents of that buffer will be
+saved back into the tar-file buffer; in this way you can edit a file
inside of a tar archive without extracting it and re-archiving it.
See also: variables `tar-update-datestamp' and `tar-anal-blocksize'.
;; mode on and off. You can corrupt things that way.
;; rms: with permanent locals, it should now be possible to make this work
;; interactively in some reasonable fashion.
- (kill-all-local-variables)
(make-local-variable 'tar-header-offset)
(make-local-variable 'tar-parse-info)
- (make-local-variable 'require-final-newline)
- (setq require-final-newline nil) ; binary data, dude...
- (make-local-variable 'revert-buffer-function)
- (setq revert-buffer-function 'tar-mode-revert)
- (make-local-variable 'local-enable-local-variables)
- (setq local-enable-local-variables nil)
- (make-local-variable 'next-line-add-newlines)
- (setq next-line-add-newlines nil)
+ (set (make-local-variable 'require-final-newline) nil) ; binary data, dude...
+ (set (make-local-variable 'revert-buffer-function) 'tar-mode-revert)
+ (set (make-local-variable 'local-enable-local-variables) nil)
+ (set (make-local-variable 'next-line-add-newlines) nil)
+ (set (make-local-variable 'tar-file-name-coding-system)
+ (or file-name-coding-system
+ default-file-name-coding-system
+ locale-coding-system))
;; Prevent loss of data when saving the file.
- (make-local-variable 'file-precious-flag)
- (setq file-precious-flag t)
- (setq major-mode 'tar-mode)
- (setq mode-name "Tar")
- (use-local-map tar-mode-map)
+ (set (make-local-variable 'file-precious-flag) t)
(auto-save-mode 0)
- (make-local-variable 'write-contents-hooks)
- (setq write-contents-hooks '(tar-mode-write-file))
+ (set (make-local-variable 'write-contents-hooks) '(tar-mode-write-file))
(widen)
(if (and (boundp 'tar-header-offset) tar-header-offset)
- (narrow-to-region 1 (byte-to-position tar-header-offset))
- (tar-summarize-buffer)
- (tar-next-line 0))
- (run-hooks 'tar-mode-hook)
- )
+ (narrow-to-region (point-min) tar-header-offset)
+ (tar-summarize-buffer)
+ (tar-next-line 0)))
(defun tar-subfile-mode (p)
(interactive "P")
(or (and (boundp 'tar-superior-buffer) tar-superior-buffer)
(error "This buffer is not an element of a tar file"))
-;;; 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")))))
+ ;; 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)
(not tar-subfile-mode)
(> (prefix-numeric-value p) 0)))
(cond (tar-subfile-mode
- (make-local-variable 'local-write-file-hooks)
- (setq local-write-file-hooks '(tar-subfile-save-buffer))
+ (add-hook 'write-file-functions 'tar-subfile-save-buffer nil t)
;; turn off auto-save.
(auto-save-mode -1)
(setq buffer-auto-save-file-name nil)
(run-hooks 'tar-subfile-mode-hook))
(t
- (kill-local-variable 'local-write-file-hooks))))
+ (remove-hook 'write-file-functions 'tar-subfile-save-buffer t))))
;; Revert the buffer and recompute the dired-like listing.
(setq tar-header-offset old-offset)))))
-(defun tar-next-line (p)
+(defun tar-next-line (arg)
+ "Move cursor vertically down ARG lines and to the start of the filename."
(interactive "p")
- (forward-line p)
+ (forward-line arg)
(if (eobp) nil (forward-char (if tar-mode-show-date 54 36))))
-(defun tar-previous-line (p)
+(defun tar-previous-line (arg)
+ "Move cursor vertically up ARG lines and to the start of the filename."
(interactive "p")
- (tar-next-line (- p)))
+ (tar-next-line (- arg)))
(defun tar-current-descriptor (&optional noerror)
"Return the tar-descriptor of the current line, or signals an error."
(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 28) "next has longname")
((eq link-p 29) "multivolume-continuation")
((eq link-p 35) "sparse entry")
((eq link-p 38) "volume header")
(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))
+ (start (+ (tar-desc-data-start descriptor)
+ (- tar-header-offset (point-min))))
(end (+ start size)))
(let* ((tar-buffer (current-buffer))
- (tar-buffer-multibyte enable-multibyte-characters)
(tarname (buffer-name))
- (bufname (generate-new-buffer-name
- (concat (file-name-nondirectory name)
- " ("
+ (bufname (concat (file-name-nondirectory name)
+ " ("
tarname
- ")")))
+ ")"))
(read-only-p (or buffer-read-only view-p))
- (buffer (get-buffer bufname))
- (just-created nil)
(new-buffer-file-name (expand-file-name
;; `:' is not allowed on Windows
- (concat tarname "!" name))))
- (if (and buffer
- ;; Check that the buffer is visiting the same file
- (equal (buffer-file-name buffer) new-buffer-file-name))
- nil
+ (concat tarname "!" name)))
+ (buffer (get-file-buffer new-buffer-file-name))
+ (just-created nil)
+ (pos (point)))
+ (unless buffer
(setq buffer (generate-new-buffer bufname))
(setq bufname (buffer-name buffer))
(setq just-created t)
(unwind-protect
- (progn
+ (let (coding)
+ (narrow-to-region start end)
+ (goto-char start)
+ (setq coding (or coding-system-for-read
+ (and set-auto-coding-function
+ (funcall set-auto-coding-function
+ name (- end start)))))
+ (if (or (not coding)
+ (eq (coding-system-type coding) 'undecided))
+ (setq coding (detect-coding-region start end t)))
+ (if (and default-enable-multibyte-characters
+ (coding-system-get coding :for-unibyte))
+ (save-excursion
+ (set-buffer buffer)
+ (set-buffer-multibyte nil)))
(widen)
- (set-buffer-multibyte nil)
+ (decode-coding-region start end coding buffer)
(save-excursion
(set-buffer buffer)
- (if enable-multibyte-characters
- (progn
- ;; We must avoid unibyte->multibyte conversion.
- (set-buffer-multibyte nil)
- (insert-buffer-substring tar-buffer start end)
- (set-buffer-multibyte t))
- (insert-buffer-substring tar-buffer start end))
(goto-char (point-min))
(setq buffer-file-name new-buffer-file-name)
(setq buffer-file-truename
(abbreviate-file-name buffer-file-name))
- ;; We need to mimic the parts of insert-file-contents
- ;; which determine the coding-system and decode the text.
- (let ((coding
- (or coding-system-for-read
- (and set-auto-coding-function
- (save-excursion
- (funcall set-auto-coding-function
- name (- (point-max) (point)))))))
- (multibyte enable-multibyte-characters)
- (detected (detect-coding-region
- 1 (min 16384 (point-max)) t)))
- (if coding
- (or (numberp (coding-system-eol-type coding))
- (setq coding (coding-system-change-eol-conversion
- coding
- (coding-system-eol-type detected))))
- (setq coding
- (or (find-new-buffer-file-coding-system detected)
- (let ((file-coding
- (find-operation-coding-system
- 'insert-file-contents buffer-file-name)))
- (if (consp file-coding)
- (setq file-coding (car file-coding))
- file-coding)))))
- (if (or (eq coding 'no-conversion)
- (eq (coding-system-type coding) 5))
- (setq multibyte (set-buffer-multibyte nil)))
- (or multibyte
- (setq coding
- (coding-system-change-text-conversion
- coding 'raw-text)))
- (decode-coding-region 1 (point-max) coding)
- (set-buffer-file-coding-system coding))
+ (set-buffer-file-coding-system coding)
;; Set the default-directory to the dir of the
- ;; superior buffer.
+ ;; superior buffer.
(setq default-directory
(save-excursion
(set-buffer tar-buffer)
(make-local-variable 'tar-superior-descriptor)
(setq tar-superior-buffer tar-buffer)
(setq tar-superior-descriptor descriptor)
- (setq buffer-read-only read-only-p)
+ (setq buffer-read-only read-only-p)
(set-buffer-modified-p nil)
(tar-subfile-mode 1))
(set-buffer tar-buffer))
- (narrow-to-region 1 tar-header-offset)
- (set-buffer-multibyte tar-buffer-multibyte)))
+ (narrow-to-region (point-min) tar-header-offset)
+ (goto-char pos)))
(if view-p
(view-buffer buffer (and just-created 'kill-buffer))
(if (eq other-window-p 'display)
(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))
+ (start (+ (tar-desc-data-start descriptor)
+ (- tar-header-offset (point-min))))
(end (+ start size))
- (multibyte enable-multibyte-characters)
(inhibit-file-name-handlers inhibit-file-name-handlers)
(inhibit-file-name-operation inhibit-file-name-operation))
(save-restriction
(and (eq inhibit-file-name-operation 'write-region)
inhibit-file-name-handlers))
inhibit-file-name-operation 'write-region))
- (unwind-protect
- (let ((coding-system-for-write 'no-conversion))
- (set-buffer-multibyte nil)
- (write-region start end to-file nil nil nil t))
- (set-buffer-multibyte multibyte)))
+ (let ((coding-system-for-write 'no-conversion))
+ (write-region start end to-file nil nil nil t)))
(message "Copied tar entry %s to %s" name to-file)))
(defun tar-flag-deleted (p &optional unflag)
(tar-flag-deleted (- p) t))
-;; When this function is called, it is sure that the buffer is unibyte.
(defun tar-expunge-internal ()
"Expunge the tar-entry specified by the current line."
(let* ((descriptor (tar-current-descriptor))
(tar-setf (tar-desc-data-start desc)
(- (tar-desc-data-start desc) data-length))))
))
- (narrow-to-region 1 tar-header-offset))
+ (narrow-to-region (point-min) tar-header-offset))
(defun tar-expunge (&optional noconfirm)
(interactive)
(if (or noconfirm
(y-or-n-p "Expunge files marked for deletion? "))
- (let ((n 0)
- (multibyte enable-multibyte-characters))
- (set-buffer-multibyte nil)
+ (let ((n 0))
(save-excursion
(goto-char (point-min))
(while (not (eobp))
(forward-line 1)))
;; after doing the deletions, add any padding that may be necessary.
(tar-pad-to-blocksize)
- (narrow-to-region 1 tar-header-offset))
- (set-buffer-multibyte multibyte)
+ (narrow-to-region (point-min) tar-header-offset))
(if (zerop n)
(message "Nothing to expunge.")
(message "%s files expunged. Be sure to save this buffer." n)))))
(interactive)
(save-excursion
(goto-char (point-min))
- (while (< (position-bytes (point)) tar-header-offset)
+ (while (< (point) tar-header-offset)
(if (not (eq (following-char) ?\ ))
(progn (delete-char 1) (insert " ")))
(forward-line 1))))
(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"))
- (tar-setf (tar-header-name (tar-desc-tokens (tar-current-descriptor)))
- new-name)
- (tar-alter-one-field 0
- (substring (concat new-name (make-string 99 0)) 0 99)))
+ (let ((encoded-new-name (encode-coding-string new-name
+ tar-file-name-coding-system)))
+ (if (> (length encoded-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
+ (substring (concat encoded-new-name (make-string 99 0)) 0 99))))
(defun tar-chmod-entry (new-mode)
(defun tar-alter-one-field (data-position new-data-string)
(let* ((descriptor (tar-current-descriptor))
- (tokens (tar-desc-tokens descriptor))
- (multibyte enable-multibyte-characters))
+ (tokens (tar-desc-tokens descriptor)))
(unwind-protect
(save-excursion
;;
(forward-line 1)
(delete-region p (point))
(insert (tar-header-block-summarize tokens) "\n")
- (setq tar-header-offset (position-bytes (point-max))))
-
+ (setq tar-header-offset (point-max)))
+
(widen)
- (set-buffer-multibyte nil)
(let* ((start (+ (tar-desc-data-start descriptor) tar-header-offset -513)))
;;
;; delete the old field and insert a new one.
(goto-char (+ start data-position))
(delete-region (point) (+ (point) (length new-data-string))) ; <--
- (insert new-data-string) ; <--
+
+ ;; As new-data-string is unibyte, just inserting it will
+ ;; make eight-bit chars to the corresponding multibyte
+ ;; chars. This avoid that conversion, i.e., eight-bit
+ ;; chars are converted to multibyte form of eight-bit
+ ;; chars.
+ (insert (string-to-multibyte new-data-string))
;;
;; compute a new checksum and insert it.
(let ((chk (tar-header-block-checksum
(buffer-substring start (+ start 512))
chk (tar-header-name tokens))
)))
- (narrow-to-region 1 tar-header-offset)
- (set-buffer-multibyte multibyte)
+ (narrow-to-region (point-min) tar-header-offset)
(tar-next-line 0))))
(defun tar-octal-time (timeval)
;; Format a timestamp as 11 octal digits. Ghod, I hope this works...
(let ((hibits (car timeval)) (lobits (car (cdr timeval))))
- (insert (format "%05o%01o%05o"
- (lsh hibits -2)
- (logior (lsh (logand 3 hibits) 1) (> (logand lobits 32768) 0))
- (logand 32767 lobits)
- ))))
+ (format "%05o%01o%05o"
+ (lsh hibits -2)
+ (logior (lsh (logand 3 hibits) 1)
+ (if (> (logand lobits 32768) 0) 1 0))
+ (logand 32767 lobits)
+ )))
(defun tar-subfile-save-buffer ()
"In tar subfile mode, save this buffer into its parent tar-file buffer.
(error "This buffer doesn't have an index into its superior tar file!"))
(save-excursion
(let ((subfile (current-buffer))
- (subfile-multibyte enable-multibyte-characters)
(coding buffer-file-coding-system)
(descriptor tar-superior-descriptor)
subfile-size)
- ;; We must make the current buffer unibyte temporarily to avoid
- ;; multibyte->unibyte conversion in `insert-buffer'.
- (set-buffer-multibyte nil)
- (setq subfile-size (buffer-size))
(set-buffer tar-superior-buffer)
(let* ((tokens (tar-desc-tokens descriptor))
(start (tar-desc-data-start descriptor))
(size (tar-header-size tokens))
(size-pad (ash (ash (+ size 511) -9) 9))
(head (memq descriptor tar-parse-info))
- (following-descs (cdr head))
- (tar-buffer-multibyte enable-multibyte-characters))
+ (following-descs (cdr head)))
(if (not head)
(error "Can't find this tar file entry in its parent tar file!"))
(unwind-protect
(save-excursion
- (widen)
- (set-buffer-multibyte nil)
;; delete the old data...
- (let* ((data-start (+ start tar-header-offset -1))
+ (let* ((data-start (+ start (- tar-header-offset (point-min))))
(data-end (+ data-start (ash (ash (+ size 511) -9) 9))))
- (delete-region data-start data-end)
+ (narrow-to-region data-start data-end)
+ (delete-region (point-min) (point-max))
;; insert the new data...
(goto-char data-start)
- (insert-buffer subfile)
- (setq subfile-size
- (encode-coding-region
- data-start (+ data-start subfile-size) coding))
+ (save-excursion
+ (set-buffer subfile)
+ (save-restriction
+ (widen)
+ (encode-coding-region 1 (point-max) coding tar-superior-buffer)))
+ (setq subfile-size (- (point-max) (point-min)))
;;
;; pad the new data out to a multiple of 512...
(let ((subfile-size-pad (ash (ash (+ subfile-size 511) -9) 9)))
- (goto-char (+ data-start subfile-size))
+ (goto-char (point-max))
(insert (make-string (- subfile-size-pad subfile-size) 0))
;;
;; update the data pointer of this and all following files...
(+ (tar-desc-data-start desc) difference))))
;;
;; Update the size field in the header block.
+ (widen)
(let ((header-start (- data-start 512)))
(goto-char (+ header-start tar-size-offset))
(delete-region (point) (+ (point) 12))
;; Insert the new text after the old, before deleting,
;; to preserve the window start.
(let ((line (tar-header-block-summarize tokens t)))
- (if (multibyte-string-p line)
- (insert-before-markers (string-as-unibyte line) "\n")
- (insert-before-markers line "\n")))
+ (insert-before-markers line "\n"))
(delete-region p after)
(setq tar-header-offset (marker-position m)))
)))
;; after doing the insertion, add any final padding that may be necessary.
(tar-pad-to-blocksize))
- (narrow-to-region 1 tar-header-offset)
- (set-buffer-multibyte tar-buffer-multibyte)))
+ (narrow-to-region (point-min) tar-header-offset)))
(set-buffer-modified-p t) ; mark the tar file as modified
(tar-next-line 0)
(set-buffer subfile)
- ;; Restore the buffer multibyteness.
- (set-buffer-multibyte subfile-multibyte)
(set-buffer-modified-p nil) ; mark the tar subfile as unmodified
(message "Saved into tar-buffer `%s'. Be sure to save that buffer!"
(buffer-name tar-superior-buffer))
;; tar-header-offset turns out to be null for files fetched with W3,
;; at least.
(let ((coding-system-for-write 'no-conversion))
- (write-region (or (byte-to-position tar-header-offset)
+ (write-region (or tar-header-offset
(point-min))
(point-max)
buffer-file-name nil t))
(tar-clear-modification-flags)
(set-buffer-modified-p nil))
- (narrow-to-region 1 (byte-to-position tar-header-offset)))
+ (narrow-to-region (point-min) tar-header-offset))
;; Return t because we've written the file.
t)
\f