1#@!#!123s

��JFIF�� 1#@!#!123s
: / proc / self / root / usr / share / emacs / 24.3 / lisp / vc /
Filename : pcvs.elc
back
;ELC���
;;; Compiled by mockbuild@buildfarm06-new.corp.cloudlinux.com on Fri Oct 11 10:08:54 2024
;;; from file /builddir/build/BUILD/emacs-24.3/lisp/vc/pcvs.el
;;; in Emacs version 24.3.1
;;; 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\300\302!\210\300\303!\210\300\304!\210\300\305!\207" [require ewoc pcvs-defs pcvs-util pcvs-parse pcvs-info] 2)
#@30 Bound to t inside VC advice.
(defvar cvs-from-vc nil (#$ . 688))
(defalias 'cvs-defaults #[(&rest defs) "\303	\"\304\305	GZ@\"\n#)\207" [defs cvs-shared-start cvs-shared-flags cvs-first append make-list] 5])
(defconst cvs-cvs-flags (byte-code "\304\301!\211\203!�\305	!\203!�	G\306Y\203!�	\307H\n>\203!�	\2028�\310\311\312\2030�	AB\2021�\313\211\211\211&))\207" [bound cvs-cvs-flags cl-struct-cvs-flags-tags defaults boundp vectorp 6 0 (("-f")) vector cl-struct-cvs-flags nil] 8) nil)
(defconst cvs-checkout-flags (byte-code "\304\301!\211\203!�\305	!\203!�	G\306Y\203!�	\307H\n>\203!�	\202:�\310\311!\312\313\2032�	AB\2023�\314\211\211\211&))\207" [bound cvs-checkout-flags cl-struct-cvs-flags-tags defaults boundp vectorp 6 0 cvs-defaults ("-P") vector cl-struct-cvs-flags nil] 8) nil)
(defconst cvs-status-flags (byte-code "\304\301!\211\203!�\305	!\203!�	G\306Y\203!�	\307H\n>\203!�	\202;�\310\311\312\"\313\314\2033�	AB\2024�\312\211\211\211&))\207" [bound cvs-status-flags cl-struct-cvs-flags-tags defaults boundp vectorp 6 0 cvs-defaults ("-v") nil vector cl-struct-cvs-flags] 8) nil)
(defconst cvs-log-flags (byte-code "\304\301!\211\203!�\305	!\203!�	G\306Y\203!�	\307H\n>\203!�	\202:�\310\311!\312\313\2032�	AB\2023�\311\211\211\211&))\207" [bound cvs-log-flags cl-struct-cvs-flags-tags defaults boundp vectorp 6 0 cvs-defaults nil vector cl-struct-cvs-flags] 8) nil)
(defconst cvs-diff-flags (byte-code "\304\301!\211\203!�\305	!\203!�	G\306Y\203!�	\307H\n>\203!�	\202<�\310\311\312\313#\314\315\2034�	AB\2025�\316\211\211\211&))\207" [bound cvs-diff-flags cl-struct-cvs-flags-tags defaults boundp vectorp 6 0 cvs-defaults ("-u" "-N") ("-c" "-N") ("-u" "-b") vector cl-struct-cvs-flags nil] 8) nil)
(defconst cvs-tag-flags (byte-code "\304\301!\211\203!�\305	!\203!�	G\306Y\203!�	\307H\n>\203!�	\202:�\310\311!\312\313\2032�	AB\2023�\311\211\211\211&))\207" [bound cvs-tag-flags cl-struct-cvs-flags-tags defaults boundp vectorp 6 0 cvs-defaults nil vector cl-struct-cvs-flags] 8) nil)
(defconst cvs-add-flags (byte-code "\304\301!\211\203!�\305	!\203!�	G\306Y\203!�	\307H\n>\203!�	\202:�\310\311!\312\313\2032�	AB\2023�\311\211\211\211&))\207" [bound cvs-add-flags cl-struct-cvs-flags-tags defaults boundp vectorp 6 0 cvs-defaults nil vector cl-struct-cvs-flags] 8) nil)
(defconst cvs-commit-flags (byte-code "\304\301!\211\203!�\305	!\203!�	G\306Y\203!�	\307H\n>\203!�	\202:�\310\311!\312\313\2032�	AB\2023�\311\211\211\211&))\207" [bound cvs-commit-flags cl-struct-cvs-flags-tags defaults boundp vectorp 6 0 cvs-defaults nil vector cl-struct-cvs-flags] 8) nil)
(defconst cvs-remove-flags (byte-code "\304\301!\211\203!�\305	!\203!�	G\306Y\203!�	\307H\n>\203!�	\202:�\310\311!\312\313\2032�	AB\2023�\311\211\211\211&))\207" [bound cvs-remove-flags cl-struct-cvs-flags-tags defaults boundp vectorp 6 0 cvs-defaults nil vector cl-struct-cvs-flags] 8) nil)
(defconst cvs-update-flags (byte-code "\304\301!\211\203!�\305	!\203!�	G\306Y\203!�	\307H\n>\203!�	\202:�\310\311!\312\313\2032�	AB\2023�\314\211\211\211&))\207" [bound cvs-update-flags cl-struct-cvs-flags-tags defaults boundp vectorp 6 0 cvs-defaults ("-d" "-P") vector cl-struct-cvs-flags nil] 8) nil)
#@63 Reset the default arguments to those in the `cvs-cvsrc-file'.
(defalias 'cvs-reread-cvsrc #[nil "\300\301\302\217\207" [nil (byte-code "\306\307!rq\210\310\216\311	!\210\312\313\211\203g�@eb\210\314\315\n\316Q\313\317#\203`�\320\321\n\322Q!\323\324\325!\2066�\326!\f\327
#$$\fJ\327H%>\204R�\330\331\332\333#\210\fJ\334H\233\211&#\240,\210*A\211\204�*\335\327\336\337\340\341\335\313\342#\"AB#$$\fJ\327H%>\204\214�\330\331\332\333#\210\fJ\334H\233\211&#\240.\207" [#1=#:temp-buffer cvs-cvsrc-file cmd --dolist-tail-- sym val generate-new-buffer " *temp*" ((byte-code "\301!\203\n�\302!\210\301\207" [#1# buffer-name kill-buffer] 2)) insert-file-contents ("cvs" "checkout" "status" "log" "diff" "tag" "add" "commit" "remove" "update") nil re-search-forward "^" "\\(\\s-+\\(.*\\)\\)?$" t intern "cvs-" "-flags" split-string-and-unquote match-string 2 "" 0 error "%s accessing a non-%s" cvs-flags-defaults cvs-flags 1 cvs-cvs-flags "-f" cvs-partition #[(x) "\301\235\207" [x ("-q" "-Q" "-f")] 2] cvs-flags-query noquery value index cl-struct-cvs-flags-tags #2=#:c] 10) ((file-error))] 3 (#$ . 3929) nil])
(cvs-reread-cvsrc)
#@21 Popup the CVS menu.
(defalias 'cvs-menu #[(e) "\306\307	!\310\n8\206�\nA@:\203�\nA@@\202�\nA@)\"\211\311H)C\312
	\")\207" [cvs-cookies e position cl-x cvs-minor-current-files cvs-menu ewoc-locate event-end 5 2 popup-menu] 5 (#$ . 5084) "e"])
#@62 Mode-line control for displaying info on cvs process status.
(defvar cvs-mode-line-process nil (#$ . 5339))
(autoload 'cvs-status-get-tags "cvs-status")
#@58 Return a list of acceptable tags, ready for completions.
(defalias 'cvs-tags-list #[nil "\304 \204�\305\306\307C\"\210\310 \311\312\2059�\313\314!r	q\210\315\216\316\n\317\320\317\321\322\323@!&\210eb\210\324 \211<\2058�,)BB\207" [marked #1=#:temp-buffer cvs-program tags cvs-buffer-p signal cl-assertion-failed (cvs-buffer-p) cvs-get-marked ("BASE") ("HEAD") generate-new-buffer " *temp*" ((byte-code "\301!\203\n�\302!\210\301\207" [#1# buffer-name kill-buffer] 2)) process-file nil t "status" "-v" cvs-fileinfo->full-name cvs-status-get-tags] 12 (#$ . 5498)])
(defvar cvs-tag-history nil)
(defconst cvs-qtypedesc-tag (byte-code "\300\301\302\211\303\304\305&\207" [vector cl-struct-cvs-qtypedesc identity cvs-tag-history cvs-tags-list nil] 7))
#@262 Switch to the *cvs* buffer.
If -CVS-MODE!-FUN is provided, it is executed *cvs* being the current buffer
  and with its window selected.  Else, the *cvs* buffer is simply selected.
-CVS-MODE!-FUN is called interactively if applicable and else with no argument.
(defalias 'cvs-mode! #[(&optional -cvs-mode!-fun) "p\306 \203�p\202�	\203�\306	!\203�	\202�\307\310!\311\204+�\nq\202U�p\312 \313\n\314\"\315\216\nq\210\203G�\316!\210\f\203R�\f
\"\202T�
 ,,\207" [-cvs-mode!-buf cvs-buffer cvsbuf cvs-minor-wrap-function -cvs-mode!-wrapper -cvs-mode!-cont cvs-buffer-p error "can't find the *cvs* buffer" #[nil "r\301!\203
�\302!\202� )\207" [-cvs-mode!-fun commandp call-interactively] 2] selected-window get-buffer-window visible ((byte-code "q\210	\203�	\303 =\203�\304\n!\210\303\207" [cvs-mode!-buf cvs-mode!-nwin cvs-mode!-owin selected-window select-window] 2)) select-window -cvs-mode!-fun cvs-mode!-nwin cvs-mode!-owin cvs-mode!-buf] 5 (#$ . 6263)])
(defvar cvs-branches (byte-code "\301\211E\207" [cvs-vendor-branch "HEAD"] 3))
#@88 Current selected branch.
See `cvs-prefix-set' for further description of the behavior.
(defvar cvs-branch-prefix nil (#$ . 7332))
(defvar cvs-branch-prefix-cps (byte-code "	B\211GY\204�\305\n\306S\n@\"\"\307\310\n\311\312\f\311&)\207" [cvs-vendor-branch cvs-branches defaults cvs-prefix-number cvs-qtypedesc-tag append make-list vector cl-struct-cvs-flags nil "version"] 8))
#@223 Set the branch prefix to take action at the next command.
See `cvs-prefix-set' for a further the description of the behavior.
\[universal-argument] 1 selects the vendor branch
and \[universal-argument] 2 selects the HEAD.
(defalias 'cvs-set-branch-prefix #[(arg) "\301 \210\302\303\"\207" [arg cvs-mode! cvs-prefix-set cvs-branch-prefix] 3 (#$ . 7721) "P"])
#@187 Add branch selection argument if the branch prefix was set.
The argument is added (or not) to the list of FLAGS and is constructed
by appending the branch to ARG which defaults to "-r".
(defalias 'cvs-add-branch-prefix #[(flags &optional arg) "\303\304!\303\305!\210\203�	\206�\306P\nB\202�\n)\207" [branch arg flags cvs-prefix-get cvs-branch-prefix cvs-secondary-branch-prefix "-r"] 2 (#$ . 8087)])
#@98 Current secondary selected branch.
See `cvs-prefix-set' for further description of the behavior.
(defvar cvs-secondary-branch-prefix nil (#$ . 8499))
(defvar cvs-secondary-branch-prefix-cps (byte-code "	B\211GY\204�\305\n\306S\n@\"\"\307\310\n\311\312\f\311&)\207" [cvs-vendor-branch cvs-branches defaults cvs-prefix-number cvs-qtypedesc-tag append make-list vector cl-struct-cvs-flags nil "version"] 8))
#@223 Set the branch prefix to take action at the next command.
See `cvs-prefix-set' for a further the description of the behavior.
\[universal-argument] 1 selects the vendor branch
and \[universal-argument] 2 selects the HEAD.
(defalias 'cvs-set-secondary-branch-prefix #[(arg) "\301 \210\302\303\"\207" [arg cvs-mode! cvs-prefix-set cvs-secondary-branch-prefix] 3 (#$ . 8918) "P"])
#@394 Add branch selection argument if the secondary branch prefix was set.
The argument is added (or not) to the list of FLAGS and is constructed
by appending the branch to ARG which defaults to "-r".
Since the `cvs-secondary-branch-prefix' is only active if the primary
prefix is active, it is important to read the secondary prefix before
the primary since reading the primary can deactivate it.
(defalias 'cvs-add-secondary-branch-prefix #[(flags &optional arg) "\303\304\305\"\205\n�\303\306!\211\203�	\206�\307P\nB\202�\n)\207" [branch arg flags cvs-prefix-get cvs-branch-prefix read-only cvs-secondary-branch-prefix "-r"] 4 (#$ . 9304)])
#@97 Non-nil if CVS minor mode is enabled.
Use the command `cvs-minor-mode' to change this variable.
(defvar cvs-minor-mode nil (#$ . 9954))
(make-variable-buffer-local 'cvs-minor-mode)
#@153 This mode is used for buffers related to a main *cvs* buffer.
All the `cvs-mode' buffer operations are simply rebound under
the \[cvs-mode-map] prefix.
(defalias 'cvs-minor-mode #[(&optional arg) "\303 	\304=\203�\n?\202�\305	!\306V\307\310\n\203�\311\202�\312\"\210\313\314!\203@�\303 \2033�\303 \232\203@�\315\316\n\203=�\317\202>�\320\"\210)\321 \210\n\207" [#1=#:last-message arg cvs-minor-mode current-message toggle prefix-numeric-value 0 run-hooks cvs-minor-mode-hook cvs-minor-mode-on-hook cvs-minor-mode-off-hook called-interactively-p any message "CVS minor mode %sabled" "en" "dis" force-mode-line-update] 3 (#$ . 10142) (list (or current-prefix-arg 'toggle))])
(byte-code "\301\302\303\304\300!\205\n�\305\211%\210\306\302\307\310#\207" [cvs-minor-mode-map add-minor-mode cvs-minor-mode " CVS" boundp nil put permanent-local t] 6)
(defvar cvs-temp-buffers nil)
#@420 Create a temporary buffer to run CMD in.
If CMD is a string, use it to lookup `cvs-buffer-name-alist' to find
the buffer name to be used and its `major-mode'.

The selected window will not be changed.  The new buffer will not maintain undo
information and will be read-only unless NORMAL is non-nil.  It will be emptied
(unless NOSETUP is non-nil) and its `default-directory' will be inherited
from the current buffer.
(defalias 'cvs-temp-buffer #[(&optional cmd normal nosetup) "p\306	\n\"A\307@!A@$%\f\203�\310\f!\202@�\311\f!\2032�\312\f!\2032�\f\202@�\313\314!\210\310\307&!\315\"\211\f'\316'!()\204m�\317(!\203m�\320(!\321>\203m�	\203i�\322(!\210\202m�\323\324!\210)\f\204y�\325\326!\210\202\215�*\204\205�\212\327'!\210)\313\326!\210'\330\331'\"\210r'q\210\332+%$*\204\252�\333 \210\334 \210\313\335!\210,-\336
!\203\301�
 \210\202\304�\337 \210-\203\315�-,)\340\341!\210)\203\335�\342 \210\202\343�\343+\333 \210'.\207" [cvs-buf cmd cvs-buffer-name-alist info name mode assoc eval cvs-get-buffer-create bufferp buffer-live-p make-local-variable cvs-temp-buffer noreuse get-buffer-process processp process-status (run stop) delete-process error "Can not run two cvs processes simultaneously" kill-local-variable other-window-scroll-buffer display-buffer add-to-list cvs-temp-buffers nil buffer-disable-undo erase-buffer cvs-buffer fboundp fundamental-mode cvs-minor-mode 1 buffer-enable-undo t default-directory dir cvs-temp-buffer-name buf proc normal nosetup buffer-read-only list-buffers-directory lbd] 3 (#$ . 11030)])
#@63 Kill all the "temporary" buffers created by the *cvs* buffer.
(defalias 'cvs-mode-kill-buffers #[nil "\303\211\205�\n@\303\304\305\217\210\nA\211\204�\303*\207" [cvs-temp-buffers buf --dolist-tail-- nil (kill-buffer buf) ((error))] 4 (#$ . 12609) nil])
#@105 Create the *cvs* buffer for directory DIR.
If non-nil, NEW means to create a new buffer no matter what.
(defalias 'cvs-make-cvs-buffer #[(dir &optional new) "\306\307	!!)\310\n!\f\204 �
\311=\203 �\312 \203 �p\2061�\212\f?\205)�\313\314\215)\2061�\315\f\".r.q\210/\230\203K�\312 \203K�\316\317\320\217\206\300�/\3160\321 \210\322\323\324 !\325\326 \327\330!\331\332!\204j�\333\202\225�\334\332!1\335\3361\"\203\201�\3371\340\316OP\202\224�\335\3411\"\203\223�\3421\340\316OP\202\224�\333)\333\261\210\3430\344 \210\345\346!\210&\347\350\351\333\343$2\345\352!\2102*\353\354\355\316\343$\210.)+\207" [dir d cvs-buffer-name buffer-name new cvs-reuse-cvs-buffer file-name-as-directory expand-file-name eval current cvs-buffer-p --cl-block-nil-- (byte-code "p\305 B\306\211\205M�	@\211q\210\307 \203E�\n\310=\204@�\n\311=\2030�\312\f\"\204@�\312\f\"\202=�\n\313=\203<�\f\230\202=�\306\203E�\314\315\"\210	A\211\204�\306*\207" [buffer --dolist-tail-- cvs-reuse-cvs-buffer default-directory dir buffer-list nil cvs-buffer-p always subdir string-prefix-p samedir throw --cl-block-nil--] 4) cvs-get-buffer-create nil (byte-code "\301\302\211\303$\210p\207" [cvs-cookies cvs-cleanup-collection nil t] 5) ((error)) erase-buffer "Repository : " directory-file-name cvs-get-cvsroot "\nModule     : " cvs-get-module "\nWorking dir: " abbreviate-file-name file-readable-p "CVS/Tag" "\n" cvs-file-to-string string-match "\\`T" "\nTag        : " 1 "\\`D" "\nDate       : " t cvs-mode make-local-variable list-buffers-directory ewoc-create cvs-fileinfo-pp "\n\n" cvs-cookies add-hook kill-buffer-hook #[nil "\300\301\302\217\207" [nil (kill-buffer cvs-temp-buffer) ((error))] 3] buffer default-directory buffer-read-only tag cookies] 10 (#$ . 12876)])
#@75 

(fn CMD DIR FLAGS FIS NEW &key CVSARGS NOEXIST DONT-CHANGE-DISC NOSHOW)
(defalias 'cvs-cmd-do #[(cmd dir flags fis new &rest #1=#:--cl-rest--) "\306>A@\307>A@\310>A@\311>A@
\203D�
@\312>\203-�
AA\211\202�\313>A@\203;�\314\211\202�\315\316
@\"\210\202�)\317\320\321!!!\322\"\323!\204d�\315\324\"\210\n\204\202�\323\321\325\"!\204\202�\326\321\327\"!\204\202�\315\330\"\210q\210\331 \306	\310&\210\f\203\235�\202\245�\314!\332!).\207" [#1# cvsargs noexist dont-change-disc noshow #2=#:--cl-keys-- :cvsargs :noexist :dont-change-disc :noshow (:cvsargs :noexist :dont-change-disc :noshow :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:cvsargs :noexist :dont-change-disc :noshow)" file-name-as-directory abbreviate-file-name expand-file-name cvs-make-cvs-buffer file-directory-p "%s is not a directory" "CVS" file-expand-wildcards "*/CVS" "%s does not contain CVS controlled files" cvs-mode-run pop-to-buffer dir new cvsbuf cmd flags fis pop-up-windows] 9 (#$ . 14653)])
(defalias 'cvs-run-process #[(args fis postprocess &optional single-dir) "\306!\204\f�\307\310\311C\"\210rp	\206�\n\312=\211q\210db\210n\204)�\312\313c\210):\2032�	\204=�\314\315\316:\"\317E\202\266�:@\320H;>\204N�\321\322\323\324#\210:@\325H<\312\326<\313\261\210)\317=:\211:@>:\203\256�<>\320H;>\204\201�\321\322\323\324#\210>\325H\230\203\256�>\320H;>\204\231�\321\322\327\324#\210>\330H=B=:A\211:@>\202j�<=:E,\211?@<?A@=\331?8@\332\333\334\317\312$\210\335A:\"B\336\337\340\317\341#C\205\346�\342CDA=$A\317D<E\343\344E!!)F\345\346\347\fGA%)H\350H\300#\210rq\210\351B\352\"\210)\350H\353B#\210\350H\354@\2041I\202C\355\356AD\356@D\356ID\356	D\257#\210\357H\360\"\210\361H\362\"\210\363H!d\317\223\210\317\364\365\217\210q\210\366\367H!!J\370 \210.\f\371\320!\207" [cvs-buffer single-dir cvs-execute-single-dir cvsbuf procbuf inhibit-read-only cvs-buffer-p signal cl-assertion-failed (cvs-buffer-p cvs-buffer) t "\n" "" mapcar cvs-fileinfo->full-name nil 0 error "%s accessing a non-%s" cvs-fileinfo->dir cvs-fileinfo 4 "pcl-cvs: descending directory " cvs-fileinfo->file 5 2 add-hook kill-buffer-hook #[nil "\301p!\302!\205�\303\304\"\210\305\306\304#\210\307!)\207" [proc get-buffer-process processp set-process-filter nil process-put cvs-postprocess interrupt-process] 4] cvs-header-msg append cvs-flags-query cvs-cvs-flags noquery "-d" file-name-as-directory expand-file-name apply start-file-process "cvs" process-put cvs-update-header add cvs-header cvs-postprocess cvs-run-process quote set-process-sentinel cvs-sentinel set-process-filter cvs-update-filter process-mark (process-send-eof process) ((error)) symbol-name process-status force-mode-line-update sit-for fis cl-struct-cvs-fileinfo-tags dir files fi dir+files+rest rest args msg cvs-cvsroot process-connection-type d default-directory cvs-program process postprocess cvs-mode-line-process] 10])
(defalias 'cvs-header-msg #[(args fis) "\305\306\307	\"\n\310\311\312\313\314\305\315#\205�\316D	\306\317\f\"$!Q*\207" [lastarg args cvs-program cvs-cvsroot fis nil mapcar #[(arg) "\302=\203�	\303\230\203�\304	\207\304=\203 �	\305\230\203 �\306	\207\306=\203*�\307\310\207\302=\203:�	\311\230\203:�\312	\207\312=\203P�\313\314	\"\203P�\307\315\316	\"\310P\207	\207" [lastarg arg nil "commit" commit "-m" -m done "<log message>" "admin" admin string-match "\\`-m[^:]*:" match-string 0] 3] " " combine-and-quote-strings append cvs-flags-query cvs-cvs-flags noquery "-d" cvs-fileinfo->full-name] 10])
(defalias 'cvs-update-header #[(cmd add) "\306!\211@\307\310\311\"\211\2037�\f\312H\211\311H$>\204%�\313\314\315\316#\210
\312H)\317>\2037�\320\f\"\211\204�%\203O�\321\322\n\"\204E�\323\324&\325\nR\202y�\321\326\327&!\330Q\n\"\204c�\313\331!\210\202y�\332\307\333\211\n$\321\322\n\"\204s�\334\335&\336Q\337\n\340\f\203\205�\341\202\206�\342\343R#,\207" [cvs-cookies hf str done tin cl-x ewoc-get-hf "" ewoc-nth 0 2 error "%s accessing a non-%s" cvs-fileinfo->type cvs-fileinfo (MESSAGE DIRCHANGE) ewoc-next string-match "." "\n" "-- Running " " ...\n" "^-- Running " regexp-quote " \\.\\.\\.\n" "Internal PCL-CVS error while removing message" replace-match t "\n\n" "-- last cmd: " " --\n" ewoc-set-hf "\n--------------------- " "End" "Empty" " ---------------------\n" cl-struct-cvs-fileinfo-tags add cmd] 8])
#@122 Sentinel for the cvs update process.
This is responsible for parsing the output from the cvs update when
it is finished.
(defalias 'cvs-sentinel #[(proc msg) "\305!\306>\205\204�\307\310\"\307\311\"\312!\313\n!\204�\314\313	!\204&�\314\315\316\314#\210\317!\210\n\203c�r\nq\210\320\307\321\"\314\"\210\322\305!!\323 \210\203b�	\204X�\324\325!\210\202b�r	q\210\212\326!\210*)	\205\203�\327	!?\205\203�r	q\210\330 \210r\n\206{�pq\210\331\332\333 \"*+\207" [proc procbuf cvs-buf cvs-postproc cvs-mode-line-process process-status (signal exit) process-get cvs-postprocess cvs-buffer process-buffer buffer-live-p nil process-put postprocess delete-process cvs-update-header cvs-header symbol-name force-mode-line-update error "cvs' process buffer was killed" eval get-buffer-process buffer-enable-undo message "CVS process has completed in %s" buffer-name] 4 (#$ . 19111)])
#@319 Parse the output of a cvs process.
DCD is the `dont-change-disc' flag to use when parsing that output.
SUBDIR is the subdirectory (if any) where this command was run.
OLD-FIS is the list of fileinfos on which the cvs command was applied and
  which should be considered up-to-date if they are missing from the output.
(defalias 'cvs-parse-process #[(dcd &optional subdir old-fis) "\306=\203�\212eb\210\307\310\311\312#\203�\312\313\224\313\225|\210)\202\n�)\314\315\n#\311rq\210\311\311 \211!\203\206�!@\211 \313H\">\204N�\316\317\320\321#\210 \322H\323=\203v�\324#\325 \313H\">\204k�\316\317\326\321#\210 \327H#\244\202{� B!A\211!\204:�*)\311\311 \211!\203\307�!@\211 \313H\">\204\256�\316\317\320\321#\210 \322H\330=\204\276� B!A\211!\204\232�*)\f\311 \211!\203\366�!@ \331# 
#\332
\322H\"!A\211!\204\327�*\311 \211!\2031!@\211 \313H\">\204\316\317\320\321#\210 \211$\322\330I\210)\331# 
#!A\211!\204*\f\244\333#%\312=&\311$\210'\205V\n?\205V(?\205V\334\f!+\207" [system-type inhibit-read-only dcd subdir fileinfos last darwin re-search-forward "^\\^D+" nil t 0 cvs-parse-buffer cvs-parse-table error "%s accessing a non-%s" cvs-fileinfo->type cvs-fileinfo 2 DIRCHANGE ewoc-collect cvs-dir-member-p cvs-fileinfo->dir 4 UP-TO-DATE cvs-addto-collection delq cvs-cleanup-collection cvs-revert-if-needed cvs-buffer fis old-fis fi --dolist-tail-- cl-struct-cvs-fileinfo-tags cvs-cookies #1=#:v cvs-auto-remove-handled cvs-auto-remove-directories cvs-auto-revert cvs-from-vc] 8 (#$ . 20004)])
#@859 Define a function to be used in a *cvs* buffer.
This will look for a *cvs* buffer and execute BODY in it.
Since the interactive arguments might need to be queried after
switching to the *cvs* buffer, the generic code is rather ugly,
but luckily we can often use simpler alternatives.

FUN can be either a symbol (i.e. STYLE is nil) or a cons (FUN . STYLE).
ARGS and DOCSTRING are the normal argument list.
INTERACT is the interactive specification or nil for non-commands.

STYLE can be either SIMPLE, NOARGS or DOUBLE.  It's an error for it
to have any other value, unless other details of the function make it
clear what alternative to use.
- SIMPLE will get all the interactive arguments from the original buffer.
- NOARGS will get all the arguments from the *cvs* buffer and will
  always behave as if called interactively.
- DOUBLE is the generic case.
(defalias 'defun-cvs-mode '(macro . #[(fun args docstring interact &rest body) "\306!\211:\203�	@\202�	)\211\307=\204&�A@\203&�A@;\2038�\310\f
\311\312\313!BBD\257\202\250�\n\314=\203R�\310\313
\315\311\312\f!BBBD\257\202\250�\n\316=\203\244�\317\320
\"\210\321\322
\"\323\324!\325P!\"#\326\310\"\f
\327\324!\330R!BBBBB\331\332\"D\333\332DF\310\313#\334\324\"!\335R\336\311\332\"DD\257F*\202\250�\337\340\n\"*\207" [fun x style interact args docstring cvs-cdr SIMPLE defun cvs-mode! lambda nil NOARGS (interactive) DOUBLE string-match ".*" match-string 0 intern symbol-name "-1" progn "\nThis function only works within a *cvs* buffer.\nFor interactive use, use `" "' instead." put quote 'definition-name "\nWrapper function that switches to a *cvs* buffer\nbefore calling the real function `" "'.\n" (interactive) error "Unknown style %s in `defun-cvs-mode'" body fun-1 line1] 12 (#$ . 21601)]))
(byte-code "\300\301\302\303#\210\300\301\304\305#\207" [put defun-cvs-mode edebug-form-spec (&define sexp lambda-list stringp ("interactive" interactive) def-body) doc-string-elt 3] 4)
#@51 Kill the temporary buffer and associated process.
(defalias 'cvs-mode-kill-process #[nil "\300\301!\207" [cvs-mode! #[nil "\302!\205�\303!\205�\304!\211\205�\305	!)\207" [cvs-temp-buffer proc bufferp buffer-live-p get-buffer-process delete-process] 3]] 2 (#$ . 23579) nil])
#@191 Add FI to C and return FI's corresponding tin.
FI is inserted in its proper place or maybe even merged with a preexisting
  fileinfo if applicable.
TIN specifies an optional starting point.
(defalias 'cvs-addto-collection #[(c fi &optional tin) "\204	�\305	\306\"\203�\307\n\310H\"\203�\311	\"\211\204
�\204(�\312	\n\"\207\307\n\310H\"\2037�\313\314\315C\"\210\316	\"\211\203T�\307\n\310H\"\204T�\316	\"\211\204@�\307\310H\n\"\204s�\n\306H\f>\204k�\317\320\321\322#\210\n\310H\323=\203{�\324	\n#\202\217�\325\310H\n\"\210\326	\"\210n\203\216�\327 \210)\207" [tin c fi next-tin cl-struct-cvs-fileinfo-tags ewoc-nth 0 cvs-fileinfo< 2 ewoc-prev ewoc-enter-first signal cl-assertion-failed (not (cvs-fileinfo< fi (ewoc-data tin))) ewoc-next error "%s accessing a non-%s" cvs-fileinfo->type cvs-fileinfo MESSAGE ewoc-enter-after cvs-fileinfo-update ewoc-invalidate cvs-move-to-goal-column] 5 (#$ . 23867)])
#@172 Functions to tweak the cleanup process.
The functions are called with a single argument (a FILEINFO) and should
return a non-nil value if that fileinfo should be removed.
(custom-declare-variable 'cvs-cleanup-functions nil '(#$ . 24798) :group 'pcl-cvs :type '(hook :options (cvs-cleanup-removed)))
#@300 Non-nil if FI has been cvs-removed but still exists.
This is intended for use on `cvs-cleanup-functions' when you have cvs-removed
automatically generated files (which should hence not be under CVS control)
but can't commit the removal because the repository's owner doesn't understand
the problem.
(defalias 'cvs-cleanup-removed #[(fi) "\302H	>\204�\303\304\305\306#\210\307H\310=\204B�\302H	>\204$�\303\304\305\306#\210\307H\311=\205G�\302H	>\204:�\303\304\312\306#\210\313H\310=\205G�\314\315!!\207" [fi cl-struct-cvs-fileinfo-tags 0 error "%s accessing a non-%s" cvs-fileinfo->type cvs-fileinfo 2 REMOVED CONFLICT cvs-fileinfo->subtype 3 file-exists-p cvs-fileinfo->full-name] 4 (#$ . 25104)])
#@193 Remove undesired entries.
C is the collection
RM-HANDLED if non-nil means remove handled entries.
RM-DIRS behaves like `cvs-auto-remove-directories'.
RM-MSGS if non-nil means remove messages.
(defalias 'cvs-cleanup-collection #[(c rm-handled rm-dirs rm-msgs) "\306\211\307\205V�\306\307\310\311\312\313\211$\314\315\"\210\f\203�	\204�\n\316H
>\2040�\317\320\321\322#\210\n\323H\324=\203�\n\316H
>\204F�\317\320\321\322#\210\n\211\323\311I\210)\307\211\204\n�\306+\207" [rerun first-dir last-fi c rm-dirs cl-struct-cvs-fileinfo-tags nil t cvs-create-fileinfo DEAD "../" "" ewoc-filter #[(fi) "\306H	>\204�\307\310\311\312#\210\313H\306H	>\204 �\307\310\314\312#\210\315H\n\316=\2035�\f\2061�\317=?\202[�\n\320=\203?�\321\202[�\n\322=\203V�\323\324!!\203Q�\325\202[�
?\202[�\326\327\"?\211\203\350� \203\350�!\306H	>\204u�\307\310\311\312#\210!\313H\330=\203\350�\"\203\211�\321\"\202\350� \331=\204\314�\332!\306H	>\204\240�\307\310\333\312#\210!\334H\306H	>\204\262�\307\310\333\312#\210\334H\"\203\314�\n\330=\203\306� \335=\204\314�\336=\203\350�!\306H	>\204\333�\307\310\311\312#\210!\211#\313\320I\210)\325$\205\361�\211!+\207" [fi cl-struct-cvs-fileinfo-tags type subtype rm-msgs rm-handled 0 error #2="%s accessing a non-%s" cvs-fileinfo->type cvs-fileinfo 2 cvs-fileinfo->subtype 3 MESSAGE TEMP DEAD nil UP-TO-DATE find-buffer-visiting cvs-fileinfo->full-name t run-hook-with-args-until-success cvs-cleanup-functions DIRCHANGE all string-prefix-p cvs-fileinfo->dir 4 empty FOOTER keep rm-dirs last-fi first-dir #1=#:v rerun] 7] 0 error #2# cvs-fileinfo->type cvs-fileinfo 2 DIRCHANGE #3=#:v] 6 (#$ . 25817)])
#@27 Gets the CVSROOT for DIR.
(defalias 'cvs-get-cvsroot #[nil "\302\303\304\"\305\306\"\206�	\206�\307\310!\206�\311)\207" [cvs-cvsroot-file cvs-cvsroot expand-file-name "Root" "CVS" cvs-file-to-string t getenv "CVSROOT" "?????"] 3 (#$ . 27485)])
#@101 Return the current CVS module.
This usually doesn't really work but is a handy initval in a prompt.
(defalias 'cvs-get-module #[nil "\304\305\306\"\307\310\"\211\204�\311\202@�\312	!\204�	\202@�\313 \314\n\206%�\315!\316	Q\n\203<�\317\320\"\203<�\321\322\"\202?�\323	!**\207" [repfile rep root str expand-file-name "Repository" "CVS" cvs-file-to-string t "" file-name-absolute-p cvs-get-cvsroot file-name-as-directory "/" " || " string-match "\\(.*\\) || \\1\\(.*\\)\\'" match-string 2 file-name-nondirectory] 4 (#$ . 27741)])
#@187 Run a 'cvs checkout MODULES' in DIR.
Feed the output to a *cvs* buffer, display it in the current window,
and run `cvs-mode' on it.

With a prefix argument, prompt for cvs FLAGS to use.
(defalias 'cvs-checkout #[(modules dir flags &optional root) "\306=\203\f�\307\310\311\312#	\313\314\206�\f\315
\"\311\316\317\306&)\207" [flags root cvs-cvsroot dir default-directory modules t cvs-flags-query cvs-checkout-flags nil noquery cvs-cmd-do "checkout" append new :noexist] 8 (#$ . 28284) (let ((root (cvs-get-cvsroot))) (if (or (null root) current-prefix-arg) (setq root (read-string "CVS Root: "))) (list (split-string-and-unquote (read-string "Module(s): " (cvs-get-module))) (read-directory-name "CVS Checkout Directory: " nil default-directory nil) (cvs-add-branch-prefix (cvs-flags-query 'cvs-checkout-flags "cvs checkout flags")) root))])
#@75 Run cvs checkout against the current branch.
The files are stored to DIR.
(defalias 'cvs-mode-checkout #[nil "\300\301!\207" [cvs-mode! #[(dir) "\304\305 !\306\307\310\311\"!\312 \313\n	#+\207" [cvs-cvsroot flags modules dir split-string-and-unquote cvs-get-module cvs-add-branch-prefix cvs-flags-query cvs-checkout-flags "cvs checkout flags" cvs-get-cvsroot cvs-checkout] 5 nil (let* ((branch (cvs-prefix-get 'cvs-branch-prefix)) (prompt (format "CVS Checkout Directory for `%s%s': " (cvs-get-module) (if branch (format " (branch: %s)" branch) "")))) (list (read-directory-name prompt nil default-directory nil)))]] 2 (#$ . 29139) nil])
#@70 Rerun `cvs-examine' on the current directory with the default flags.
(defalias 'cvs-mode-revert-buffer #[(&optional ignore-auto noconfirm) "\300\301!\207" [cvs-mode! #[nil "\301\302\"\207" [default-directory cvs-examine t] 3]] 2 (#$ . 29787) nil])
#@115 Read directory name, prompting with PROMPT.
If in a *cvs* buffer, don't prompt unless a prefix argument is given.
(defalias 'cvs-query-directory #[(prompt) "\303 \203�\204�	\207\304\n\305	\305$\207" [current-prefix-arg default-directory prompt cvs-buffer-p read-directory-name nil] 5 (#$ . 30043)])
#@304 Open a *cvs* buffer on DIR without running cvs.
With a prefix argument, prompt for a directory to use.
A prefix arg >8 (ex: \[universal-argument] \[universal-argument]),
  prevents reuse of an existing *cvs* buffer.
Optional argument NOSHOW if non-nil means not to display the buffer.
FLAGS is ignored.
(defalias 'cvs-quickdir #[(dir &optional flags noshow) "\306\307\310!!!\311	!\312V\313\n\"\314\315!\204 �\316\317\"\210\315\310\320\"!\204.�\316\321\"\210q\210\322\323!\314\211\203P�@\324
\f#A\211\204<�*\325\326=\314$\210\203f�\202m�\314\327!),\207" [dir current-prefix-arg new cvsbuf last fi file-name-as-directory abbreviate-file-name expand-file-name prefix-numeric-value 8 cvs-make-cvs-buffer nil file-directory-p error "%s is not a directory" "CVS" "%s does not contain CVS controlled files" cvs-fileinfo-from-entries "" cvs-addto-collection cvs-cleanup-collection t pop-to-buffer --dolist-tail-- cvs-cookies cvs-auto-remove-handled cvs-auto-remove-directories noshow pop-up-windows] 6 (#$ . 30352) (list (cvs-query-directory "CVS quickdir (directory): "))])
#@427 Run a `cvs -n update' in the specified DIRECTORY.
That is, check what needs to be done, but don't change the disc.
Feed the output to a *cvs* buffer and run `cvs-mode' on it.
With a prefix argument, prompt for a directory and cvs FLAGS to use.
A prefix arg >8 (ex: \[universal-argument] \[universal-argument]),
  prevents reuse of an existing *cvs* buffer.
Optional argument NOSHOW if non-nil means not to display the buffer.
(defalias 'cvs-examine #[(directory flags &optional noshow) "\305=\203\f�\306\307\310\311#	\203�\312\n!\313\314\n\310\315!\316V\317\320\321\f\322\305&\207" [flags find-file-visit-truename directory current-prefix-arg noshow t cvs-flags-query cvs-update-flags nil noquery file-truename cvs-cmd-do "update" prefix-numeric-value 8 :cvsargs ("-n") :noshow :dont-change-disc] 12 (#$ . 31462) (list (cvs-query-directory "CVS Examine (directory): ") (cvs-flags-query 'cvs-update-flags "cvs -n update flags"))])
#@388 Run a `cvs update' in the current working DIRECTORY.
Feed the output to a *cvs* buffer and run `cvs-mode' on it.
With a \[universal-argument] prefix argument, prompt for a directory to use.
A prefix arg >8 (ex: \[universal-argument] \[universal-argument]),
  prevents reuse of an existing *cvs* buffer.
The prefix is also passed to `cvs-flags-query' to select the FLAGS
  passed to cvs.
(defalias 'cvs-update #[(directory flags) "\303=\203\f�\304\305\306\307#\310\311	\306\312\n!\313V%\207" [flags directory current-prefix-arg t cvs-flags-query cvs-update-flags nil noquery cvs-cmd-do "update" prefix-numeric-value 8] 7 (#$ . 32406) (list (cvs-query-directory "CVS Update (directory): ") (cvs-flags-query 'cvs-update-flags "cvs update flags"))])
#@365 Run a `cvs status' in the current working DIRECTORY.
Feed the output to a *cvs* buffer and run `cvs-mode' on it.
With a prefix argument, prompt for a directory and cvs FLAGS to use.
A prefix arg >8 (ex: \[universal-argument] \[universal-argument]),
  prevents reuse of an existing *cvs* buffer.
Optional argument NOSHOW if non-nil means not to display the buffer.
(defalias 'cvs-status #[(directory flags &optional noshow) "\304=\203\f�\305\306\307\310#\311\312	\307\313\n!\314V\315\316\304&	\207" [flags directory current-prefix-arg noshow t cvs-flags-query cvs-status-flags nil noquery cvs-cmd-do "status" prefix-numeric-value 8 :noshow :dont-change-disc] 10 (#$ . 33162) (list (cvs-query-directory "CVS Status (directory): ") (cvs-flags-query 'cvs-status-flags "cvs status flags"))])
#@247 Filter function for pcl-cvs.
This function gets the output that CVS sends to stdout.  It inserts
the STRING into (process-buffer PROC) but it also checks if CVS is waiting
for a lock file.  If so, it inserts a message cookie in the *cvs* buffer.
(defalias 'cvs-update-filter #[(proc string) "\306 \307\216r\310	!q\210\311\212\312	!b\210c\210\312	!`\313\223\210\314\315!\210\316\317!\205]�\320\321!\320\322!r!q\210\323\324!\210\f\325\"\326\327\330\331
\332\f!\205L�\333\334!P\335\336&\"\210\337p!\210db\210\340 +-\207" [save-match-data-internal proc inhibit-read-only string lock msg match-data ((byte-code "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3)) process-buffer t process-mark nil beginning-of-line 0 looking-at "^[ a-z]+: \\(.*waiting for .*lock in \\(.*\\)\\)$" match-string 1 2 make-local-variable cvs-lock-file ewoc-enter-last cvs-create-fileinfo MESSAGE "" " " file-exists-p substitute-command-keys "\n	(type \\[cvs-mode-delete-lock] to delete it)" :subtype TEMP pop-to-buffer beep cvs-buffer cvs-cookies] 9 (#$ . 33960)])
#@64 
See `cvs-prefix-set' for further description of the behavior.
(defvar cvs-force-command nil (#$ . 35037))
(defvar cvs-force-command-cps (byte-code "\303\211G	Y\204�\304\305	S@\"\"\306\307\310\311\n\310&)\207" [defaults cvs-prefix-number cvs-qtypedesc-string1 ("/F") append make-list vector cl-struct-cvs-flags nil ""] 8))
#@352 Force the next cvs command to operate on all the selected files.
By default, cvs commands only operate on files on which the command
"makes sense".  This overrides the safety feature on the next cvs command.
It actually behaves as a toggle.  If prefixed by \[universal-argument] \[universal-argument],
the override will persist until the next toggle.
(defalias 'cvs-mode-force-command #[(arg) "\300\301!\207" [cvs-mode! #[nil "\301\302\"\207" [arg cvs-prefix-set cvs-force-command] 3]] 2 (#$ . 35374) "P"])
(byte-code "\300\301\302\303#\210\304\305N\204�\300\304\305\306\307!#\210\310\311!\204 �\300\311\312\301#\210\300\207" [put cvs-mode mode-class special cvs-mode-hook variable-documentation purecopy "Hook run when entering CVS mode.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it.  (This is true for all hook variables.)" boundp cvs-mode-map definition-name] 5)
(defvar cvs-mode-map (make-sparse-keymap))
(byte-code "\300\301N\204�\302\300\301\303\304!#\210\305\306!\204�\302\306\307\310#\210\300\207" [cvs-mode-map variable-documentation put purecopy "Keymap for `cvs-mode'." boundp cvs-mode-syntax-table definition-name cvs-mode] 5)
(defvar cvs-mode-syntax-table (make-syntax-table))
(byte-code "\300\301N\204�\302\300\301\303\304!#\210\302\305\306\307#\207" [cvs-mode-syntax-table variable-documentation put purecopy "Syntax table for `cvs-mode'." cvs-mode-abbrev-table definition-name cvs-mode] 5)
(defvar cvs-mode-abbrev-table (progn (define-abbrev-table 'cvs-mode-abbrev-table nil) cvs-mode-abbrev-table))
(byte-code "\300\301N\204�\302\300\301\303\304!#\210\302\305\306\307#\207" [cvs-mode-abbrev-table variable-documentation put purecopy "Abbrev table for `cvs-mode'." cvs-mode derived-mode-parent nil] 5)
#@186 Mode used for PCL-CVS, a frontend to CVS.
Full documentation is in the Texinfo file.

This mode runs the hook `cvs-mode-hook', as the final step
during initialization.

\{cvs-mode-map}
(defalias 'cvs-mode #[nil "\306\300!\210\307\310 \210\311\312\313!\210\314\f!\210
\315\203$�\316\317!\210\320 \210\306\321!\210\322\307\323\324!\210\323\325!\210\323\326!\210\323\327!\210\306\330!\210\306\331!\210)\332\333!\207" [delay-mode-hooks major-mode mode-name cvs-mode-map cvs-mode-syntax-table cvs-mode-abbrev-table make-local-variable t kill-all-local-variables cvs-mode "CVS" use-local-map set-syntax-table (#1="" cvs-force-command cvs-ignore-marks-modif ":" (cvs-branch-prefix (#1# cvs-branch-prefix (cvs-secondary-branch-prefix ("->" cvs-secondary-branch-prefix)))) " " cvs-mode-line-process) error "Use M-x cvs-quickdir to get a *cvs* buffer" buffer-disable-undo revert-buffer-function cvs-mode-revert-buffer cvs-prefix-make-local cvs-branch-prefix cvs-secondary-branch-prefix cvs-force-command cvs-ignore-marks-modif cvs-mode-line-process cvs-temp-buffers run-mode-hooks cvs-mode-hook local-abbrev-table mode-line-process buffer-file-name truncate-lines] 2 (#$ . 37146) nil])
#@72 Return whether the (by default current) BUFFER is a `cvs-mode' buffer.
(defalias 'cvs-buffer-p #[(&optional buffer) "\212\203�q\210	)\302=\207" [buffer major-mode cvs-mode] 2 (#$ . 38342)])
#@65 Check that the current buffer follows cvs-buffer's conventions.
(defalias 'cvs-buffer-check #[nil "p\306\307\211\203<�\310\n!	=\203<�\303\211\203<�\2038�\311!\2038�rq\210\f)	=\203<�rq\210
)
\232\203<�\312\202C�\313\314\315	!#*\207" [check buf cvs-cookies cvs-temp-buffer cvs-buffer default-directory none collection ewoc-buffer buffer-live-p t error "Inconsistent %s in buffer %s" buffer-name] 5 (#$ . 38541)])
#@41 Quit PCL-CVS, killing the *cvs* buffer.
(defalias 'cvs-mode-quit #[nil "\300\301!\205	�\302p!\207" [y-or-n-p "Quit pcl-cvs? " kill-buffer] 2 (#$ . 38967) nil])
#@44 Display help for various PCL-CVS commands.
(defalias 'cvs-help #[nil "\301=\203\n�\302\303!\207\304\305\306\307!\"\207" [last-command cvs-help describe-function cvs-mode message "%s" substitute-command-keys "`\\[cvs-help]':help `\\[cvs-mode-add]':add `\\[cvs-mode-commit]':commit `\\[cvs-mode-diff-map]':diff* `\\[cvs-mode-log]':log `\\[cvs-mode-remove]':remove `\\[cvs-mode-status]':status `\\[cvs-mode-undo]':undo"] 4 (#$ . 39133) nil])
(defalias 'cvs-move-to-goal-column #[nil "\302 \303`\304\305$\211W\205�	b*\207" [eol fpos line-end-position next-single-property-change cvs-goal-column nil] 6])
#@82 Go to the previous line.
If a prefix argument is given, move by that many lines.
(defalias 'cvs-mode-previous-line #[(arg) "\300\301!\207" [cvs-mode! #[nil "\302	\"\210\303 \207" [cvs-cookies arg ewoc-goto-prev cvs-move-to-goal-column] 3]] 2 (#$ . 39745) "p"])
#@78 Go to the next line.
If a prefix argument is given, move by that many lines.
(defalias 'cvs-mode-next-line #[(arg) "\300\301!\207" [cvs-mode! #[nil "\302	\"\210\303 \207" [cvs-cookies arg ewoc-goto-next cvs-move-to-goal-column] 3]] 2 (#$ . 40013) "p"])
#@160 Mark the fileinfo on the current line.
If the fileinfo is a directory, all the contents of that directory are
marked instead. A directory can never be marked.
(defalias 'cvs-mode-mark #[(&optional arg) "\300\301!\207" [cvs-mode! #[nil "\306!\211\307H\211\310H>\204�\311\312\313\314#\210\n\307H\315=\2036�\316\317\n\310H>\204/�\311\312\320\314#\210\n\321H#\202o�\n\310H>\204D�\311\312\322\314#\210\n\211\323
\324=\203b�\n\310H>\204\\�\311\312\322\314#\210\n\323H\202c�
?I\210)\325	\"\210\326\323!*\207" [cvs-cookies tin fi cl-struct-cvs-fileinfo-tags #1=#:v arg ewoc-locate 2 0 error "%s accessing a non-%s" cvs-fileinfo->type cvs-fileinfo DIRCHANGE ewoc-map #[(f dir) "\305	\"\2059�\306H\n>\204�\307\310\311\312#\210\211\313\f\314=\2033�\306H\n>\204-�\307\310\311\312#\210\313H\2024�\f?I\210)\315\207" [f dir cl-struct-cvs-fileinfo-tags #2=#:v arg cvs-dir-member-p 0 error "%s accessing a non-%s" cvs-fileinfo->marked cvs-fileinfo 1 toggle t] 7] cvs-fileinfo->dir 4 cvs-fileinfo->marked 1 toggle ewoc-invalidate cvs-mode-next-line] 8]] 2 (#$ . 40274) nil])
(defalias 'cvs-mouse-toggle-mark 'cvs-mode-toggle-mark)
#@40 Toggle the mark of the entry at point.
(defalias 'cvs-mode-toggle-mark #[(e) "\212\301\302!!\210\303\304!)\207" [e posn-set-point event-end cvs-mode-mark toggle] 3 (#$ . 41411) (list last-input-event)])
#@42 Unmark the fileinfo on the current line.
(defalias 'cvs-mode-unmark #[nil "\300\301!\207" [cvs-mode! #[nil "\300\301!\207" [cvs-mode-mark t] 2]] 2 (#$ . 41621) nil])
#@17 Mark all files.
(defalias 'cvs-mode-mark-all-files #[nil "\300\301!\207" [cvs-mode! #[nil "\301\302\"\207" [cvs-cookies ewoc-map #[(cookie) "\303H	>\204�\304\305\306\307#\210\310H\311=?\205,�\303H	>\204%�\304\305\312\307#\210\211\313\314I)\207" [cookie cl-struct-cvs-fileinfo-tags #1=#:v 0 error "%s accessing a non-%s" cvs-fileinfo->type cvs-fileinfo 2 DIRCHANGE cvs-fileinfo->marked 1 t] 5]] 3]] 2 (#$ . 41793) nil])
#@32 Mark all files in state STATE.
(defalias 'cvs-mode-mark-on-state #[(state) "\300\301!\207" [cvs-mode! #[nil "\301\302\"\207" [cvs-cookies ewoc-map #[(fi) "\304H	>\204�\305\306\307\310#\210\311H\n=\205+�\304H	>\204$�\305\306\312\310#\210\211\313\314I)\207" [fi cl-struct-cvs-fileinfo-tags state #1=#:v 0 error "%s accessing a non-%s" cvs-fileinfo->type cvs-fileinfo 2 cvs-fileinfo->marked 1 t] 5]] 3]] 2 (#$ . 42225) (list (let ((default (condition-case nil (downcase (symbol-name (let ((cl-x (cvs-mode-marked nil nil :read-only t :one t :noquery t))) (progn (or (and (memq (aref cl-x 0) cl-struct-cvs-fileinfo-tags)) (error "%s accessing a non-%s" 'cvs-fileinfo->type 'cvs-fileinfo)) (aref cl-x 2))))) (error nil)))) (intern (upcase (completing-read (concat "Mark files in state" (if default (concat " [" default "]")) ": ") (mapcar #'(lambda (x) (list (downcase (symbol-name (car x))))) cvs-states) nil t nil nil default)))))])
#@32 Mark all files matching REGEX.
(defalias 'cvs-mode-mark-matching-files #[(regex) "\300\301!\207" [cvs-mode! #[nil "\301\302\"\207" [cvs-cookies ewoc-map #[(cookie) "\304H	>\204�\305\306\307\310#\210\311H\312=?\205C�\313\n\304H	>\204'�\305\306\314\310#\210\315H\"\205C�\304H	>\204<�\305\306\316\310#\210\211\317\320I)\207" [cookie cl-struct-cvs-fileinfo-tags regex #1=#:v 0 error "%s accessing a non-%s" cvs-fileinfo->type cvs-fileinfo 2 DIRCHANGE string-match cvs-fileinfo->file 5 cvs-fileinfo->marked 1 t] 7]] 3]] 2 (#$ . 43167) "sMark files matching: "])
#@113 Unmark all files.
Directories are also unmarked, but that doesn't matter, since
they should always be unmarked.
(defalias 'cvs-mode-unmark-all-files #[nil "\300\301!\207" [cvs-mode! #[nil "\301\302\"\207" [cvs-cookies ewoc-map #[(cookie) "\303H	>\204�\304\305\306\307#\210\211\310\311I\210)\312\207" [cookie cl-struct-cvs-fileinfo-tags #1=#:v 0 error "%s accessing a non-%s" cvs-fileinfo->marked cvs-fileinfo 1 nil t] 5]] 3]] 2 (#$ . 43740) nil])
#@39 Unmark the file on the previous line.
(defalias 'cvs-mode-unmark-up #[nil "\300\301!\207" [cvs-mode! #[nil "\305\306\"\211\203(�	\307H\211\310H>\204�\311\312\313\314#\210\n\211\306\315I\210*\316	\"\210)\317 \207" [cvs-cookies tin cl-x cl-struct-cvs-fileinfo-tags #1=#:v ewoc-goto-prev 1 2 0 error "%s accessing a non-%s" cvs-fileinfo->marked cvs-fileinfo nil ewoc-invalidate cvs-move-to-goal-column] 5]] 2 (#$ . 44198) nil])
(defconst cvs-ignore-marks-alternatives '(("toggle-marks" . "/TM") ("force-marks" . "/FM") ("ignore-marks" . "/IM")))
#@112 Prefix to decide whether to ignore marks or not.
See `cvs-prefix-set' for further description of the behavior.
(defvar cvs-ignore-marks-modif nil (#$ . 44755))
(defvar cvs-ignore-marks-modif-cps (byte-code "\306\307\"\211G\nY\204�\310	\311\nS	@\"\"	\312\313\314\315\316
\f\317\320&+\315\321	\317\322\317&+\207" [cvs-ignore-marks-alternatives defaults cvs-prefix-number complete obj2str str2obj mapcar cdr append make-list #[(str) "\302	\"A\207" [str cvs-ignore-marks-alternatives assoc] 3] #[(obj) "\302	\"@\207" [obj cvs-ignore-marks-alternatives rassoc] 3] #[nil "\207" [cvs-ignore-marks-alternatives] 1] vector cl-struct-cvs-qtypedesc nil t cl-struct-cvs-flags "active" qtypedesc] 9))
#@254 Toggle whether the next CVS command uses marks.
See `cvs-prefix-set' for further description of the behavior.
\[universal-argument] 1 selects `force-marks',
\[universal-argument] 2 selects `ignore-marks',
\[universal-argument] 3 selects `toggle-marks'.
(defalias 'cvs-mode-toggle-marks #[(arg) "\300\301!\207" [cvs-mode! #[nil "\301\302\"\207" [arg cvs-prefix-set cvs-ignore-marks-modif] 3]] 2 (#$ . 45468) "P"])
(defalias 'cvs-ignore-marks-p #[(cmd &optional read-only) "	\235\203�\n?\202\f�\n\306\307\"\f\310\232\203�\311\2022�\f\312\232\203'�
?\2022�\f\313\232\2031�\314\2022�
*\207" [cmd cvs-invert-ignore-marks cvs-default-ignore-marks read-only modif default cvs-prefix-get cvs-ignore-marks-modif "/IM" t "/TM" "/FM" nil] 4])
(defalias 'cvs-mode-mark-get-modif #[(cmd) "\301\302\"\203	�\303\207\304\207" [cmd cvs-ignore-marks-p read-only "/IM" "/FM"] 3])
#@363 Return a list of all selected fileinfos.
If there are any marked tins, and IGNORE-MARKS is nil, return them.
Otherwise, if the cursor selects a directory, and IGNORE-CONTENTS is
nil, return all files in it, else return just the directory.
Otherwise return (a list containing) the file the cursor points to, or
an empty list if it doesn't point to a file at all.
(defalias 'cvs-get-marked #[(&optional ignore-marks ignore-contents) "\306\307\301!\203�	:\203�\310\311	\"\202(�\n\204�\312\313\"\206(�\314!\211\315H)C\306\211\203z�@\204P�
\316H>\204H�\317\320\321\322#\210
\315H\323=\204W�
B\202q�\324\312\325
\316H>\204j�\317\320\326\322#\210
\327H#\"A\211\2040�*\237)\207" [fis cvs-minor-current-files ignore-marks cvs-cookies cl-x fi nil boundp mapcar #[(f) "\304!\203�G\305Y\203�\306H	>\203�\207\307!\310!\203,�\311\312\313!\314\315$\202?�\316!\317!\311\320\206;�\315\n\315$*)\207" [f cl-struct-cvs-fileinfo-tags file dir vectorp 10 0 file-relative-name file-directory-p cvs-create-fileinfo DIRCHANGE file-name-as-directory "." "" file-name-directory file-name-nondirectory UNKNOWN] 5] ewoc-collect cvs-fileinfo->marked ewoc-locate 2 0 error "%s accessing a non-%s" cvs-fileinfo->type cvs-fileinfo DIRCHANGE append cvs-dir-member-p cvs-fileinfo->dir 4 --dolist-tail-- ignore-contents cl-struct-cvs-fileinfo-tags] 9 (#$ . 46344)])
#@387 Get the list of marked FIS.
CMD is used to determine whether to use the marks or not.
Only files for which FILTER is applicable are returned.
If READ-ONLY is non-nil, the current toggling is left intact.
If ONE is non-nil, marks are ignored and a single FI is returned.
If FILE is non-nil, directory entries won't be selected.

(fn FILTER &optional CMD &key READ-ONLY ONE FILE NOQUERY)
(defalias 'cvs-mode-marked #[(filter &optional cmd &rest #1=#:--cl-rest--) "\306>A@\307>A@\310>A@\311>A@
\203D�
@\312>\203-�
AA\211\202�\313>A@\203;�\314\211\202�\315\316
@\"\210\202�)!\204P�\317\"!!\320\n\206Z�\321!	\"?\205d�\322\323\"\"\"#\324\325!$\326\327#\"@\211#\203\202�\n\203\245�#A\203\245�\f\204\245�\330#\204\220�\331\202\221�\332!\"\210\333\334!\210\335\336\337\340!\"!!C#\n\203\257�#@\202\261�#.\207" [#1# read-only one file noquery #2=#:--cl-keys-- :read-only :one :file :noquery (:read-only :one :file :noquery :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:read-only :one :file :noquery)" symbol-name cvs-get-marked cvs-ignore-marks-p cvs-applicable-p DIRCHANGE cvs-prefix-get cvs-force-command cvs-partition #[(fi) "\303	?\205�\n\"\207" [fi force filter cvs-applicable-p] 3] message "`%s' is not applicable to any of the selected files." "`%s' is only applicable to a single file." sit-for 1 cvs-insert-file read-file-name format "File to %s: " cmd filter fis force] 6 (#$ . 47726)])
#@73 Determine whether FILTER applies to at least one of the selected files.
(defalias 'cvs-enabledp #[(filter) "\300\301\302\217\207" [nil (byte-code "\301\302\303\304\305\304&\207" [filter cvs-mode-marked nil :read-only t :noquery] 7) ((error))] 3 (#$ . 49189)])
(defalias 'cvs-mode-files #[(&rest -cvs-mode-files-args) "\300\301!\207" [cvs-mode! #[nil "\301\302\303\304\"\"\207" [-cvs-mode-files-args mapcar cvs-fileinfo->full-name apply cvs-mode-marked] 5]] 2])
#@35 Run `cvs-mode-commit' with setup.
(defalias 'cvs-mode-commit-setup #[nil "\300\301!\207" [cvs-mode-commit force] 2 (#$ . 49659) nil])
#@46 Hook run after setting up the commit buffer.
(custom-declare-variable 'cvs-mode-commit-hook nil '(#$ . 49799) :type 'hook :options '(cvs-mode-diff) :group 'pcl-cvs)
#@300 Check in all marked files, or the current file.
The user will be asked for a log message in a buffer.
The buffer's mode and name is determined by the "message" setting
  of `cvs-buffer-name-alist'.
The POSTPROC specified there (typically `log-edit') is then called,
  passing it the SETUP argument.
(defalias 'cvs-mode-commit #[(setup) "\305 \210\306\307\310\311#\312\313\307\"A8\206�\314	\315\316\n$\210\317\304!\210\320\321\322!*\207" [cvs-buffer-name-alist setupfun buf setup cvs-minor-wrap-function cvs-mode! cvs-temp-buffer "message" normal nosetup 2 assoc log-edit cvs-do-commit ((log-edit-listfun . cvs-commit-filelist) (log-edit-diff-function . cvs-mode-diff)) make-local-variable cvs-commit-minor-wrap run-hooks cvs-mode-commit-hook] 5 (#$ . 49971) "P"])
(defalias 'cvs-commit-minor-wrap #[(buf f) "\302\303!	 )\207" [cvs-ignore-marks-modif f cvs-mode-mark-get-modif "commit"] 2])
(defalias 'cvs-commit-filelist #[nil "\300\301\302\303\304\305\304\306\304&\207" [cvs-mode-files commit nil :read-only t :file :noquery] 9])
#@68 Do the actual commit, using the current buffer as the log message.
(defalias 'cvs-do-commit #[(flags) "\302ed\"\303 \210\304\305\306	BB\307#)\207" [msg flags buffer-substring-no-properties cvs-mode! cvs-mode-do "commit" "-m" commit] 5 (#$ . 51016) (list (cvs-flags-query 'cvs-commit-flags "cvs commit flags"))])
(defalias 'cvs-edit-log-text-at-point #[nil "\212\300\210\301\302\300\303#\2051�\304y\210\305\306!\203�\304y\210\305\307!\203!�\304y\210`\310\311\300\303#\203/�\312\224\2020�`{)\207" [nil re-search-backward "^revision " t 1 looking-at "date:" "branches:" re-search-forward "^\\(-\\{28\\}\\|=\\{77\\}\\|revision [.0-9]+\\)$" 0] 5])
(put 'cvs-edit-log-files 'permanent-local t)
#@83 Edit the log message at point.
This is best called from a `log-view-mode' buffer.
(defalias 'cvs-mode-edit-log #[(file rev &optional text) "\306 \210\307\310\311\312#\313\314\310\"A8\206�\315r\nq\210\316\304!\210C)	\317\320\321\n$\210
\2032�\322 \210
c\210\316\323!\210\316\324!\210\325\211*\207" [cvs-buffer-name-alist setupfun buf file cvs-edit-log-files text cvs-mode! cvs-temp-buffer "message" normal nosetup 2 assoc log-edit make-local-variable cvs-do-edit-log nil ((log-edit-listfun . cvs-edit-log-filelist) (log-edit-diff-function . cvs-mode-diff)) erase-buffer cvs-edit-log-revision cvs-minor-wrap-function cvs-edit-log-minor-wrap rev] 5 (#$ . 51714) (list (or (cvs-mode! #'(lambda nil (car (cvs-mode-files nil nil :read-only t :file t :noquery t)))) (read-string "File name: ")) (or (cvs-mode! #'(lambda nil (cvs-prefix-get 'cvs-branch-prefix))) (read-string "Revision to edit: ")) (cvs-edit-log-text-at-point))])
(defalias 'cvs-edit-log-minor-wrap #[(buf f) "rq\210	)rq\210\n)\306 +\207" [buf cvs-edit-log-revision cvs-edit-log-files cvs-force-command cvs-minor-current-files cvs-branch-prefix "/F" f] 3])
(defalias 'cvs-edit-log-filelist #[nil "\203�\302\303\211\304\305\306\305\307\305&\207	\207" [cvs-minor-wrap-function cvs-edit-log-files cvs-mode-files nil :read-only t :file :noquery] 9])
#@68 Do the actual commit, using the current buffer as the log message.
(defalias 'cvs-do-edit-log #[(rev) "\301ed\"\302\303!)\207" [msg buffer-substring-no-properties cvs-mode! #[nil "\302\303\304\305	RC\306#\207" [rev msg cvs-mode-do "admin" "-m" ":" nil] 6]] 3 (#$ . 53047) (list cvs-edit-log-revision)])
#@193 Insert an entry for a specific file into the current listing.
This is typically used if the file is up-to-date (or has been added
outside of PCL-CVS) and one wants to do some operation on it.
(defalias 'cvs-mode-insert #[nil "\300\301!\207" [cvs-mode! #[(file) "\301!\207" [file cvs-insert-file] 2 nil (list (read-file-name "File to insert: " (condition-case nil (file-name-as-directory (expand-file-name (let ((cl-x (cvs-mode-marked nil nil :read-only t :one t :noquery t))) (progn (or (and (memq (aref cl-x 0) cl-struct-cvs-fileinfo-tags)) (error "%s accessing a non-%s" 'cvs-fileinfo->dir 'cvs-fileinfo)) (aref cl-x 4))))) (error nil))))]] 2 (#$ . 53359) nil])
#@65 Insert FILE (and its contents if it's a dir) and return its FI.
(defalias 'cvs-insert-file #[(file) "\305\306!!\307\310!\307\211\203\"�@\311\f\n	#A\211\204�*\312	!b\210	\313H*\207" [file last fi --dolist-tail-- cvs-cookies file-relative-name directory-file-name nil cvs-fileinfo-from-entries cvs-addto-collection ewoc-location 2] 5 (#$ . 54030)])
(defalias 'cvs-mark-fis-dead #[(fis) "\305\211\205)�\n@\211\306H>\204�\307\310\311\312#\210	\211\313\314I\210)\nA\211\204�\305*\207" [fis fi --dolist-tail-- cl-struct-cvs-fileinfo-tags #1=#:v nil 0 error "%s accessing a non-%s" cvs-fileinfo->type cvs-fileinfo 2 DEAD] 5])
#@85 Add marked files to the cvs repository.
With prefix argument, prompt for cvs flags.
(defalias 'cvs-mode-add #[(flags) "\300\301!\207" [cvs-mode! #[nil "\306\307!\310\211\211\310\211\203A�\f@\311\312!!\203\"�B\202:�\313H
>\2040�\314\315\316\317#\210\320H\321=\203:�\322\fA\211\204�*	\203V�\204P� \204V�\323\324!\202\\� \206\\�\325!\326!\"BB\"\205z�\327\330\331D\332BBB\333\331DDD#\334\335\"\n\336#%.\207" [dirs needdesc fis fi --dolist-tail-- cl-struct-cvs-fileinfo-tags cvs-mode-marked add nil file-directory-p cvs-fileinfo->full-name 0 error "%s accessing a non-%s" cvs-fileinfo->type cvs-fileinfo 2 UNKNOWN t read-from-minibuffer "Enter description: " "" "-m" cvs-run-process (list "-n" "update") quote ('(cvs-parse-process t)) cvs-mark-fis-dead cvs-mode-run "add" :postproc current-prefix-arg cvs-add-default-message msg flags postproc] 7]] 2 (#$ . 54676) (list (cvs-flags-query 'cvs-add-flags "cvs add flags"))])
#@282 Diff the selected files against the repository.
This command compares the files in your working area against the
revision which they are based upon.
See also `cvs-diff-ignore-marks'.
This function only works within a *cvs* buffer.
For interactive use, use `cvs-mode-diff' instead.
(defalias 'cvs-mode-diff-1 #[(flags) "\301\302\303\304\305%\207" [flags cvs-mode-do "diff" diff :show t] 6 (#$ . 55630) (list (cvs-add-branch-prefix (cvs-add-secondary-branch-prefix (cvs-flags-query 'cvs-diff-flags "cvs diff flags"))))])
(put 'cvs-mode-diff-1 'definition-name 'cvs-mode-diff)
#@151 Diff the selected files against the repository.
Wrapper function that switches to a *cvs* buffer
before calling the real function `cvs-mode-diff-1'.

(defalias 'cvs-mode-diff #[nil "\300\301!\207" [cvs-mode! cvs-mode-diff-1] 2 (#$ . 56212) nil])
#@102 Diff the selected files against the head of the current branch.
See ``cvs-mode-diff'' for more info.
(defalias 'cvs-mode-diff-head #[(flags) "\300\301!\207" [cvs-mode! #[nil "\301\302B!\207" [flags cvs-mode-diff-1 "-rHEAD"] 3]] 2 (#$ . 56465) (list (cvs-flags-query 'cvs-diff-flags "cvs diff flags"))])
#@112 Diff the files for changes in the repository since last co/update/commit.
See ``cvs-mode-diff'' for more info.
(defalias 'cvs-mode-diff-repository #[(flags) "\300\301!\207" [cvs-mode! #[nil "\301\302\303BB!\207" [flags cvs-mode-diff-1 "-rBASE" "-rHEAD"] 4]] 2 (#$ . 56776) (list (cvs-flags-query 'cvs-diff-flags "cvs diff flags"))])
#@110 Diff the selected files against yesterday's head of the current branch.
See ``cvs-mode-diff'' for more info.
(defalias 'cvs-mode-diff-yesterday #[(flags) "\300\301!\207" [cvs-mode! #[nil "\301\302B!\207" [flags cvs-mode-diff-1 "-Dyesterday"] 3]] 2 (#$ . 57117) (list (cvs-flags-query 'cvs-diff-flags "cvs diff flags"))])
#@101 Diff the selected files against the head of the vendor branch.
See ``cvs-mode-diff'' for more info.
(defalias 'cvs-mode-diff-vendor #[(flags) "\300\301!\207" [cvs-mode! #[nil "\302\303P	B!\207" [cvs-vendor-branch flags cvs-mode-diff-1 "-r"] 3]] 2 (#$ . 57446) (list (cvs-flags-query 'cvs-diff-flags "cvs diff flags"))])
#@140 Diff the files against the backup file.
This command can be used on files that are marked with "Merged"
or "Conflict" in the *cvs* buffer.
(defalias 'cvs-mode-diff-backup #[(flags) "\300\301!\207" [cvs-mode! #[nil "<\204	�\306\307!\210\310 \210\311\312\313!!\314\315	\"@\211:\204!�\306\316!\210\n@\317H>\2040�\306\320\321\322#\210\n@\323H\n@\317H>\204D�\306\320\324\322#\210\n@\325H\326\313!q\210*\327\330!\210\331\n\332$\210*\327\333!\207" [flags marked fis cl-struct-cvs-fileinfo-tags dir file error "flags should be a list of strings" save-some-buffers cvs-get-marked cvs-ignore-marks-p "diff" cvs-partition cvs-fileinfo->backup-file "No files with a backup file selected!" 0 "%s accessing a non-%s" cvs-fileinfo->dir cvs-fileinfo 4 cvs-fileinfo->file 5 cvs-temp-buffer message "cvs diff backup..." cvs-execute-single-file-list cvs-diff-backup-extractor "cvs diff backup... Done." cvs-diff-program] 6]] 2 (#$ . 57774) (list (cvs-flags-query 'cvs-diff-flags "diff flags"))])
#@108 Return the filename and the name of the backup file as a list.
Signal an error if there is no backup file.
(defalias 'cvs-diff-backup-extractor #[(fileinfo) "\302!\211\204�\303\304\305!\"\210	\305!)D\207" [fileinfo backup-file cvs-fileinfo->backup-file error "%s has no backup file" cvs-fileinfo->full-name] 5 (#$ . 58768)])
(defalias 'cvs-emerge-diff #[(b1 b2) "\302	#\207" [b1 b2 emerge-buffers] 4])
(defalias 'cvs-emerge-merge #[(b1 b2 base out) "\304	\n\305!$\207" [b1 b2 base out emerge-buffers-with-ancestor find-file-noselect] 6])
(defalias 'cvs-ediff-startup-hook #[nil "\302\303\304\305\306\307D\307	DEE\305\310$\207" [ediff-after-quit-destination-buffer cvs-transient-buffers add-hook ediff-after-quit-hook-internal lambda nil cvs-ediff-exit-hook quote local] 8])
(defalias 'cvs-ediff-exit-hook #[(cvs-buf tmp-bufs) "\305\211\2037�\n@\211\2030�\306	!\2030�\307	!\2040�\310	\311\"\312	!\210\313!\203/�\305\314\315\217\210)\nA\211\204�*\f\205N�\306\f!\205N�\310\f\311\"?\205N�\305\316\317\217\207" [tmp-bufs tb --dolist-tail-- win cvs-buf nil buffer-live-p buffer-modified-p get-buffer-window t kill-buffer window-live-p (delete-window win) ((error)) (switch-to-buffer cvs-buf) ((error))] 4])
(defalias 'cvs-ediff-diff #[(b1 b2) "p\304\305\n\306$*\207" [startup-hook ediff-after-quit-destination-buffer b1 b2 (cvs-ediff-startup-hook) ediff-buffers ediff-revision] 5])
(defalias 'cvs-ediff-merge #[(b1 b2 base out) "p\306\307\n\f\310
&*\207" [startup-hook ediff-after-quit-destination-buffer b1 b2 base out (cvs-ediff-startup-hook) ediff-merge-buffers-with-ancestor ediff-merge-revisions-with-ancestor] 7])
#@72 Retrieve the given REVision of the file in FILEINFO into a new buffer.
(defalias 'cvs-retrieve-revision #[(fileinfo rev) "\306!\211\307\nQ\310!\206r�r\311!q\210\312\313\n\"\210\314\315\316
\317\320\317\321\322\323\324\n\325\232?\2050�\326\nD	C\"&	)\211\"\203J�\"\327\232\204J�\330\331\n\"#\210\332ed	\333\317\211\333&\210\334\335 \333\"\210\336\317!\210\337	!#\340 \210)\333$\312\341\n\"\210p**\207" [fileinfo file rev buffile coding-system-for-read cvs-program cvs-fileinfo->full-name "." find-buffer-visiting create-file-buffer message "Retrieving revision %s..." binary apply process-file nil (t nil) "-q" "update" "-p" append "HEAD" "-r" 0 error "Something went wrong retrieving revision %s: %s" decode-coding-inserted-region t after-insert-file-set-coding buffer-size set-buffer-modified-p expand-file-name after-find-file "Retrieving revision %s... Done" res buffer-file-name buffer-read-only] 13 (#$ . 60415)])
#@65 Merge interactively appropriate revisions of the selected file.
(defalias 'cvs-mode-imerge #[nil "\300\301!\207" [cvs-mode! #[nil "\306\304\307\310\311\312\311&\211\313H	>\204�\314\315\316\317#\210\320H\321!\322!\211\203,�\n\204>�\323!\324\325!\210r
q\210\326 *\202x�\327\f@\"\327\fA\"\307\323\n!)Erq\210\330!\331 \210* A$,,\207" [fi cl-struct-cvs-fileinfo-tags backup-file file merge buf cvs-mode-marked nil :one t :file 0 error "%s accessing a non-%s" cvs-fileinfo->merge cvs-fileinfo 8 cvs-fileinfo->full-name cvs-fileinfo->backup-file find-file-noselect message "Missing merge info or backup file, using VC." smerge-ediff cvs-retrieve-revision expand-file-name after-find-file ancestor-buf head-buf auto-mode-alist backup-buf cvs-transient-buffers buffer-file-name cvs-idiff-imerge-handlers] 8]] 2 (#$ . 61351) nil])
(defconst cvs-idiff-version (byte-code "\306\301!\211\203!�\307	!\203!�	G\310Y\203!�	\311H\n>\203!�	\202>�\312\211\312\211\257\313\314\2036�	\fAB\2027�\f\315\316
\315&))\207" [bound cvs-idiff-version cl-struct-cvs-flags-tags cvs-vendor-branch defaults cvs-qtypedesc-tag boundp vectorp 6 0 "BASE" vector cl-struct-cvs-flags nil "version: "] 8) nil)
#@47 Diff interactively current file to revisions.
(defalias 'cvs-mode-idiff #[nil "\300\301!\207" [cvs-mode! #[(&optional rev1 rev2) "\306\307\310\311\312\313\312&\314!\315\n\206�\316\"\f\205�\315\f\"
D@
\2060�\317	!\"-\207" [fi file rev1 rev1-buf rev2 rev2-buf cvs-mode-marked diff "idiff" :one t :file cvs-fileinfo->full-name cvs-retrieve-revision "BASE" find-file-noselect cvs-transient-buffers cvs-idiff-imerge-handlers] 7 nil (let* ((rev1 (cvs-prefix-get 'cvs-branch-prefix)) (rev2 (and rev1 (cvs-prefix-get 'cvs-secondary-branch-prefix)))) (list (or rev1 (cvs-flags-query 'cvs-idiff-version)) rev2))]] 2 (#$ . 62574) nil])
#@47 Diff interactively current file to revisions.
(defalias 'cvs-mode-idiff-other #[nil "\300\301!\207" [cvs-mode! #[nil "\306\307!\211\205�\306\310!\311\312\313\314\315$\211G\316V\203�\317\320!\210\n@\203,�\321\"\2021�\322\323!!\324\nA\203U�\nA@	\203J�\321	\"\202P�\322\323!!)\202Y�\317\325!\210\f
D@\f
\".\207" [rev1 rev2 fis fi1 rev1-buf rev2-buf cvs-prefix-get cvs-branch-prefix cvs-secondary-branch-prefix cvs-mode-marked diff "idiff" :file t 2 error "idiff-other cannot be applied to more than 2 files at a time" cvs-retrieve-revision find-file-noselect cvs-fileinfo->full-name nil "idiff-other doesn't know what other file/buffer to use" fi2 cvs-transient-buffers cvs-idiff-imerge-handlers] 6]] 2 (#$ . 63221) nil])
#@50 Non-nil if buffer is inside one of FIS (in DIR).
(defalias 'cvs-is-within-p #[(fis dir) ";\2058�\306!\307\n\206�\310\311\312\313\312$C\307\211\2035�\f@\314\306\315!
\"\"\203.�\316\fA\211\204�*	)\207" [buffer-file-name ret fis fi --dolist-tail-- dir expand-file-name nil cvs-create-fileinfo DIRCHANGE "" "." string-prefix-p cvs-fileinfo->full-name t] 6 (#$ . 63970)])
#@476 Generic cvs-mode-<foo> function.
Executes `cvs CVSARGS CMD FLAGS FIS'.
BUF is the buffer to be used for cvs' output.
DONT-CHANGE-DISC non-nil indicates that the command will not change the
  contents of files.  This is only used by the parser.
POSTPROC is a list of expressions to be evaluated at the very end (after
  parsing if applicable).  It will be prepended with `progn' if necessary.

(fn CMD FLAGS FIS &key (BUF (cvs-temp-buffer)) DONT-CHANGE-DISC CVSARGS POSTPROC)
(defalias 'cvs-mode-run #[(cmd flags fis &rest #1=#:--cl-rest--) "\306>\206\n�\307\310 DA@\311>A@\312>A@\313>A@
\203K�
@\314>\2034�
AA\211\202\"�\315>A@\203B�\307\211\202\"�\316\317
@\"\210\202!�),-\320\307\321\"\210).<\204`�\316\322!\210/@\203\245�/A\204\245�/@\323H0>\204}�\316\324\325\326#\210/@\327H\330=\203\245�/@\323H0>\204\230�\316\324\331\326#\210/@\332H\333\232\203\245�\307/1<?\206\261�21\235324\2355\3342C.#6\327\33527\"A88\3369:\337=\307\340$\210\3418!\203\351�\334\f8CC\"5\2032\342\235\205/\206\343\330\333\344\333$C;\345\346\nD\307\346;DF\fB)\fA\203\347\fB\202\f@r	q\210\340<\350 \210)\351\3522\"\210\3536/\f3$.	\207" [#1# buf dont-change-disc cvsargs postproc #2=#:--cl-keys-- :buf nil cvs-temp-buffer :dont-change-disc :cvsargs :postproc (:buf :dont-change-disc :cvsargs :postproc :allow-other-keys) :allow-other-keys error "Keyword argument %s not one of (:buf :dont-change-disc :cvsargs :postproc)" save-some-buffers #[nil "\302	\"\207" [fis def-dir cvs-is-within-p] 3] "flags should be a list of strings" 0 "%s accessing a non-%s" cvs-fileinfo->type cvs-fileinfo 2 DIRCHANGE cvs-fileinfo->dir 4 "" append assoc cvs-cleanup-collection delayed t fboundp ("status" "update") cvs-create-fileinfo "." cvs-parse-process quote progn erase-buffer message "Running cvs %s ..." cvs-run-process default-directory def-dir flags fis cl-struct-cvs-fileinfo-tags cvs-execute-single-dir cmd single-dir cvs-parse-known-commands parse args cvs-buffer-name-alist after-mode cvs-cookies cvs-auto-remove-handled old-fis inhibit-read-only] 6 (#$ . 64357)])
#@569 Generic cvs-mode-<foo> function.
Executes `cvs CVSARGS CMD FLAGS' on the selected files.
FILTER is passed to `cvs-applicable-p' to only apply the command to
  files for which it makes sense.
SHOW indicates that CMD should be not be run in the default temp buffer and
  should be shown to the user.  The buffer and mode to be used is determined
  by `cvs-buffer-name-alist'.
DONT-CHANGE-DISC non-nil indicates that the command will not change the
  contents of files.  This is only used by the parser.

(fn CMD FLAGS FILTER &key SHOW DONT-CHANGE-DISC CVSARGS POSTPROC)
(defalias 'cvs-mode-do #[(cmd flags filter &rest #1=#:--cl-rest--) "\306>A@\307>A@\310>A@\311>A@
\203D�
@\312>\203-�
AA\211\202�\313>A@\203;�\314\211\202�\315\316
@\"\210\202�)\317\320\"\321\322	\205X�!\307\n\310\311\f&,\207" [#1# show dont-change-disc cvsargs postproc #2=#:--cl-keys-- :show :dont-change-disc :cvsargs :postproc (:show :dont-change-disc :cvsargs :postproc :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:show :dont-change-disc :cvsargs :postproc)" cvs-mode-run cvs-mode-marked :buf cvs-temp-buffer cmd flags filter] 13 (#$ . 66461)])
#@83 Show cvs status for all marked files.
With prefix argument, prompt for cvs flags.
(defalias 'cvs-mode-status #[(flags) "\300\301!\207" [cvs-mode! #[nil "\302\303\304\305\306\307\306\310	\311=\205�\312p\313BBC&	\207" [flags cvs-auto-remove-handled cvs-mode-do "status" nil :dont-change-disc t :show :postproc status with-current-buffer ((cvs-mode-remove-handled))] 12]] 2 (#$ . 67648) (list (cvs-flags-query 'cvs-status-flags "cvs status flags"))])
#@59 Call cvstree using the file under the point as a keyfile.
(defalias 'cvs-mode-tree #[(flags) "\300\301!\207" [cvs-mode! #[nil "\301\302\303B\304\305\302\"\306\307\310!\311\312\313\314&	\207" [flags cvs-mode-run "status" "-v" cvs-mode-marked nil :buf cvs-temp-buffer "tree" :dont-change-disc t :postproc ((cvs-status-cvstrees))] 10]] 2 (#$ . 68104) (list (cvs-flags-query 'cvs-status-flags "cvs status flags"))])
#@88 Display the cvs log of all selected files.
With prefix argument, prompt for cvs flags.
(defalias 'cvs-mode-log #[nil "\300\301!\207" [cvs-mode! #[(flags) "\301\302\303\304\305%\207" [flags cvs-mode-do "log" nil :show t] 6 nil (list (cvs-add-branch-prefix (cvs-flags-query 'cvs-log-flags "cvs log flags")))]] 2 (#$ . 68523) nil])
#@72 Update all marked files.
With a prefix argument, prompt for cvs flags.
(defalias 'cvs-mode-update #[nil "\300\301!\207" [cvs-mode! #[(flags) "\301\302\303#\207" [flags cvs-mode-do "update" update] 4 nil (list (cvs-add-branch-prefix (cvs-add-secondary-branch-prefix (cvs-flags-query 'cvs-update-flags "cvs update flags") "-j") "-j"))]] 2 (#$ . 68859) nil])
#@76 Re-examine all marked files.
With a prefix argument, prompt for cvs flags.
(defalias 'cvs-mode-examine #[nil "\300\301!\207" [cvs-mode! #[(flags) "\301\302\303\304\305\306\307&\207" [flags cvs-mode-do "update" nil :cvsargs ("-n") :dont-change-disc t] 8 nil (list (cvs-add-branch-prefix (cvs-add-secondary-branch-prefix (cvs-flags-query 'cvs-update-flags "cvs -n update flags") "-j") "-j"))]] 2 (#$ . 69222) nil])
#@111 Arrange so that CVS ignores the selected files.
This command ignores files that are not flagged as `Unknown'.
(defalias 'cvs-mode-ignore #[(&optional pattern) "\300\301!\207" [cvs-mode! #[nil "\305\306!\307\211\203b�	@\310\311H\n>\204�\312\313\314\315#\210\316H\311H\n>\204-�\312\313\317\315#\210\320H\311H\n>\204>�\312\313\321\315#\210\322H\323=#\210\311H\n>\204S�\312\313\324\315#\210\211\325\326I\210)	A\211\204\n�*\327\f\307\211\211$\207" [fi --dolist-tail-- cl-struct-cvs-fileinfo-tags #1=#:v cvs-cookies cvs-mode-marked ignore nil cvs-append-to-ignore 0 error "%s accessing a non-%s" cvs-fileinfo->dir cvs-fileinfo 4 cvs-fileinfo->file 5 cvs-fileinfo->subtype 3 NEW-DIR cvs-fileinfo->type 2 DEAD cvs-cleanup-collection] 8]] 2 (#$ . 69644) nil])
#@130 Add STR to the .cvsignore file in DIR.
If OLD-DIR is non-nil, then this is a directory that we don't want
to hear about anymore.
(defalias 'cvs-append-to-ignore #[(dir str &optional old-dir) "r\305\306\307\"!q\210\310\311\312\217\203�\313	\314\"\210db\210n\204�\315c\210\n\203(�\316\202)�\315\261\210\f\2036�\317\310ed#\210\320 )\207" [dir buffer-file-name str old-dir cvs-sort-ignore-file find-file-noselect expand-file-name ".cvsignore" nil (byte-code "\205�\302	!\303=\205�\304	!?\207" [buffer-read-only buffer-file-name vc-backend CVS vc-editable-p] 2) ((error)) vc-checkout t "\n" "/\n" sort-lines save-buffer] 4 (#$ . 70416)])
#@56 Select a buffer containing the file in another window.
(defalias 'cvs-mode-find-file-other-window #[(e) "\301\302\"\207" [e cvs-mode-find-file t] 3 (#$ . 71063) (list last-input-event)])
#@54 Show a buffer containing the file in another window.
(defalias 'cvs-mode-display-file #[(e) "\301\302\"\207" [e cvs-mode-find-file dont-select] 3 (#$ . 71257) (list last-input-event)])
#@16 View the file.
(defalias 'cvs-mode-view-file #[(e) "\301\302\303#\207" [e cvs-mode-find-file nil t] 4 (#$ . 71449) (list last-input-event)])
#@16 View the file.
(defalias 'cvs-mode-view-file-other-window #[(e) "\301\302\211#\207" [e cvs-mode-find-file t] 4 (#$ . 71597) (list last-input-event)])
(defalias 'cvs-find-modif #[(fi) "\304\305!rq\210\306\216\307	\310p\310\311\312\n\313H>\204�\314\315\316\317#\210\n\320H&\210eb\210\321\322\310\323#\2038�\324\325\326!!\2029�\326+\207" [#1=#:temp-buffer cvs-program fi cl-struct-cvs-fileinfo-tags generate-new-buffer " *temp*" ((byte-code "\301!\203\n�\302!\210\301\207" [#1# buffer-name kill-buffer] 2)) process-file nil "-f" "diff" 0 error "%s accessing a non-%s" cvs-fileinfo->file cvs-fileinfo 5 re-search-forward "^\\([0-9]+\\)" t string-to-number match-string 1] 11])
#@90 Select a buffer containing the file.
With a prefix, opens the buffer in an OTHER window.
(defalias 'cvs-mode-find-file #[(e &optional other view) "`\301\302!!\210`U\204�\303\304 S\305\"\306>\204�\307\310!\210\311\312!\207" [e posn-set-point event-end get-text-property line-end-position font-lock-face (cvs-header cvs-filename) error "Not a file name" cvs-mode! #[(&optional rev) "p\306\307\211\310\311$\211\312H\n>\204�\313\314\315\316#\210	\317H\320=\203d�	\312H\n>\204/�\313\314\321\316#\210	\322H\323\324
!!)#\325=\203J�\326\327!!\210\202Z�#\203V�\330!\210\202Z�\331!\210q\210\f\211)\202\277�$\203q�\332	$\"\202v�\327\333	!!%#\325=\203\203�\326\202\237�#\203\225�&\203\221�\334\202\237�\335\202\237�&\203\236�\336\202\237�\337%!\210'\203\274�\340	\341\"\203\274�\214~\210eb\210\342	!Sy\210)%)*\207" [cvs-buf fi cl-struct-cvs-fileinfo-tags default-directory odir d cvs-mode-marked nil :one t 0 error "%s accessing a non-%s" cvs-fileinfo->type cvs-fileinfo 2 DIRCHANGE cvs-fileinfo->dir 4 file-name-as-directory expand-file-name dont-select display-buffer find-file-noselect dired-other-window dired cvs-retrieve-revision cvs-fileinfo->full-name view-buffer-other-window switch-to-buffer-other-window view-buffer switch-to-buffer cvs-applicable-p diff-base cvs-find-modif other rev buf view cvs-find-file-and-jump] 6 nil (list (cvs-prefix-get 'cvs-branch-prefix))]] 4 (#$ . 72284) (list last-input-event current-prefix-arg)])
#@91 Undo local changes to all marked files.
The file is removed and `cvs update FILE' is run.
(defalias 'cvs-mode-undo #[(flags) "\300\301!\207" [cvs-mode! #[nil "\203�\306\307!\207\310\311\312\313#\314\315\n	\"\211@A\211\204+�\f\205A�\316\317\320\f#\202A�\316\312
\321\f\205@�\322p\316\317\320\323\fDFEC%-\207" [current-prefix-arg fis removedp fis-split fis-removed fis-other call-interactively cvs-mode-revert-to-rev cvs-do-removal undo "update" all #[(fi) "\302H	>\204�\303\304\305\306#\210\307H\310=\206?�\302H	>\204$�\303\304\305\306#\210\307H\311=\205?�\302H	>\204:�\303\304\312\306#\210\313H\310=\207" [fi cl-struct-cvs-fileinfo-tags 0 error "%s accessing a non-%s" cvs-fileinfo->type cvs-fileinfo 2 REMOVED CONFLICT cvs-fileinfo->subtype 3] 4] cvs-partition cvs-mode-run "add" nil :postproc with-current-buffer quote flags] 13]] 2 (#$ . 73745) (list nil)])
#@47 Revert the selected files to an old revision.
(defalias 'cvs-mode-revert-to-rev #[nil "\300\301!\207" [cvs-mode! #[(rev) "\305\306\307\310\311$\312\313\314!P\315p\316\317\320\321\322	DE\322DFEC\315p\316\323\320\324\322	D\324\322D\257\322D\325\322\nD\257EC\316\317	C\325\f%,\207" [fis tag untag rev update cvs-mode-marked revert "revert" :file t "tmp_pcl_tag_" make-temp-name "" with-current-buffer cvs-mode-run "tag" list "-d" quote "update" "-j" :postproc] 10 nil (list (or (cvs-prefix-get 'cvs-branch-prefix) (let ((current-prefix-arg '(4))) (cvs-flags-query 'cvs-idiff-version))))]] 2 (#$ . 74629) nil])
#@174 Delete the lock file that CVS is waiting for.
Note that this can be dangerous.  You should only do this
if you are convinced that the process that created the lock is dead.
(defalias 'cvs-mode-delete-lock #[nil "\300\301!\207" [cvs-mode! #[nil "\306\307	!!)\310\n\311#\211\204�\312\313!\202Q�\314\315\316Q!\205Q�\f\311\211\205P�@\317
!\203<�\320
!\210\202F�\321
!\203F�\322
!\210A\211\204+�\311**\207" [cvs-lock-file d default-directory cvs-lock-file-regexp locks lock file-name-as-directory expand-file-name directory-files nil error "No lock files found" yes-or-no-p "Really delete locks in " "? " file-directory-p delete-directory file-exists-p delete-file --dolist-tail--] 5]] 2 (#$ . 75253) nil])
#@67 Remove all lines that are handled.
Empty directories are removed.
(defalias 'cvs-mode-remove-handled #[nil "\300\301!\207" [cvs-mode! #[nil "\302\303	\206�\304\303$\207" [cvs-cookies cvs-auto-remove-directories cvs-cleanup-collection t handled] 5]] 2 (#$ . 75978) nil])
#@42 Remove all marked files from the buffer.
(defalias 'cvs-mode-acknowledge #[nil "\300\301!\207" [cvs-mode! #[nil "\305\306\307!\310\"\311\211\203-�	@\211\312H\n>\204�\313\314\315\316#\210\211\317\320I\210)	A\211\204
�*\321\f\311\211\211$\207" [fi --dolist-tail-- cl-struct-cvs-fileinfo-tags #1=#:v cvs-cookies cvs-get-marked cvs-ignore-marks-p "acknowledge" t nil 0 error "%s accessing a non-%s" cvs-fileinfo->type cvs-fileinfo 2 DEAD cvs-cleanup-collection] 6]] 2 (#$ . 76256) nil])
#@67 Remove files.
Returns a list of FIS that should be `cvs remove'd.
(defalias 'cvs-do-removal #[(filter &optional cmd all) "\306	\307\310\311\310&\312\313\306	\"\"A\f?\2066�\314\n,
:\2033�,
\211A@!\204�\310\211\202�
*?-\315 .-\204^�\f\316\232\203^�r.q\210\310/\317\320\321\"!\210\322p!\210\323 \210*-\204\256�\324\216\325\nG\326=\203r�\327\202s�\3300\2111\331U\203\231�\332\3330\n@\334H2>\204\221�\335\336\337\340#\210\n@\341H#\202\240�\332\34201#*!)\204\256�\343\344!\210\345\202\n\3453\2114\2034@\2113\334H2>\204\314�\335\336\346\340#\2103\347H5\3213!67\204\344�5\350=\203\3516!\203\360�\3526!\2107\2043\334H2>\204\335\336\346\340#\2103\2118\347\353I\210)*4A\2114\204\270�*,\207" [filter cmd files fis cvs-confirm-removals -cvs-every-l cvs-mode-marked :file t :read-only cvs-partition #[(fi) "\302H	>\204�\303\304\305\306#\210\307H\310=\207" [fi cl-struct-cvs-fileinfo-tags 0 error "%s accessing a non-%s" cvs-fileinfo->type cvs-fileinfo 2 UNKNOWN] 4] #[(fi) "\301\302!!?\206
�\303\304\"\207" [fi file-exists-p cvs-fileinfo->full-name cvs-applicable-p safe-rm] 3] cvs-temp-buffer list cvs-insert-strings mapcar cvs-fileinfo->full-name cvs-pop-to-buffer-same-frame shrink-window-if-larger-than-buffer ((cvs-bury-buffer tmpbuf cvs-buffer)) yes-or-no-p undo "Undo" "Delete" 1 format "%s file: \"%s\" ? " 0 error "%s accessing a non-%s" cvs-fileinfo->file cvs-fileinfo 5 "%s %d files? " message "Aborting" nil cvs-fileinfo->type 2 UNKNOWN file-exists-p delete-file DEAD -cvs-every-f silent tmpbuf inhibit-read-only verb nfiles cl-struct-cvs-fileinfo-tags fi --dolist-tail-- type file all #1=#:v] 9 (#$ . 76752)])
#@70 Remove all marked files.
With prefix argument, prompt for cvs flags.
(defalias 'cvs-mode-remove #[(flags) "\300\301!\207" [cvs-mode! #[nil "\303\304!\211\203�\305\306\307	B#\202�\310\n\311\211\211$)\207" [fis flags cvs-cookies cvs-do-removal remove cvs-mode-run "remove" "-f" cvs-cleanup-collection nil] 6]] 2 (#$ . 78429) (list (cvs-flags-query 'cvs-remove-flags "cvs remove flags"))])
(defvar cvs-tag-name "")
#@238 Run `cvs tag TAG' on all selected files.
With prefix argument, prompt for cvs flags.
By default this can only be used on directories.
Use \[cvs-mode-force-command] or change `cvs-force-dir-tag' if you need
to use it on individual files.
(defalias 'cvs-mode-tag #[(tag &optional flags) "\300\301!\207" [cvs-mode! #[nil "\303\304\305	C\"\n\205\f�\301#\207" [flags tag cvs-force-dir-tag cvs-mode-do "tag" append] 5]] 2 (#$ . 78852) (list (setq cvs-tag-name (cvs-query-read cvs-tag-name "Tag name: " cvs-qtypedesc-tag)) (cvs-flags-query 'cvs-tag-flags "tag flags"))])
#@89 Run `cvs tag -d TAG' on all selected files.
With prefix argument, prompt for cvs flags.
(defalias 'cvs-mode-untag #[(tag &optional flags) "\300\301!\207" [cvs-mode! #[nil "\303\304\305\306	C#\n\205
�\301#\207" [flags tag cvs-force-dir-tag cvs-mode-do "tag" append ("-d")] 6]] 2 (#$ . 79423) (list (setq cvs-tag-name (cvs-query-read cvs-tag-name "Tag to delete: " cvs-qtypedesc-tag)) (cvs-flags-query 'cvs-tag-flags "tag flags"))])
#@64 Run byte-compile-file on all selected files that end in '.el'.
(defalias 'cvs-mode-byte-compile-files #[nil "\300\301!\207" [cvs-mode! #[nil "\304\305\306!!\211\307\211\205)�\n@\310	!\311\312\"\203 �\313!\210)\nA\211\204�\307+\207" [marked fi --dolist-tail-- filename cvs-get-marked cvs-ignore-marks-p "byte-compile" nil cvs-fileinfo->full-name string-match "\\.el\\'" byte-compile-file] 4]] 2 (#$ . 79861) nil])
#@66 Add a ChangeLog entry in the ChangeLog of the current directory.
(defalias 'cvs-mode-add-change-log-entry-other-window #[nil "\300\301!\207" [cvs-mode! #[nil "\306\307!\210\310\311\211\"\311\211\205>�	@\211\312H\n>\204 �\313\314\315\316#\210\317H\320\321!!)\322\323\324!\210\212\325 \210+	A\211\204�\311*\207" [fi --dolist-tail-- cl-struct-cvs-fileinfo-tags d default-directory add-log-buffer-file-name-function require add-log cvs-mode-marked nil 0 error "%s accessing a non-%s" cvs-fileinfo->dir cvs-fileinfo 4 file-name-as-directory expand-file-name #[nil "\303\304H	>\204�\305\306\307\310#\210\311H!\312\n!\203 �\313\n!\202!�\n)\207" [fi cl-struct-cvs-fileinfo-tags file expand-file-name 0 error "%s accessing a non-%s" cvs-fileinfo->file cvs-fileinfo 5 file-directory-p file-name-as-directory] 5] kill-local-variable change-log-default-name add-change-log-entry-other-window] 5]] 2 (#$ . 80289) nil])
#@40 Ask for new setting of cvs-FLAG-flags.
(defalias 'cvs-mode-set-flags #[(flag) "\303\304\305Q!\306\307	\310P\"*\207" [flag sym current-prefix-arg intern "cvs-" "-flags" (16) cvs-flags-query " flags"] 4 (#$ . 81215) (list (completing-read "Which flag: " '("cvs" "diff" "update" "status" "log" "tag" "commit" "remove" "undo" "checkout") nil t))])
#@61 Return true if FILEINFO represents a file in directory DIR.
(defalias 'cvs-dir-member-p #[(fileinfo dir) "\303H	>\204�\304\305\306\307#\210\310H\311=?\205+�\312\n\303H	>\204'�\304\305\313\307#\210\314H\"\207" [fileinfo cl-struct-cvs-fileinfo-tags dir 0 error "%s accessing a non-%s" cvs-fileinfo->type cvs-fileinfo 2 DIRCHANGE string-prefix-p cvs-fileinfo->dir 4] 6 (#$ . 81569)])
#@55 Internal function for `cvs-execute-single-file-list'.
(defalias 'cvs-execute-single-file #[(fi extractor program constant-args) "	!\306\n<\205(�\307\f\n\"\310\311\312
!#c\210\313\314\315\306\211
&\210db)*\207" [extractor fi arg-list inhibit-read-only constant-args args t append format "=== %s %s\n\n" split-string-and-unquote apply process-file nil program] 7 (#$ . 81961)])
#@400 Run PROGRAM on all elements on FIS.
CONSTANT-ARGS is a list of strings to pass as arguments to PROGRAM.
The arguments given to the program will be CONSTANT-ARGS followed by
the list that EXTRACTOR returns.

EXTRACTOR will be called once for each file on FIS.  It is given
one argument, the cvs-fileinfo.  It can return t, which means ignore
this file, or a list of arguments to send to the program.
(defalias 'cvs-execute-single-file-list #[(fis extractor program constant-args) "\306\211\205�\n@\307	\f
$\210\nA\211\204�\306*\207" [fis fi --dolist-tail-- extractor program constant-args nil cvs-execute-single-file] 6 (#$ . 82353)])
(defalias 'cvs-revert-if-needed #[(fis) "\306\211\205F�\n@\307	!\310!\211\203=�	\311H
>\204%�\312\313\314\315#\210	\316H\317>\204=�\320\f!\204=�r\fq\210\306\321\322\217\210)*\nA\211\204�\306*\207" [fis fileinfo --dolist-tail-- file buffer cl-struct-cvs-fileinfo-tags nil cvs-fileinfo->full-name find-buffer-visiting 0 error #1="%s accessing a non-%s" cvs-fileinfo->type cvs-fileinfo 2 (MESSAGE UNKNOWN) buffer-modified-p (byte-code "\302\303\304\305#\210\306 \210\307H	>\204�\310\311\312\313#\210\314H\315=\203\"�\316 \210\302\207" [fileinfo cl-struct-cvs-fileinfo-tags revert-buffer ignore-auto dont-ask preserve-modes vc-find-file-hook 0 error #1# cvs-fileinfo->type cvs-fileinfo 2 CONFLICT smerge-start-session] 4) ((error))] 5])
#@21 Change the cvsroot.
(defalias 'cvs-change-cvsroot #[(newroot) "\302\303\304\"!\204�\305\306!\205�\211\207" [newroot cvs-cvsroot file-directory-p expand-file-name "CVSROOT" y-or-n-p "Warning: no CVSROOT found inside repository. Change cvs-cvsroot anyhow? "] 4 (#$ . 83746) "DNew repository: "])
(byte-code "\300\301\302\303\304\305\306\307&\210\300\310\311\312\304\305\306\313&\207" [custom-declare-variable cvs-dired-action 'cvs-quickdir "The action to be performed when opening a CVS directory.\nSensible values are `cvs-examine', `cvs-status' and `cvs-quickdir'." :group pcl-cvs :type (choice (const cvs-examine) (const cvs-status) (const cvs-quickdir)) cvs-dired-use-hook '(4) "Whether or not opening a CVS directory should run PCL-CVS.\nA value of nil means never do it.\nALWAYS means to always do it unless a prefix argument is given to the\n  command that prompted the opening of the directory.\nAnything else means to do it only if the prefix arg is equal to this value." (choice (const :tag "Never" nil) (const :tag "Always" always) (const :tag "Prefix" (4)))] 8)
#@124 Run `cvs-examine' if DIR is a CVS administrative directory.
The exact behavior is determined also by `cvs-dired-use-hook'.
(defalias 'cvs-dired-noselect #[(dir) ";\2058�\304!\305!\306\230\2058�\307\310\311\"!\2058�	\2058�	\312=\203)�\n?\202,�\n	\232\2058�\212\313!\314\211#)\207" [dir cvs-dired-use-hook current-prefix-arg cvs-dired-action directory-file-name file-name-nondirectory "CVS" file-readable-p expand-file-name "Entries" always file-name-directory t] 4 (#$ . 84832)])
(add-hook 'vc-post-command-functions 'cvs-vc-command-advice)
(defalias 'cvs-vc-command-advice #[(command files flags) "\306\232\205\336�	@;\203�\307\310	@\"\203�	\211A@\210\202�	@\n\235\205\336�	@\311\235\205K�\312	\312\211\203G�
@\211\313\232\203@�\314
A\211\2045�\312+?\205\336�rp\314\315 \312\211\205\334�
@\211q\210\316=\203\324�\317\"\203\324�G\312Oq\210\320\321!\210	@\322\232\203\315�eb\203\315�\323\324!\203\315� <\203\255� \202\260� C\312!\211\203\314�
@!\325\326!!\327\261\210
A\211\204\270�*\330\312\"\210)
A\211\204d�\312.\207" [command flags cvs-parse-known-commands found-p flag --dolist-tail-- "cvs" string-match "\\`-" ("update" "checkout") nil "-p" t buffer-list cvs-mode string-prefix-p make-local-variable cvs-buffer "add" looking-at ".*to add this file permanently\n\\'" "cvs add: scheduling file `" file-name-nondirectory "' for addition\n" cvs-parse-process default-directory cvs-from-vc dir buffer cvs-buf major-mode subdir files file] 4])
(defalias 'cvs-mark-buffer-changed #[nil "\306!\307\310!\205�\310	!\311=\205�\312	!\211\205j�\212\313 \314\211\205i�\f@\211q\210
\315=\203a�\316	\"\203a�	G\314O\317\n\320\230\203J�\321\202K�\322\323	!\206R�\324\325	!\326$\327\"\210*\fA\211\204$�\314+*\207" [buffer-file-name file version cvs-buf --dolist-tail-- major-mode expand-file-name fboundp vc-backend CVS vc-working-revision buffer-list nil cvs-mode string-prefix-p cvs-create-fileinfo "0" ADDED MODIFIED file-name-directory "" file-name-nondirectory "cvs-mark-buffer-changed" cvs-addto-collection default-directory fi cvs-cookies] 6])
(add-hook 'after-save-hook 'cvs-mark-buffer-changed)
(defalias 'cvs-insert-visited-file #[nil "\306!\307\310!\205�\310	!\311=\205�\312	!\211\205E�r\313 \314\211\205D�\f@\211q\210
\315=\203<�\316	\"\203<�\317	!\210\fA\211\204$�\314+*\207" [buffer-file-name file version cvs-buf --dolist-tail-- major-mode expand-file-name fboundp vc-backend CVS vc-working-revision buffer-list nil cvs-mode string-prefix-p cvs-insert-file default-directory] 4])
(byte-code "\300\301\302\303#\210\304\305!\207" [add-hook find-file-hook cvs-insert-visited-file append provide pcvs] 4)