%PDF- %PDF- Mini Shell
Mini Shell

Direktori : /usr/local/share/emacs/27.2/lisp/
Current File : //usr/local/share/emacs/27.2/lisp/tar-mode.elc
;ELC
;;; Compiled
;;; in Emacs version 27.2
;;; with all optimizations.

;;; This file uses dynamic docstrings, first added in Emacs 19.29.

;;; This file does not contain utf-8 non-ASCII characters,
;;; and so can be loaded in Emacs versions earlier than 23.

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;


(byte-code "\300\301!\210\302\303\304\305\306\307\310\311&\210\312\313\314\315\316DD\317\320\321%\210\312\322\314\315\323DD\324\320\325%\210\312\326\314\315\327DD\330\320\325%\210\312\331\314\315\332DD\333\320\325\334\335&\207" [require arc-mode custom-declare-group tar nil "Simple editing of tar files." :prefix "tar-" :group data custom-declare-variable tar-anal-blocksize funcall function #[0 "\300\207" [20] 1] "The blocksize of tar files written by Emacs, or nil, meaning don't care.\nThe blocksize of a tar file is not really the size of the blocks; rather, it is\nthe number of blocks written with one system call.  When tarring to a tape,\nthis is the size of the *tape* blocks, but when writing to a file, it doesn't\nmatter much.  The only noticeable difference is that if a tar file does not\nhave a blocksize of 20, tar will tell you that; all this really controls is\nhow many null padding bytes go on the end of the tar file." :type (choice integer (const nil)) tar-update-datestamp #[0 "\300\207" [nil] 1] "Non-nil means Tar mode should play fast and loose with sub-file datestamps.\nIf this is true, then editing and saving a tar file entry back into its\ntar file will update its datestamp.  If false, the datestamp is unchanged.\nYou may or may not want this - it is good in that you can tell when a file\nin a tar archive has been changed, but it is bad for the same reason that\nediting a file in the tar archive at all is bad - the changed version of\nthe file never exists on disk." boolean tar-mode-show-date #[0 "\300\207" [nil] 1] "Non-nil means Tar mode should show the date/time of each subfile.\nThis information is useful, but it takes screen space away from file names." tar-copy-preserve-time #[0 "\300\207" [nil] 1] "Non-nil means that Tar mode preserves the timestamp when copying files." :version "27.1"] 8)
(defvar tar-parse-info nil)
#@70 Buffer containing the tar archive from which a member was extracted.
(defvar tar-superior-buffer nil (#$ . 2281))
#@56 Tar descriptor for a member extracted from an archive.
(defvar tar-superior-descriptor nil (#$ . 2401))
(defvar tar-file-name-coding-system nil)
(byte-code "\300\301\302\303#\210\300\304\302\303#\207" [put tar-superior-buffer permanent-local t tar-superior-descriptor] 4)
#@45 Buffer that holds the actual raw tar bytes.
(defvar tar-data-buffer nil (#$ . 2679))
(make-variable-buffer-local 'tar-data-buffer)
#@59 If non-nil, `tar-data-buffer' indeed holds raw tar bytes.
(defvar tar-data-swapped nil (#$ . 2816))
(make-variable-buffer-local 'tar-data-swapped)
#@57 Return non-nil if the tar-data is in `tar-data-buffer'.
(defalias 'tar-data-swapped-p #[0 "\302!\205\303!\303 U\204	\303!\303 V=\204\304\305!\210	\207" [tar-data-buffer tar-data-swapped buffer-live-p buffer-size cl--assertion-failed (or (= (buffer-size tar-data-buffer) (buffer-size)) (eq tar-data-swapped (> (buffer-size tar-data-buffer) (buffer-size))))] 3 (#$ . 2969)])
#@143 Swap buffer contents between current buffer and `tar-data-buffer'.
Preserve the modified states of the buffers and set `buffer-swapped-with'.
(defalias 'tar-swap-data #[0 "\302!\302 \303!\210	?\304!\210rq\210\304!)\207" [tar-data-buffer tar-data-swapped buffer-modified-p buffer-swap-text restore-buffer-modified-p] 4 (#$ . 3358)])
#@69 compiler-macro for inlining `tar-header-p'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'tar-header-p--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block tar-header-p (and (vectorp cl-x) (>= (length cl-x) 17) (memq (aref cl-x 0) cl-struct-tar-header-tags) t)) nil] 9 (#$ . 3702)])
(put 'tar-header-p 'compiler-macro 'tar-header-p--cmacro)
#@13 

(fn CL-X)
(defalias 'tar-header-p #[257 "\301!\205\211G\302Y\205\211\303H>\205\304\207" [cl-struct-tar-header-tags vectorp 17 0 t] 3 (#$ . 4072)])
(byte-code "\300\301\302\303#\304\305\306\301#\207" [function-put tar-header-p side-effect-free error-free put tar-header cl-deftype-satisfies] 5)
#@78 compiler-macro for inlining `tar-header-data-start'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'tar-header-data-start--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block tar-header-data-start (progn (or (and (memq (aref cl-x 0) cl-struct-tar-header-tags)) (signal 'wrong-type-argument (list 'tar-header cl-x))) (aref cl-x 1))) nil] 9 (#$ . 4382)])
(put 'tar-header-data-start 'compiler-macro 'tar-header-data-start--cmacro)
#@66 Access slot "data-start" of `tar-header' struct CL-X.

(fn CL-X)
(defalias 'tar-header-data-start #[257 "\211\301H>\204\302\303\304D\"\210\211\305H\207" [cl-struct-tar-header-tags 0 signal wrong-type-argument tar-header 1] 5 (#$ . 4839)])
(byte-code "\300\301\302\303#\300\207" [function-put tar-header-data-start side-effect-free t] 4)
#@72 compiler-macro for inlining `tar-header-name'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'tar-header-name--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block tar-header-name (progn (or (and (memq (aref cl-x 0) cl-struct-tar-header-tags)) (signal 'wrong-type-argument (list 'tar-header cl-x))) (aref cl-x 2))) nil] 9 (#$ . 5186)])
(put 'tar-header-name 'compiler-macro 'tar-header-name--cmacro)
#@60 Access slot "name" of `tar-header' struct CL-X.

(fn CL-X)
(defalias 'tar-header-name #[257 "\211\301H>\204\302\303\304D\"\210\211\305H\207" [cl-struct-tar-header-tags 0 signal wrong-type-argument tar-header 2] 5 (#$ . 5613)])
(byte-code "\300\301\302\303#\300\207" [function-put tar-header-name side-effect-free t] 4)
#@72 compiler-macro for inlining `tar-header-mode'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'tar-header-mode--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block tar-header-mode (progn (or (and (memq (aref cl-x 0) cl-struct-tar-header-tags)) (signal 'wrong-type-argument (list 'tar-header cl-x))) (aref cl-x 3))) nil] 9 (#$ . 5942)])
(put 'tar-header-mode 'compiler-macro 'tar-header-mode--cmacro)
#@60 Access slot "mode" of `tar-header' struct CL-X.

(fn CL-X)
(defalias 'tar-header-mode #[257 "\211\301H>\204\302\303\304D\"\210\211\305H\207" [cl-struct-tar-header-tags 0 signal wrong-type-argument tar-header 3] 5 (#$ . 6369)])
(byte-code "\300\301\302\303#\300\207" [function-put tar-header-mode side-effect-free t] 4)
#@71 compiler-macro for inlining `tar-header-uid'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'tar-header-uid--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block tar-header-uid (progn (or (and (memq (aref cl-x 0) cl-struct-tar-header-tags)) (signal 'wrong-type-argument (list 'tar-header cl-x))) (aref cl-x 4))) nil] 9 (#$ . 6698)])
(put 'tar-header-uid 'compiler-macro 'tar-header-uid--cmacro)
#@59 Access slot "uid" of `tar-header' struct CL-X.

(fn CL-X)
(defalias 'tar-header-uid #[257 "\211\301H>\204\302\303\304D\"\210\211\305H\207" [cl-struct-tar-header-tags 0 signal wrong-type-argument tar-header 4] 5 (#$ . 7120)])
(byte-code "\300\301\302\303#\300\207" [function-put tar-header-uid side-effect-free t] 4)
#@71 compiler-macro for inlining `tar-header-gid'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'tar-header-gid--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block tar-header-gid (progn (or (and (memq (aref cl-x 0) cl-struct-tar-header-tags)) (signal 'wrong-type-argument (list 'tar-header cl-x))) (aref cl-x 5))) nil] 9 (#$ . 7446)])
(put 'tar-header-gid 'compiler-macro 'tar-header-gid--cmacro)
#@59 Access slot "gid" of `tar-header' struct CL-X.

(fn CL-X)
(defalias 'tar-header-gid #[257 "\211\301H>\204\302\303\304D\"\210\211\305H\207" [cl-struct-tar-header-tags 0 signal wrong-type-argument tar-header 5] 5 (#$ . 7868)])
(byte-code "\300\301\302\303#\300\207" [function-put tar-header-gid side-effect-free t] 4)
#@72 compiler-macro for inlining `tar-header-size'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'tar-header-size--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block tar-header-size (progn (or (and (memq (aref cl-x 0) cl-struct-tar-header-tags)) (signal 'wrong-type-argument (list 'tar-header cl-x))) (aref cl-x 6))) nil] 9 (#$ . 8194)])
(put 'tar-header-size 'compiler-macro 'tar-header-size--cmacro)
#@60 Access slot "size" of `tar-header' struct CL-X.

(fn CL-X)
(defalias 'tar-header-size #[257 "\211\301H>\204\302\303\304D\"\210\211\305H\207" [cl-struct-tar-header-tags 0 signal wrong-type-argument tar-header 6] 5 (#$ . 8621)])
(byte-code "\300\301\302\303#\300\207" [function-put tar-header-size side-effect-free t] 4)
#@72 compiler-macro for inlining `tar-header-date'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'tar-header-date--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block tar-header-date (progn (or (and (memq (aref cl-x 0) cl-struct-tar-header-tags)) (signal 'wrong-type-argument (list 'tar-header cl-x))) (aref cl-x 7))) nil] 9 (#$ . 8950)])
(put 'tar-header-date 'compiler-macro 'tar-header-date--cmacro)
#@60 Access slot "date" of `tar-header' struct CL-X.

(fn CL-X)
(defalias 'tar-header-date #[257 "\211\301H>\204\302\303\304D\"\210\211\305H\207" [cl-struct-tar-header-tags 0 signal wrong-type-argument tar-header 7] 5 (#$ . 9377)])
(byte-code "\300\301\302\303#\300\207" [function-put tar-header-date side-effect-free t] 4)
#@76 compiler-macro for inlining `tar-header-checksum'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'tar-header-checksum--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block tar-header-checksum (progn (or (and (memq (aref cl-x 0) cl-struct-tar-header-tags)) (signal 'wrong-type-argument (list 'tar-header cl-x))) (aref cl-x 8))) nil] 9 (#$ . 9706)])
(put 'tar-header-checksum 'compiler-macro 'tar-header-checksum--cmacro)
#@64 Access slot "checksum" of `tar-header' struct CL-X.

(fn CL-X)
(defalias 'tar-header-checksum #[257 "\211\301H>\204\302\303\304D\"\210\211\305H\207" [cl-struct-tar-header-tags 0 signal wrong-type-argument tar-header 8] 5 (#$ . 10153)])
(byte-code "\300\301\302\303#\300\207" [function-put tar-header-checksum side-effect-free t] 4)
#@77 compiler-macro for inlining `tar-header-link-type'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'tar-header-link-type--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block tar-header-link-type (progn (or (and (memq (aref cl-x 0) cl-struct-tar-header-tags)) (signal 'wrong-type-argument (list 'tar-header cl-x))) (aref cl-x 9))) nil] 9 (#$ . 10495)])
(put 'tar-header-link-type 'compiler-macro 'tar-header-link-type--cmacro)
#@65 Access slot "link-type" of `tar-header' struct CL-X.

(fn CL-X)
(defalias 'tar-header-link-type #[257 "\211\301H>\204\302\303\304D\"\210\211\305H\207" [cl-struct-tar-header-tags 0 signal wrong-type-argument tar-header 9] 5 (#$ . 10948)])
(byte-code "\300\301\302\303#\300\207" [function-put tar-header-link-type side-effect-free t] 4)
#@77 compiler-macro for inlining `tar-header-link-name'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'tar-header-link-name--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block tar-header-link-name (progn (or (and (memq (aref cl-x 0) cl-struct-tar-header-tags)) (signal 'wrong-type-argument (list 'tar-header cl-x))) (aref cl-x 10))) nil] 9 (#$ . 11293)])
(put 'tar-header-link-name 'compiler-macro 'tar-header-link-name--cmacro)
#@65 Access slot "link-name" of `tar-header' struct CL-X.

(fn CL-X)
(defalias 'tar-header-link-name #[257 "\211\301H>\204\302\303\304D\"\210\211\305H\207" [cl-struct-tar-header-tags 0 signal wrong-type-argument tar-header 10] 5 (#$ . 11747)])
(byte-code "\300\301\302\303#\300\207" [function-put tar-header-link-name side-effect-free t] 4)
#@73 compiler-macro for inlining `tar-header-magic'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'tar-header-magic--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block tar-header-magic (progn (or (and (memq (aref cl-x 0) cl-struct-tar-header-tags)) (signal 'wrong-type-argument (list 'tar-header cl-x))) (aref cl-x 11))) nil] 9 (#$ . 12093)])
(put 'tar-header-magic 'compiler-macro 'tar-header-magic--cmacro)
#@61 Access slot "magic" of `tar-header' struct CL-X.

(fn CL-X)
(defalias 'tar-header-magic #[257 "\211\301H>\204\302\303\304D\"\210\211\305H\207" [cl-struct-tar-header-tags 0 signal wrong-type-argument tar-header 11] 5 (#$ . 12527)])
(byte-code "\300\301\302\303#\300\207" [function-put tar-header-magic side-effect-free t] 4)
#@73 compiler-macro for inlining `tar-header-uname'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'tar-header-uname--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block tar-header-uname (progn (or (and (memq (aref cl-x 0) cl-struct-tar-header-tags)) (signal 'wrong-type-argument (list 'tar-header cl-x))) (aref cl-x 12))) nil] 9 (#$ . 12861)])
(put 'tar-header-uname 'compiler-macro 'tar-header-uname--cmacro)
#@61 Access slot "uname" of `tar-header' struct CL-X.

(fn CL-X)
(defalias 'tar-header-uname #[257 "\211\301H>\204\302\303\304D\"\210\211\305H\207" [cl-struct-tar-header-tags 0 signal wrong-type-argument tar-header 12] 5 (#$ . 13295)])
(byte-code "\300\301\302\303#\300\207" [function-put tar-header-uname side-effect-free t] 4)
#@73 compiler-macro for inlining `tar-header-gname'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'tar-header-gname--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block tar-header-gname (progn (or (and (memq (aref cl-x 0) cl-struct-tar-header-tags)) (signal 'wrong-type-argument (list 'tar-header cl-x))) (aref cl-x 13))) nil] 9 (#$ . 13629)])
(put 'tar-header-gname 'compiler-macro 'tar-header-gname--cmacro)
#@61 Access slot "gname" of `tar-header' struct CL-X.

(fn CL-X)
(defalias 'tar-header-gname #[257 "\211\301H>\204\302\303\304D\"\210\211\305H\207" [cl-struct-tar-header-tags 0 signal wrong-type-argument tar-header 13] 5 (#$ . 14063)])
(byte-code "\300\301\302\303#\300\207" [function-put tar-header-gname side-effect-free t] 4)
#@72 compiler-macro for inlining `tar-header-dmaj'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'tar-header-dmaj--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block tar-header-dmaj (progn (or (and (memq (aref cl-x 0) cl-struct-tar-header-tags)) (signal 'wrong-type-argument (list 'tar-header cl-x))) (aref cl-x 14))) nil] 9 (#$ . 14397)])
(put 'tar-header-dmaj 'compiler-macro 'tar-header-dmaj--cmacro)
#@60 Access slot "dmaj" of `tar-header' struct CL-X.

(fn CL-X)
(defalias 'tar-header-dmaj #[257 "\211\301H>\204\302\303\304D\"\210\211\305H\207" [cl-struct-tar-header-tags 0 signal wrong-type-argument tar-header 14] 5 (#$ . 14826)])
(byte-code "\300\301\302\303#\300\207" [function-put tar-header-dmaj side-effect-free t] 4)
#@72 compiler-macro for inlining `tar-header-dmin'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'tar-header-dmin--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block tar-header-dmin (progn (or (and (memq (aref cl-x 0) cl-struct-tar-header-tags)) (signal 'wrong-type-argument (list 'tar-header cl-x))) (aref cl-x 15))) nil] 9 (#$ . 15157)])
(put 'tar-header-dmin 'compiler-macro 'tar-header-dmin--cmacro)
#@60 Access slot "dmin" of `tar-header' struct CL-X.

(fn CL-X)
(defalias 'tar-header-dmin #[257 "\211\301H>\204\302\303\304D\"\210\211\305H\207" [cl-struct-tar-header-tags 0 signal wrong-type-argument tar-header 15] 5 (#$ . 15586)])
(byte-code "\300\301\302\303#\300\207" [function-put tar-header-dmin side-effect-free t] 4)
#@80 compiler-macro for inlining `tar-header-header-start'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'tar-header-header-start--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block tar-header-header-start (progn (or (and (memq (aref cl-x 0) cl-struct-tar-header-tags)) (signal 'wrong-type-argument (list 'tar-header cl-x))) (aref cl-x 16))) nil] 9 (#$ . 15917)])
(put 'tar-header-header-start 'compiler-macro 'tar-header-header-start--cmacro)
#@68 Access slot "header-start" of `tar-header' struct CL-X.

(fn CL-X)
(defalias 'tar-header-header-start #[257 "\211\301H>\204\302\303\304D\"\210\211\305H\207" [cl-struct-tar-header-tags 0 signal wrong-type-argument tar-header 16] 5 (#$ . 16386)])
(byte-code "\300\301\302\303#\304\305\306\"\207" [function-put tar-header-header-start side-effect-free t defalias copy-tar-header copy-sequence] 4)
#@163 compiler-macro for inlining `make-tar-header'.

(fn CL-WHOLE-ARG DATA-START NAME MODE UID GID SIZE DATE CHECKSUM LINK-TYPE LINK-NAME MAGIC UNAME GNAME DMAJ DMIN)
(defalias 'make-tar-header--cmacro #[4112 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (data-start name mode uid gid size date checksum link-type link-name magic uname gname dmaj dmin) (cl-block make-tar-header (vector 'tar-header data-start name mode uid gid size date checksum link-type link-name magic uname gname dmaj dmin nil)) nil] 37 (#$ . 16791)])
(put 'make-tar-header 'compiler-macro 'make-tar-header--cmacro)
#@149 Constructor for objects of type `tar-header'.

(fn DATA-START NAME MODE UID GID SIZE DATE CHECKSUM LINK-TYPE LINK-NAME MAGIC UNAME GNAME DMAJ DMIN)
(defalias 'make-tar-header #[3855 "\300\301\302&\207" [vector tar-header nil] 33 (#$ . 17419)])
(byte-code "\300\301\302\303#\304\305\306\211\307\303\310\311\305\306&	\207" [function-put make-tar-header side-effect-free t cl-struct-define tar-header nil vector ((cl-tag-slot) (data-start) (name) (mode) (uid) (gid) (size) (date) (checksum) (link-type) (link-name) (magic) (uname) (gname) (dmaj) (dmin) (header-start)) cl-struct-tar-header-tags] 11)
(defconst tar-name-offset 0)
(defconst tar-mode-offset (+ tar-name-offset 100))
(defconst tar-uid-offset (+ tar-mode-offset 8))
(defconst tar-gid-offset (+ tar-uid-offset 8))
(defconst tar-size-offset (+ tar-gid-offset 8))
(defconst tar-time-offset (+ tar-size-offset 12))
(defconst tar-chk-offset (+ tar-time-offset 12))
(defconst tar-linkp-offset (+ tar-chk-offset 8))
(defconst tar-link-offset (1+ tar-linkp-offset))
(defconst tar-magic-offset (+ tar-link-offset 100))
(defconst tar-uname-offset (+ tar-magic-offset 8))
(defconst tar-gname-offset (+ tar-uname-offset 32))
(defconst tar-dmaj-offset (+ tar-gname-offset 32))
(defconst tar-dmin-offset (+ tar-dmaj-offset 8))
(defconst tar-prefix-offset (+ tar-dmin-offset 8))
(defconst tar-end-offset (+ tar-prefix-offset 155))
#@49 Round S up to the next multiple of 512.

(fn S)
(defalias 'tar-roundup-512 #[257 "\300\211\301\\\302\"\303\"\207" [ash 511 -9 9] 5 (#$ . 18831)])
#@424 Return a `tar-header' structure.
This is a list of name, mode, uid, gid, size,
write-date, checksum, link-type, and link-name.
CODING is our best guess for decoding non-ASCII file names.
DISABLE-SLASH, if non-nil, means don't decide an entry is a directory
based on the trailing slash, only based on the "link-type" field
of the file header.  This is used for "old GNU" Tar format.

(fn POS CODING &optional DISABLE-SLASH)
(defalias 'tar-header-block-tokenize #[770 "\306\\dV\203\f\307\310!\210\311eZ\306\"\312U\204\313\314!\210\203#\313\315!\210\211\306\\\211\262{\211\312H\312U\203<\211\316H\312U?\205\\	\nSS\fS
H\317\n/\320Z#\211\321\235@\322\211\323\324\f0#\203h	\312\225S^\262\n\324\f1#\203z\312\225S^\262	\324\f/#\203\214\312\225S^\262\324\f#\203\235\312\225S^\262\3170\f#\262\312U\206\260\325U?\205\267\325Z\262\3171#\262\326\232\203\352\324\f2#\203\352\312\2252TV\203\352\3172\312\225S#\327Q\262\330\"\262\330\"\262\204\204\324\331\"\203\332\262\333\232\203\314\334\235\203\314\33534#\330\336\337#{\"\340\341!\\\342#\343\267\202r\211\312H5>\204N\344\345\346D\"\210\211\211\320I\266\202v\211\312H5>\204h\344\345\346D\"\210\211\211\347I\266\202v\350\351!\210\211\312H5>\204\206\344\345\346D\"\210\211\352H\204\252\324\331\"\203\252\211\312H5>\204\243\344\345\346D\"\210\211\211\352\332I\266\211\312H5>\204\272\344\345\346D\"\210\211\211\353\354\306Z\355\"I\266\266\202\202Z\354\322\"\335
	6#\33567#\33573#\33534#\33548#\3358
#
\n
\211\205\330\317/#\"\205&\330\317#\"\335\f9#\33592#\356\346\322&\266\217\266\212\207" [enable-multibyte-characters tar-mode-offset tar-magic-offset tar-gname-offset tar-dmaj-offset tar-linkp-offset 512 error "Malformed Tar header" mod 0 cl--assertion-failed (zerop (mod (- pos (point-min)) 512)) (not enable-multibyte-characters) 101 substring 2 ("ustar " "ustar") nil "[^]*" string-match 48 "ustar" "/" decode-coding-string "/\\'" 5 "././@LongLink" ("ustar " "ustar") tar-parse-octal-integer + -1 tar-header-block-tokenize tar-roundup-512 ignore-trailing-slash #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (28 318 27 344)) signal wrong-type-argument tar-header 10 message "Unrecognized GNU Tar @LongLink format" 9 16 copy-marker t vector tar-uname-offset tar-name-offset tar-link-offset tar-prefix-offset tar-size-offset tar-time-offset cl-struct-tar-header-tags tar-uid-offset tar-gid-offset tar-chk-offset tar-dmin-offset] 47 (#$ . 18985)])
#@19 

(fn DESCRIPTOR)
(defalias 'tar-header-data-end #[257 "\211\301H>\204\302\303\304D\"\210\211\305H\301H>\204!\302\303\304D\"\210\306H\301H>\2043\302\303\304D\"\210\307H\310>\204I\301V\203I\311!\202J\301\\\207" [cl-struct-tar-header-tags 0 signal wrong-type-argument tar-header 1 9 6 (1 2 3 4 5 6) tar-roundup-512] 7 (#$ . 21642)])
#@35 

(fn STRING &optional START END)
(defalias 'tar-parse-octal-integer #[769 "\204\300\262\211\204G\262H\300U\203\300\207\300W\203>H\301W\203,\211\2025\211\302_H\301Z\\\262T\262\202\211\207" [0 48 8] 7 (#$ . 22000)])
(byte-code "\300\301\302\303#\210\304\301\302\305#\207" [defalias tar-parse-octal-long-integer tar-parse-octal-integer nil make-obsolete "27.1"] 4)
#@15 

(fn STRING)
(defalias 'tar-parse-octal-integer-safe #[257 "\211G\300U\203\301\302!\210\303\304\"\210\305!\207" [0 error "empty string" mapc #[257 "\211\300W\204\f\211\301V\205\302\303\"\207" [48 55 error "`%c' is not an octal digit"] 4 "\n\n(fn C)"] tar-parse-octal-integer] 4 (#$ . 22395)])
#@399 Return a Tar header for a regular file.
The header will lack a proper checksum; use `tar-header-block-checksum'
to compute one, or request `tar-header-serialize' to do that.

Other tar-mode facilities may also require the data-start header
field to be set to a valid value.

If SIZE is not given or nil, it defaults to 0.
If TIME is not given or nil, assume now.

(fn FILENAME &optional SIZE TIME)
(defalias 'tar-new-regular-file-header #[769 "\300\301\302\303\304\211\206
\304\206\305 \302\211\211\211\211\211\211\211\211&\207" [vector tar-header nil 420 0 current-time] 21 (#$ . 22704)])
#@12 

(fn POS)
(defalias 'tar--pad-to #[257 "\300\301`[e#\302\"\207" [make-string + 0] 6 (#$ . 23309)])
#@35 

(fn POS VAL &optional FMT MASK)
(defalias 'tar--put-at #[1026 "\205!\300!\203\301\203\302\"\202\"\202\261\207" [tar--pad-to format logand] 10 (#$ . 23416)])
#@286 Return the serialization of a Tar HEADER as a string.
This function calls `tar-header-block-check-checksum' to ensure the
checksum is correct.

If UPDATE-CHECKSUM is non-nil, update HEADER with the newly-computed
checksum before doing the check.

(fn HEADER &optional UPDATE-CHECKSUM)
(defalias 'tar-header-serialize #[513 "\306\307!r\211q\210\310\311\312\313\314!\315\"\316$\216\317\320!\210\321\311H>\204(\322\323\324D\"\210\316H	\"\211G\325W\2048\326\327!\210\211c\266\330\n\311H>\204N\322\323\324D\"\210\331H\332\333$\210\330\311H>\204g\322\323\324D\"\210\334H\332\333$\210\330\f\311H>\204\200\322\323\324D\"\210\335H\332\333$\210\330
\311H>\204\231\322\323\324D\"\210\336H\337#\210\3405!\341\311H>\204\264\322\323\324D\"\210\342H!\343\261\210\3306\311H>\204\317\322\323\324D\"\210\344H\"\210\3307\311H>\204\347\322\323\324D\"\210\345H\"\210\311H>\204\373\322\323\324D\"\210\346H\203}\3308\311H>\204\322\323\324D\"\210\346H\"\210\3309\311H>\204,\322\323\324D\"\210\347H\"\210\330:\311H>\204D\322\323\324D\"\210\350H\"\210\330;\311H>\204\\\322\323\324D\"\210\351H\352\353$\210\330<\311H>\204v\322\323\324D\"\210\354H\352\353$\210\330\355\356\"\210\357\360 !e=\\b\210\361\362!\210\363\332\"c\210\203\261\311H>\204\252\322\323\324D\"\210\211\362I\266\364\360 \311H>\204\304\322\323\324D\"\210\362H\311H>\204\330\322\323\324	D\"\210\316H#\266\360 *\207" [cl-struct-tar-header-tags tar-file-name-coding-system tar-mode-offset tar-uid-offset tar-gid-offset tar-size-offset generate-new-buffer " *temp*" make-byte-code 0 "\301\300!\205	\302\300!\207" vconcat vector [buffer-name kill-buffer] 2 set-buffer-multibyte nil encode-coding-string signal wrong-type-argument tar-header 99 error "Long file name support is not implemented" tar--put-at 3 "%6o " 262143 4 5 6 "%11o " tar--pad-to tar-octal-time 7 " " 9 10 11 12 13 14 "%7o" 2097151 15 512 "" tar-header-block-checksum buffer-string delete-char 8 format tar-header-block-check-checksum tar-time-offset tar-linkp-offset tar-link-offset tar-magic-offset tar-uname-offset tar-gname-offset tar-dmaj-offset tar-dmin-offset tar-chk-offset] 11 (#$ . 23602)])
#@75 Compute and return a tar-acceptable checksum for this block.

(fn STRING)
(defalias 'tar-header-block-checksum #[257 "\301!\203\n\302\303!\210\211\304\\\305\211\211W\203$H\\\262\211T\262\202\262\211\306W\203;H\\\262\211T\262\202'\307\\\207" [tar-chk-offset multibyte-string-p cl--assertion-failed (not (multibyte-string-p string)) 8 0 512 256] 8 (#$ . 25838)])
#@97 Beep and print a warning if the checksum doesn't match.

(fn HBLOCK DESIRED-CHECKSUM FILE-NAME)
(defalias 'tar-header-block-check-checksum #[771 "\300!U?\205\301 \210\302\303\"\207" [tar-header-block-checksum beep message "Invalid checksum for file %s!"] 6 (#$ . 26227)])
#@13 

(fn TIME)
(defalias 'tar-clip-time-string #[257 "\300!\301\302\303\304#\305\306\"Q\207" [current-time-string " " substring 4 16 format-time-string " %Y"] 7 (#$ . 26510)])
(make-obsolete 'tar-clip-time-string 'format-time-string "27.1")
#@114 Construct a `rw-r--r--' string indicating MODE.
MODE should be an integer which is a file mode value.

(fn MODE)
(defalias 'tar-grind-file-mode #[257 "\300\301\302\"\303U\203\304\202\305\301\306\"\303U\203\304\202\307\301\310\"\303U\2037\301\311\"\303U\2033\304\202E\312\202E\301\311\"\303U\203D\313\202E\314\301\315\"\303U\203S\304\202T\305\301\316\"\303U\203b\304\202c\307\301\317\"\303U\203\301\320\"\303U\203{\304\202\216\312\202\216\301\320\"\303U\203\215\313\202\216\314\301\321	\"\303U\203\234\304\202\235\305\301\322\n\"\303U\203\253\304\202\254\307\301\323\"\303U\203\310\301\324\"\303U\203\304\304\202\327\312\202\327\301\324\"\303U\203\326\325\202\327\326&	\207" [string logand 256 0 45 114 128 119 2048 64 120 83 115 32 16 1024 8 4 2 512 1 84 116] 13 (#$ . 26758)])
#@85 Return a line similar to the output of `tar -vtf'.

(fn TAR-HBLOCK &optional MOD-P)
(defalias 'tar-header-block-summarize #[513 "\302H>\204\303\304\305D\"\210\306H\302H>\204!\303\304\305D\"\210\307H\302H>\2044\303\304\305D\"\210\310H\302H>\204G\303\304\305D\"\210\311H\302H>\204Z\303\304\305D\"\210\312H\302H>\204n\303\304\305	D\"\210\313H\302H>\204\203\303\304\305\nD\"\210\314H\302H>\204\230\303\304\305D\"\210\315H	\302H>\204\255\303\304\305\fD\"\210	\316H\n\302H>\204\302\303\304\305
D\"\210\n\317H\320\321\f\203\321\322\202\322\323\324=\204\336\302=\203\342\325\202\326\267\202\327\202\330\202\331\202\332\202\333\202\334\202\322\202\335\202\336\202\337\202\340\202\341\202\342\202\323\343
!\nG\302U\203.\f\2020\n\nG\302U\203=\f\202?\n\n	\203M\344\345\f\"\202N\346\347\350\351\352\353%\354=\204d\306=\203v\354U\203o\355\202p\356P\202w\346&\n\207" [cl-struct-tar-header-tags tar-mode-show-date 0 signal wrong-type-argument tar-header 2 3 4 5 12 13 6 7 9 10 format "%c%c%s %7s/%-7s %7s%s %s%s" 42 32 nil 45 #s(hash-table size 13 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (1 232 2 236 3 240 4 244 5 248 6 252 20 256 28 260 29 264 35 268 38 272 55 276 72 280)) 104 108 99 98 100 112 76 77 83 86 72 88 tar-grind-file-mode format-time-string " %Y-%m-%d %H:%M" "" propertize mouse-face highlight help-echo "mouse-2: extract this file into a buffer" 1 " ==> " " --> "] 27 (#$ . 27600)])
#@73 Extract all archive members in the tar-file into the current directory.
(defalias 'tar-untar-buffer #[0 "\306 \203	\202\np\307\310!rq\210	\203\311\312!\210)\n\211\203\366\211@\211\313H>\2040\314\315\316D\"\210\211\317H\320!\313H>\204E\314\315\316D\"\210\321H\322=\203Q\211\202T\323!\324!\313H>\204g\314\315\316D\"\210\325H\211\313H>\204|\314\315\316	D\"\210\326H\\\327!\204\355\330\247\203\227@Y\205\234\331#\266\203\255\332!\204\255\333\334\"\210\327!\204\355r	q\210\335\334\203\312\336\337\340\341%\210\342\330\343%\210+\344\313H>\204\347\314\315\316D\"\210\345H\"\210\266A\266\202\202\210\346!\207" [tar-data-buffer enable-multibyte-characters tar-parse-info cl-struct-tar-header-tags write-region-inhibit-fsync coding-system-for-write tar-data-swapped-p make-progress-reporter "Extracting" cl--assertion-failed (not enable-multibyte-characters) 0 signal wrong-type-argument tar-header 2 expand-file-name 9 5 file-name-directory tar--describe-as-link 1 6 file-directory-p nil progress-reporter-do-update file-exists-p make-directory t no-conversion lwarn (tar link) :warning "Extracted `%s', %s, as a normal file" write-region :nomessage set-file-modes 3 progress-reporter-done] 17 (#$ . 29141) nil])
#@59 Parse the contents of the tar file in the current buffer.
(defalias 'tar-summarize-buffer #[0 "\306 \204	\307\310!\210\311 \312er	q\210\313\314ed#)\312r	q\210dW\203\201\315\"\211\262\203\201\211\316H\n>\204<\317\320\321D\"\210\211\322H\211\316W\203]\323\324\316H\n>\204W\317\320\321D\"\210\325H#\210\210\211B\262\326!\262\312\247\203w@Y\205|\327#\266\202)\330\303!\210\237\211\204\224\331!\210\202\230\332\333!\210eb\210\312\334\335\336\337#\211\337\261\210eb\210\340	!*\266\203\207" [tar-file-name-coding-system tar-data-buffer cl-struct-tar-header-tags tar-parse-info inhibit-read-only create-lockfiles tar-data-swapped-p cl--assertion-failed (tar-data-swapped-p) buffer-modified-p nil make-progress-reporter "Parsing tar file..." tar-header-block-tokenize 0 signal wrong-type-argument tar-header 6 error "%s has size %s - corrupted" 2 tar-header-data-end progress-reporter-do-update make-local-variable progress-reporter-done message "Warning: premature EOF parsing tar file" t mapconcat tar-header-block-summarize "\n" restore-buffer-modified-p] 13 (#$ . 30432)])
#@37 Local keymap for Tar mode listings.
(defvar tar-mode-map (byte-code "\300 \301!\210\302\303\304#\210\302\305\306#\210\302\307\310#\210\302\311\310#\210\302\312\313#\210\302\314\313#\210\302\315\313#\210\302\316\317#\210\302\320\321#\210\302\322\304#\210\302\323\304#\210\302\324\304#\210\302\325\326#\210\302\327\330#\210\302\331\330#\210\302\332\330#\210\302\333\334#\210\302\335\336#\210\302\337\340#\210\302\341\342#\210\302\343\344#\210\302\345\346#\210\302\347\350#\210\302\351\326#\210\302\352\353#\210\302\354\355#\210\302\356\357#\210\302\360\361#\210\302\362\363#\210\302\364\365\366\365!B#\210\302\367\370#\210\302\371\372#\210\302\373\374#\210\302\375\376#\210\302\377\201@#\210\302\201A\201B\366\201B!B#\210\302\201C\201D#\210\302\201E\201F#\210\302\201G\201H#\210\302\201I\201J\366\201J!B#\210\302\201K\201L#\210\302\201M\201N#\210\302\201O\201P#\210\302\201Q\201R#\210\302\201S\201T#\210\302\201U\201V#\210\211\207" [make-keymap suppress-keymap define-key " " tar-next-line "C" tar-copy "d" tar-flag-deleted "" "e" tar-extract "f" "
" [mouse-2] tar-mouse-extract "g" revert-buffer "n" "" [down] "o" tar-extract-other-window "p" tar-previous-line "" [up] "I" tar-new-entry "R" tar-rename-entry "u" tar-unflag "v" tar-view "w" woman-tar-extract-file "x" tar-expunge "" tar-unflag-backwards "E" "M" tar-chmod-entry "G" tar-chgrp-entry "O" tar-chown-entry [follow-link] mouse-face [menu-bar edit] undefined [menu-bar immediate] "Immediate" make-sparse-keymap [menu-bar immediate woman] ("Read Man Page (WoMan)" . woman-tar-extract-file) [menu-bar immediate view] ("View This File" . tar-view) [menu-bar immediate display] ("Display in Other Window" . tar-display-other-window) [menu-bar immediate find-file-other-window] ("Find in Other Window" . tar-extract-other-window) [menu-bar immediate find-file] ("Find This File" . tar-extract) [menu-bar mark] "Mark" [menu-bar mark unmark-all] ("Unmark All" . tar-clear-modification-flags) [menu-bar mark deletion] ("Flag" . tar-flag-deleted) [menu-bar mark unmark] ("Unflag" . tar-unflag) [menu-bar operate] "Operate" [menu-bar operate chown] ("Change Owner..." . tar-chown-entry) [menu-bar operate chgrp] ("Change Group..." . tar-chgrp-entry) [menu-bar operate chmod] ("Change Mode..." . tar-chmod-entry) [menu-bar operate rename] ("Rename to..." . tar-rename-entry) [menu-bar operate copy] ("Copy to..." . tar-copy) [menu-bar operate expunge] ("Expunge Marked Files" . tar-expunge)] 7) (#$ . 31552))
(byte-code "\300\301\302\303#\210\300\304\302\303#\207" [put tar-mode mode-class special tar-subfile-mode] 4)
(defalias 'tar-change-major-mode-hook #[0 "\301 \203\302 \210\303!\205\304!\207" [tar-data-buffer tar-data-swapped-p tar-swap-data buffer-live-p kill-buffer] 2])
(defalias 'tar-mode-kill-buffer-hook #[0 "\301!\205	\302!\207" [tar-data-buffer buffer-live-p kill-buffer] 2])
(defvar tar-mode-hook nil)
(byte-code "\300\301N\204\f\302\300\301\303#\210\304\305!\204\302\305\306\307#\210\300\207" [tar-mode-hook variable-documentation put "Hook run after entering Tar mode.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it.  (This is true for all hook variables.)" boundp tar-mode-map definition-name tar-mode] 4)
(defvar tar-mode-map (make-sparse-keymap))
(byte-code "\301\302N\204\303\301\302\304\305!#\210\306\307!\204\303\307\310\311#\210\312\313 !\210\307\302N\204-\303\307\302\304\314!#\210\306\300!\204B\303\300\310\311#\210\315\316\300\317\"\210!\210\300\302N\204P\303\300\302\304\320!#\210\303\311\321\322#\207" [tar-mode-abbrev-table tar-mode-map variable-documentation put purecopy "Keymap for `tar-mode'." boundp tar-mode-syntax-table definition-name tar-mode (lambda (#1=#:def-tmp-var) (defvar tar-mode-syntax-table #1#)) make-syntax-table "Syntax table for `tar-mode'." (lambda (#1#) (defvar tar-mode-abbrev-table #1#)) define-abbrev-table nil "Abbrev table for `tar-mode'." derived-mode-parent special-mode] 5)
#@900 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;
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 \[save-buffer], 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'.
\{tar-mode-map}

In addition to any hooks its parent mode `special-mode' might have run,
this mode runs the hook `tar-mode-hook', as the final or penultimate step
during initialization.
(defalias 'tar-mode #[0 "\306\300!\210\307\310 \210\311\312\310\313N\203\314\311\313\310\313N#\210\315!\204'\316\317 \"\210\320\f!\211\2035\211\321 =\203;\322\f\323 \"\210\210\324
\325\"\204R
>=\204R\326
\325>C#\210\327!\210\330\f!\210
>?\203l\331?!\203l\332@\306\333!\210\306\334!\210\332\306\335!\210\332\306\336!\210\332\306\337!\210A\206\225B\206\225C\306\340!\210\307 \341 \210~\210\342 \203\254\343\344!\210\306\345!\210\346%\347\350\351\332\307$\210\347\352\353\332\307$\210\347\354\355\332\307$\210\356\332!\210\306\357!\210\360\361\362\363?\206\333\364 !\"!/\3651\361\366 \210\367 \210\370\371!0\202\374\372 \210\373@A\"\262\210)\374\375!\207" [delay-mode-hooks major-mode mode-name tar-mode-map tar-mode-syntax-table tar-mode-abbrev-table make-local-variable t special-mode tar-mode "Tar" mode-class put keymap-parent set-keymap-parent current-local-map char-table-parent standard-syntax-table set-char-table-parent syntax-table abbrev-table-get :parents abbrev-table-put use-local-map set-syntax-table file-writable-p nil tar-parse-info require-final-newline local-enable-local-variables next-line-add-newlines tar-file-name-coding-system file-precious-flag buffer-disable-undo tar-data-swapped-p cl--assertion-failed (not (tar-data-swapped-p)) revert-buffer-function tar-mode-revert add-hook write-region-annotate-functions tar-write-region-annotate kill-buffer-hook tar-mode-kill-buffer-hook change-major-mode-hook tar-change-major-mode-hook set-buffer-multibyte tar-data-buffer generate-new-buffer format " *tar-data %s*" file-name-nondirectory buffer-name (error) tar-swap-data tar-summarize-buffer tar-next-line 0 fundamental-mode signal run-mode-hooks tar-mode-hook local-abbrev-table buffer-file-name buffer-read-only file-name-coding-system default-file-name-coding-system locale-coding-system] 5 (#$ . 35579) nil])
#@59 In tar mode, run the WoMan man-page browser on this file.
(autoload 'woman-tar-extract-file "woman" '(#$ . 38364) t)
#@101 Non-nil if Tar-Subfile mode is enabled.
Use the command `tar-subfile-mode' to change this variable.
(defvar tar-subfile-mode nil (#$ . 38488))
(make-variable-buffer-local 'tar-subfile-mode)
#@500 Minor mode for editing an element of a tar-file.

If called interactively, enable Tar-Subfile mode if ARG is positive,
and disable it if ARG is zero or negative.  If called from Lisp, also
enable the mode if ARG is omitted or nil, and toggle it if ARG is
`toggle'; disable the mode otherwise.

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.

(fn &optional ARG)
(defalias 'tar-subfile-mode #[256 "\303 \304=\203
?\202\305!\306V\307\301!\203	\204!\310\311!\210\2035\312\313\314\315\316$\210\317\320!\210\315\202;\321\313\314\316#\210\322\323\203E\324\202F\325\"\210\326\327!\203j\303 \203Z\211\303 \232\203j\330\331\332\203e\333\202f\334#\266\210\335 \210\207" [tar-subfile-mode tar-superior-buffer buffer-auto-save-file-name current-message toggle prefix-numeric-value 0 boundp error "This buffer is not an element of a tar file" add-hook write-file-functions tar-subfile-save-buffer nil t auto-save-mode -1 remove-hook run-hooks tar-subfile-mode-hook tar-subfile-mode-on-hook tar-subfile-mode-off-hook called-interactively-p any " in current buffer" message "Tar-Subfile mode %sabled%s" "en" "dis" force-mode-line-update] 7 (#$ . 38685) (byte-code "\206\301C\207" [current-prefix-arg toggle] 1)])
(defvar tar-subfile-mode-hook nil)
(byte-code "\301\302N\204\f\303\301\302\304#\210\305\306\307\310\300!\205\307\211%\207" [tar-subfile-mode-map tar-subfile-mode-hook variable-documentation put "Hook run after entering or leaving `tar-subfile-mode'.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it.  (This is true for all hook variables.)" add-minor-mode tar-subfile-mode nil boundp] 6)
#@42 

(fn &optional NO-AUTO-SAVE NO-CONFIRM)
(defalias 'tar-mode-revert #[512 "\302\216\303\304 \203\f\305 \210\306\307#\210\310	!\203\311	!\210\312 *\207" [revert-buffer-function tar-data-buffer #[0 "\300 ?\205\301 \207" [tar-data-swapped-p tar-swap-data] 1] nil tar-data-swapped-p tar-swap-data revert-buffer preserve-modes buffer-live-p kill-buffer tar-mode] 6 (#$ . 40484)])
#@83 Move cursor vertically down ARG lines and to the start of the filename.

(fn ARG)
(defalias 'tar-next-line #[257 "\211y\210\300`\301\"\206`b\207" [next-single-property-change mouse-face] 4 (#$ . 40873) "p"])
#@81 Move cursor vertically up ARG lines and to the start of the filename.

(fn ARG)
(defalias 'tar-previous-line #[257 "\300[!\207" [tar-next-line] 3 (#$ . 41089) "p"])
#@57 Return the `tar-parse-info' index for the current line.
(defalias 'tar-current-position #[0 "\300e\301 \"\207" [count-lines line-beginning-position] 3 (#$ . 41261)])
#@93 Return the tar-descriptor of the current line, or signals an error.

(fn &optional NOERROR)
(defalias 'tar-current-descriptor #[256 "\301 8\206\211?\205\302\303!\207" [tar-parse-info tar-current-position error "This line does not describe a tar-file entry"] 3 (#$ . 41433)])
#@19 

(fn DESCRIPTOR)
(defalias 'tar--describe-as-link #[257 "\211\301H>\204\302\303\304D\"\210\211\305H\211\205=\211\306\267\202<\307\202=\310\202=\311\202=\312\202=\313\202=\314\202=\315\202=\316\202=\317\207" [cl-struct-tar-header-tags 0 signal wrong-type-argument tar-header 9 #s(hash-table size 8 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (5 28 20 32 28 36 29 40 35 44 38 48 55 52 72 56)) "a directory" "a tar directory header" "a next has longname" "a multivolume-continuation" "a sparse entry" "a volume header" "a pax global extended header" "a pax extended header" "a link"] 5 (#$ . 41719)])
#@19 

(fn DESCRIPTOR)
(defalias 'tar--check-descriptor #[257 "\300!\211\205\301\302\"\207" [tar--describe-as-link error "This is %s, not a real file"] 5 (#$ . 42358)])
(defalias 'tar-get-descriptor #[0 "\301 \211\302H>\204\303\304\305D\"\210\211\306H\307!\210\211\302U\203\"\310\311!\210\207" [cl-struct-tar-header-tags tar-current-descriptor 0 signal wrong-type-argument tar-header 6 tar--check-descriptor message "This is a zero-length file"] 5])
#@13 

(fn FILE)
(defalias 'tar-get-file-descriptor #[257 "\302\211\203)\211@\303H	>\204\304\305\306D\"\210\307H\232\203\"\211\262A\266\202\202\210\310!\210\211\207" [tar-parse-info cl-struct-tar-header-tags nil 0 signal wrong-type-argument tar-header 2 tar--check-descriptor] 9 (#$ . 42820)])
#@67 Extract a file whose tar directory line you click on.

(fn EVENT)
(defalias 'tar-mouse-extract #[257 "r\300\301!\211@\262!q\210\212\302\301!!b\210\303 \210*\304\301!\211@\262!\210\302\301!!b\210\305 \207" [window-buffer event-end posn-point tar-get-descriptor select-window tar-extract] 4 (#$ . 43129) "e"])
#@56 Helper function for `tar-extract'.

(fn OP &rest ARGS)
(defalias 'tar-file-name-handler #[385 "\301=\206
\302\303\")\207" [file-name-handler-alist file-exists-p nil apply] 5 (#$ . 43449)])
#@74 Extract this entry of the tar file into its own buffer.

(fn DESCRIPTOR)
(defalias 'tar--extract #[257 "\211\306H>\204\307\310\311D\"\210\211\312H\306H>\204!\307\310\311D\"\210\313H\306H>\2043\307\310\311D\"\210\314H\211\\\315 \316!\317\320R\321!r	q\210\322}\210b\210\n\206q\203eZ\"\206q\323\324\325	pB\326#@)\262\211\203\327!\330=\203\210\331\326#\262\332\333\"\203\230rq\210\334\322!\210)~\210rq\210\326)\335$\210rq\210\322)\210)\207" [cl-struct-tar-header-tags tar-data-buffer coding-system-for-read set-auto-coding-function file-name-handler-alist buffer-undo-list 0 signal wrong-type-argument tar-header 2 6 1 buffer-name file-name-nondirectory " (" ")" generate-new-buffer nil (("" . tar-file-name-handler)) find-operation-coding-system insert-file-contents t coding-system-type undecided detect-coding-region coding-system-get :for-unibyte set-buffer-multibyte decode-coding-region] 14 (#$ . 43649)])
#@101 In Tar mode, extract this entry of the tar file into its own buffer.

(fn &optional OTHER-WINDOW-P)
(defalias 'tar-extract #[256 "\211\306=\307 \211\310H>\204\311\312\313D\"\210\211\314Hp\315 	\206\316\317\320\321\"\203/\2023\322PQ!\323!\324\204\325!\262\326\262rq\210eb\210\327\n!\330 \210\331\f\326\"\210rq\210
)\332\324!\210\333 \210\334\335!\210\334\336!\210\337\340!\210)\203\217\341\205\213\342\"\202\252	\343=\203\234\344!\202\252	\203\247\345!\202\252\346!\207" [cl-struct-tar-header-tags buffer-read-only buffer-file-name buffer-file-truename last-coding-system-used default-directory view tar-get-descriptor 0 signal wrong-type-argument tar-header 2 buffer-name expand-file-name "!" string-match "/" "./" get-file-buffer nil tar--extract t abbreviate-file-name archive-try-jka-compr set-buffer-file-coding-system set-buffer-modified-p normal-mode make-local-variable tar-superior-buffer tar-superior-descriptor tar-subfile-mode 1 view-buffer kill-buffer-if-not-modified display display-buffer switch-to-buffer-other-window switch-to-buffer] 13 (#$ . 44621) nil])
#@65 In Tar mode, find this entry of the tar file in another window.
(defalias 'tar-extract-other-window #[0 "\300\301!\207" [tar-extract t] 2 (#$ . 45755) nil])
#@68 In Tar mode, display this entry of the tar file in another window.
(defalias 'tar-display-other-window #[0 "\300\301!\207" [tar-extract display] 2 (#$ . 45918) nil])
#@52 In Tar mode, view the tar file entry on this line.
(defalias 'tar-view #[0 "\300\301!\207" [tar-extract view] 2 (#$ . 46090) nil])
#@80 Read a file name with this line's entry as the default.

(fn &optional PROMPT)
(defalias 'tar-read-file-name #[256 "\211\204\301\262\302\303 \211\304H>\204\305\306\307D\"\210\211\310H\262!\302\311\312!\313$!\314!\315\230\2047\316!\203P\317\320\"\203H\321\304\211\225S#\202I\211\322\314!Q\262\207" [cl-struct-tar-header-tags "Copy to: " expand-file-name tar-current-descriptor 0 signal wrong-type-argument tar-header 2 read-file-name file-name-directory nil file-name-nondirectory "" file-directory-p string-match "/$" substring "/"] 8 (#$ . 46227)])
#@320 In Tar mode, extract this entry of the tar file into a file on disk.
If TO-FILE is not supplied, it is prompted for, defaulting to the name of
the current tar-entry.

If `tar-copy-preserve-time' is non-nil, the original
timestamp (if present in the tar file) will be used on the
extracted file.

(fn &optional TO-FILE)
(defalias 'tar-copy #[256 "\306 \211\307H>\204\310\311\312D\"\210\211\313H\307H>\204#\310\311\312D\"\210\314H\307H>\2045\310\311\312D\"\210\315H\307H>\204H\310\311\312D\"\210\316H\211\\	\nr\317 \203\\\202]pq\210\320\321\"\322=\203~\320\321\"\322=\203~\322\n\321=\205z	B\321\323\321	\324\211\211\325&\210)
\203\233\203\233\326\"\210)\327\330	#*\207" [cl-struct-tar-header-tags inhibit-file-name-handlers inhibit-file-name-operation tar-data-buffer coding-system-for-write tar-copy-preserve-time tar-get-descriptor 0 signal wrong-type-argument tar-header 2 6 7 1 tar-data-swapped-p find-file-name-handler write-region jka-compr-handler no-conversion nil t set-file-times message "Copied tar entry %s to %s"] 15 (#$ . 46805) (byte-code "\300 C\207" [tar-read-file-name] 1)])
#@78 Insert a new empty regular file before point.

(fn FILENAME &optional INDEX)
(defalias 'tar-new-entry #[513 "\211\206\304 \211\305U?\205\211S\233\211\203\306@!\202e\307!r	q\210b\210\310\311\"c\210\211\305H\n>\204<\312\313\314D\"\210\211\211\315\316`\317\"I\266)\203UAB\241\210\202Y\211B\212eb\210y\210\311\320!\321\261\210*\207" [tar-parse-info tar-data-buffer cl-struct-tar-header-tags inhibit-read-only tar-current-position 0 tar-header-data-end tar-new-regular-file-header tar-header-serialize t signal wrong-type-argument tar-header 1 copy-marker nil tar-header-block-summarize 10] 12 (#$ . 47950) "*sFile name: "])
#@137 In Tar mode, mark this sub-file to be deleted from the tar file.
With a prefix argument, mark that many files.

(fn P &optional UNFLAG)
(defalias 'tar-flag-deleted #[513 "\300 \210\301!\302\211W\2038\211\303!\203#\304\305!\210\203 \306\202!\307c\210\302W\203-\310\202.\305y\266\211T\262\202\266m?\205A\311u\207" [beginning-of-line abs 0 tar-current-descriptor delete-char 1 " " "D" -1 36] 7 (#$ . 48606) "p"])
#@132 In Tar mode, un-mark this sub-file if it is marked to be deleted.
With a prefix argument, un-mark that many files forward.

(fn P)
(defalias 'tar-unflag #[257 "\300\301\"\207" [tar-flag-deleted t] 4 (#$ . 49040) "p"])
#@133 In Tar mode, un-mark this sub-file if it is marked to be deleted.
With a prefix argument, un-mark that many files backward.

(fn P)
(defalias 'tar-unflag-backwards #[257 "\300[\301\"\207" [tar-flag-deleted t] 4 (#$ . 49266) "p"])
#@54 Expunge the tar-entry specified by the current line.
(defalias 'tar-expunge-internal #[0 "\303 \304 \304\305!|\210\306\"r	q\210\211\307H\n>\204!\310\311\312D\"\210\211\313H\206;\211\307H\n>\2046\310\311\312D\"\210\211\314H\315Z\316!|)\207" [tar-parse-info tar-data-buffer cl-struct-tar-header-tags tar-current-descriptor line-beginning-position 2 delq 0 signal wrong-type-argument tar-header 16 1 512 tar-header-data-end] 5 (#$ . 49503)])
#@189 In Tar mode, delete all the archived files flagged for deletion.
This does not modify the disk image; you must save the tar file itself
for this to be permanent.

(fn &optional NOCONFIRM)
(defalias 'tar-expunge #[256 "\211\204\n\300\301!\205?\302\212eb\210m\204)g\303U\203#\304 \210\211T\262\202\305y\210\202\306 \210)\211\302U\2039\307\310!\202=\307\311\"\262\207" [y-or-n-p "Expunge files marked for deletion? " 0 68 tar-expunge-internal 1 tar-pad-to-blocksize message "Nothing to expunge." "%s files expunged.  Be sure to save this buffer."] 5 (#$ . 49958) nil])
#@49 Remove the stars at the beginning of each line.
(defalias 'tar-clear-modification-flags #[0 "\212eb\210m?\205g\300=\204\301\302!\210\303c\210\302y\210\202)\207" [32 delete-char 1 " "] 2 (#$ . 50543) nil])
#@381 Change the user-id associated with this entry in the tar file.
If this tar file was written by GNU tar, then you will be able to edit
the user id as a string; otherwise, you must edit it as a number.
You can force editing as a number by calling this with a prefix arg.
This does not modify the disk image; you must save the tar file itself
for this to be permanent.

(fn NEW-UID)
(defalias 'tar-chown-entry #[257 "\211;\203'\304 \211\305H>\204\306\307\310D\"\210\211\211\311I\266\312	\313\n\"\314P\"\207\304 \211\305H>\2048\306\307\310D\"\210\211\211\315I\266\312\316\317\320\"\305\321#\322P\"\207" [cl-struct-tar-header-tags tar-uname-offset tar-file-name-coding-system tar-uid-offset tar-current-descriptor 0 signal wrong-type-argument tar-header 12 tar-alter-one-field encode-coding-string "" 4 substring format "%6o" 6 " "] 7 (#$ . 50761) (byte-code "\302 \204\211\303H	>\204\304\305\306D\"\210\211\307H\2047\310\311\312\313\303H	>\204/\304\305\306D\"\210\314H\"\"\202L\315\316\303H	>\204H\304\305\306D\"\210\317H\"\262C\207" [current-prefix-arg cl-struct-tar-header-tags tar-current-descriptor 0 signal wrong-type-argument tar-header 11 read-number "New UID number: " format "%s" 4 read-string "New UID string: " 12] 9)])
#@383 Change the group-id associated with this entry in the tar file.
If this tar file was written by GNU tar, then you will be able to edit
the group id as a string; otherwise, you must edit it as a number.
You can force editing as a number by calling this with a prefix arg.
This does not modify the disk image; you must save the tar file itself
for this to be permanent.

(fn NEW-GID)
(defalias 'tar-chgrp-entry #[257 "\211;\203'\304 \211\305H>\204\306\307\310D\"\210\211\211\311I\266\312	\313\n\"\314P\"\207\304 \211\305H>\2048\306\307\310D\"\210\211\211\315I\266\312\316\317\320\"\305\321#\322P\"\207" [cl-struct-tar-header-tags tar-gname-offset tar-file-name-coding-system tar-gid-offset tar-current-descriptor 0 signal wrong-type-argument tar-header 13 tar-alter-one-field encode-coding-string "" 5 substring format "%6o" 6 " "] 7 (#$ . 52030) (byte-code "\302 \204\211\303H	>\204\304\305\306D\"\210\211\307H\2047\310\311\312\313\303H	>\204/\304\305\306D\"\210\314H\"\"\202L\315\316\303H	>\204H\304\305\306D\"\210\317H\"\262C\207" [current-prefix-arg cl-struct-tar-header-tags tar-current-descriptor 0 signal wrong-type-argument tar-header 11 read-number "New GID number: " format "%s" 5 read-string "New GID string: " 13] 9)])
#@173 Change the name associated with this entry in the tar file.
This does not modify the disk image; you must save the tar file itself
for this to be permanent.

(fn NEW-NAME)
(defalias 'tar-rename-entry #[257 "\211\304\230\203\n\305\306!\210\307\"\310 \311\312H	>\204 \313\314\315D\"\210\316H\203*\305\317!\210G\320V\203n\321\322\211G\323Z#\203n\312\224\324W\203n\312H	>\204R\313\314\315D\"\210\325H\326\232\204_\327\n\330\"\210\331\312\211\224#\262\331\312\225\"\262G\320V\203y\305\332!\210\312H	>\204\210\313\314\315D\"\210\211\333I\266\327\312\331\334\323\312\"P\312\323#\"\210\211\205\257\327\331\334\324\312\"P\312\324#\"\207" [tar-file-name-coding-system cl-struct-tar-header-tags tar-magic-offset tar-prefix-offset "" error "zero length name" encode-coding-string tar-current-descriptor nil 0 signal wrong-type-argument tar-header 16 "Rename with @LongLink format is not implemented" 98 string-match "/" 99 155 11 "ustar" tar-alter-one-field "ustar00" substring "name too long" 2 make-string] 11 (#$ . 53301) (byte-code "\301\302\303 \211\304H>\204\305\306\307D\"\210\211\310H\262\"C\207" [cl-struct-tar-header-tags read-string "New name: " tar-current-descriptor 0 signal wrong-type-argument tar-header 2] 7)])
#@184 Change the protection bits associated with this entry in the tar file.
This does not modify the disk image; you must save the tar file itself
for this to be permanent.

(fn NEW-MODE)
(defalias 'tar-chmod-entry #[257 "\302 \211\303H>\204\304\305\306D\"\210\211\211\307I\266\310	\311\312\313\"\303\314#\315P\"\207" [cl-struct-tar-header-tags tar-mode-offset tar-current-descriptor 0 signal wrong-type-argument tar-header 3 tar-alter-one-field substring format "%6o" 6 " "] 7 (#$ . 54566) (byte-code "\300\301\302!!C\207" [tar-parse-octal-integer-safe read-string "New protection (octal): "] 3)])
#@59 

(fn DATA-POSITION NEW-DATA-STRING &optional DESCRIPTOR)
(defalias 'tar-alter-one-field #[770 "\211\204\304 \262i\305 \306y\210`\307!\310\261\210|\210\311y\210\312!\266\313 \204)\314\315!\210rq\210\211\316H	>\204<\317\320\321D\"\210\211\306H\322Z\211\\b\210``G\\|\210\n\204W\323!\203[\314\324!\210c\210\325\211\322\\{!\\b\210``\326\\|\210\327\330\"c\210\316H	>\204\205\317\320\321D\"\210\211\326I\266\331\211\322\\{\316H	>\204\243\317\320\321D\"\210\332H#\262\262)\207" [tar-data-buffer cl-struct-tar-header-tags enable-multibyte-characters tar-chk-offset tar-current-descriptor line-beginning-position 1 tar-header-block-summarize "\n" -1 move-to-column tar-data-swapped-p cl--assertion-failed (tar-data-swapped-p) 0 signal wrong-type-argument tar-header 512 multibyte-string-p (not (or enable-multibyte-characters (multibyte-string-p new-data-string))) tar-header-block-checksum 8 format "%6o " tar-header-block-check-checksum 2] 12 (#$ . 55174)])
#@16 

(fn TIMEVAL)
(defalias 'tar-octal-time #[257 "\300\301\302\303\"\"\207" [format "%011o" time-convert integer] 6 (#$ . 56168)])
#@182 In tar subfile mode, save this buffer into its parent tar-file buffer.
This doesn't write anything to disk; you must save the parent tar-file buffer
to make your changes permanent.
(defalias 'tar-subfile-save-buffer #[0 "\306\300!\203\n\204\307\310!\210\306\301!\203	\204\307\311!\210p\n	\312rq\210\313H>\2043\314\315\316D\"\210\317H\313H>\204E\314\315\316D\"\210\320H\f>\211\204S\307\321!\210r
q\210\211\322!\\}\210ed|\210b\210pr	q\210\214~\210\323ed$\210*\210deZ\262\322!db\210\324Z\313\"c\210\313H>\204\241\314\315\316\nD\"\210\211\320	I\266~\266)\fGGZeb\210\211y\210\325\"\326\327\"\"\210#\203\323\325$\330\331 !\332P\"\210\210\333 \266\334\335!\210\336\313!\210)\334\312!\210\337\340\341!\"\210\n%\335\207" [tar-superior-buffer tar-superior-descriptor buffer-file-coding-system cl-struct-tar-header-tags tar-parse-info tar-data-buffer boundp error "This buffer has no superior tar file buffer" "This buffer doesn't have an index into its superior tar file!" nil 0 signal wrong-type-argument tar-header 1 6 "Can't find this tar file entry in its parent tar file!" tar-roundup-512 encode-coding-region make-string tar-alter-one-field format "%11o " tar-octal-time current-time " " tar-pad-to-blocksize set-buffer-modified-p t tar-next-line message "Saved into tar-buffer `%s'.  Be sure to save that buffer!" buffer-name tar-size-offset tar-update-datestamp tar-time-offset last-coding-system-used] 15 (#$ . 56305) nil])
#@100 If we are being anal about tar file blocksizes, fix up the current buffer.
Leaves the region wide.
(defalias 'tar-pad-to-blocksize #[0 "\205y	GS	8\211\304H\n>\204\305\306\307D\"\210\211\310H\304H\n>\204*\305\306\307D\"\210\311H\211\2035\304\202G\304H\n>\204D\305\306\307D\"\210\312H\\\313\311\"\211eZ\245_\\rq\210e\\dV\203j\211d|\202tdb\210\314dZ\304\"c\262)\266\207\207" [tar-anal-blocksize tar-parse-info cl-struct-tar-header-tags tar-data-buffer 0 signal wrong-type-argument tar-header 1 9 6 ash make-string] 11 (#$ . 57791)])
#@18 

(fn START END)
(defalias 'tar-write-region-annotate #[514 "\206\301 ??\205\302 \210q\210\303\207" [tar-data-buffer tar-data-swapped-p tar-clear-modification-flags nil] 3 (#$ . 58355)])
(provide 'tar-mode)
Zerion Mini Shell 1.0