Current File : //kunden/usr/share/emacs/27.2/lisp/vc/pcvs.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\300\302!\210\300\303!\210\300\304!\210\300\305!\210\300\306!\207" [require ewoc pcvs-defs pcvs-util pcvs-parse pcvs-info vc-cvs] 2)
#@30 Bound to t inside VC advice.
(defvar cvs-from-vc nil (#$ . 566))
#@19 

(fn &rest DEFS)
(defalias 'cvs-defaults #[128 "\302
\"\303
\304GZ@\"	#\207" [cvs-shared-start cvs-shared-flags cvs-first append make-list] 7 (#$ . 637)])
(defconst cvs-cvs-flags (byte-code "\302\300!\211\203\303!	>\203\202*\304\305\306\203!AB\202\"\307\211\211\211&\262
\207" [cvs-cvs-flags cl-struct-cvs-flags-tags boundp type-of (("-f")) record cvs-flags nil] 9) nil)
(defconst cvs-checkout-flags (byte-code "\302\300!\211\203\303!	>\203\202,\304\305!\306\307\203#AB\202$\310\211\211\211&\262
\207" [cvs-checkout-flags cl-struct-cvs-flags-tags boundp type-of cvs-defaults ("-P") record cvs-flags nil] 9) nil)
(defconst cvs-status-flags (byte-code "\302\300!\211\203\303!	>\203\202-\304\305\306\"\307\310\203$AB\202%\306\211\211\211&\262
\207" [cvs-status-flags cl-struct-cvs-flags-tags boundp type-of cvs-defaults ("-v") nil record cvs-flags] 9) nil)
(defconst cvs-log-flags (byte-code "\302\300!\211\203\303!	>\203\202,\304\305!\306\307\203#AB\202$\305\211\211\211&\262
\207" [cvs-log-flags cl-struct-cvs-flags-tags boundp type-of cvs-defaults nil record cvs-flags] 9) nil)
(defconst cvs-diff-flags (byte-code "\302\300!\211\203\303!	>\203\202.\304\305\306\307#\310\311\203%AB\202&\312\211\211\211&\262
\207" [cvs-diff-flags cl-struct-cvs-flags-tags boundp type-of cvs-defaults ("-u" "-N") ("-c" "-N") ("-u" "-b") record cvs-flags nil] 9) nil)
(defconst cvs-tag-flags (byte-code "\302\300!\211\203\303!	>\203\202,\304\305!\306\307\203#AB\202$\305\211\211\211&\262
\207" [cvs-tag-flags cl-struct-cvs-flags-tags boundp type-of cvs-defaults nil record cvs-flags] 9) nil)
(defconst cvs-add-flags (byte-code "\302\300!\211\203\303!	>\203\202,\304\305!\306\307\203#AB\202$\305\211\211\211&\262
\207" [cvs-add-flags cl-struct-cvs-flags-tags boundp type-of cvs-defaults nil record cvs-flags] 9) nil)
(defconst cvs-commit-flags (byte-code "\302\300!\211\203\303!	>\203\202,\304\305!\306\307\203#AB\202$\305\211\211\211&\262
\207" [cvs-commit-flags cl-struct-cvs-flags-tags boundp type-of cvs-defaults nil record cvs-flags] 9) nil)
(defconst cvs-remove-flags (byte-code "\302\300!\211\203\303!	>\203\202,\304\305!\306\307\203#AB\202$\305\211\211\211&\262
\207" [cvs-remove-flags cl-struct-cvs-flags-tags boundp type-of cvs-defaults nil record cvs-flags] 9) nil)
(defconst cvs-update-flags (byte-code "\302\300!\211\203\303!	>\203\202,\304\305!\306\307\203#AB\202$\310\211\211\211&\262
\207" [cvs-update-flags cl-struct-cvs-flags-tags boundp type-of cvs-defaults ("-d" "-P") record cvs-flags nil] 9) nil)
#@63 Reset the default arguments to those in the `cvs-cvsrc-file'.
(defalias 'cvs-reread-cvsrc #[0 "\3061\234\307\310!r\211q\210\311\312\313\314\315!\316\"\317$\216\320!\210\321\211\203j\211@eb\210\322\323\324Q\325\326#\203c\327\330\331Q!\332\333\317!\206>\334!
\312\n\335J!\f>\204W\336\337\340JD\"\210J\341H\233\211	\240,\266
A\266\202\202\210\342\312\343\344\345\346\342\325\347#\"AB\n\335J!\f>\204\215\336\337\340JD\"\210J\341H\233\211	\240.\262
0\207\210\325\207" [cvs-cvsrc-file value index sym cl-struct-cvs-flags-tags #1=#:c (file-error) generate-new-buffer " *temp*" make-byte-code 0 "\301\300!\205	\302\300!\207" vconcat vector [buffer-name kill-buffer] 2 insert-file-contents ("cvs" "checkout" "status" "log" "diff" "tag" "add" "commit" "remove" "update") re-search-forward "^" "\\(\\s-+\\(.*\\)\\)?$" nil t intern "cvs-" "-flags" split-string-and-unquote match-string "" type-of signal wrong-type-argument cvs-flags 1 cvs-cvs-flags "-f" cvs-partition #[257 "\211\300\235\207" [("-q" "-Q" "-f")] 3 "\n\n(fn X)"] cvs-flags-query noquery] 10 (#$ . 3286) nil])
(cvs-reread-cvsrc)
#@29 Popup the CVS menu.

(fn E)
(defalias 'cvs-menu #[257 "\303\304\305!!\"\211\306H\262
C\307\n\")\207" [cvs-cookies cvs-minor-current-files cvs-menu ewoc-locate posn-point event-end 2 popup-menu] 6 (#$ . 4404) "e"])
#@62 Mode-line control for displaying info on cvs process status.
(defvar cvs-mode-line-process nil (#$ . 4628))
(autoload 'cvs-status-get-tags "cvs-status")
#@58 Return a list of acceptable tags, ready for completions.
(defalias 'cvs-tags-list #[0 "\301 \204	\302\303!\210\304 \305\306\205C\307\310!r\211q\210\311\312\313\314\315!\316\"\317$\216\320\321\322\321\323\324\325@!&\210eb\210\326 \211<\205>\211\262
*\262
BB\207" [cvs-program cvs-buffer-p cl--assertion-failed (cvs-buffer-p) cvs-get-marked ("BASE") ("HEAD") generate-new-buffer " *temp*" make-byte-code 0 "\301\300!\205	\302\300!\207" vconcat vector [buffer-name kill-buffer] 2 process-file nil t "status" "-v" cvs-fileinfo->full-name cvs-status-get-tags] 13 (#$ . 4787)])
(defvar cvs-tag-history nil)
(defconst cvs-qtypedesc-tag (byte-code "\300\301\302\211\303\304\305&\207" [record cvs-qtypedesc identity cvs-tag-history cvs-tags-list nil] 7))
#@293 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.

(fn &optional -CVS-MODE!-FUN)
(defalias 'cvs-mode! #[256 "p\302 \203\np\202\203\302!\203\202\303\304!	\305\306\307\310\311!\312\"\313$\2041q\202ep\314 \315\316\"\305\306\317\310\311#\320\"\313$\216q\210\211\203T\321
!\210\203`\"\202b )\266\203\207" [cvs-buffer cvs-minor-wrap-function cvs-buffer-p error "can't find the *cvs* buffer" make-byte-code 0 "r\301\300!\203
\302\300!\202\300 )\207" vconcat vector [commandp call-interactively] 2 selected-window get-buffer-window visible "\300q\210\302\205\302\303 =\205\304\301!\207" [selected-window select-window] select-window] 16 (#$ . 5551)])
(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 (#$ . 6533))
(defvar cvs-branch-prefix-cps (byte-code "	B\211G\nY\204\304
\305\nS@\"\"\262
\306\307\310\311\310&\207" [cvs-vendor-branch cvs-branches cvs-prefix-number cvs-qtypedesc-tag append make-list record cvs-flags nil "version"] 8))
#@233 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.

(fn ARG)
(defalias 'cvs-set-branch-prefix #[257 "\300 \210\301\302\"\207" [cvs-mode! cvs-prefix-set cvs-branch-prefix] 4 (#$ . 6903) "P"])
#@213 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".

(fn FLAGS &optional ARG)
(defalias 'cvs-add-branch-prefix #[513 "\300\301!\300\302!\210\211\203
\206\303
PB\202\207" [cvs-prefix-get cvs-branch-prefix cvs-secondary-branch-prefix "-r"] 5 (#$ . 7273)])
#@98 Current secondary selected branch.
See `cvs-prefix-set' for further description of the behavior.
(defvar cvs-secondary-branch-prefix nil (#$ . 7675))
(defvar cvs-secondary-branch-prefix-cps (byte-code "	B\211G\nY\204\304
\305\nS@\"\"\262
\306\307\310\311\310&\207" [cvs-vendor-branch cvs-branches cvs-prefix-number cvs-qtypedesc-tag append make-list record cvs-flags nil "version"] 8))
#@233 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.

(fn ARG)
(defalias 'cvs-set-secondary-branch-prefix #[257 "\300 \210\301\302\"\207" [cvs-mode! cvs-prefix-set cvs-secondary-branch-prefix] 4 (#$ . 8075) "P"])
#@420 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.

(fn FLAGS &optional ARG)
(defalias 'cvs-add-secondary-branch-prefix #[513 "\300\301\302\"\205\n\300\303!\211\203
\206\304
PB\202\207" [cvs-prefix-get cvs-branch-prefix read-only cvs-secondary-branch-prefix "-r"] 5 (#$ . 8465)])
#@97 Non-nil if CVS minor mode is enabled.
Use the command `cvs-minor-mode' to change this variable.
(defvar cvs-minor-mode nil (#$ . 9102))
(make-variable-buffer-local 'cvs-minor-mode)
#@415 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.

If called interactively, enable CVS minor 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.

(fn &optional ARG)
(defalias 'cvs-minor-mode #[256 "\301 
\302=\203
?\202\303!\304V\305\306\203\307\202\310\"\210\311\312!\203B\301 \2032\211\301 \232\203B\313\314\315\203=\316\202>\317#\266\210\320 \210\207" [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 " in current buffer" message "CVS minor mode %sabled%s" "en" "dis" force-mode-line-update] 7 (#$ . 9290) (byte-code "\206\301C\207" [current-prefix-arg toggle] 1)])
(defvar cvs-minor-mode-hook nil)
(byte-code "\301\302N\204\f\303\301\302\304#\210\305\306\307\310\300!\205\311\211%\210\303\306\312\313#\207" [cvs-minor-mode-map cvs-minor-mode-hook variable-documentation put "Hook run after entering or leaving `cvs-minor-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 cvs-minor-mode " CVS" boundp nil permanent-local t] 6)
(defvar cvs-temp-buffers nil)
#@453 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.

(fn &optional CMD NORMAL NOSETUP)
(defalias 'cvs-temp-buffer #[768 "p\306\"A\307
@\310BC\"
A@	\203\311!\202=\312\n!\203-\313\n!\203-\n\202=\314\302!\210\311\307\315BC\"\316\"\211\317
!\204c\320
!\203c\321
!\322>\203c	\203_\323
!\210\202c\324\325!\210\210\204o\326\304!\210\202\200\204z\212\327
!\210)\314\304!\210\211\211
\235\203\213
\210\202\217\211
Br\211q\210\330\"
\204\243\331 \210\332 \210\314\333!\210#\334!\203\270 \210\202\273\335 \210\211\203\302\211#\210\336\337!\210\203\322\340 \210\202\330\341\"\331 \210)\207" [cvs-buffer-name-alist default-directory cvs-temp-buffer cvs-temp-buffer-name other-window-scroll-buffer cvs-temp-buffers assoc eval cmd cvs-get-buffer-create bufferp buffer-live-p make-local-variable dir noreuse get-buffer-process processp process-status (run stop) delete-process error "Can not run two cvs processes simultaneously" kill-local-variable display-buffer nil buffer-disable-undo erase-buffer cvs-buffer fboundp fundamental-mode cvs-minor-mode 1 buffer-enable-undo t buffer-read-only list-buffers-directory] 13 (#$ . 10750)])
#@63 Kill all the "temporary" buffers created by the *cvs* buffer.
(defalias 'cvs-mode-kill-buffers #[0 "\211\205\211@\3011\302
!0\202\210\202\210
A\266\202\202
\207" [cvs-temp-buffers (error) kill-buffer] 4 (#$ . 12293) nil])
#@129 Create the *cvs* buffer for directory DIR.
If non-nil, NEW means to create a new buffer no matter what.

(fn DIR &optional NEW)
(defalias 'cvs-make-cvs-buffer #[513 "
\306\307!!)\262\310	\311BC\"
\204$\n\312=\203$\313 \203$p\206y\212
?\205q\3142qp\315 B\211\205n\211@\211q\210\313 \203g\n\316\267\202^\202b\317\"\204b\317\"\202_\230\202_\320\203g\321\314\"\210
A\266\202\2022\262
0)\206y\322
\"r\211q\210\230\203\235\313 \203\235\3231\230\324\f\320\211\325$\210p0\202\232\210\320\206
\320\326 \210\327\330\331 !\332\333 \334\335	!\336\337!\204\273\340\202\341\341\337!\342\343\"\203\316\344\345\346\"P\202\337\342\347\"\203\336\350\345\346\"P\202\337\340\262
\340\261\210\325\351 \210\352\353!\210
+\354\355\356\340\325$\352\304!\210\211\357\360\361\320\325$\210
\262
)\207" [d cvs-buffer-name cvs-reuse-cvs-buffer default-directory cvs-cookies buffer-read-only file-name-as-directory expand-file-name eval dir current cvs-buffer-p --cl-block-nil-- buffer-list #s(hash-table size 3 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (always 70 subdir 73 samedir 88)) string-prefix-p nil throw cvs-get-buffer-create (error) cvs-cleanup-collection t 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        : " substring 1 "\\`D" "\nDate       : " cvs-mode make-local-variable list-buffers-directory ewoc-create cvs-fileinfo-pp "\n\n" add-hook kill-buffer-hook #[0 "\3011	\302!0\207\210\303\207" [cvs-temp-buffer (error) kill-buffer nil] 2]] 15 (#$ . 12532)])
#@75 

(fn CMD DIR FLAGS FIS NEW &key CVSARGS NOEXIST DONT-CHANGE-DISC NOSHOW)
(defalias 'cvs-cmd-do #[1413 "\301
\302\"A@\301\303\"A@\301\304\"A@\301\305\"A@\211\203D\211@\306>\203,\211AA\262
\202\307>A@\203;\310\262
\202\311\312@\"\210\202\210\313\314\315!!!\316
\"\317!\204]\311\320\"\210\204x\317\315\321\"!\204x\322\315\323\"!\204x\311\324\"\210\211q\210\325\f\302\n\304\n&\210\203\223\211\202\231\310\326
!)\266\202\207" [pop-up-windows plist-member :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] 20 (#$ . 14229)])
#@50 

(fn ARGS FIS POSTPROCESS &optional SINGLE-DIR)
(defalias 'cvs-run-process #[1027 "\306!\204\n\307\310!\210rp\206	\311=q\210db\210n\204$\311\312c\210)\203,\211\2047\313\314\315\"\316E\202\240\317@!>\204J\320\321\322@D\"\210@\323H\311\324
\312\261\210)\316\211@
\203\230\317!>\204p\320\321\322D\"\210
\323H\230\203\230\317
!>\204\206\320\321\322D\"\210\211\325HB\262
A\262
@\262
\202\\E\266\203\262
\211@
A@\3268\327\330\331\316\311$\210\332\"\333\334\335\316\336#\f\205\302\337\fD$\316;\340\341;!!)<\342\343\344=%)\345
\300#\210rq\210\346\347\"\210)\345
\350#\210\345
\351\204
\202
\352\353\354\355\356
\f$\357\"\325$#\210\360
\361\"\210\362
\363\"\210\364
!d\316\223\210\36512
\366
!0\2026
\210\2027
\210q\210\367\370!!>\371 \210)\266\n)\372\353!\207" [cvs-buffer cvs-execute-single-dir inhibit-read-only cl-struct-cvs-fileinfo-tags cvs-cvsroot process-connection-type cvs-buffer-p cl--assertion-failed (cvs-buffer-p cvs-buffer) t "\n" "" mapcar cvs-fileinfo->full-name nil type-of signal wrong-type-argument cvs-fileinfo 4 "pcl-cvs: descending directory " 5 2 add-hook kill-buffer-hook #[0 "\300p!\301
!\205\302
\303\"\210\304
\305\303#\210\306
!\207" [get-buffer-process processp set-process-filter nil process-put cvs-postprocess interrupt-process] 5] 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 make-byte-code 0 "\304\303\302\300\301$\207" vconcat vector [cvs-run-process] set-process-sentinel cvs-sentinel set-process-filter cvs-update-filter process-mark (error) process-send-eof symbol-name process-status force-mode-line-update sit-for d default-directory cvs-program cvs-mode-line-process] 26 (#$ . 15190)])
#@17 

(fn ARGS FIS)
(defalias 'cvs-header-msg #[514 "\302C\303\304\305\306\307\310!\311\"\312\313%\"\314\315\316\317\320\302\321#	\205\"\322	D\303\323\"$!Q\207" [cvs-program cvs-cvsroot nil mapcar make-byte-code 257 "\300\242\301=\203\211\302\230\203\300\303\240\210\207\300\242\303=\203$\211\304\230\203$\300\305\240\210\207\300\242\305=\2031\300\306\240\210\307\207\300\242\301=\203C\211\310\230\203C\300\311\240\210\207\300\242\311=\203\\\312\313\"\203\\\300\306\240\210\314\315\"\307P\207\207" vconcat vector [nil "commit" commit "-m" -m done "<log message>" "admin" admin string-match "\\`-m[^:]*:" match-string 0] 4 "\n\n(fn ARG)" " " combine-and-quote-strings append cvs-flags-query cvs-cvs-flags noquery "-d" cvs-fileinfo->full-name] 14 (#$ . 17052)])
#@16 

(fn CMD ADD)
(defalias 'cvs-update-header #[514 "\302!\211@\303\304\305\"\211\2033\211\306H\307
!	>\204 \310\311\312D\"\210\211\306H\262
\313>\2033\314\"\262
\202\n\203L\315\316\"\204A\317\262\320\321R\262\202z\315\322\323!\324Q\"\204`\325\326!\210\202z\327\303\330\211$\262\315\316\"\204s\331\262\332\333Q\262\334\335\203\206\336\202\207\337\340R#\207" [cvs-cookies cl-struct-cvs-fileinfo-tags ewoc-get-hf "" ewoc-nth 0 2 type-of signal wrong-type-argument cvs-fileinfo (MESSAGE DIRCHANGE) ewoc-next string-match "." "\n" "-- Running " " ...\n" "^-- Running " regexp-quote " \\.\\.\\.\n" error "Internal PCL-CVS error while removing message" replace-match t "\n\n" "-- last cmd: " " --\n" ewoc-set-hf "\n--------------------- " "End" "Empty" " ---------------------\n"] 13 (#$ . 17836)])
#@137 Sentinel for the cvs update process.
This is responsible for parsing the output from the cvs update when
it is finished.

(fn PROC MSG)
(defalias 'cvs-sentinel #[514 "\301!\302>\205\205\303\304\"\303\305\"\306!\307!\204\310\262\307
!\204%\310\262
\311\312\310#\210\313!\210
\203cr
q\210\314\303\315\"\310\"\210\316\301!!\317 \210\203b\211\204Y\320\321!\210\202br\211q\210\212 \210*)\211\205\203\322
!?\205\203r\211q\210\323 \210r
\206{pq\210\324\325\326 \"*\266\203\207" [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" get-buffer-process buffer-enable-undo message "CVS process has completed in %s" buffer-name] 9 (#$ . 18674)])
#@354 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.

(fn DCD &optional SUBDIR OLD-FIS)
(defalias 'cvs-parse-process #[769 "\306=\203\212eb\210\307\310\311\312#\203\312\313\224\313\225|\210)\202\n)\314\315#\311r\nq\210\311\211\203p\211@\316
!>\204@\317\320\321D\"\210\211\322H\323=\203d\324\f\325\316!>\204[\317\320\321D\"\210\326H#\244\202g\211B\262
A\266\202\202+\210\262\311\211\203\236\211@\316
!>\204\212\317\320\321D\"\210\211\322H\327=\204\227\211B\262
A\266\202\202u\210\262
\211\203\277\211@\330\f#\262\331\322H\"\262
A\266\202\202\242\210\211\203\353\211@\316
!>\204\326\317\320\321D\"\210\211\211\322\327I\266\330\f#\262
A\266\202\202\301\210\244\262\332\f
\312=\311$\210\205
?\205
?\205
\333!)\207" [system-type inhibit-read-only cvs-buffer cl-struct-cvs-fileinfo-tags cvs-cookies cvs-auto-remove-handled darwin re-search-forward "^\\^D+" nil t 0 cvs-parse-buffer cvs-parse-table type-of signal wrong-type-argument cvs-fileinfo 2 DIRCHANGE ewoc-collect cvs-dir-member-p 4 UP-TO-DATE cvs-addto-collection delq cvs-cleanup-collection cvs-revert-if-needed cvs-auto-remove-directories cvs-auto-revert cvs-from-vc] 15 (#$ . 19554)])
#@916 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.

(fn FUN ARGS DOCSTRING INTERACT &rest BODY)
(defalias 'defun-cvs-mode '(macro . #[1156 "\301!\211:\203@\202)
\302=\204$A@\203$A@;\2039\303
\304\305\306\nBBD\257\202\251
\307\267\202\245\303
\306\310\304\305\fBBBD\257\202\251\311\312\"\210\313\314\"\315\316!\317P!\320\303\n\n\321\316	!\322R\n\nBBBBB\323\324D\325\324DF\303\306\326\316	!\327R\330\304\324\nDD\257F\266\202\202\251\331\332\"\207" [x cvs-cdr SIMPLE defun cvs-mode! lambda nil #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (NOARGS 63 DOUBLE 86)) (interactive) 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'"] 21 (#$ . 21037)]))
(byte-code "\300\301\302\303#\210\304\301\305\306#\300\207" [put defun-cvs-mode edebug-form-spec (&define sexp lambda-list stringp ("interactive" interactive) def-body) function-put doc-string-elt 3] 4)
#@51 Kill the temporary buffer and associated process.
(defalias 'cvs-mode-kill-process #[0 "\300\301!\207" [cvs-mode! #[0 "\301!\205\302!\205\303!\211\205\304
!\262
\207" [cvs-temp-buffer bufferp buffer-live-p get-buffer-process delete-process] 3]] 2 (#$ . 23092) nil])
#@216 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.

(fn C FI &optional TIN)
(defalias 'cvs-addto-collection #[770 "\211\204\n\301\302\"\262
\211\203 \303\304H\"\203 \305\"\262
\202\n\211\204)\306\"\207\303\304H\"\2036\307\310!\210\311\"\211\203S\303\304H\"\204S\211\262\311\"\262
\202:\303\304H\"\204s\312!>\204k\313\314\315D\"\210\304H\316=\203{\317#\202\217\320\304H\"\210\321\"\210n\203\216\322 \210
\207" [cl-struct-cvs-fileinfo-tags ewoc-nth 0 cvs-fileinfo< 2 ewoc-prev ewoc-enter-first cl--assertion-failed (not (cvs-fileinfo< fi (ewoc-data tin))) ewoc-next type-of signal wrong-type-argument cvs-fileinfo MESSAGE ewoc-enter-after cvs-fileinfo-update ewoc-invalidate cvs-move-to-goal-column] 8 (#$ . 23374)])
(byte-code "\300\301\302\303\304DD\305\306\307\310\311&\207" [custom-declare-variable cvs-cleanup-functions funcall function #[0 "\300\207" [nil] 1] "Functions to tweak the cleanup process.\nThe functions are called with a single argument (a FILEINFO) and should\nreturn a non-nil value if that fileinfo should be removed." :group pcl-cvs :type (hook :options (cvs-cleanup-removed))] 8)
#@309 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.

(fn FI)
(defalias 'cvs-cleanup-removed #[257 "\301
!>\204\302\303\304D\"\210\211\305H\306=\204E\301
!>\204&\302\303\304D\"\210\211\305H\307=\205J\301
!>\204=\302\303\304D\"\210\211\310H\306=\205J\311\312!!\207" [cl-struct-cvs-fileinfo-tags type-of signal wrong-type-argument cvs-fileinfo 2 REMOVED CONFLICT 3 file-exists-p cvs-fileinfo->full-name] 5 (#$ . 24666)])
#@292 Remove undesired entries.
C is the collection
RM-HANDLED if non-nil means remove handled entries (if file is currently
  visited, only remove if value is `all').
RM-DIRS behaves like `cvs-auto-remove-directories'.
RM-MSGS if non-nil means remove messages.

(fn C RM-HANDLED RM-DIRS RM-MSGS)
(defalias 'cvs-cleanup-collection #[1028 "\301C\301C\302C\211\242\205|\211\301\240\210
\302\240\210\303\304\305\306\211$\240\210\307\310\311\312\313\314\f\f\f\f\f\f&\315\"\316\317%\"\210\203
\242\204\320\242!>\204S\321\322\323\242D\"\210\242\324H\325=\203\320\242!>\204m\321\322\323\242D\"\210\242\211\324\304I\266\211\302\240\210\202\207" [cl-struct-cvs-fileinfo-tags nil t cvs-create-fileinfo DEAD "../" "" ewoc-filter make-byte-code 257 "\306
!>\204\307\310\311D\"\210\211\312H\306!>\204#\307\310\311D\"\210
\313H
\314\267\202N\302\2063\211\315=?\202S\316\202S\317\320!!\203I\300\321=\202J\300?\202S\322\323\"?\211\203\350\301\203\350\306\303\242!>\204m\307\310\311\303\242D\"\210\303\242\312H\324=\203\350\304\242\203\202\304\316\240\210\202\350\301\321=\204\312\325\306\303\242!>\204\233\307\310\311\303\242D\"\210\303\242\326H\306!>\204\261\307\310\311D\"\210\326H\"\203\312\324=\203\304\301\327=\204\312
\330=\203\350\306\303\242!>\204\334\307\310\311\303\242D\"\210\303\242\211\312\331I\266\305\332\240\210\211\205\357\303\240\207" vconcat vector [type-of signal wrong-type-argument cvs-fileinfo 2 3 #s(hash-table size 3 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (MESSAGE 44 DEAD 55 UP-TO-DATE 59)) TEMP nil find-buffer-visiting cvs-fileinfo->full-name all run-hook-with-args-until-success cvs-cleanup-functions DIRCHANGE string-prefix-p 4 empty FOOTER DEAD t cl-struct-cvs-fileinfo-tags] 10 "\n\n(fn FI)" type-of signal wrong-type-argument cvs-fileinfo 2 DIRCHANGE] 20 (#$ . 25352)])
#@26 Get the CVSROOT for DIR.
(defalias 'cvs-get-cvsroot #[0 "\301\302\303\"\304
\305\"\206\206\306\307!\206\310\207" [cvs-cvsroot expand-file-name "Root" "CVS" cvs-file-to-string t getenv "CVSROOT" "?????"] 4 (#$ . 27245)])
#@101 Return the current CVS module.
This usually doesn't really work but is a handy initval in a prompt.
(defalias 'cvs-get-module #[0 "\300\301\302\"\303
\304\"\211\204\305\202=\306
!\204\211\202=\307 \310
\206\"\311!\312Q
\2038\313\314\"\2038\315\316\"\202;\317!\266\202\207" [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] 7 (#$ . 27479)])
#@226 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.

(fn MODULES DIR FLAGS &optional ROOT)
(defalias 'cvs-checkout #[1027 "
\302=\203
\303\304\305\306#\262\211\307\310\206	\311\"\305\312\313\302&)\207" [cvs-cvsroot default-directory t cvs-flags-query cvs-checkout-flags nil noquery cvs-cmd-do "checkout" append new :noexist] 12 (#$ . 28003) (byte-code "\302 \211\203\n\203\303\304!\262
\305\303\306\307 \"!\310\311\312	\312$\313\314\315\316\"!F\207" [current-prefix-arg default-directory cvs-get-cvsroot read-string "CVS Root: " split-string-and-unquote "Module(s): " cvs-get-module read-directory-name "CVS Checkout Directory: " nil cvs-add-branch-prefix cvs-flags-query cvs-checkout-flags "cvs checkout flags"] 7)])
#@77 Run `cvs checkout' against the current branch.
The files are stored to DIR.
(defalias 'cvs-mode-checkout #[0 "\300\301!\207" [cvs-mode! #[257 "\301\302 !\303\304\305\306\"!\307 \310#)\207" [cvs-cvsroot 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] 7 "\n\n(fn DIR)" (byte-code "\301\302!\303\304\305 \203\306\307\"\202\310#\311
\312\312$C\207" [default-directory cvs-prefix-get cvs-branch-prefix format-message "CVS Checkout Directory for `%s%s': " cvs-get-module format " (branch: %s)" "" read-directory-name nil] 7)]] 2 (#$ . 28876) nil])
#@108 Rerun `cvs-examine' on the current directory with the default flags.

(fn &optional IGNORE-AUTO NOCONFIRM)
(defalias 'cvs-mode-revert-buffer #[512 "\300\301!\207" [cvs-mode! #[0 "\301\302\"\207" [default-directory cvs-examine t] 3]] 4 (#$ . 29536) nil])
#@128 Read directory name, prompting with PROMPT.
If in a *cvs* buffer, don't prompt unless a prefix argument is given.

(fn PROMPT)
(defalias 'cvs-query-directory #[257 "\302 \203\204	\207\303
\304	\304$\207" [current-prefix-arg default-directory cvs-buffer-p read-directory-name nil] 6 (#$ . 29798)])
#@337 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.

(fn DIR &optional FLAGS NOSHOW)
(defalias 'cvs-quickdir #[769 "\305\306\307!!!\310!\311V\312\"\313\314!\204\315\316\"\210\314\307\317\"!\204+\315\320\"\210
q\210\321\322!\211\203E\211@\323	#\262
A\266\202\2021\210\324	\n\325=\313$\210\203W
\202]\313\326!)\207" [current-prefix-arg cvs-cookies cvs-auto-remove-handled cvs-auto-remove-directories pop-up-windows 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] 13 (#$ . 30107) (byte-code "\300\301!C\207" [cvs-query-directory "CVS quickdir (directory): "] 2)])
#@466 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.

(fn DIRECTORY FLAGS &optional NOSHOW)
(defalias 'cvs-examine #[770 "
\302=\203
\303\304\305\306#\262\203\307!\262\310\311\305\312	!\313V\314\315\316	\317\302&\207" [find-file-visit-truename current-prefix-arg 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] 15 (#$ . 31195) (byte-code "\300\301!\302\303\304\"D\207" [cvs-query-directory "CVS Examine (directory): " cvs-flags-query cvs-update-flags "cvs -n update flags"] 4)])
#@410 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.

(fn DIRECTORY FLAGS)
(defalias 'cvs-update #[514 "\211\301=\203
\302\303\304\305#\262
\306\307\304\310!\311V%\207" [current-prefix-arg t cvs-flags-query cvs-update-flags nil noquery cvs-cmd-do "update" prefix-numeric-value 8] 9 (#$ . 32164) (byte-code "\300\301!\302\303\304\"D\207" [cvs-query-directory "CVS Update (directory): " cvs-flags-query cvs-update-flags "cvs update flags"] 4)])
#@404 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.

(fn DIRECTORY FLAGS &optional NOSHOW)
(defalias 'cvs-status #[770 "
\301=\203
\302\303\304\305#\262\306\307\304\310!\311V\312\313\301&	\207" [current-prefix-arg t cvs-flags-query cvs-status-flags nil noquery cvs-cmd-do "status" prefix-numeric-value 8 :noshow :dont-change-disc] 13 (#$ . 32952) (byte-code "\300\301!\302\303\304\"D\207" [cvs-query-directory "CVS Status (directory): " cvs-flags-query cvs-status-flags "cvs status flags"] 4)])
#@265 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.

(fn PROC STRING)
(defalias 'cvs-update-filter #[514 "\304 \305\306\307\310\311!\312\"\313$\216r\314!q\210\315\212\316!b\210
c\210\316!`\317\223\210\320\306!\210\321\322!\205e\323\324!\323\325!r	q\210\326\302!\210\211\327\330\331\332\333\334!\205R\335\336!P\337\340&\"\210\341p!\210db\210\342 )\266\202,\207" [inhibit-read-only cvs-buffer cvs-lock-file cvs-cookies match-data make-byte-code 0 "\301\300\302\"\207" vconcat vector [set-match-data evaporate] 3 process-buffer t process-mark nil beginning-of-line looking-at "^[ a-z]+: \\(.*waiting for .*lock in \\(.*\\)\\)$" match-string 1 2 make-local-variable 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] 14 (#$ . 33773)])
#@64 
See `cvs-prefix-set' for further description of the behavior.
(defvar cvs-force-command nil (#$ . 34840))
(defvar cvs-force-command-cps (byte-code "\302\211GY\204\303
\304S@\"\"\262
\305\306\307\310	\307&\207" [cvs-prefix-number cvs-qtypedesc-string1 ("/F") append make-list record cvs-flags nil ""] 8))
#@362 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.

(fn ARG)
(defalias 'cvs-mode-force-command #[257 "\300\301\302\303\304\305!\306\"\307$!\207" [cvs-mode! make-byte-code 0 "\301\302\300\"\207" vconcat vector [cvs-prefix-set cvs-force-command] 3] 8 (#$ . 35159) "P"])
(put 'cvs-mode 'mode-class 'special)
(defvar cvs-mode-hook nil)
(byte-code "\300\301N\204\f\302\300\301\303#\210\304\305!\204\302\305\306\307#\210\300\207" [cvs-mode-hook variable-documentation put "Hook run after 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 cvs-mode] 4)
(defvar cvs-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\317#\207" [cvs-mode-abbrev-table cvs-mode-map variable-documentation put purecopy "Keymap for `cvs-mode'." boundp cvs-mode-syntax-table definition-name cvs-mode (lambda (#1=#:def-tmp-var) (defvar cvs-mode-syntax-table #1#)) make-syntax-table "Syntax table for `cvs-mode'." (lambda (#1#) (defvar cvs-mode-abbrev-table #1#)) define-abbrev-table nil "Abbrev table for `cvs-mode'." derived-mode-parent] 5)
#@201 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 or penultimate step
during initialization.

\{cvs-mode-map}
(defalias 'cvs-mode #[0 "\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 (#$ . 36856) nil])
#@95 Return whether the (by default current) BUFFER is a `cvs-mode' buffer.

(fn &optional BUFFER)
(defalias 'cvs-buffer-p #[256 "\212\211\203\211q\210)\301=\207" [major-mode cvs-mode] 3 (#$ . 38065)])
#@65 Check that the current buffer follows cvs-buffer's conventions.
(defalias 'cvs-buffer-check #[0 "p\304\305\211\262\203<\306!=\203<\301\211\262\203<	\2038\307	!\2038r	q\210\n)=\203<r	q\210)\232\203<\310\202C\311\312\313!#\207" [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] 7 (#$ . 38271)])
#@41 Quit PCL-CVS, killing the *cvs* buffer.
(defalias 'cvs-mode-quit #[0 "\300\301!\205	\302p!\207" [y-or-n-p "Quit pcl-cvs? " kill-buffer] 2 (#$ . 38689) nil])
#@44 Display help for various PCL-CVS commands.
(defalias 'cvs-help #[0 "\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 (#$ . 38853) nil])
(defalias 'cvs-move-to-goal-column #[0 "\300 \301`\302\303$\211W\205\211b\207" [line-end-position next-single-property-change cvs-goal-column nil] 6])
#@92 Go to the previous line.
If a prefix argument is given, move by that many lines.

(fn ARG)
(defalias 'cvs-mode-previous-line #[257 "\300\301\302\303\304\305!\306\"\307$!\207" [cvs-mode! make-byte-code 0 "\302	\300\"\210\303 \207" vconcat vector [cvs-cookies ewoc-goto-prev cvs-move-to-goal-column] 3] 8 (#$ . 39452) "p"])
#@88 Go to the next line.
If a prefix argument is given, move by that many lines.

(fn ARG)
(defalias 'cvs-mode-next-line #[257 "\300\301\302\303\304\305!\306\"\307$!\207" [cvs-mode! make-byte-code 0 "\302	\300\"\210\303 \207" vconcat vector [cvs-cookies ewoc-goto-next cvs-move-to-goal-column] 3] 8 (#$ . 39782) "p"])
#@181 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.

(fn &optional ARG)
(defalias 'cvs-mode-mark #[256 "\300\301\302\303\304\305!\306\"\307$!\207" [cvs-mode! make-byte-code 0 "\303	!\211\304H\305
!\n>\204\306\307\310D\"\210\211\304H\311=\203B\312\313\314\315\316\317\300!\320\"\321\322%	\305!\n>\204;\306\307\310D\"\210\323H#\202}\305
!\n>\204Q\306\307\310D\"\210\211\211\324\300\325=\203p\305!\n>\204j\306\307\310D\"\210\324H\202q\300?I\266\326	\"\210\327\324!\207" vconcat vector [cvs-cookies cl-struct-cvs-fileinfo-tags ewoc-locate 2 type-of signal wrong-type-argument cvs-fileinfo DIRCHANGE ewoc-map make-byte-code 514 "\302\"\205;\303!	>\204\304\305\306D\"\210
\211\307\300\310=\2035\303!	>\204/\304\305\306D\"\210\307H\2026\300?I\266\311\207" vconcat vector [cl-struct-cvs-fileinfo-tags cvs-dir-member-p type-of signal wrong-type-argument cvs-fileinfo 1 toggle t] 9 "\n\n(fn F DIR)" 4 1 toggle ewoc-invalidate cvs-mode-next-line] 9] 8 (#$ . 40105) nil])
(defalias 'cvs-mouse-toggle-mark 'cvs-mode-toggle-mark)
#@48 Toggle the mark of the entry at point.

(fn E)
(defalias 'cvs-mode-toggle-mark #[257 "\212\300\301!!\210\302\303!)\207" [posn-set-point event-end cvs-mode-mark toggle] 4 (#$ . 41273) (list last-input-event)])
#@42 Unmark the fileinfo on the current line.
(defalias 'cvs-mode-unmark #[0 "\300\301!\207" [cvs-mode! #[0 "\300\301!\207" [cvs-mode-mark t] 2]] 2 (#$ . 41489) nil])
#@17 Mark all files.
(defalias 'cvs-mode-mark-all-files #[0 "\300\301!\207" [cvs-mode! #[0 "\301\302\"\207" [cvs-cookies ewoc-map #[257 "\301
!>\204\302\303\304D\"\210\211\305H\306=?\205.\301
!>\204'\302\303\304D\"\210\211\211\307\310I\262
\207" [cl-struct-cvs-fileinfo-tags type-of signal wrong-type-argument cvs-fileinfo 2 DIRCHANGE 1 t] 5 "\n\n(fn COOKIE)"]] 3]] 2 (#$ . 41657) nil])
#@44 Mark all files in state STATE.

(fn STATE)
(defalias 'cvs-mode-mark-on-state #[257 "\300\301\302\303\304\305!\306\"\307$!\207" [cvs-mode! make-byte-code 0 "\302\303\304\305\306\307\300!\310\"\311\312%	\"\207" vconcat vector [cvs-cookies ewoc-map make-byte-code 257 "\302
!	>\204\303\304\305D\"\210\211\306H\300=\205-\302
!	>\204&\303\304\305D\"\210\211\211\307\310I\262
\207" vconcat vector [cl-struct-cvs-fileinfo-tags type-of signal wrong-type-argument cvs-fileinfo 2 1 t] 5 "\n\n(fn FI)"] 7] 8 (#$ . 42054) (byte-code "\3021*\303\304\305\211\306\307\310\307\311\307&\312
!>\204\313\314\315D\"\210\211\316H\262
!\2270\202,\210\305\317\320\321\2057\322\323Q\324Q\325\326	\"\305\307\305\211&\226!\262
C\207" [cl-struct-cvs-fileinfo-tags cvs-states (error) symbol-name cvs-mode-marked nil :read-only t :one :noquery type-of signal wrong-type-argument cvs-fileinfo 2 intern completing-read "Mark files in state" " [" "]" ": " mapcar #[257 "\300
@!\227C\207" [symbol-name] 3 "\n\n(fn X)"]] 10)])
#@44 Mark all files matching REGEX.

(fn REGEX)
(defalias 'cvs-mode-mark-matching-files #[257 "\300\301\302\303\304\305!\306\"\307$!\207" [cvs-mode! make-byte-code 0 "\302\303\304\305\306\307\300!\310\"\311\312%	\"\207" vconcat vector [cvs-cookies ewoc-map make-byte-code 257 "\302
!	>\204\303\304\305D\"\210\211\306H\307=?\205F\310\300\302!	>\204)\303\304\305D\"\210\311H\"\205F\302
!	>\204?\303\304\305D\"\210\211\211\312\313I\262
\207" vconcat vector [cl-struct-cvs-fileinfo-tags type-of signal wrong-type-argument cvs-fileinfo 2 DIRCHANGE string-match 5 1 t] 7 "\n\n(fn COOKIE)"] 7] 8 (#$ . 43074) "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 #[0 "\300\301!\207" [cvs-mode! #[0 "\301\302\"\207" [cvs-cookies ewoc-map #[257 "\301
!>\204\302\303\304D\"\210\211\211\305\306I\266\307\207" [cl-struct-cvs-fileinfo-tags type-of signal wrong-type-argument cvs-fileinfo 1 nil t] 5 "\n\n(fn COOKIE)"]] 3]] 2 (#$ . 43718) nil])
#@39 Unmark the file on the previous line.
(defalias 'cvs-mode-unmark-up #[0 "\300\301!\207" [cvs-mode! #[0 "\302\303\"\211\203&\211\304H\305
!	>\204\306\307\310D\"\210\211\211\303\311I\266\312\"\210\210\313 \207" [cvs-cookies cl-struct-cvs-fileinfo-tags ewoc-goto-prev 1 2 type-of signal wrong-type-argument cvs-fileinfo nil ewoc-invalidate cvs-move-to-goal-column] 6]] 2 (#$ . 44154) 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 (#$ . 44674))
(defvar cvs-ignore-marks-modif-cps (byte-code "\302\303\"\211G	Y\204\304
\305	S@\"\"\262
\211\306\307\310\311\312\313\314&\266\203\311\315\313\316\313&\266\202\207" [cvs-ignore-marks-alternatives cvs-prefix-number mapcar cdr append make-list #[257 "\301
\"A\207" [cvs-ignore-marks-alternatives assoc] 4 "\n\n(fn STR)"] #[257 "\301
\"@\207" [cvs-ignore-marks-alternatives rassoc] 4 "\n\n(fn OBJ)"] #[0 "\207" [cvs-ignore-marks-alternatives] 1] record cvs-qtypedesc nil t cvs-flags "active"] 12))
#@264 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'.

(fn ARG)
(defalias 'cvs-mode-toggle-marks #[257 "\300\301\302\303\304\305!\306\"\307$!\207" [cvs-mode! make-byte-code 0 "\301\302\300\"\207" vconcat vector [cvs-prefix-set cvs-ignore-marks-modif] 3] 8 (#$ . 45350) "P"])
#@32 

(fn CMD &optional READ-ONLY)
(defalias 'cvs-ignore-marks-p #[513 "
\235\203	?\202\f	\302\303\"\211\304\267\202#\305\202$
?\202$\306\202$
\207" [cvs-invert-ignore-marks cvs-default-ignore-marks cvs-prefix-get cvs-ignore-marks-modif #s(hash-table size 3 test equal rehash-size 1.5 rehash-threshold 0.8125 purecopy t data ("/IM" 22 "/TM" 26 "/FM" 31)) t nil] 6 (#$ . 45832)])
#@12 

(fn CMD)
(defalias 'cvs-mode-mark-get-modif #[257 "\300
\301\"\203	\302\207\303\207" [cvs-ignore-marks-p read-only "/IM" "/FM"] 4 (#$ . 46222)])
#@408 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.

(fn &optional IGNORE-MARKS IGNORE-CONTENTS)
(defalias 'cvs-get-marked #[512 "\303\304\300!\203:\203\305\306\"\202'\204\307	\310\"\206'\311	!\211\312H\262
C\211\203s\211@\204H\313
!\n>\204@\314\315\316D\"\210\211\312H\317=\204P\211B\262\202l\320\307	\321\313!\n>\204d\314\315\316D\"\210\322H#\"\262
A\266\202\202'\210\211\237\207" [cvs-minor-current-files cvs-cookies cl-struct-cvs-fileinfo-tags nil boundp mapcar #[257 "\301
!>\203	\207\302
!\303
!\203\304\305\306!\307\310$\202/\311
!\312!\304\313\206*\310\310$\266\202\207" [cl-struct-cvs-fileinfo-tags type-of file-relative-name file-directory-p cvs-create-fileinfo DIRCHANGE file-name-as-directory "." "" file-name-directory file-name-nondirectory UNKNOWN] 9 "\n\n(fn F)"] ewoc-collect cvs-fileinfo->marked ewoc-locate 2 type-of signal wrong-type-argument cvs-fileinfo DIRCHANGE append cvs-dir-member-p 4] 13 (#$ . 46377)])
#@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 #[641 "\300
\301\"A@\300\302\"A@\300\303\"A@\300\304\"A@\211\203D\211@\305>\203,\211AA\262
\202\306>A@\203;\307\262
\202\310\311@\"\210\202\210\204O\312!\262\313\206Z\314\"?\205d\315\316\n\"\"\317\320!\321\322\323\324\325\326\"\327\"\330\331%\"@\211\203\210\203\252\211A\203\252\204\252\332
\204\225\333\202\226\334\n\"\210\335\336!\210\337\340\341\342\f\"!!C\262
\203\263\211@\202\264\211\266\203\207" [plist-member :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 make-byte-code 257 "\302
\301?\205\300\"\207" vconcat vector [cvs-applicable-p] 4 "\n\n(fn FI)" 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: "] 17 (#$ . 47663)])
#@86 Determine whether FILTER applies to at least one of the selected files.

(fn FILTER)
(defalias 'cvs-enabledp #[257 "\3001\301
\302\303\304\305\304&0\207\210\302\207" [(error) cvs-mode-marked nil :read-only t :noquery] 8 (#$ . 49130)])
#@35 

(fn &rest -CVS-MODE-FILES-ARGS)
(defalias 'cvs-mode-files #[128 "\300\301\302\303\304\305!\306\"\307$!\207" [cvs-mode! make-byte-code 0 "\301\302\303\304\300\"\"\207" vconcat vector [mapcar cvs-fileinfo->full-name apply cvs-mode-marked] 5] 8 (#$ . 49374)])
#@35 Run `cvs-mode-commit' with setup.
(defalias 'cvs-mode-commit-setup #[0 "\300\301!\207" [cvs-mode-commit force] 2 (#$ . 49641) nil])
(byte-code "\300\301\302\303\304DD\305\306\307\310\311\312\313&	\207" [custom-declare-variable cvs-mode-commit-hook funcall function #[0 "\300\207" [nil] 1] "Hook run after setting up the commit buffer." :type hook :options (cvs-mode-diff) :group pcl-cvs] 10)
#@312 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.

(fn SETUP)
(defalias 'cvs-mode-commit #[257 "\302 \210\303\304\305\306#\307\310\304\"A8\206\311\211\312\313$\210\314\301!\210\315\316\317!\207" [cvs-buffer-name-alist 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] 8 (#$ . 50040) "P"])
#@14 

(fn BUF F)
(defalias 'cvs-commit-minor-wrap #[514 "\301\302!\211 )\207" [cvs-ignore-marks-modif cvs-mode-mark-get-modif "commit"] 4 (#$ . 50804)])
(defalias 'cvs-commit-filelist #[0 "\300\301\302\303\304\305\304\306\304&\207" [cvs-mode-files commit nil :read-only t :file :noquery] 9])
#@80 Do the actual commit, using the current buffer as the log message.

(fn FLAGS)
(defalias 'cvs-do-commit #[257 "\300ed\"\301 \210\302\303\304BB\305#\207" [buffer-substring-no-properties cvs-mode! cvs-mode-do "commit" "-m" commit] 7 (#$ . 51100) (byte-code "\300\301\302\"C\207" [cvs-flags-query cvs-commit-flags "cvs commit flags"] 3)])
(defalias 'cvs-edit-log-text-at-point #[0 "\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)
#@113 Edit the log message at point.
This is best called from a `log-view-mode' buffer.

(fn FILE REV &optional TEXT)
(defalias 'cvs-mode-edit-log #[770 "\304 \210\305\306\307\310#\311\312\306\"A8\206\313r
q\210\314\301!\210C)\211\315\316\317$\210\2030\320 \210c\210\314\302!\210\314\303!\210\321\211\207" [cvs-buffer-name-alist cvs-edit-log-files cvs-edit-log-revision cvs-minor-wrap-function 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-minor-wrap] 10 (#$ . 51821) (byte-code "\300\301!\206	\302\303!\300\304!\206\302\305!\306 E\207" [cvs-mode! #[0 "\300\301\211\302\303\304\303\305\303&@\207" [cvs-mode-files nil :read-only t :file :noquery] 9] read-string "File name: " #[0 "\300\301!\207" [cvs-prefix-get cvs-branch-prefix] 2] "Revision to edit: " cvs-edit-log-text-at-point] 3)])
#@14 

(fn BUF F)
(defalias 'cvs-edit-log-minor-wrap #[514 "r
q\210)rq\210	)\305\211 +\207" [cvs-edit-log-revision cvs-edit-log-files cvs-force-command cvs-minor-current-files cvs-branch-prefix "/F"] 5 (#$ . 52798)])
(defalias 'cvs-edit-log-filelist #[0 "\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])
#@78 Do the actual commit, using the current buffer as the log message.

(fn REV)
(defalias 'cvs-do-edit-log #[257 "\300ed\"\301\302\303\304\305\306\"\307\"\310$!\207" [buffer-substring-no-properties cvs-mode! make-byte-code 0 "\302\303\304\300\305\301RC\306#\207" vconcat vector [cvs-mode-do "admin" "-m" ":" nil] 6] 10 (#$ . 53211) (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 #[0 "\300\301!\207" [cvs-mode! #[257 "\300
!\207" [cvs-insert-file] 3 "\n\n(fn FILE)" (byte-code "\301\302\3031-\304\305\306\307\211\310\311\312\311\313\311&\314
!>\204\"\315\316\317D\"\210\211\320H\262
!!0\202/\210\307\"C\207" [cl-struct-cvs-fileinfo-tags read-file-name "File to insert: " (error) file-name-as-directory expand-file-name cvs-mode-marked nil :read-only t :one :noquery type-of signal wrong-type-argument cvs-fileinfo 4] 13)]] 2 (#$ . 53582) nil])
#@76 Insert FILE (and its contents if it's a dir) and return its FI.

(fn FILE)
(defalias 'cvs-insert-file #[257 "\301\302!!\303\304!\211\203\211@\305#\262
A\266\202\202	\210\306
!b\210\211\307H\207" [cvs-cookies file-relative-name directory-file-name nil cvs-fileinfo-from-entries cvs-addto-collection ewoc-location 2] 9 (#$ . 54277)])
#@12 

(fn FIS)
(defalias 'cvs-mark-fis-dead #[257 "\211\211\205$\211@\301
!>\204\302\303\304D\"\210\211\211\305\306I\266
A\266\202\202
\207" [cl-struct-cvs-fileinfo-tags type-of signal wrong-type-argument cvs-fileinfo 2 DEAD] 7 (#$ . 54624)])
#@97 Add marked files to the cvs repository.
With prefix argument, prompt for cvs flags.

(fn FLAGS)
(defalias 'cvs-mode-add #[257 "\300\301\302\303\304\305!\306\"\307$!\207" [cvs-mode! make-byte-code 0 "\304\305!\306\211C\211\203@\211@\307\310!!\203
\242B\240\210\2029\311
!	>\204.\312\313\314D\"\210\211\315H\316=\2039\317\262
A\266\202\202\210
\203S\n\204M\204S\320\321!\202X\206X\322\323
\300BB\242\205n\324\325\326\327\330!\331\"\332$\333\334\335%\266\203\207" vconcat vector [cl-struct-cvs-fileinfo-tags current-prefix-arg cvs-add-default-message cvs-mode-marked add nil file-directory-p cvs-fileinfo->full-name type-of signal wrong-type-argument cvs-fileinfo 2 UNKNOWN t read-from-minibuffer "Enter description: " "" "-m" make-byte-code 0 "\301\302\303D\300\242\304#\210\305\300\242!\207" vconcat vector [cvs-run-process "-n" "update" #[0 "\300\301!\207" [cvs-parse-process t] 2] cvs-mark-fis-dead] 4 cvs-mode-run "add" :postproc] 12] 8 (#$ . 54876) (byte-code "\300\301\302\"C\207" [cvs-flags-query cvs-add-flags "cvs add flags"] 3)])
#@260 Diff the selected files against the repository.
This command compares the files in your working area against the
revision which they are based upon.
This function only works within a *cvs* buffer.
For interactive use, use `cvs-mode-diff' instead.

(fn FLAGS)
(defalias 'cvs-mode-diff-1 #[257 "\300\301\302\303\304%\207" [cvs-mode-do "diff" diff :show t] 7 (#$ . 55952) (byte-code "\300\301\302\303\304\"!!C\207" [cvs-add-branch-prefix cvs-add-secondary-branch-prefix cvs-flags-query cvs-diff-flags "cvs diff flags"] 5)])
(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 #[0 "\300\301!\207" [cvs-mode! cvs-mode-diff-1] 2 (#$ . 56536) nil])
#@112 Diff the selected files against the head of the current branch.
See `cvs-mode-diff' for more info.

(fn FLAGS)
(defalias 'cvs-mode-diff-head #[257 "\300\301\302\303\304\305!\306\"\307$!\207" [cvs-mode! make-byte-code 0 "\301\302\300B!\207" vconcat vector [cvs-mode-diff-1 "-rHEAD"] 3] 8 (#$ . 56787) (byte-code "\300\301\302\"C\207" [cvs-flags-query cvs-diff-flags "cvs diff flags"] 3)])
#@122 Diff the files for changes in the repository since last co/update/commit.
See `cvs-mode-diff' for more info.

(fn FLAGS)
(defalias 'cvs-mode-diff-repository #[257 "\300\301\302\303\304\305!\306\"\307$!\207" [cvs-mode! make-byte-code 0 "\301\302\303\300BB!\207" vconcat vector [cvs-mode-diff-1 "-rBASE" "-rHEAD"] 4] 8 (#$ . 57184) (byte-code "\300\301\302\"C\207" [cvs-flags-query cvs-diff-flags "cvs diff flags"] 3)])
#@120 Diff the selected files against yesterday's head of the current branch.
See `cvs-mode-diff' for more info.

(fn FLAGS)
(defalias 'cvs-mode-diff-yesterday #[257 "\300\301\302\303\304\305!\306\"\307$!\207" [cvs-mode! make-byte-code 0 "\301\302\300B!\207" vconcat vector [cvs-mode-diff-1 "-Dyesterday"] 3] 8 (#$ . 57611) (byte-code "\300\301\302\"C\207" [cvs-flags-query cvs-diff-flags "cvs diff flags"] 3)])
#@111 Diff the selected files against the head of the vendor branch.
See `cvs-mode-diff' for more info.

(fn FLAGS)
(defalias 'cvs-mode-diff-vendor #[257 "\300\301\302\303\304\305!\306\"\307$!\207" [cvs-mode! make-byte-code 0 "\302\303	P\300B!\207" vconcat vector [cvs-vendor-branch cvs-mode-diff-1 "-r"] 3] 8 (#$ . 58026) (byte-code "\300\301\302\"C\207" [cvs-flags-query cvs-diff-flags "cvs diff flags"] 3)])
#@152 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.

(fn FLAGS)
(defalias 'cvs-mode-diff-backup #[257 "\300\301\302\303\304\305!\306\"\307$!\207" [cvs-mode! make-byte-code 0 "\300<\204	\302\303!\210\304 \210\305\306\307!!\310\311\"@\211:\204\302\312!\210\313\307!q\210\314\315!\210\316
\317	\300$\266\314\320!\207" vconcat vector [cvs-diff-program 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!" cvs-temp-buffer message "cvs diff backup..." cvs-execute-single-file-list cvs-diff-backup-extractor "cvs diff backup... Done."] 7] 8 (#$ . 58440) (byte-code "\300\301\302\"C\207" [cvs-flags-query cvs-diff-flags "diff flags"] 3)])
#@123 Return the filename and the name of the backup file as a list.
Signal an error if there is no backup file.

(fn FILEINFO)
(defalias 'cvs-diff-backup-extractor #[257 "\300
!\211\204\301\302\303!\"\210\211\303!D\207" [cvs-fileinfo->backup-file error "%s has no backup file" cvs-fileinfo->full-name] 6 (#$ . 59300)])
#@14 

(fn B1 B2)
(defalias 'cvs-emerge-diff #[514 "\300#\207" [emerge-buffers] 6 (#$ . 59624)])
#@23 

(fn B1 B2 BASE OUT)
(defalias 'cvs-emerge-merge #[1028 "\300\301!$\207" [emerge-buffers-with-ancestor find-file-noselect] 10 (#$ . 59725)])
(defalias 'cvs-ediff-startup-hook #[0 "\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])
#@25 

(fn CVS-BUF TMP-BUFS)
(defalias 'cvs-ediff-exit-hook #[514 "\211\211\203=\211@\211\2036\300
!\2036\301
!\2046\302
\303\"\304!\210\305
!\2035\30610\307
!0\2024\210\2025\210\210
A\266\202\202
\210
\205[\300!\205[\302\303\"?\205[\3101Y\311!0\207\210\312\207" [buffer-live-p buffer-modified-p get-buffer-window t kill-buffer window-live-p (error) delete-window (error) switch-to-buffer nil] 7 (#$ . 60112)])
#@14 

(fn B1 B2)
(defalias 'cvs-ediff-diff #[514 "p\301
\302\303$)\207" [ediff-after-quit-destination-buffer (cvs-ediff-startup-hook) ediff-buffers ediff-revision] 9 (#$ . 60541)])
#@23 

(fn B1 B2 BASE OUT)
(defalias 'cvs-ediff-merge #[1028 "p\301
\302\303&)\207" [ediff-after-quit-destination-buffer (cvs-ediff-startup-hook) ediff-merge-buffers-with-ancestor ediff-merge-revisions-with-ancestor] 13 (#$ . 60728)])
#@91 Retrieve the given REVision of the file in FILEINFO into a new buffer.

(fn FILEINFO REV)
(defalias 'cvs-retrieve-revision #[514 "\304!\211\305Q\306
!\206or\307
!q\210\310\311\"\210\312\313\314	\315\316\315\317\320\321\322\f\323\232?\2050\324
D\fC\"&	)\211\203G\211\325\232\204G\326\327#\210\330ed\331\315\211\331&\210\332\333 \331\"\210\334\315!\210\335!\336 \210)\331\310\337\"\210p\262
)\207" [coding-system-for-read cvs-program buffer-file-name buffer-read-only 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"] 16 (#$ . 60975)])
#@65 Merge interactively appropriate revisions of the selected file.
(defalias 'cvs-mode-imerge #[0 "\300\301!\207" [cvs-mode! #[0 "\305\306\307\310\311\312\311&\313
!>\204\314\315\316D\"\210\211\317H\320!\321!\203)\211\204<\322!\323\324!\210r\211q\210\325 )\262
\202h\326@\"\326A\"\307\322!)
Er\211q\210\327!\330 \210*\fA
$)\266\203\266\203\207" [cl-struct-cvs-fileinfo-tags auto-mode-alist cvs-transient-buffers buffer-file-name cvs-idiff-imerge-handlers cvs-mode-marked merge nil :one t :file type-of signal wrong-type-argument 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] 12]] 2 (#$ . 61884) nil])
(defconst cvs-idiff-version (byte-code "\304\300!\211\203\305!	>\203\2020\306\n\211\306\211\257\307\310\203'AB\202(\311\312\311&\262
\207" [cvs-idiff-version cl-struct-cvs-flags-tags cvs-vendor-branch cvs-qtypedesc-tag boundp type-of "BASE" record cvs-flags nil "version: "] 9) nil)
#@47 Diff interactively current file to revisions.
(defalias 'cvs-mode-idiff #[0 "\300\301!\207" [cvs-mode! #[512 "\302\303\304\305\306\307\306&\310
!\311\206\312\"\205\311\"

D	@\206*\313!\")\266\203\207" [cvs-transient-buffers cvs-idiff-imerge-handlers cvs-mode-marked diff "idiff" :one t :file cvs-fileinfo->full-name cvs-retrieve-revision "BASE" find-file-noselect] 10 "\n\n(fn &optional REV1 REV2)" (byte-code "\300\301!\211\205\n\300\302!
\206\303\304!
D\207" [cvs-prefix-get cvs-branch-prefix cvs-secondary-branch-prefix cvs-flags-query cvs-idiff-version] 4)]] 2 (#$ . 62976) nil])
#@47 Diff interactively current file to revisions.
(defalias 'cvs-mode-idiff-other #[0 "\300\301!\207" [cvs-mode! #[0 "\302\303!\211\205\n\302\304!\305\306\307\310\311$\211G\312V\203\313\314!\210\211@\203(\315
\"\202-\316\317!!\320A\203LA@\203B\315
\"\202G\316\317!!\266\202\202P\313\321!\210

D	@\")\266\203\207" [cvs-transient-buffers cvs-idiff-imerge-handlers 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"] 10]] 2 (#$ . 63584) nil])
#@64 Non-nil if buffer is inside one of FIS (in DIR).

(fn FIS DIR)
(defalias 'cvs-is-within-p #[514 ";\2056\301!\302\206\303\304\305\306\305$C\211\2032\211@\307\301\310!\"\"\203+\311\262
A\266\202\202\210\211\262
\207" [buffer-file-name expand-file-name nil cvs-create-fileinfo DIRCHANGE "" "." string-prefix-p cvs-fileinfo->full-name t] 9 (#$ . 64291)])
#@431 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 function of no argument to be evaluated at the very end (after
  parsing if applicable).

(fn CMD FLAGS FIS &key (BUF (cvs-temp-buffer)) DONT-CHANGE-DISC CVSARGS POSTPROC)
(defalias 'cvs-mode-run #[899 "
C\306\307\"\206
\310\311 DA@\306\312\"A@\306\313\"A@\306\314\"A@\211\203M\211@\315>\2035\211AA\262
\202\"\316>A@\203D\310\262
\202\"\317\320@\"\210\202\"\210\211\204U\321\262
\322\310\323\324\325\326\327\f\"\330\"\331$\"\266<\204s\317\332!\210\242@\203\277\242A\204\277\333\242@!	>\204\223\334\335\336\242@D\"\210\242@\337H\340=\203\277\333\242@!	>\204\261\334\335\336\242@D\"\210\242@\341H\342\232\203\277\310\240\210\n<?\206\311\n\235	\235\343\fC\f#\337\344
\f\"A8\345
5\346=\310\347$\210\350
!\203
\323\324\351\326\327\"\352\"\353$\262
\262\203-
\f\354\235\205
\242\206
\355\340\342\356\342$C\323\324\357\326\327
#\360\"\341$\262\266rq\210\3476\361 \210)\362\363\"\210\364\n\242$)\266\204\266\204\207" [default-directory cl-struct-cvs-fileinfo-tags cvs-execute-single-dir cvs-parse-known-commands cvs-buffer-name-alist cvs-cookies plist-member :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)" ignore save-some-buffers make-byte-code 0 "\302\300\242\301\"\207" vconcat vector [cvs-is-within-p] 3 "flags should be a list of strings" type-of signal wrong-type-argument cvs-fileinfo 2 DIRCHANGE 4 "" append assoc cvs-cleanup-collection delayed t fboundp "\301 \210\300 \207" [] 1 ("status" "update") cvs-create-fileinfo "." "\303\300\304\301#\210\302 \207" [cvs-parse-process nil] erase-buffer message "Running cvs %s ..." cvs-run-process cvs-auto-remove-handled inhibit-read-only] 23 (#$ . 64665)])
#@570 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 are 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 #[899 "\300
\301\"A@\300\302\"A@\300\303\"A@\300\304\"A@\211\203D\211@\305>\203,\211AA\262
\202\306>A@\203;\307\262
\202\310\311@\"\210\202\210\312\313	\f\"\314\315	\205Y
!\302	\303\n\304&\207" [plist-member :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] 20 (#$ . 66792)])
#@95 Show cvs status for all marked files.
With prefix argument, prompt for cvs flags.

(fn FLAGS)
(defalias 'cvs-mode-status #[257 "\300\301\302\303\304\305!\306\"\307$!\207" [cvs-mode! make-byte-code 0 "\302\303\300\304\305\306\307\306\310	\311=\205p\312\313\314\315\316!\317\"\320$\262
&	\207" vconcat vector [cvs-auto-remove-handled cvs-mode-do "status" nil :dont-change-disc t :show :postproc status make-byte-code 0 "r\300q\210\301 )\207" vconcat vector [cvs-mode-remove-handled] 1] 16] 8 (#$ . 67909) (byte-code "\300\301\302\"C\207" [cvs-flags-query cvs-status-flags "cvs status flags"] 3)])
(autoload 'cvs-status-cvstrees "cvs-status")
#@71 Call cvstree using the file under the point as a keyfile.

(fn FLAGS)
(defalias 'cvs-mode-tree #[257 "\300\301\302\303\304\305!\306\"\307$!\207" [cvs-mode! make-byte-code 0 "\301\302\303\300B\304\305\302\"\306\307\310!\311\312\313\314&	\207" vconcat vector [cvs-mode-run "status" "-v" cvs-mode-marked nil :buf cvs-temp-buffer "tree" :dont-change-disc t :postproc cvs-status-cvstrees] 10] 8 (#$ . 68560) (byte-code "\300\301\302\"C\207" [cvs-flags-query cvs-status-flags "cvs status flags"] 3)])
#@88 Display the cvs log of all selected files.
With prefix argument, prompt for cvs flags.
(defalias 'cvs-mode-log #[0 "\300\301!\207" [cvs-mode! #[257 "\300\301\302\303\304%\207" [cvs-mode-do "log" nil :show t] 7 "\n\n(fn FLAGS)" (byte-code "\300\301\302\303\"!C\207" [cvs-add-branch-prefix cvs-flags-query cvs-log-flags "cvs log flags"] 4)]] 2 (#$ . 69063) nil])
#@72 Update all marked files.
With a prefix argument, prompt for cvs flags.
(defalias 'cvs-mode-update #[0 "\300\301!\207" [cvs-mode! #[257 "\300\301\302#\207" [cvs-mode-do "update" update] 5 "\n\n(fn FLAGS)" (byte-code "\300\301\302\303\304\"\305\"\305\"C\207" [cvs-add-branch-prefix cvs-add-secondary-branch-prefix cvs-flags-query cvs-update-flags "cvs update flags" "-j"] 5)]] 2 (#$ . 69431) nil])
#@76 Re-examine all marked files.
With a prefix argument, prompt for cvs flags.
(defalias 'cvs-mode-examine #[0 "\300\301!\207" [cvs-mode! #[257 "\300\301\302\303\304\305\306&\207" [cvs-mode-do "update" nil :cvsargs ("-n") :dont-change-disc t] 9 "\n\n(fn FLAGS)" (byte-code "\300\301\302\303\304\"\305\"\305\"C\207" [cvs-add-branch-prefix cvs-add-secondary-branch-prefix cvs-flags-query cvs-update-flags "cvs -n update flags" "-j"] 5)]] 2 (#$ . 69834) nil])
#@111 Arrange so that CVS ignores the selected files.
This command ignores files that are not flagged as `Unknown'.
(defalias 'cvs-mode-ignore #[0 "\300\301!\207" [cvs-mode! #[0 "\303\304!\211\203c\211@\305\306!>\204\307\310\311D\"\210
\312H\306!>\204+\307\310\311D\"\210\313H\306!>\204>\307\310\311D\"\210\314H\315=	$\210\306
!>\204U\307\310\311D\"\210\211\211\316\317I\266
A\266\202\202\210\320\n\321\211\211$\207" [cl-struct-cvs-fileinfo-tags cvs-sort-ignore-file cvs-cookies cvs-mode-marked ignore vc-cvs-append-to-ignore type-of signal wrong-type-argument cvs-fileinfo 4 5 3 NEW-DIR 2 DEAD cvs-cleanup-collection nil] 9]] 2 (#$ . 70296) nil])
(byte-code "\300\301\302\303#\210\304\301\302\305#\207" [defalias cvs-append-to-ignore vc-cvs-append-to-ignore nil make-obsolete "24.4"] 4)
#@64 Select a buffer containing the file in another window.

(fn E)
(defalias 'cvs-mode-find-file-other-window #[257 "\300
\301\"\207" [cvs-mode-find-file t] 4 (#$ . 71107) (list last-input-event)])
#@62 Show a buffer containing the file in another window.

(fn E)
(defalias 'cvs-mode-display-file #[257 "\300
\301\"\207" [cvs-mode-find-file dont-select] 4 (#$ . 71307) (list last-input-event)])
#@24 View the file.

(fn E)
(defalias 'cvs-mode-view-file #[257 "\300
\301\302#\207" [cvs-mode-find-file nil t] 5 (#$ . 71505) (list last-input-event)])
#@42 View the file in another window.

(fn E)
(defalias 'cvs-mode-view-file-other-window #[257 "\300
\301\211#\207" [cvs-mode-find-file t] 5 (#$ . 71659) (list last-input-event)])
#@11 

(fn FI)
(defalias 'cvs-find-modif #[257 "\302\303!r\211q\210\304\305\306\307\310!\311\"\312$\216\313\314p\314\315\316\317	!	>\204+\320\321\322D\"\210\323H&\210eb\210\324\325\314\326#\203E\327\330\331!!\202F\331*\207" [cvs-program cl-struct-cvs-fileinfo-tags generate-new-buffer " *temp*" make-byte-code 0 "\301\300!\205	\302\300!\207" vconcat vector [buffer-name kill-buffer] 2 process-file nil "-f" "diff" type-of signal wrong-type-argument cvs-fileinfo 5 re-search-forward "^\\([0-9]+\\)" t string-to-number match-string 1] 13 (#$ . 71840)])
#@119 Select a buffer containing the file.
With a prefix, opens the buffer in an OTHER window.

(fn E &optional OTHER VIEW)
(defalias 'cvs-mode-find-file #[769 "`\300\301!!\210`U\204\302\303 S\304\"\305>\204\306\307!\210\310\311\312\313\314\315\"\316\"\317\320\321&!\207" [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! make-byte-code 256 "p\306\307\211\310\311$\312
!\n>\204\313\314\315D\"\210\211\316H\317=\203b\312!\n>\204.\313\314\315D\"\210
\320H\321\322\f!!)\300\323=\203H\324\325!!\210\202W\300\203S\326!\210\202W\327!\210q\210\211\211\262
\202\263\203m\330
\"\202r\325\331!!\300\323=\203|\324\202\225\300\203\214\301\203\210\332\202\225\333\202\225\301\203\224\334\202\225\335
!\210
\203\260\336\337\"\203\260\214~\210eb\210\340!Sy\210)\211\262
\207" vconcat vector [cl-struct-cvs-fileinfo-tags default-directory d cvs-find-file-and-jump cvs-mode-marked nil :one t type-of signal wrong-type-argument cvs-fileinfo 2 DIRCHANGE 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] 8 "\n\n(fn &optional REV)" (byte-code "\300\301!C\207" [cvs-prefix-get cvs-branch-prefix] 2)] 11 (#$ . 72405) (list last-input-event current-prefix-arg)])
#@103 Undo local changes to all marked files.
The file is removed and `cvs update FILE' is run.

(fn FLAGS)
(defalias 'cvs-mode-undo #[257 "\300\301\302\303\304\305!\306\"\307$!\207" [cvs-mode! make-byte-code 0 "	\203\302\303!\207\304\305\306\307#\310\311
\"\211@
A\211\204&
\205B\312\313\314#\202B\312\306\300\315\205Ap\316\317\320\321\322\f\"\323\"\324$\262
%\207" vconcat vector [current-prefix-arg call-interactively cvs-mode-revert-to-rev cvs-do-removal undo "update" all #[257 "\301
!>\204\302\303\304D\"\210\211\305H\306=\206B\301
!>\204&\302\303\304D\"\210\211\305H\307=\205B\301
!>\204=\302\303\304D\"\210\211\310H\306=\207" [cl-struct-cvs-fileinfo-tags type-of signal wrong-type-argument cvs-fileinfo 2 REMOVED CONFLICT 3] 5 "\n\n(fn FI)"] cvs-partition cvs-mode-run "add" nil :postproc make-byte-code 0 "r\301q\210\302\303\304\300#)\207" vconcat vector [cvs-mode-run "add" nil] 4] 18] 8 (#$ . 73916) (list nil)])
#@47 Revert the selected files to an old revision.
(defalias 'cvs-mode-revert-to-rev #[0 "\300\301!\207" [cvs-mode! #[257 "\300\301\302\303\304$\305\306\307!Pp\310\311\312\313\314#\315\"\316$\310\311\317\313\314					%\320\"\321$\322\323C\324%\207" [cvs-mode-marked revert "revert" :file t "tmp_pcl_tag_" make-temp-name "" make-byte-code 0 "r\302q\210\303\304\305\301D\300#)\207" vconcat vector [cvs-mode-run "tag" "-d"] 4 "r\303q\210\305\306\307\302\307\300F\301\310\304%)\207" [cvs-mode-run "update" "-j" :postproc] 6 cvs-mode-run "tag" :postproc] 15 "\n\n(fn REV)" (byte-code "\301\302!\206\f\303\304\305!)C\207" [current-prefix-arg cvs-prefix-get cvs-branch-prefix (4) cvs-flags-query cvs-idiff-version] 2)]] 2 (#$ . 74868) 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 #[0 "\300\301!\207" [cvs-mode! #[0 "\304\305	!!)\306\n\307#\211\204\310\311!\202H\312\313\314Q!\205H\211\211\205F\211@\315
!\2035\316
!\210\202?\317
!\203?\320
!\210
A\266\202\202\"\262
)\207" [cvs-lock-file d default-directory cvs-lock-file-regexp 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] 5]] 2 (#$ . 75620) nil])
#@67 Remove all lines that are handled.
Empty directories are removed.
(defalias 'cvs-mode-remove-handled #[0 "\300\301!\207" [cvs-mode! #[0 "\302\303	\206\304\305$\207" [cvs-cookies cvs-auto-remove-directories cvs-cleanup-collection all handled t] 5]] 2 (#$ . 76311) nil])
#@42 Remove all marked files from the buffer.
(defalias 'cvs-mode-acknowledge #[0 "\300\301!\207" [cvs-mode! #[0 "\302\303\304!\305\"\211\203)\211@\306
!>\204\307\310\311D\"\210\211\211\312\313I\266
A\266\202\202\210\314	\315\211\211$\207" [cl-struct-cvs-fileinfo-tags cvs-cookies cvs-get-marked cvs-ignore-marks-p "acknowledge" t type-of signal wrong-type-argument cvs-fileinfo 2 DEAD cvs-cleanup-collection nil] 6]] 2 (#$ . 76589) nil])
#@98 Remove files.
Returns a list of FIS that should be `cvs remove'd.

(fn FILTER &optional CMD ALL)
(defalias 'cvs-do-removal #[769 "\305\306\307\310\307&\311\312\305\"\"A?\2064\313	:\2031\n	\211A\242!\204\307\211\202	*?\314 
\204U\315=\203Ur\211q\210\307\316\317\320\"!\210\321p!\210\322 \210*
\204\255\323\324\325\326\327!\330\"\331$\216\332G\333=\203s\334\202t\335
\336U\203\231\337\340\341\n@!\f>\204\220\342\343\344\f@D\"\210	@\345H#\202\236\337\346#\266\202!)\204\255\347\350!\210\351\202
\211\203
\211@\341
!\f>\204\303\342\343\344D\"\210\211\352H\320!\204\324
\353=\203\371\354
!\203\336\355
!\210\204\371\341!\f>\204\362\342\343\344D\"\210\211\352\356I\266\266
A\266\202\202\256\210\207" [cvs-confirm-removals -cvs-every-l -cvs-every-f inhibit-read-only cl-struct-cvs-fileinfo-tags cvs-mode-marked :file t :read-only cvs-partition #[257 "\301
!>\204\302\303\304D\"\210\211\305H\306=\207" [cl-struct-cvs-fileinfo-tags type-of signal wrong-type-argument cvs-fileinfo 2 UNKNOWN] 5 "\n\n(fn FI)"] #[257 "\300\301!!?\206
\302
\303\"\207" [file-exists-p cvs-fileinfo->full-name cvs-applicable-p safe-rm] 4 "\n\n(fn FI)"] cvs-temp-buffer list cvs-insert-strings mapcar cvs-fileinfo->full-name cvs-pop-to-buffer-same-frame shrink-window-if-larger-than-buffer make-byte-code 0 "\302\300	\"\207" vconcat vector [cvs-buffer cvs-bury-buffer] 3 yes-or-no-p undo "Undo" "Delete" 1 format "%s file: \"%s\" ? " type-of signal wrong-type-argument cvs-fileinfo 5 "%s %d files? " message "Aborting" nil 2 UNKNOWN file-exists-p delete-file DEAD] 17 (#$ . 77037)])
#@82 Remove all marked files.
With prefix argument, prompt for cvs flags.

(fn FLAGS)
(defalias 'cvs-mode-remove #[257 "\300\301\302\303\304\305!\306\"\307$!\207" [cvs-mode! make-byte-code 0 "\302\303!\211\203\304\305\306\300B#\202\307	\310\211\211$\207" vconcat vector [cvs-cookies cvs-do-removal remove cvs-mode-run "remove" "-f" cvs-cleanup-collection nil] 6] 8 (#$ . 78662) (byte-code "\300\301\302\"C\207" [cvs-flags-query cvs-remove-flags "cvs remove flags"] 3)])
(defvar cvs-tag-name "")
#@264 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.

(fn TAG &optional FLAGS)
(defalias 'cvs-mode-tag #[513 "\300\301\302\303\304\305\"\306\"\307$!\207" [cvs-mode! make-byte-code 0 "\303\304\305\301\300C\"\n\205\f\306#\207" vconcat vector [cvs-force-dir-tag cvs-mode-do "tag" append tag] 5] 10 (#$ . 79166) (byte-code "\302\303	#\211\304\305\306\"D\207" [cvs-tag-name cvs-qtypedesc-tag cvs-query-read "Tag name: " cvs-flags-query cvs-tag-flags "tag flags"] 4)])
#@115 Run `cvs tag -d TAG' on all selected files.
With prefix argument, prompt for cvs flags.

(fn TAG &optional FLAGS)
(defalias 'cvs-mode-untag #[513 "\300\301\302\303\304\305\"\306\"\307$!\207" [cvs-mode! make-byte-code 0 "\303\304\305\306\301\300C#\n\205
\307#\207" vconcat vector [cvs-force-dir-tag cvs-mode-do "tag" append ("-d") tag] 6] 10 (#$ . 79827) (byte-code "\302\303	#\211\304\305\306\"D\207" [cvs-tag-name cvs-qtypedesc-tag cvs-query-read "Tag to delete: " cvs-flags-query cvs-tag-flags "tag flags"] 4)])
#@67 Run byte-compile-file on all selected files with `.el' extension.
(defalias 'cvs-mode-byte-compile-files #[0 "\300\301!\207" [cvs-mode! #[0 "\300\301\302!!\211\211\205\"\211@\303
!\304\305\"\203\306
!\210\210
A\266\202\202\262
\207" [cvs-get-marked cvs-ignore-marks-p "byte-compile" cvs-fileinfo->full-name string-match "\\.el\\'" byte-compile-file] 7]] 2 (#$ . 80354) nil])
#@66 Add a ChangeLog entry in the ChangeLog of the current directory.
(defalias 'cvs-mode-add-change-log-entry-other-window #[0 "\300\301!\207" [cvs-mode! #[0 "\304\305!\210\306\307\211\"\211\205D\211@\310
!>\204\311\312\313D\"\210\211\314H\315\316	!!)\317\320\321\322\323!\324\"\325$\326\327!\210\212\330 \210+
A\266\202\202\207" [cl-struct-cvs-fileinfo-tags d default-directory add-log-buffer-file-name-function require add-log cvs-mode-marked nil type-of signal wrong-type-argument cvs-fileinfo 4 file-name-as-directory expand-file-name make-byte-code 0 "\302\303\300!	>\204\304\305\306\300D\"\210\300\307H!\310
!\203 \311
!\202!\211\207" vconcat vector [cl-struct-cvs-fileinfo-tags expand-file-name type-of signal wrong-type-argument cvs-fileinfo 5 file-directory-p file-name-as-directory] 5 kill-local-variable change-log-default-name add-change-log-entry-other-window] 8]] 2 (#$ . 80741) nil])
#@51 Ask for new setting of cvs-FLAG-flags.

(fn FLAG)
(defalias 'cvs-mode-set-flags #[257 "\301\302\303Q!\304\305
\306P\")\207" [current-prefix-arg intern "cvs-" "-flags" (16) cvs-flags-query " flags"] 6 (#$ . 81657) (byte-code "\300\301\302\303\304$C\207" [completing-read "Which flag: " ("cvs" "diff" "update" "status" "log" "tag" "commit" "remove" "undo" "checkout") nil t] 5)])
#@80 Return true if FILEINFO represents a file in directory DIR.

(fn FILEINFO DIR)
(defalias 'cvs-dir-member-p #[514 "\301!>\204\302\303\304D\"\210
\305H\306=?\205.\307
\301!>\204*\302\303\304D\"\210\310H\"\207" [cl-struct-cvs-fileinfo-tags type-of signal wrong-type-argument cvs-fileinfo 2 DIRCHANGE string-prefix-p 4] 8 (#$ . 82044)])
#@96 Internal function for `cvs-execute-single-file-list'.

(fn FI EXTRACTOR PROGRAM CONSTANT-ARGS)
(defalias 'cvs-execute-single-file #[1028 "!\301\211<\205&\302\"\303\304\305!#c\210\306\307\310\301\211&\210db\262
)\207" [inhibit-read-only t append format "=== %s %s\n\n" split-string-and-unquote apply process-file nil] 13 (#$ . 82395)])
#@442 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.

(fn FIS EXTRACTOR PROGRAM CONSTANT-ARGS)
(defalias 'cvs-execute-single-file-list #[1028 "\211\205\211@\300
$\210
A\266\202\202
\207" [cvs-execute-single-file] 11 (#$ . 82749)])
#@12 

(fn FIS)
(defalias 'cvs-revert-if-needed #[257 "\211\211\205k\211@\301
!\302
!\211\203b\303!>\204 \304\305\306D\"\210\307H\310>\204b\311
!\204br\211q\210\3121\\\313\314\315\316#\210\317 \210\303!>\204N\304\305\306D\"\210\307H\320=\205X\321 0\202`\210\202a\210)\266
A\266\202\202
\207" [cl-struct-cvs-fileinfo-tags cvs-fileinfo->full-name find-buffer-visiting type-of signal wrong-type-argument cvs-fileinfo 2 (MESSAGE UNKNOWN) buffer-modified-p (error) revert-buffer ignore-auto dont-ask preserve-modes vc-refresh-state CONFLICT smerge-start-session] 9 (#$ . 83342)])
#@35 Change the CVSROOT.

(fn NEWROOT)
(defalias 'cvs-change-cvsroot #[257 "\301\302\303\"!\204\304\305!\205\211\211\207" [cvs-cvsroot file-directory-p expand-file-name "CVSROOT" y-or-n-p "Warning: no CVSROOT found inside repository. Change cvs-cvsroot anyhow? "] 5 (#$ . 83938) "DNew repository: "])
(byte-code "\300\301\302\303\304DD\305\306\307\310\311&\210\300\312\302\303\313DD\314\306\307\310\315&\207" [custom-declare-variable cvs-dired-action funcall function #[0 "\300\207" [cvs-quickdir] 1] "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 #[0 "\300\207" [(4)] 1] "Whether or not opening a CVS directory should run PCL-CVS.\nA value of nil means never do it.\n`always' 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)
#@134 Run `cvs-examine' if DIR is a CVS administrative directory.
The exact behavior is determined also by `cvs-dired-use-hook'.

(fn DIR)
(defalias 'cvs-dired-noselect #[257 "\211;\2059\303
!\262
\304
!\305\230\2059\306\307\310\"!\2059\2059\311=\203*	?\202-	\232\2059\212\n\312!\313\211#)\207" [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] 5 (#$ . 85104)])
(add-hook 'vc-post-command-functions 'cvs-vc-command-advice)
#@28 

(fn COMMAND FILES FLAGS)
(defalias 'cvs-vc-command-advice #[771 "\305\232\205\277\211@;\203\306\307@\"\203\211
A\266\202\202\211@\235\205\277\211@\310\235\205G\311
\211\203B\211@\211\312\232\203;\313\262
A\266\202\202,
\262
\262
?\205\277rp	\313\314 \211\205\271\211@\211q\210\315=\203\262\316	\"\203\262\317	G\"q\210\320\304!\210
@\321\232\203\254eb\203\254\322\323!\203\254<\203\223\202\226C\211\203\253\211@\324\325\326!\"c\210
A\266\202\202\226\210\327\311\"\266
A\266\202\202R\262
)\266\202)\207" [cvs-parse-known-commands default-directory cvs-from-vc major-mode cvs-buffer "cvs" string-match "\\`-" ("update" "checkout") nil "-p" t buffer-list cvs-mode string-prefix-p substring make-local-variable "add" looking-at ".*to add this file permanently\n\\'" format-message "cvs add: scheduling file `%s' for addition\n" file-name-nondirectory cvs-parse-process] 14 (#$ . 85667)])
(defalias 'cvs-mark-buffer-changed #[0 "\304!\305\306!\205\306
!\307=\205\310
!\211\205^\212\311 \211\205[\211@\211q\210	\312=\203T\313\n\"\203T\314\nG\"\315\316\230\203A\317\202B\320\321!\206I\322\323!\324$\325\"\266
A\266\202\202\262
)\207" [buffer-file-name major-mode default-directory cvs-cookies expand-file-name fboundp vc-backend CVS vc-working-revision buffer-list cvs-mode string-prefix-p substring cvs-create-fileinfo "0" ADDED MODIFIED file-name-directory "" file-name-nondirectory "cvs-mark-buffer-changed" cvs-addto-collection] 10])
(add-hook 'after-save-hook 'cvs-mark-buffer-changed)
(defalias 'cvs-insert-visited-file #[0 "\303!\304\305!\205\305
!\306=\205\307
!\211\205?r\310 \211\205<\211@\211q\210	\311=\2035\312\n\"\2035\313!\210
A\266\202\202\262
)\207" [buffer-file-name major-mode default-directory expand-file-name fboundp vc-backend CVS vc-working-revision buffer-list cvs-mode string-prefix-p cvs-insert-file] 7])
(byte-code "\300\301\302\303#\210\304\305!\207" [add-hook find-file-hook cvs-insert-visited-file append provide pcvs] 4)