;; Copyright (C) 1990, 1991, 1993, 1994, 1995 Free Software Foundation, Inc.
;; Author: Jamie Zawinski <jwz@lucid.com>
+;; Maintainer: FSF
;; Created: 04 Apr 1990
;; Keywords: unix
;;; Code:
-(defvar tar-anal-blocksize 20
+(defgroup tar nil
+ "Simple editing of tar files."
+ :prefix "tar-"
+ :group 'data)
+
+(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,
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
-how many null padding bytes go on the end of the tar file.")
+how many null padding bytes go on the end of the tar file."
+ :type '(choice integer (const nil))
+ :group 'tar)
-(defvar tar-update-datestamp nil
- "*Non-nil means tar-mode should play fast and loose with sub-file datestamps.
+(defcustom tar-update-datestamp nil
+ "*Non-nil means Tar mode should play fast and loose with sub-file datestamps.
If this is true, then editing and saving a tar file entry back into its
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
-the file never exists on disk.")
+the file never exists on disk."
+ :type 'boolean
+ :group 'tar)
-(defvar tar-mode-show-date nil
+(defcustom tar-mode-show-date nil
"*Non-nil means Tar mode should show the date/time of each subfile.
-This information is useful, but it takes screen space away from file names.")
+This information is useful, but it takes screen space away from file names."
+ :type 'boolean
+ :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)
(put 'tar-superior-buffer 'permanent-local t)
(put 'tar-superior-descriptor 'permanent-local t)
\f
-;;; First, duplicate some Common Lisp functions; I used to just (require 'cl)
-;;; but "cl.el" was messing some people up (also it's really big).
-
(defmacro tar-setf (form val)
"A mind-numbingly simple implementation of setf."
(let ((mform (macroexpand form (and (boundp 'byte-compile-macro-environment)
((eq (car mform) 'cdr)
(list 'setcdr (nth 1 mform) val))
(t (error "don't know how to setf %s" form)))))
-
-(defmacro tar-dolist (control &rest body)
- "syntax: (dolist (var-name list-expr &optional return-value) &body body)"
- (let ((var (car control))
- (init (car (cdr control)))
- (val (car (cdr (cdr control)))))
- (list 'let (list (list '_dolist_iterator_ init))
- (list 'while '_dolist_iterator_
- (cons 'let
- (cons (list (list var '(car _dolist_iterator_)))
- (append body
- (list (list 'setq '_dolist_iterator_
- (list 'cdr '_dolist_iterator_)))))))
- val)))
-
-(defmacro tar-dotimes (control &rest body)
- "syntax: (dolist (var-name count-expr &optional return-value) &body body)"
- (let ((var (car control))
- (n (car (cdr control)))
- (val (car (cdr (cdr control)))))
- (list 'let (list (list '_dotimes_end_ n)
- (list var 0))
- (cons 'while
- (cons (list '< var '_dotimes_end_)
- (append body
- (list (list 'setq var (list '1+ var))))))
- val)))
-
\f
;;; down to business.
(link-p (aref string tar-linkp-offset))
(magic-str (substring string tar-magic-offset (1- tar-uname-offset)))
(uname-valid-p (or (string= "ustar " magic-str) (string= "GNUtar " magic-str)))
- name
+ name linkname
(nulsexp "[^\000]*\000"))
- (and (string-match nulsexp string tar-name-offset) (setq name-end (min name-end (1- (match-end 0)))))
- (and (string-match nulsexp string tar-link-offset) (setq link-end (min link-end (1- (match-end 0)))))
- (and (string-match nulsexp string tar-uname-offset) (setq uname-end (min uname-end (1- (match-end 0)))))
- (and (string-match nulsexp string tar-gname-offset) (setq gname-end (min gname-end (1- (match-end 0)))))
+ (when (string-match nulsexp string tar-name-offset)
+ (setq name-end (min name-end (1- (match-end 0)))))
+ (when (string-match nulsexp string tar-link-offset)
+ (setq link-end (min link-end (1- (match-end 0)))))
+ (when (string-match nulsexp string tar-uname-offset)
+ (setq uname-end (min uname-end (1- (match-end 0)))))
+ (when (string-match nulsexp string tar-gname-offset)
+ (setq gname-end (min gname-end (1- (match-end 0)))))
(setq name (substring string tar-name-offset name-end)
link-p (if (or (= link-p 0) (= link-p ?0))
nil
(- link-p ?0)))
+ (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))
+ linkname
+ (decode-coding-string linkname (or file-name-coding-system
+ 'undecided))))
(if (and (null link-p) (string-match "/$" name)) (setq link-p 5)) ; directory
(make-tar-header
name
- (tar-parse-octal-integer string tar-mode-offset (1- tar-uid-offset))
- (tar-parse-octal-integer string tar-uid-offset (1- tar-gid-offset))
- (tar-parse-octal-integer string tar-gid-offset (1- tar-size-offset))
- (tar-parse-octal-integer string tar-size-offset (1- tar-time-offset))
- (tar-parse-octal-long-integer string tar-time-offset (1- tar-chk-offset))
- (tar-parse-octal-integer string tar-chk-offset (1- tar-linkp-offset))
+ (tar-parse-octal-integer string tar-mode-offset tar-uid-offset)
+ (tar-parse-octal-integer string tar-uid-offset tar-gid-offset)
+ (tar-parse-octal-integer string tar-gid-offset tar-size-offset)
+ (tar-parse-octal-integer string tar-size-offset tar-time-offset)
+ (tar-parse-octal-long-integer string tar-time-offset tar-chk-offset)
+ (tar-parse-octal-integer string tar-chk-offset tar-linkp-offset)
link-p
- (substring string tar-link-offset link-end)
+ linkname
uname-valid-p
(and uname-valid-p (substring string tar-uname-offset uname-end))
(and uname-valid-p (substring string tar-gname-offset gname-end))
- (tar-parse-octal-integer string tar-dmaj-offset (1- tar-dmin-offset))
- (tar-parse-octal-integer string tar-dmin-offset (1- tar-end-offset))
+ (tar-parse-octal-integer string tar-dmaj-offset tar-dmin-offset)
+ (tar-parse-octal-integer string tar-dmin-offset tar-end-offset)
)))
(t 'empty-tar-block)))
(defun tar-parse-octal-integer-safe (string)
(let ((L (length string)))
(if (= L 0) (error "empty string"))
- (tar-dotimes (i L)
+ (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))
(l (length chk-string)))
(aset hblock 154 0)
(aset hblock 155 32)
- (tar-dotimes (i l) (aset hblock (- 153 i) (aref chk-string (- l i 1)))))
+ (dotimes (i l) (aset hblock (- 153 i) (aref chk-string (- l i 1)))))
hblock)
(defun tar-clip-time-string (time)
(lastdigit (+ slash groupw sizew))
(datestart (+ lastdigit 2))
(namestart (+ datestart datew))
- (string (make-string (+ namestart (length name) (if link-p (+ 5 (length link-name)) 0)) 32))
+ (multibyte (or (multibyte-string-p name)
+ (multibyte-string-p link-name)))
+ ;; If multibyte, we can't use optimized method of aset,
+ ;; instead we must use concat.
+ (string (make-string (if multibyte
+ namestart
+ (+ namestart
+ (length name)
+ (if link-p (+ 5 (length link-name)) 0)))
+ 32))
(type (tar-header-link-type tar-hblock)))
(aset string 0 (if mod-p ?* ? ))
(aset string 1
(setq gid (if (= 0 (length gname)) (int-to-string gid) gname))
(setq size (int-to-string size))
(setq time (tar-clip-time-string time))
- (tar-dotimes (i (min (1- namew) (length uid))) (aset string (- slash i) (aref uid (- (length uid) i 1))))
+ (dotimes (i (min (1- namew) (length uid))) (aset string (- slash i) (aref uid (- (length uid) i 1))))
(aset string (1+ slash) ?/)
- (tar-dotimes (i (min (1- groupw) (length gid))) (aset string (+ (+ slash 2) i) (aref gid i)))
- (tar-dotimes (i (min sizew (length size))) (aset string (- lastdigit i) (aref size (- (length size) i 1))))
+ (dotimes (i (min (1- groupw) (length gid))) (aset string (+ (+ slash 2) i) (aref gid i)))
+ (dotimes (i (min sizew (length size))) (aset string (- lastdigit i) (aref size (- (length size) i 1))))
(if tar-mode-show-date
- (tar-dotimes (i (length time)) (aset string (+ datestart i) (aref time i))))
- (tar-dotimes (i (length name)) (aset string (+ namestart i) (aref name i)))
+ (dotimes (i (length time)) (aset string (+ datestart i) (aref time i))))
+ (if multibyte
+ (setq string (concat string name))
+ (dotimes (i (length name)) (aset string (+ namestart i) (aref name i))))
(if (or (eq link-p 1) (eq link-p 2))
- (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)))))
+ (if multibyte
+ (setq string (concat string
+ (if (= link-p 1) " ==> " " --> ")
+ link-name))
+ (dotimes (i 3) (aset string (+ namestart 1 (length name) i) (aref (if (= link-p 1) "==>" "-->") i)))
+ (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)))
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)
(summaries nil))
;; Collect summary lines and insert them all at once since tar files
;; can be pretty big.
- (tar-dolist (tar-desc (reverse tar-parse-info))
+ (dolist (tar-desc (reverse tar-parse-info))
(setq summaries
(cons (tar-header-block-summarize (tar-desc-tokens tar-desc))
(cons "\n"
summaries))))
- (insert (apply 'concat 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)))
(set-buffer-modified-p nil))))
\f
(defvar tar-mode-map nil "*Local keymap for Tar mode listings.")
(setq tar-mode-map (make-keymap))
(suppress-keymap tar-mode-map)
(define-key tar-mode-map " " 'tar-next-line)
- (define-key tar-mode-map "c" 'tar-copy)
+ (define-key tar-mode-map "C" 'tar-copy)
(define-key tar-mode-map "d" 'tar-flag-deleted)
(define-key tar-mode-map "\^D" 'tar-flag-deleted)
(define-key tar-mode-map "e" 'tar-extract)
(define-key tar-mode-map "h" 'describe-mode)
(define-key tar-mode-map "n" 'tar-next-line)
(define-key tar-mode-map "\^N" 'tar-next-line)
+ (define-key tar-mode-map [down] 'tar-next-line)
(define-key tar-mode-map "o" 'tar-extract-other-window)
(define-key tar-mode-map "p" 'tar-previous-line)
+ (define-key tar-mode-map "q" 'quit-window)
(define-key tar-mode-map "\^P" 'tar-previous-line)
- (define-key tar-mode-map "r" 'tar-rename-entry)
+ (define-key tar-mode-map [up] 'tar-previous-line)
+ (define-key tar-mode-map "R" 'tar-rename-entry)
(define-key tar-mode-map "u" 'tar-unflag)
(define-key tar-mode-map "v" 'tar-view)
(define-key tar-mode-map "x" 'tar-expunge)
(define-key tar-mode-map [menu-bar immediate view]
'("View This File" . tar-view))
(define-key tar-mode-map [menu-bar immediate display]
- '("Display in Other Window" . tar-display-other-file))
+ '("Display in Other Window" . tar-display-other-window))
(define-key tar-mode-map [menu-bar immediate find-file-other-window]
'("Find in Other Window" . tar-extract-other-window))
(define-key tar-mode-map [menu-bar immediate find-file]
(setq require-final-newline nil) ; binary data, dude...
(make-local-variable 'revert-buffer-function)
(setq revert-buffer-function 'tar-mode-revert)
- (make-local-variable 'enable-local-variables)
- (setq enable-local-variables nil)
+ (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)
+ ;; 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)
(setq write-contents-hooks '(tar-mode-write-file))
(widen)
(if (and (boundp 'tar-header-offset) tar-header-offset)
- (narrow-to-region 1 tar-header-offset)
- (tar-summarize-buffer))
+ (narrow-to-region 1 (byte-to-position tar-header-offset))
+ (tar-summarize-buffer)
+ (tar-next-line 0))
(run-hooks 'tar-mode-hook)
)
(defun tar-subfile-mode (p)
"Minor mode for editing an element of a tar-file.
-This mode redefines the save-buffer command to save the current buffer back
-into its associated tar-file buffer. You must save that buffer to actually
-save your changes to disk."
+This mode arranges for \"saving\" this buffer to write the data
+into the tar-file buffer that it came from. The changes will actually
+appear on disk when you save the tar-file's buffer."
(interactive "P")
(or (and (boundp 'tar-superior-buffer) tar-superior-buffer)
(error "This buffer is not an element of a tar file"))
(make-local-variable 'local-write-file-hooks)
(setq local-write-file-hooks '(tar-subfile-save-buffer))
;; turn off auto-save.
- (auto-save-mode nil)
+ (auto-save-mode -1)
(setq buffer-auto-save-file-name nil)
(run-hooks 'tar-subfile-mode-hook))
(t
;; Revert the buffer and recompute the dired-like listing.
-(defun tar-mode-revert (&optional no-autosave no-confirm)
- (setq tar-header-offset nil)
- (let ((revert-buffer-function nil))
- (revert-buffer t no-confirm)
- (widen))
- (tar-mode))
+(defun tar-mode-revert (&optional no-auto-save no-confirm)
+ (let ((revert-buffer-function nil)
+ (old-offset tar-header-offset)
+ success)
+ (setq tar-header-offset nil)
+ (unwind-protect
+ (and (revert-buffer t no-confirm)
+ (progn (widen)
+ (setq success t)
+ (tar-mode)))
+ ;; If the revert was canceled,
+ ;; put back the old value of tar-header-offset.
+ (or success
+ (setq tar-header-offset old-offset)))))
(defun tar-next-line (p)
(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)))
+ (tar-buffer-multibyte enable-multibyte-characters)
+ (tarname (if (buffer-file-name)
+ (file-name-nondirectory (buffer-file-name))
+ (buffer-name)))
(bufname (concat (file-name-nondirectory name)
" ("
tarname
(unwind-protect
(progn
(widen)
+ (set-buffer-multibyte nil)
(save-excursion
(set-buffer buffer)
- (insert-buffer-substring tar-buffer start end)
+ (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 0)
(setq buffer-file-name
- (expand-file-name (concat tarname ":" name)))
+ ;; `:' is not allowed on Windows
+ (expand-file-name (concat tarname "!" 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
+ (and set-auto-coding-function
+ (save-excursion
+ (funcall set-auto-coding-function
+ name (point-max)))))
+ (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 the default-directory to the dir of the
;; superior buffer.
(setq default-directory
(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)
- (set-buffer-modified-p nil))
+ (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)))
+ (narrow-to-region 1 tar-header-offset)
+ (set-buffer-multibyte tar-buffer-multibyte)))
(if view-p
- (progn
- (view-buffer buffer)
- (and just-created
- ;; This will be created by view.el
- (setq view-exit-action 'kill-buffer)))
+ (view-buffer buffer (and just-created 'kill-buffer))
(if (eq other-window-p 'display)
(display-buffer buffer)
(if other-window-p
(size (tar-header-size tokens))
(start (+ (tar-desc-data-start descriptor) tar-header-offset -1))
(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))
- (write-region start end to-file))
+ (unwind-protect
+ (let ((coding-system-for-write 'no-conversion))
+ (set-buffer-multibyte nil)
+ (write-region start end to-file))
+ (set-buffer-multibyte multibyte)))
(message "Copied tar entry %s to %s" name to-file)))
(defun tar-flag-deleted (p &optional unflag)
With a prefix argument, mark that many files."
(interactive "p")
(beginning-of-line)
- (tar-dotimes (i (if (< p 0) (- p) p))
+ (dotimes (i (if (< p 0) (- p) p))
(if (tar-current-descriptor unflag) ; barf if we're not on an entry-line.
(progn
(delete-char 1)
(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))
;; iteration over the files that remain, or only iterate up to
;; the next file to be deleted.
(let ((data-length (- data-end data-start)))
- (tar-dolist (desc following-descs)
+ (dolist (desc following-descs)
(tar-setf (tar-desc-data-start desc)
(- (tar-desc-data-start desc) data-length))))
))
(interactive)
(if (or noconfirm
(y-or-n-p "Expunge files marked for deletion? "))
- (let ((n 0))
+ (let ((n 0)
+ (multibyte enable-multibyte-characters))
+ (set-buffer-multibyte nil)
(save-excursion
(goto-char 0)
(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)
- )
+ (narrow-to-region 1 tar-header-offset))
+ (set-buffer-multibyte multibyte)
(if (zerop n)
(message "Nothing to expunge.")
(message "%s files expunged. Be sure to save this buffer." n)))))
(interactive)
(save-excursion
(goto-char 1)
- (while (< (point) tar-header-offset)
+ (while (< (position-bytes (point)) tar-header-offset)
(if (not (eq (following-char) ?\ ))
(progn (delete-char 1) (insert " ")))
(forward-line 1))))
(defun tar-alter-one-field (data-position new-data-string)
(let* ((descriptor (tar-current-descriptor))
- (tokens (tar-desc-tokens descriptor)))
+ (tokens (tar-desc-tokens descriptor))
+ (multibyte enable-multibyte-characters))
(unwind-protect
(save-excursion
;;
(forward-line 1)
(delete-region p (point))
(insert (tar-header-block-summarize tokens) "\n")
- (setq tar-header-offset (point-max)))
+ (setq tar-header-offset (position-bytes (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.
(buffer-substring start (+ start 512))
chk (tar-header-name tokens))
)))
- (narrow-to-region 1 tar-header-offset))))
+ (narrow-to-region 1 tar-header-offset)
+ (set-buffer-multibyte multibyte)
+ (tar-next-line 0))))
(defun tar-octal-time (timeval)
(error "This buffer doesn't have an index into its superior tar file!"))
(save-excursion
(let ((subfile (current-buffer))
- (subfile-size (buffer-size))
- (descriptor tar-superior-descriptor))
+ (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)))
+ (following-descs (cdr head))
+ (tar-buffer-multibyte enable-multibyte-characters))
(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))
(data-end (+ data-start (ash (ash (+ size 511) -9) 9))))
;; insert the new data...
(goto-char data-start)
(insert-buffer subfile)
+ (setq subfile-size
+ (encode-coding-region
+ data-start (+ data-start subfile-size) coding))
;;
;; pad the new data out to a multiple of 512...
(let ((subfile-size-pad (ash (ash (+ subfile-size 511) -9) 9)))
;; update the data pointer of this and all following files...
(tar-setf (tar-header-size tokens) subfile-size)
(let ((difference (- subfile-size-pad size-pad)))
- (tar-dolist (desc following-descs)
+ (dolist (desc following-descs)
(tar-setf (tar-desc-data-start desc)
(+ (tar-desc-data-start desc) difference))))
;;
(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")
+ (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")))
(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)))
+ (narrow-to-region 1 tar-header-offset)
+ (set-buffer-multibyte tar-buffer-multibyte)))
(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))
+ ;; Prevent basic-save-buffer from changing our coding-system.
+ (setq last-coding-system-used buffer-file-coding-system)
;; Prevent ordinary saving from happening.
t)))
+;; When this function is called, it is sure that the buffer is unibyte.
(defun tar-pad-to-blocksize ()
"If we are being anal about tar file blocksizes, fix up the current buffer.
Leaves the region wide."
;; Doing this here confuses things - the region gets left too wide!
;; I suppose this is run in a context where changing the buffer is bad.
;; (tar-pad-to-blocksize)
- (write-region tar-header-offset (point-max) buffer-file-name nil t)
- (tar-clear-modification-flags))
- (narrow-to-region 1 tar-header-offset))
- ;; return T because we've written the file.
+ ;; 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)
+ (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)))
+ ;; Return t because we've written the file.
t)
\f
(provide 'tar-mode)