;ELC   
;;; Compiled by jmacd@linux.local on Sun May  9 17:18:15 2004
;;; from file /home/jmacd/nfs/projects/prcs1/emacs/elc.22822/prcs.el
;;; in Emacs version 21.2.1
;;; with bytecomp version 2.85
;;; with all optimizations.

;;; This file uses dynamic docstrings, first added in Emacs 19.29.
(if (and (boundp 'emacs-version)
	 (< (aref emacs-version (1- (length emacs-version))) ?A)
	 (or (and (boundp 'epoch::version) epoch::version)
	     (string-lessp emacs-version "19.29")))
    (error "`prcs.el' was compiled for Emacs 19.29 or later"))

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


(byte-code "\300\301!\210\300\302!\210\300\303!\210\300\304!\210\300\305!\207" [require lisp-mode emerge cl add-log prcs-hooks] 2)
#@437 *Use fast but unsafe version prompts?
If true, then whenever a PRCS version number (or branch) is
prompted for that is normally supposed to be an existing version
(branch), permit the user to enter any value without confirming its
existence, to save time on projects with many versions or a slow
repository. The calculation is done anyway if the user tries to use
TAB completion; this only affects typing in a value without
completion.
(custom-declare-variable 'prcs-sloppy-version-prompts 'nil '(#$ . -747) :type 'boolean :group 'prcs)
#@192 *Do asynchronous modification checks on files.
If true, check visited PRCS files to see if they have been
modified since last checkout. The check is done in the background to
avoid overhead.
(custom-declare-variable 'prcs-check-if-file-modified 't '(#$ . -1291) :type 'boolean :group 'prcs)
#@292 *Timeout on modification checks?
If set to a number, that is treated as a number of seconds to wait
before killing off the PRCS status checker on a buffer, under the
assumption that it either (a) was hung, or (b) what is more likely,
Emacs totally forgot to run its sentinel & just left it.
(custom-declare-variable 'prcs-timeout-on-modified-checks '15 '(#$ . -1589) :type '(choice (const :tag "Disable" nil) number) :group 'prcs)
#@221 *Automatically insert ChangeLog entries?
If non nil and the project contains a file matching named
ChangeLog in its root directory, prcs-mode will automatically insert
the contents of New-Version-Log into the ChangeLog.
(custom-declare-variable 'prcs-auto-add-changelog 't '(#$ . -2027) :type 'boolean :group 'prcs)
#@131 *If not nil, PRCS checkin asks which buffers to save before checking in.
Otherwise, it saves all modified buffers without asking.
(custom-declare-variable 'prcs-ask-about-save 't '(#$ . -2350) :type 'boolean :group 'prcs)
#@378 *Find repositories based on project name.
List of (REGEXP . REPOSITORY) pairs associating project names to
repositories. When (if any) REGEXP matches a file's project name,
REPOSITORY is used instead of the PRCS_REPOSITORY environment
variable. The first match is retained. E.g.:

'(("sharedproject" . "/user/sharedaccount/PRCS")
  ("personalproject" . "/user/username/PRCS"))
(custom-declare-variable 'prcs-repository-alist 'nil '(#$ . -2579) :type '(repeat (cons :format "%v" (regexp :tag "Project Name") (file :tag "Repository"))) :group 'prcs)
#@267 Preferred repository to use for this project file (buffer-local).
This takes precedence over `prcs-repository-alist', so you can e.g.
set this as a buffer-local variable in the magic line of a project
file, e.g.:

-*- mode: PRCS; prcs-my-repository: "/foo/PRCS" -*-
(defvar prcs-my-repository nil (#$ . 3134))
(make-variable-buffer-local 'prcs-my-repository)
#@53 *Extra options passed to checkin (list of strings).
(custom-declare-variable 'prcs-extra-checkin-options ''("--long-format") '(#$ . -3499) :type '(repeat (string :tag "Option")) :group 'prcs)
#@50 *Extra options passed to diff (list of strings).
(custom-declare-variable 'prcs-extra-diff-args ''("--context") '(#$ . -3697) :type '(repeat (string :tag "Option")) :group 'prcs)
#@74 *If true, display the project path to a controlled file in its modeline.
(custom-declare-variable 'prcs-display-path 't '(#$ . -3882) :type 'boolean :group 'prcs)
#@49 Divider between sections of PRCS output buffer.
(custom-declare-variable 'prcs-output-buffer-divider '(concat "------------------%<------------------%<" "------------------%<------------------") '(#$ . 4051) :type 'string :group 'prcs)
#@298 Function to select name of the prcs output buffer, possibly based on PROJECT.
COMMAND is the PRCS command being executed (see
`prcs-command'). DISPLAYED indicates whether or not the command was
intended to be displayed.

May ignore any or all arguments (but best to retain DISPLAYED
distinction).
(custom-declare-variable 'prcs-output-buffer-name-function ''prcs-standard-output-buffer-name '(#$ . 4294) :type 'symbol :group 'prcs)
#@50 See variable `prcs-output-buffer-name-function'.
(defalias 'prcs-output-buffer-name #[(project command displayed) "	\n#\207" [prcs-output-buffer-name-function project command displayed] 4 (#$ . 4732)])
(defalias 'prcs-standard-output-buffer-name #[(project command displayed) "\203 \302\202	 \303	\304Q\207" [displayed project "*prcs-output [" " *prcs-hidden-output [" "]*"] 3])
#@215 *Suggested size for `prcs-obarray'.
Good numbers are either prime,
or 2^n-1. You only need to change this if you have a huge project, in
which case you want something on the order of 2-3 times the number of
files.
(custom-declare-variable 'prcs-obarray-size '16383 '(#$ . -5122) :type 'number :group 'prcs)
#@196 *Program to run for callbacks, e.g. for EDiff support.
Should be
name of executable `prcs-callback' script distributed with prcs.el,
either present in your `exec-path' or a fully qualified name.
(custom-declare-variable 'prcs-callback-program '"prcs-callback" '(#$ . -5436) :type 'string :group 'prcs)
#@213 *Whether to invoke EDiff as the viewer during diffs.
Just make sure
the `prcs-callback' script is installed somewhere, and
`prcs-callback-program' finds it. Always use it if T, never if NIL, or
prompt otherwise.
(custom-declare-variable 'prcs-use-ediff-for-diffs ''ask '(#$ . -5745) :type '(choice (const :tag "Never" nil) (const :tag "Always" t) (const :tag "Ask" ask)) :group 'prcs)
#@40 True when in a PRCS-controlled buffer.
(defvar prcs-controlled-mode nil (#$ . 6136))
(byte-code "\304B\305B\306B\307B\310\311\211\203, \n@\312	!\210\313	\314\315#\210\nA\211\204 *\303B\316\311\207" [current-load-list minor-var #:--dolist-temp--16500 prcs-descriptors prcs-controlled-project prcs-controlled-version prcs-controlled-status prcs-controlled-path (prcs-controlled-mode prcs-controlled-project prcs-controlled-version prcs-controlled-status prcs-controlled-path) nil make-variable-buffer-local put permanent-local t (Files Created-By-Prcs-Version Project-Description Project-Version Parent-Version Version-Log New-Version-Log Checkin-Time Checkin-Login Populate-Ignore Project-Keywords Merge-Parents New-Merge-Parents)] 5)
#@133 Symbols it is handy to refer to from the project file.
The real
symbols are all interned privately, so simple quotes will not work.
(defconst prcs-useful-symbols (byte-code "\301\302\303\304\"\"\207" [prcs-descriptors mapcar symbol-name append (:symlink :no-keywords :directory)] 5) (#$ . 6893))
#@55 Obarray for symbols PRCS Mode creates during a parse.
(defvar prcs-obarray (make-vector prcs-obarray-size 0) (#$ . 7196))
(byte-code "\304\211\203 \n@\305\306	P!\305	\"L\210\nA\211\204 *\304\207" [prcs-useful-symbols var #:--dolist-temp--16501 prcs-obarray nil intern "prcs-"] 5)
#@38 Cached parse of a PRCS project file.
(defvar prcs-parse-cache nil (#$ . 7490))
(make-variable-buffer-local 'prcs-parse-cache)
#@43 Last time a PRCS project file was parsed.
(defvar prcs-parse-cache-tick nil (#$ . 7622))
(make-variable-buffer-local 'prcs-parse-cache-tick)
#@79 Try to guess repository from `prcs-repository-alist' or `prcs-my-repository'.
(defalias 'prcs-guess-repository #[(pbuffer) "\212q\210	\206\" \306\307\n\310 \311\312\313\314&\211A@)!\315\316\311\312$A))\207" [pbuffer prcs-my-repository prcs-Project-Version x project-name prcs-repository-alist prcs-coerce find prcs-parse-prj-file-cached :key car :test eq find-if #[(rx) "\302	\"\207" [rx project-name string-match] 3]] 9 (#$ . 7769)])
#@14 Descriptors.
(defconst prcs-prj-descriptor-regex (mapconcat 'symbol-name prcs-descriptors "\\|") (#$ . 8216))
#@43 PRCS project file fontification keywords.
(defconst prcs-font-lock-keywords (byte-code "\301\302Q\303B\304B\207" [prcs-prj-descriptor-regex "(\\(" "\\)\\>" (1 font-lock-function-name-face) (("^\\s-*(\\(\\([^ \n	;()\"]\\|\\\\.\\)+\\)\\s-+(\\(\\S-+/\\([^ \n	;()\"]\\|\\\\.\\)+\\s-+[0-9.]+\\s-+[0-9]+\\))" (1 font-lock-type-face) (3 font-lock-variable-name-face)) ("^\\s-*(\\(\\([^ \n	;()\"]\\|\\\\.\\)+\\)\\s-+(\\(\\([^ \n	;()\"]\\|\\\\.\\)+\\)).*\\<:symlink\\>" (1 font-lock-type-face) (3 font-lock-reference-face)) ("^\\s-*(\\(\\([^ \n	;()\"]\\|\\\\.\\)+\\)\\s-+(\\s-*)" (1 font-lock-type-face)) ("\\<:\\sw+\\>" 0 font-lock-keyword-face prepend) ("\\\\." 0 font-lock-string-face t) (";.*" 0 font-lock-comment-face t))] 3) (#$ . 8332))
#@46 PRCS project file fontification information.
(defconst prcs-font-lock-defaults (byte-code "\301\302\211\203 \303\202\f \304\305BBBB\207" [prcs-xemacs-p prcs-font-lock-keywords nil ((43 . "w") (45 . "w") (42 . "w") (47 . "w") (46 . "w") (60 . "w") (62 . "w") (61 . "w") (33 . "w") (63 . "w") (36 . "w") (37 . "w") (95 . "w") (38 . "w") (126 . "w") (94 . "w") (58 . "w")) (("+-*/.<>=!?$%_&~^:" . "w")) (beginning-of-defun (font-lock-comment-start-regexp . ";") (font-lock-mark-block-function . mark-defun))] 5) (#$ . 9074))
#@667 Handles background disk writes by PRCS and makes sure Emacs keeps everything in synch for BUFFER.

If the file has been written on disk since last visit/save, but is
marked unmodified here, it refreshes the buffer and sets the modeline,
after confirming with the user (unless FORCE is non-nil).

If the file has been written on disk but is modified, does the same
thing, but only after a sterner warning (which is never turned off).

If the file is untouched on disk (whether the buffer is modified or
not), this does not try to revert.

In any case, the PRCS modeline setting will be recalculated, unless a
modified buffer was left as is, or SKIP-MODELINE is true.
(defalias 'prcs-check-that-file-is-ok #[(&rest #1=#:--rest--16502) "\305>\206	 \306pDA@\307>A@\310>A@\f\203D \f@\311>\203- \fAA\211\202 \312>A@\203; \306\211\202 \313\314\f@\"\210\202 )\212	q\210\315	!\204r \316 \203^ \317\320\321 \322Q!\202i \n\204l \323\324\321 \325Q!\203r \326\327\211\211#\210\316 ?\205 ?\205 \330 ,\207" [#1# buffer force skip-modeline #2=#:--keys--16503 :buffer nil :force :skip-modeline (:buffer :force :skip-modeline :allow-other-keys) :allow-other-keys error "Keyword argument %s not one of (:buffer :force :skip-modeline)" verify-visited-file-modtime buffer-modified-p yes-or-no-p "Really revert " buffer-file-name " from disk, discarding modifications? " y-or-n-p "Refresh " " from disk? " revert-buffer t prcs-update-file-status] 5 (#$ . 9605)])
#@148 Return a list of all currently visited buffers.
Should correspond to
files in project file PBUFFER (not including the project file buffer
itself).
(defalias 'prcs-get-visited-buffers #[(&rest #1=#:--rest--16504) "\305>\206	 \306pDA@\n\2038 \n@\307>\203! \nAA\211\202 \310>A@\203/ \306\211\202 \311\312\n@\"\210\202 )\313\314	!!\315\316\317\320\321\f\322	!\323\324$A\"\"*\207" [#1# pbuffer #2=#:--keys--16505 base-dir prcs-Files :pbuffer nil (:pbuffer :allow-other-keys) :allow-other-keys error "Keyword argument %s not one of (:pbuffer)" file-name-directory buffer-file-name remove-if-not identity mapcar #[(desc) "\304\305\306@!	\"!\211\205 \212\nq\210)\205 \n)\207" [desc base-dir buf prcs-controlled-mode get-file-buffer expand-file-name prcs-coerce] 5] find prcs-parse-prj-file-cached :key car] 10 (#$ . 11070)])
#@351 Save some files visited in PRCS controlled mode.
For all files mentioned in the project file PBUFFER (default
current), or BUFLIST if supplied, which are also in memory buffers and
modified, save them (asking first if `prcs-ask-about-save' is
non-nil). Includes project file. If SKIP-MODELINE is set, modeline
modification checks will be suppressed.
(defalias 'prcs-prompt-for-saves #[(&rest #1=#:--rest--16506) "\306>\206	 \307pDA@\310>A@\311>\206  \307	\312\306	\"BDA@\f\203O \f@\313>\2038 \fAA\211\202& \314>A@\203F \307\211\202& \315\316\f@\"\210\202% )\212\307\211\203\217 @\211q\210\317 \203\206 \203u \320\321\322 \323Q!\203\206 \n\203\203 \307\324 \210)\202\206 \324 \210A\211\204Z .\307\207" [#1# pbuffer skip-modeline buflist #2=#:--keys--16507 buf :pbuffer nil :skip-modeline :buflist prcs-get-visited-buffers (:pbuffer :skip-modeline :buflist :allow-other-keys) :allow-other-keys error "Keyword argument %s not one of (:pbuffer :skip-modeline :buflist)" buffer-modified-p y-or-n-p "Save file " buffer-file-name "? " save-buffer #3=#:--dolist-temp--16508 prcs-ask-about-save prcs-check-if-file-modified] 6 (#$ . 11910)])
#@378 Refresh some files visited in PRCS controlled mode.
For all files mentioned in the project file PBUFFER which are also
in memory buffers, make sure they are refreshed from disk as needed
with `prcs-check-that-file-is-ok', prompting in case of
`prcs-ask-about-save'. SKIP-MODELINE used as in
`prcs-check-that-file-is-ok'. BUFLIST as in
`prcs-prompt-for-saves'. Includes p-file.
(defalias 'prcs-prompt-for-refreshes #[(&rest #1=#:--rest--16509) "\306>\206	 \307pDA@\310>A@\311>\206  \307	\312\306	\"BDA@\f\203O \f@\313>\2038 \fAA\211\202& \314>A@\203F \307\211\202& \315\316\f@\"\210\202% )\307\211\203r @\317\320\321?\310\n&\210A\211\204Y -\307\207" [#1# pbuffer skip-modeline buflist #2=#:--keys--16510 buf :pbuffer nil :skip-modeline :buflist prcs-get-visited-buffers (:pbuffer :skip-modeline :buflist :allow-other-keys) :allow-other-keys error "Keyword argument %s not one of (:pbuffer :skip-modeline :buflist)" prcs-check-that-file-is-ok :buffer :force #3=#:--dolist-temp--16511 prcs-ask-about-save] 9 (#$ . 13076)])
#@102 Retrieve the parse for this buffer, from cache or fresh parse.
Use instead of `prcs-parse-prj-file'.
(defalias 'prcs-parse-prj-file-cached #[(&rest #1=#:--rest--16512) "\203\f \211A@\202 p\203 \305\306\307GTD\"\210\310\311	\312\313$\210\212	q\210\n\314=\2040 \315\316!\210\317 V\203> \320	!\317 \f*\207" [#1# buffer major-mode prcs-parse-cache-tick prcs-parse-cache signal wrong-number-of-arguments prcs-parse-prj-file-cached prcs-check-that-file-is-ok :buffer :skip-modeline t prcs-mode error "Attempt to do a PRCS parse on something which is not really a project file. This probably indicates a bug in prcs.el; report to the author." buffer-modified-tick prcs-parse-prj-file] 5 (#$ . 14129)])
#@54 Coerce this number, string, or symbol into a string.
(defalias 'prcs-coerce #[(object) "\205  \247\203 \301!\207;\203 \2079\203 \302!\207\303\304!\207" [object number-to-string symbol-name error "Weird object"] 2 (#$ . 14841)])
#@838 Return a simple list of all s-exps in project file.
May be symbols,
strings, numbers etc. (according to the superficial form). No
buffer-position info retained. Lists are natural.

Note that e.g. filenames are returned as symbols, so you probably want
to use `prcs-coerce' on them; they are interned in `prcs-obarray', so
you could find one by searching (via `eq') on `(intern "..."
prcs-obarray)'.

To compare against a standard keyword, e.g. `New-Version-Log', use the
variable `prcs-New-Version-Log' which will contain the properly
interned symbol.

`prcs-fixup-parse' is used to perform some postprocessing.

For speed, use `prcs-parse-prj-file-cached' instead.

This format is convenient for finding things: e.g. to get checkin time as
a string, try:

  (cadr (find prcs-Checkin-Time (prcs-parse-prj-file-cached BUFFER) :key 'car))
(defalias 'prcs-parse-prj-file #[(&rest #1=#:--rest--16513) "\203\f \211A@\202 p\203 \304\305\306GTD\"\210\307\310!\210\212	q\210eb\210\311\311\312\313\217\210\314\n\237!\307\315!\210,\207" [#1# buffer prj-sexps result signal wrong-number-of-arguments prcs-parse-prj-file message "Parsing project file..." nil (byte-code "\304\n!)B\202  " [prcs-obarray obarray buffer prj-sexps read] 2) ((end-of-file) (invalid-read-syntax (byte-code "\301 \210eb\210\302\302\303\304\217\207" [prj-sexps prcs-escape-syntactic-nastiness nil (byte-code "\304\n!)B\202  " [prcs-obarray obarray buffer prj-sexps read] 2) ((end-of-file))] 3))) prcs-fixup-parse "Parsing project file...done"] 4 (#$ . 15086)])
#@299 Escape symbols in current project buffers beginning with dot.
Also escapes pound signs, with the assumption that they are part of a filename.
Operates heuristically, so is not foolproof, but mistakes
probably won't cause any harm. Skips over anything which font-lock
claims is a comment or string.
(defalias 'prcs-escape-syntactic-nastiness #[nil "\306 	\203 \307\310\311\312 \"!\204 \313\314!\210\315\316\317!\210\320\303!\203, \203, \321ed\"\210\316\322!\210eb\210\323\324\315\325#\203\215 \326\224\203D \326\202E \327\330\f\224\331\"\211\332=\204\211 \333=\204\211 \f\224b\210\f\225\f\224Z\211%\334&'&'W\203\200 \335c\210\336u\210&T\211&\202k *\334\225%\\b\210)*\2023 \316\337!\210	\203\227 \325\n?\205\302 \306 \205\302 	\203\261 \316\340\312 \"\210\341\315!\202\302 (\203\300 \307\342\312 \343Q!\205\302 \344 *\207" [buffer-read-only orig-ro orig-mod font-lock-mode subexp #1=#:G16514 buffer-modified-p y-or-n-p format "PRCS Major Mode wants to escape filenames in read-only buffer %s. Continue? " buffer-file-name error "Cannot escape filenames for PRCS parse" nil message "Fontifying syntactically before escaping filenames..." boundp font-lock-fontify-syntactically-region "Escaping filenames..." search-forward-regexp "\\((\\(\\.+\\)\\)\\|\\(^\\|[^\\\\]\\)\\(#\\)" t 2 4 get-text-property face font-lock-comment-face font-lock-string-face 0 92 1 "Escaping filenames...done" "Warning: buffer %s is read-only; not attempting to save filename escapes." set-buffer-modified-p "Save file " "? " save-buffer escape-count ignore #2=#:--dotimes-temp--16515 prcs-ask-about-save] 5 (#$ . 16637)])
#@356 If true, actually insert copies of new-style scoped modifiers into all the file descriptors they apply to.
Else skip this step, but still
remove them from the Files list so as not to interfere.

You only need to turn this on if you are changing code so as to
actually depend on attributes of files in a specific fashion. Leaving
it off is more efficient.
(defconst prcs-careful-parses nil (#$ . 18260))
#@570 Given a basic parse of a project file, transform it to give the illusion that it does not have multiple file lists.
Thus the parse
of the following:

    (Files :tag=haha :tag=hoho
      (foo (...))
      (bar (...) :no-keywords))
    (Files
      (baz (quux) :symlink))

will come out as if it were:

    (Files
      (foo (...) :tag=haha :tag=hoho)
      (bar (...) :no-keywords :tag=haha :tag=hoho)
      (baz (quux) :symlink))

With `prcs-careful-parses' off, this would be:

    (Files
      (foo (...))
      (bar (...) :no-keywords)
      (baz (quux) :symlink))
(defalias 'prcs-fixup-parse #[(parse) "\306\211\307\n!\306\211\203* \f@\211@=\203 	B\202# B\fA\211\204 *\310\311	\"B*B\207" [other-sexps files-sexps parse sexp #1=#:--dolist-temp--16516 prcs-Files nil reverse mapcan #[(files-sexp) "\304A	\203 	@:\204 	\211A@\nB\202 \n\237\203, \n\203, \305\306	\"\202- 	*\207" [files-sexp actuals modifiers prcs-careful-parses nil mapcar #[(desc) "\302	\"\207" [desc modifiers append] 3]] 3]] 4 (#$ . 18670)])
#@26 Run Emerge on two files.
(defalias 'prcs-emerge-files #[(file-A file-B file-out quit-hooks) "\304	\305\n%\207" [file-A file-B quit-hooks file-out emerge-files-internal nil] 6 (#$ . 19716)])
#@63 Run Emerge on two files, giving another file as the ancestor.
(defalias 'prcs::emerge-files-with-ancestor #[(file-A file-B file-ancestor file-out quit-hooks) "\305	\n\306\f&\207" [file-A file-B file-ancestor quit-hooks file-out emerge-files-with-ancestor-internal nil] 7 (#$ . 19914)])
#@35 Run Emerge on two or three files.
(defalias 'prcs::emerge #[(work com sel out) "\305\306	\n%\210\307\310\304\311\"\210\310\304\312\307\313DE\"\210	\314\232\203) \315\n\f$\210\2021 \316\n	\f%\210\317 \210\305\320!)\207" [work com sel out quit-hooks message "prcs::emerge with files %s %s %s %s" nil add-hook #[nil "\300 \207" [exit-recursive-edit] 1] lambda emerge-files-exit "/dev/null" prcs-emerge-files prcs::emerge-files-with-ancestor recursive-edit "prcs::emerge finished"] 6 (#$ . 20209)])
(byte-code "\302B\304\302!\204\f 	\303B\304\303!\204 \305\306\303\305\"\207" [current-load-list lisp-mode-syntax-table prcs-mode-syntax-table prcs-mode-abbrev-table boundp nil define-abbrev-table] 3)
(defalias 'prcs-mode-variables #[nil "\306\303!\n\307PL\210\306\310!L\210\306\311!\312L\210\306\313!\314L\210\306\315!\316L\210\306\317!\320L\210\306\321!\322L\210\306\323!\312L\210\306\324!\325L\210\306\326!\327L\210\306\330!\331L\210\306\332!\333L\210\306\334!\333L\210\306\335!\336L\210\306\337!\340L\210\306\341!\fL\210\316\342\211#\207" [prcs-mode-abbrev-table local-abbrev-table page-delimiter paragraph-start prcs-font-lock-defaults prcs-parse-cache make-local-variable "\\|$" paragraph-separate paragraph-ignore-fill-prefix t fill-paragraph-function lisp-fill-paragraph adaptive-fill-mode nil indent-line-function lisp-indent-line indent-region-function lisp-indent-region parse-sexp-ignore-comments outline-regexp ";;; \\|(...." comment-start ";" comment-start-skip "\\(\\(^\\|[^\\\\\n]\\)\\(\\\\\\\\\\)*\\);+ *" max-lisp-eval-depth 10000 max-specpdl-size comment-column 40 comment-indent-function lisp-comment-indent font-lock-defaults 0 prcs-parse-cache-tick] 3])
#@25 Keymap for `prcs-mode'.
(defvar prcs-mode-map nil (#$ . 21905))
#@41 PRCS menu for XEmacs (not used on FSF).
(defconst prcs-xemacs-menu '("PRCS" ["Working diff" prcs-diff :active t] ["Arbitrary diff" prcs-diff-with-prefix :active t :keys "C-u \\[prcs-diff]"] ["Info" prcs-info :active t] ["Complex info" prcs-info-with-prefix :active t :keys "C-u \\[prcs-info]"] ["Rekey" prcs-rekey :active t] "----" ["Checkin" prcs-checkin :active t]) (#$ . 21975))
(byte-code "\204\220 	\2031 \306 \307\300\"\210\310\nC\"\210\311\312\313#\210\311\314\315#\210\311\316\317#\210\311\320\321#\210\202\220 \306 \322\323\304!\203@ \f\202A \n\"\210\311\312\313#\210\311\314\315#\210\311\316\317#\210\311\320\321#\210\203\215 \311\324\325\306\325!B#\210\311\326\327#\210\311\330\331#\210\311\332\333#\210\311\334\335#\210\311\336\337#\210\311\340\341#\210)\306\207" [prcs-mode-map prcs-xemacs-p shared-lisp-mode-map map lisp-mode-shared-map prcs-use-toolbar make-sparse-keymap set-keymap-name set-keymap-parents define-key "" prcs-checkin "" prcs-diff "	" prcs-info "" prcs-rekey set-keymap-parent boundp [menu-bar prcs] "PRCS" [menu-bar prcs rekey] ("Rekey" . prcs-rekey) [menu-bar prcs complex-info] ("Complex info" . prcs-info-with-prefix) [menu-bar prcs simple-info] ("Info" . prcs-info) [menu-bar prcs complex-diff] ("Arbitrary diff" . prcs-diff-with-prefix) [menu-bar prcs simple-diff] ("Working diff" . prcs-diff) [menu-bar prcs checkin] ("Checkin" . prcs-checkin)] 6)
#@24 Hooks for `prcs-mode'.
(defvar prcs-mode-hook nil (#$ . 23398))
#@2240 Major mode for editing PRCS project files.
Commands:
Delete converts tabs to spaces as it moves back.
Blank lines separate paragraphs.  Semicolons start comments.
\{prcs-mode-map}
Entry to this mode calls the value of `prcs-mode-hook'
if that value is non-nil.

You can interact with PRCS from this buffer as well:

\[prcs-checkin] checks in the project as it stands.
\[prcs-diff] looks for differences from last checkin/checkout;
C-u \[prcs-diff] also prompts for version numbers.
\[prcs-info] gives a summary of project versions;
C-u \[prcs-info] gives more flexibility.
\[prcs-rekey] rekeys the project.
\[prcs-jump-to-project-file] jumps here from other buffers.

Designed for FSF Emacs 20 or XEmacs 20.

Major user-visible features:

* Edit project file like the Lisp code it looks like.

* Asynchronous checking of file-modification status for controlled
files. You just need to visit a controlled file and start working on
it; you can tell by the modeline what state it is in.

* Support for using EDiff, the excellent Emacs file comparison suite,
for running diffs (in place of simple diff output). Turn on
`prcs-use-ediff-for-diffs'.

* Each project has a message buffer that shows all the PRCS commands
being run and their output. Scissor-marks visually separate commands.

* Tries to keep your buffers in synch with the disk when running PRCS
commands: offers to save buffers if they are modified, and to reload
them when PRCS modifies them.

* TAB completion on all prompts asking for PRCS version numbers or
branches.

* If configured, can have several different repositories for different
projects (otherwise default repository is used).

* Some menu/toolbar integration.

* Emacs backup files are normally turned off for you.

* Some support for a ChangeLog (New-Version-Log's will get added to
it).

Internal features:

* `prcs-command' provides easy way to run new PRCS commands with all
the special treatment the existing ones get. Both synchronous and
asynchronous commands, with both mutex and queue support. Supports
callbacks of Elisp code in place of diff/merge tools.

* Provides (pretty quickly) parsed versions of the project buffer (and
some convenience functions relating to that) so you can use its
structure.
(defalias 'prcs-mode #[nil "\306 \210\307!\210	\203 \n\203 \310!\210\311\312\f\"\210\313!\210\314\315\316 \210\317\320!\207" [prcs-mode-map prcs-xemacs-p prcs-use-toolbar current-menubar prcs-xemacs-menu prcs-mode-syntax-table kill-all-local-variables use-local-map set-buffer-menubar add-submenu nil set-syntax-table prcs-mode "PRCS" prcs-mode-variables run-hooks prcs-mode-hook major-mode mode-name] 3 (#$ . 23470) nil])
(byte-code "\303\211\203 \n@\304	\305\306#\210\nA\211\204 *\303\207" [prcs-descriptors desc #:--dolist-temp--16517 nil put lisp-indent-function 0] 5)
#@287 Get a ready-to-use output buffer given PBUFFER.
COMMAND and DISPLAYED may be as in `prcs-output-buffer-name'.
If DIVIDE is `t', put in a divider at the end.
If it is `back', go back to the last divider.
If nil, just retrieve the buffer.
If SWITCH-TO is non-nil, display the buffer too.
(defalias 'prcs-output-buffer #[(&rest #1=#:--rest--16518) "\306>\206	 \307pDA@\310>\206 \311A@\312>\206 \313A@\314>A@\315>A@\203_ @\316>\203F AA\211\2021 \317>A@\203U \307\211\2021 \320\321@\"\210\202/ )p\322\323 \324	!\325\326$\211!A@)!\"\327\330\"\n#!#\203\214 \331#!\210\202\220 #q\210db\210\f\332=\203\245 $\333\261\210db\210\202\274 \f\334=\203\274 \335$\307\332#\211%\203\273 %b\210)\204\304 q\210#.\207" [#1# pbuffer command displayed divide switch-to :pbuffer nil :command (nil "command") :displayed (nil t) :divide :switch-to (:pbuffer :command :displayed :divide :switch-to :allow-other-keys) :allow-other-keys error "Keyword argument %s not one of (:pbuffer :command :displayed :divide :switch-to)" prcs-coerce find prcs-parse-prj-file-cached :key car get-buffer-create prcs-output-buffer-name pop-to-buffer t "\n" back search-backward #2=#:--keys--16519 orig-buf prcs-Project-Version x project-name output-buffer prcs-output-buffer-divider pos] 8 (#$ . 26305)])
#@110 Locks held by running asynch processes, as alist from tokens to processes.
(Tokens may
be any s-expression.)
(defvar prcs-command-locks nil (#$ . 27622))
#@364 Queues in effect.
This is an alist from queue identifiers (any
s-exp) to lists of queued-up commands to run, each of which is just
the argument list to `prcs-command' verbatim. If a queue is missing,
it is empty; if it has no elements, that means that one process is
running in it; any more elements are other processes waiting in
decreasing order of precedence.
(defvar prcs-command-queues nil (#$ . 27783))
#@341 All asynch processes running, as alist from processes to other info.
TIMER is the timer object if a timeout was specified, else NIL.
This other info is copied from `prcs-command' arguments:

    (SUBCOMMAND REAL-REFRESH DISPLAY ERROR-ON-FAIL EXCLUSIVE SENTINEL SENTINEL-DATA SKIP-MODELINE TIMER QUEUE BUFFER PBUFFER CALLBACK CALLBACK-DATA)
(defvar prcs-command-processes nil (#$ . 28199))
#@89 Reset PRCS command state information in case of trouble.
Should not
normally be needed.
(defalias 'prcs-command-reset #[nil "\303\303\303\211\207" [prcs-command-locks prcs-command-queues prcs-command-processes nil] 2 (#$ . 28594) nil])
#@3696 Run a PRCS command.
Runs a PRCS command SUBCOMMAND (one word, or "admin
subsubcommand") with options OPTIONS (a list, `-f' is implicit).
BUFFER is a PRCS-controlled buffer which serves as the reference point
for everything. The command is always run from the correct directory
with the project file as first argument; WHAT controls the second
argument: none if `nil' (i.e. whole project), project file if `t', or
if `self', the correct relative path to BUFFER (even if that is the
project file); EXTRA-ARGS if any are also appended (they are not
options!).

SAVE determines whether to prompt to save buffers: `nil' means none,
`t' means all visited buffers for this project, `p-file' means project
file only, list of buffers does just those (include the project file
buffer if you need it), `as-needed' (default) means acc. to value of
WHAT. Similar for REFRESH, after command termination. SKIP-MODELINE
`t' skips modeline update at end (refreshed buffers only); if
`saves-too', does not even refresh if it saves buffers. DISPLAY
(default on) means show the output buffer (this is always written to
in any case); normally the regular PRCS output buffer is used, but
this may be overridden with OUTPUT-BUFFER. ERROR-ON-FAIL signals an
error if PRCS completed in a failure condition (status 1 does not
signal an error).

If ASYNCH is true, the command is run asynchronously (and the process
object is returned instead); KILLABLE (default true) means it can be
killed off at Emacs exit; EXCLUSIVE if set to a symbol or some
s-expression puts a kind of lock named by the EXCLUSIVE argument
(typically containing a buffer & some symbol describing the type of
lock) and will only run if no such lock already exists (removed on
exit); SENTINEL may be given as a function accepting the process
object, the BUFFER, an exit flag (NIL for timeout, see below, or a
number for an exit status, or T for some sort of erroneous event), and
if desired SENTINEL-DATA for state, to be run upon exit. If TIMEOUT is
set, process will be stopped after that many seconds if still running,
with the sentinel being called with the timeout flag set. If QUEUE is
set to some s-expression identifying a queue, only one process may be
running in that queue at once, and the others will wait to start.

If CALLBACK is set, it should be a function accepting the process
object, the BUFFER, a list of strings representing the requested
command arguments, and possibly extra arguments CALLBACK-DATA for
state, and returning an integer. In this case, several things are
changed. First of all, the command is run on a tty. Secondly,
`PRCS_DIFF_COMMAND' (clearing `PRCS_DIFF_OPTIONS') or
`PRCS_MERGE_COMMAND' (according to the value of SUBCOMMAND) are set to
the value of `prcs-callback-program'. Then, a filter is run on the
output stream; whenever the magic token from the callback script is
recognized, the callback function is called with the appropriate
arguments that the callback script received, and its return value
determines the exit status of the callback script. Otherwise, things
proceed as normal.

XXX Note that locks & queues currently apply only to asynchronous
commands; there is no way to lock out a synchronous command based on
them (it would only make sense in any case for locking out one
synchronous command from a set of asynchronous ones).

XXX Note that callbacks are currently only supported on asynch
processes. Also, do not try to run two callbacks processes at once on
the same output buffer!

Returns the exit status for a synch process; the process for a
successful asynch process; for a locked-out asynch process, a list of
the existing process; or for an asynch process waiting for a queue,
nil.
(defalias 'prcs-command #[(subcommand &rest all) "\306>A@\307>\206 \310pDA@\311>A@\312>A@\313>\206% \314A@\315>\206/ \316A@&\317>\206: \320A@'\321>\206E \322A@(\323>A@)\324>\206W \325A@*\326>A@+\327>A@,\330>A@-\331>A@.\332>A@/\333>A@0\334>A@1\335>A@2\336>A@3\337>A@455\203\324 5@\340>\203\273 5AA\2115\202\246 \341>A@\203\312 \310\2115\202\246 \342\3435@\"\210\202\244 )\344\345\215.\207" [all options buffer what extra-args save :options :buffer nil :what :extra-args :save (nil as-needed) :refresh (nil as-needed) :display (nil t) :error-on-fail (nil t) :asynch :killable (nil t) :exclusive :queue :immediate :sentinel :sentinel-data :timeout :output-buffer :callback :callback-data :skip-modeline (:options :buffer :what :extra-args :save :refresh :display :error-on-fail :asynch :killable :exclusive :queue :immediate :sentinel :sentinel-data :timeout :output-buffer :callback :callback-data :skip-modeline :allow-other-keys) :allow-other-keys error "Keyword argument %s not one of (:options :buffer :what :extra-args :save :refresh :display :error-on-fail :asynch :killable :exclusive :queue :immediate :sentinel :sentinel-data :timeout :output-buffer :callback :callback-data :skip-modeline)" --cl-block-prcs-command-- (byte-code "\203\f 	\203\f \306\307!\210\n\203? \203? \f\204? \310\"\211@\2039 @A\311BCBBBC\244\210\312\313\314\"\210\202> CB)\315B!D\316D\317\320#\211E@F\321F!G\322F!H\323DH\"IE\211JA@)K\324F!\206z \325F!L	\206\213 \326\327L\330A\331&M\314N\212Lq\210\332\333!\211O\205\240 \333KP\334\216\333\335M\210\333Q!R\333S!THU\336A\337\340E\341L!\211V\205\315 \342VPC)WGCX\314=\203\336 \314\202\375 X\320=\203\353 GC\202\375 X\343=\203\370 IC\202\375 \306\344X\"Y&Z\345\346[ZB\347#\\\203\350\\G\351\"\352P\202\353]\354\327L\355^\356=\357R&\210	\204A\326\327L\360\320\330A\331&\210\n\203O_\203b\212Bq\210\310_`\"A\211a\203aaCN*N\204\330	\204\201Mq\210db\210\\\352]\261\210db\210Lq\210b\205\207\361c\336db\205\270A\362\230\203\242\363\364e!PC\202\270A\365\230\203\263\366\364e!PC\202\270\306\367A\"\"d\370\371\336\\M[EZ\"\"fb\203\341\372f!\204\333\306\373!\210\374f\375\"\210fN_\203\372\212Bq\210_fB`B`)\376f\377\"\210\201p fg?\"\210fATh_ij^k\205;l\2031\201q k\377f#\202;\201r k\314\377f$BLbm\257nBn+\202\330	\204t\203^\201s M!\210Mq\210db\210\\\352]\261\210db\210Lq\210\370\201t \336[\314M	?DFZ\"\"\211o\201u >\203\247oN\201v \327L\355^\357T&\210\202\273h\203\267\306\201w o\"\210\202\273oN)\203\330	\204\330\326\327L\360\201x \201y \320\330A\331&\n\210.\nN.\n\207" [display output-buffer asynch queue immediate prcs-command-queues error "It is unsupported to DISPLAY a non-default OUTPUT-BUFFER" assoc :buffer throw --cl-block-prcs-command-- nil buffer-file-name prcs-is-prcs-controlled :get-descriptor-too t file-name-nondirectory file-name-directory file-relative-name get-file-buffer find-file-noselect prcs-output-buffer :pbuffer :command :displayed fboundp interpret-s-or-r ((byte-code "\203 \302	M\210\202 \303\302!\210\302\207" [#1=#:--letf-bound--16524 #2=#:--letf-save--16523 interpret-s-or-r fmakunbound] 2)) #[(s-or-r) "<\203 \207	\305=\203 \306\202R \307=\203 \310\311	\"\202R \312=\203P \n\306=\2032 \310\311	\"\202R \n\307=\203< \306\202R \n\313=\203K \205R \fC\202R \314 \202R \314 B\207" [s-or-r pbuffer what desc buffer p-file nil t prcs-get-visited-buffers :pbuffer as-needed self error] 4] append "--force" "--plain-format" prcs-guess-repository "--repository=" self "What is `what' %S?" mapconcat identity " " make-string 45 "\n" "" prcs-prompt-for-saves :skip-modeline saves-too :buflist :divide pty "diff" "PRCS_DIFF_COMMAND=" expand-file-name "merge" "PRCS_MERGE_COMMAND=" "You may not use a callback with subcommand %s!" apply start-process process-tty-name "Process should be using a PTY but system won't allow it!" set-process-filter prcs-command-callback-filter set-process-sentinel prcs-command-dispatch-sentinel waiting subcommand buffer all filename info pfilename pfilebase pfiledir filenamerel x desc pbuffer output return-result #1# #2# save real-save refresh real-refresh default-directory repo options what extra-args command-args prcs-program-name command-string command-string-underline skip-modeline exclusive prcs-command-locks existing callback process-connection-type process-environment prcs-callback-program process killable error-on-fail sentinel sentinel-data timeout prcs-xemacs-p callback-data prcs-command-processes status process-kill-without-query add-timeout run-at-time display-buffer call-process (0 1) prcs-prompt-for-refreshes "PRCS command failed: %S" back :switch-to] 16) refresh display error-on-fail asynch killable exclusive queue immediate sentinel sentinel-data timeout output-buffer callback callback-data skip-modeline #3=#:--keys--16520] 4 (#$ . 28841)])
#@136 Dispatch PROCESS to the user-specified sentinel.
IGNORE is the
event happening to it, which will be missing in the event of a timeout.
(defalias 'prcs-command-dispatch-sentinel #[(process &optional ignore) "?	\n\236A\204 \306\307!\210\f\203 \310\311!\210@A@\3128\3138\3148\3158\3168\3178\3208\3218\3228\3238<=>?@ABCDEF>\203m \f\204m G\203h \324>!\210\202m \325>!\210B\203 \326BH\327\330\331\332&H\326	\n\327\333\331\332&\f?\205\340 \334	!\211I\335=\203\274 \336	!\211J\337=\203\250 \337\202\270 J\340=\203\263 \340\202\270 \310\341!\210\342)\202\337 I\343=\203\313 \310\344!\210\342\202\337 I\345=\203\332 \310\346!\210\342\202\337 \310\347!\210\342)K\350	\351\"\210\352	!\210K\247\204\366 C\204'A\203\353A	<K@%\210\354\355\356?\357E&\210D\203'\360\355\361\362\363\342\364F\365\342&\n\210=\203r\366=L\"\211M\204<\306\367!\210MA\203dM\211NA@)OM\211N\211AA)\241\210\353\370\371O\372\"\"\210)\202q\326=L\327\330\331\332&L)C\205\201K\247?\205\201\306\373!.\207" [ignore process prcs-command-processes info timed-out pbuffer error "Process did not seem to originate from `prcs-command'!" message "Asynch process stopped by a timeout" 2 3 4 5 6 7 8 9 10 11 disable-timeout cancel-timer delete* :test equal :key car eq process-status exit process-exit-status 0 1 "PRCS asynch process exited with an error" t run "PRCS asynch process was still running when stopped, perhaps due to timeout" signal "PRCS asynch process caught some signal" "Weird process status" set-process-sentinel nil delete-process apply prcs-prompt-for-refreshes :pbuffer :skip-modeline :buflist prcs-output-buffer :divide back :switch-to :command :displayed assoc "Should have been a queue for this process!" prcs-command append (:immediate t) "PRCS asynch command failed" buffer queue timer skip-modeline sentinel-data sentinel exclusive error-on-fail display real-refresh subcommand prcs-xemacs-p prcs-command-locks #1=#:G16525 #2=#:G16526 exit-status prcs-command-queues waiting x next-process] 14 (#$ . 37539)])
(byte-code "\301B\302\301\207" [current-load-list prcs-command-callback-token "MaGiC-PrCs-CaLlBaCk-ToKeN"] 2)
#@109 Look for a magic token in the current process' output, and if found call a callback function automagically.
(defalias 'prcs-command-callback-filter #[(process input) "p\306\216\307\211\211\310\f!q\210`\311\f!U\212\311\f!b\210`c\210\311\f!`\211\307\223\210\nb\210\312 \210\313$\314P	\315#\203\365 \316\f\307\"\210`%%b\210\317\320!\204Z \321\f\322\"\204B \323\324!\210\202B \325\326\327!!&\330%\311\f!\"&TW\203} \321\f\322\"\204a \323\324!\210\202a %b\210\327y\210\307'&\331()()W\203\261 `*\327y\210'*`S{C\244')(T\211(\202\220 *%b\210\332$\314P!\210`+&\333\\y\210+`|\210)\f,\236A-\334\335-8\f\336-8'\337-8%.\340\f\341\342.\"\"\210-\316\f\343\"\210)\205\376 \311\f!b-\207" [old-buffer end-search-point start-search-point moving process input ((set-buffer old-buffer)) nil process-buffer process-mark beginning-of-line search-forward "\n" t set-process-filter looking-at "^\\([0-9]+\\)\n" accept-process-output 5 error "Callback script appears hung" string-to-int match-string 1 count-lines 0 search-backward 2 apply 12 10 13 process-send-string format "%d\n" prcs-command-callback-filter prcs-command-callback-token arg-count-point arg-count args idx #1=#:--dotimes-temp--16529 start start-of-junk prcs-command-processes info status] 7 (#$ . 39728)])
#@55 History list for `prcs-read-version-with-minibuffer'.
(defvar prcs-version-history nil (#$ . 41023))
(byte-code "\301B\306\301!\204\f \307\302B\306\302!\204 \307\303B\306\303!\204$ \307\304B\306\304!\2040 \307\305B\306\305!\204< \307\307\207" [current-load-list *prcs-current-version-completions* *prcs-current-version-branch-only* *prcs-current-version-project* *prcs-current-version-allow-head* *prcs-current-version-default* boundp nil] 2)
#@1122 Read a PRCS version number from the minibuffer, with tab-completion available.
If BRANCH-ONLY is given, actually read a branch name, not a
version number. PROMPT is the prompt to use in the minibuffer.
REQUIRE-MATCH forces an existing PRCS version/branch to be used.
DEFAULT gives a default value; if unspecified this is taken from the
repository version of the current buffer, when in PRCS Controlled
Mode, or the working version if that is allowed. ALLOW-WORKING permits
a blank entry to be treated as the working version and accepted;
otherwise the user is not allowed to specify a blank version.
ALLOW-HEAD (default on) permits "@" to be used for branches or minor
versions. PBUFFER (sensibly defaulted) gives a project buffer to associate
with.

Note that REQUIRE-MATCH forces the versions to be calculated unless
ALLOW-WORKING is set and the user requests the working version, or
unless the users enters the prompted default. Otherwise this is put
off until a completion is requested by the user.

Return value is a string containing the branch/version, or `nil' for
the working version. "@" will be left as typed.
(defalias 'prcs-read-version-with-minibuffer #[(&rest #1=#:--rest--16530) "\306>A@\307>A@\310>\206 \311A@\312>A@\313>\206& \314\315 DA@\316>\206c \314\f\2038 \317\202b \320,\321!\322\323\324\325&-	\203S \326\327-8!\202a \326\327-8!\330\326\331-8!Q)DA@.\332>\206\227 \314\n\205s \333\334	\203| \335\202} \336\337\326\320,\321!\322\323\324\325&A@!\f\205\223 \340\341\260DA@/00\203\316 0@\342>\203\265 0AA\2110\202\240 \343>A@\203\304 \314\2110\202\240 \344\3450@\"\210\202\236 )\204\327 \344\346!\210\f\203\343 	\203\343 \344\347!\210\314\211	.\350123456\2117\203\f\2047\317\230\203\351/\352\314\n\2058?.\353&\2117\202\372 7\317\230?\205)7.\207" [#1# branch-only require-match allow-head allow-working pbuffer :branch-only :require-match :allow-head (nil t) :allow-working :pbuffer nil prcs-find-project-file-buffer :default "" find prcs-parse-prj-file-cached :test eq :key car prcs-coerce 2 "." 3 :prompt "Existing " "PRCS " "branch" "version" " in " " (blank for working)" " (TAB to complete): " (:branch-only :require-match :allow-head :allow-working :pbuffer :default :prompt :allow-other-keys) :allow-other-keys error "Keyword argument %s not one of (:branch-only :require-match :allow-head :allow-working :pbuffer :default :prompt)" "You must specify a project buffer" "You cannot permit a working version as a branch; this makes no sense" t completing-read prcs-version-completer prcs-version-history prcs-Project-Version version-info default prompt #2=#:--keys--16531 minibuffer-completion-confirm *prcs-current-version-default* *prcs-current-version-allow-head* *prcs-current-version-branch-only* *prcs-current-version-project* *prcs-current-version-completions* result prcs-sloppy-version-prompts] 14 (#$ . 41490)])
#@198 Used by `prcs-read-version-with-minibuffer' to complete versions (or branches).
Just does a regular completion, but does not try to
list existing versions until a completion is actually requested.
(defalias 'prcs-version-completer #[(string predicate type) "\305=\203 	\n\230\203 \306\207\204 \307 \210\310=\203! \311	\f#\207\306=\203- \312	\f#\207\305=\205< \313	\314\315\316\317&\207" [type string *prcs-current-version-default* *prcs-current-version-completions* predicate lambda t prcs-version-enumerate nil try-completion all-completions find :test string-equal :key car] 7 (#$ . 44406)])
#@71 Actually builds the list of completions for `prcs-version-completer'.
(defalias 'prcs-version-enumerate #[nil "\306\307!\210\310\211\311\312!\313\314\315\316\317\320\310\321\310\322\310\323\324\325\n&\210\310\212\nq\210eb\210\326\327\330\331!\332\333\334\335&A@!\336Q.`dU\204b \337.!\204M \340\341!\210\342\343!B\344\342\345!	\332\346$\310y\210\202< *\347\n!\210)\350\351/\203s 	\202t \"0\203\251 /\203\207 \352\fB\202\251 \353	B\3101\2112\203\250 2@\2111\354PC\fB2A\2112\204\223 **\306\355!\207" [versions branches output *prcs-current-version-project* *prcs-current-version-completions* prcs-Project-Version message "Getting project versions, please wait..." nil generate-new-buffer "PRCS version info output" prcs-command "info" :options ("--quiet") :buffer :save :refresh :display :skip-modeline t :output-buffer "^" prcs-coerce find prcs-parse-prj-file-cached :test eq :key car " +\\(\\([^ ]+\\)\\.[0-9]+\\) " looking-at error "Weird line" match-string 1 adjoin 2 string-equal kill-buffer mapcar #[(x) "C\207" [x] 1] ("@") "@" ".@" "Getting project versions, please wait...done" rx *prcs-current-version-branch-only* *prcs-current-version-allow-head* branch #1=#:--dolist-temp--16532] 16 (#$ . 45018)])
#@68 Ensure that the current buffer is in fact in PRCS Controlled Mode.
(defalias 'prcs-ensure-buffer-is-live #[nil "?\205 \301\302!\207" [prcs-controlled-mode error "This buffer is not considered PRCS-controlled! Probably the project is not active in your repository, etc. Use M-x prcs-controlled-mode to correct the situation if needed."] 2 (#$ . 46260)])
#@168 Checkin the current project from working dir.
Prompts for version log if necessary, and major version.
With prefix arg, takes no action, just shows what would happen.
(defalias 'prcs-checkin #[(&optional noact) "\306 \210\307p!\310	\311\312$\211A@)\211\204 eb\210\313\314!\210G\315U\2038 \316\317!\2038 eb\210\320\321\322\323#\210\313\324!\210\f\203L \204L G\315U\204L \325p\"\210\326\310-\311\312$\211AA)@!.\327\330.\331\323\332\323\333\322\334\335&\n/\336\337\340\323\341\342\343\344\345/\346QC\205\201 \347C0#&1\307p!2\310-2\311\312$3\3263\211A@)!4\3263\211AA)@!\350\3263\211AA)A@!Q5\3516\212p\352 B\3227\2118\203\351 8@\2117q\210495:6;8A\2118\204\314 .1\315U?\205\366 \353\354!-\207" [prj prcs-New-Version-Log x log prcs-auto-add-changelog noact prcs-ensure-buffer-is-live prcs-parse-prj-file-cached find :key car error "Can't find New-Version-Log" 0 y-or-n-p "No version log entered, enter one first? " search-forward-regexp "(New-Version-Log[ 	\n]+\"" nil t "Checkin aborted." prcs-add-changelog prcs-coerce prcs-read-version-with-minibuffer :default :allow-head :branch-only :require-match :prompt "PRCS major version to checkin onto: " prcs-command "checkin" :display :skip-modeline saves-too :options append "--revision=" ".@" "--no-action" "." "" prcs-get-visited-buffers message "PRCS exited with non-zero status--failed" prcs-Project-Version major new-major prcs-extra-checkin-options exited new-prj new-p-v new-project new-version new-status buf #1=#:--dolist-temp--16533 prcs-controlled-project prcs-controlled-version prcs-controlled-status] 12 (#$ . 46622) "P"])
(defalias 'prcs-add-changelog #[(buffer message) "\303\304\305\306 !\"\303	\307\n!\310\311$A\310\311$\205 \312\213\207" [prcs-obarray prcs-Files buffer find intern file-name-nondirectory change-log-name prcs-parse-prj-file-cached :key car ((byte-code "\301\302!\210\303\304 \210)	c\210\305 \210\301\306!\207" [add-log-current-defun-function message "Adding a ChangeLog entry..." #[nil "\300\207" [nil] 1] add-change-log-entry save-buffer "Adding a ChangeLog entry...done"] 2))] 7])
#@629 List differences in the working version from the repository version.
With a prefix argument, prompts for versions to compare.

When invoked with the EDiff support, normally prompted for, if there
are any differences, an EDiff directory session will be spawned.
Repository versions are placed in a special temporary area, while the
normal working files are used for the newer files when comparing
against a working version. Normally the temporary files are deleted
upon exiting the session group, but if you edit them you will be asked
first. See the EDiff manual for help on how to use EDiff, especially
in directory diff mode.
(defalias 'prcs-diff #[(&optional repo-versions) "\306 \210\205\f \307\310C\"\311p!\312\n\313\314$\312\n\313\314$7\3157\2118AA)@!\316\3157\2118AA)A@!Q9:\203f \317\320\321\322\315\f\2118AA)@!\316\315\f\2118AA)A@!Q\323\324\325\326\327\324&\n\202h 9;:\205} \317\320\330\3229\323\324\325\324\327\324&\n<:\205\232 <\203\225 \331;P\331<PD\202\232 \331;PC=>\324=\204\256 >\2034\332\333!\2034<??\334\335!\336P\211@;\336QA?\203\313 B\202\321 @<\336QC\337\340 !D\326AC\326\211\257CE\341CF\342@\324\"\210\343\344\345	\346=\347\324\350\351\352ACE?F\257\353\324\354\355\356?E@ACF\357;\360?\203(9\361P\202*<R\257&.\202X\343\344\345	\346=\347\324&\211G\362=\203M\363\364!\202WG\365=\205W\363\366!).\207" [prcs-extra-diff-args extra-args prj prcs-Parent-Version pv prcs-Project-Version prcs-ensure-buffer-is-live append "--" prcs-parse-prj-file-cached find :key car prcs-coerce "." prcs-read-version-with-minibuffer :prompt "Older version: " :default :allow-head t :allow-working nil :require-match "Newer version (blank for working): " "--revision=" y-or-n-p "Use EDiff instead of regular output? " make-temp-name "/tmp/prcs-ediff" "/" file-relative-name buffer-file-name ("dummy") make-directory prcs-command "diff" :extra-args :options :skip-modeline :callback prcs-ediff-callback :callback-data :asynch :sentinel prcs-ediff-sentinel :sentinel-data "From " " to " "(w)" 1 message "There were differences." 0 "No differences." cv x default-cv-string repo-versions pv-string cv-string options prcs-use-ediff-for-diffs new-is-working scratch-dir old-store-dir default-directory new-store-dir p-file-name index-list scratch-file-mod-times #1=#:G16534] 29 (#$ . 48740) "P"])
#@55 Like `prcs-diff', but with automatic prefix argument.
(defalias 'prcs-diff-with-prefix #[nil "\300\301!\207" [prcs-diff t] 2 (#$ . 51110) nil])
#@31 Run EDiff session (probably).
(defalias 'prcs-ediff-sentinel #[(process buffer status new-is-working index-list scratch-dir old-store-dir new-store-dir scratch-file-mod-times description) "\306=\203 \307\310!\210\311	\n\"\207\312=\205M \313\314!\210\313\315!\210\316\317\320\321\fP\322\323\324\325\326\327\330\324\325\311	\331\nDEE\332BBB\333\334\335\331\325\336BBBCDE\257C&!\207" [status scratch-dir scratch-file-mod-times index-list description old-store-dir 0 message "No differences." prcs-ediff-cleanup 1 require ediff ediff-mult ediff-show-meta-buffer ediff-prepare-meta-buffer ediff-filegroup-action "*Ediff over PRCS Diff Panel: " ediff-redraw-directory-group-buffer xxxxxxprcs-version-diff lambda nil (make-local-hook 'ediff-quit-session-group-hook) add-hook 'ediff-quit-session-group-hook quote (nil t) (setq ediff-session-action-function 'ediff-files) setq ediff-dir-difference-list (nil) new-store-dir] 19 (#$ . 51260)])
#@188 Clean up temp files.
Anything which has a modified buffer which the
user does not want to kill, or which was added after EDiff setup time,
or modified on disk thereafter, is left behind.
(defalias 'prcs-ediff-cleanup #[(scratch-dir scratch-file-mod-times) "\302\303!\211\304L\210\305\306\307\310\311D\310D\312FEL\210J	!?\205# \313\314	\")\207" [#1=#:--G16535--16536 scratch-dir make-symbol "--G16535--" nil lambda (&rest --cl-rest--) apply quote #[(#2=#:G16538 dir) "\306\307	\306\310\306$\311\211\203x @\312\n!\203Z \313\n!\211\203& \314\f!\205E \315\n\316\317$\211\203> A\320\321\n!8\232\206D \322\323\324\n\"!)\211\203O \325\n!\210\205U *\202q \326\n!\203m J\n!\205i \202q \325\n!\210A\211\204 *\203\201 \327	!\210)\207" [ok dir entry #3=#:--dolist-temp--16537 buf scratch-file-mod-times t directory-files "[^.].*\\|\\.[^.].*" nil file-regular-p get-file-buffer kill-buffer assoc* :test string-equal 5 file-attributes yes-or-no-p format "File %s was created or modified since PRCS EDiff creation; really delete it now? " delete-file file-directory-p delete-directory orig-mod-entry this-ok #2#] 6] --cl-rest-- message "Warning: directory %s was left around as some changed files or buffers in it are still in existence."] 8 (#$ . 52209)])
#@79 Just copy the indicated temp files into a good place in the old and new dirs.
(defalias 'prcs-ediff-callback #[(process buffer args old-dir new-dir index-list new-is-working scratch-file-mod-times) "@\306H\307=\203 \211A\210\202  \310\301\311L\210@A@\3128\3138\301J\n!\301J\f!PP\310EC\244\210\310\f\314\315L\210\314J\"\210\204e \314J\"\210.\n\316\207" [args #1=#:--G16543--16544 old-label old-file new-label new-file 0 45 nil #[(string) "\301\302\"\204\f \303\304\"\210\305\306\"\207" [string string-match "^[^/ ]+\\.[0-9]+\\((w)\\)?/\\([^ ]+\\) " error "Weird PRCS label: `%s'" match-string 2] 3] 2 3 #2=#:--G16547--16548 #[(a b) "\303\304!\305\"\210\306	\307\305$\210\n\310\311!8BC\244\207" [b a scratch-file-mod-times make-directory file-name-directory t copy-file nil 5 file-attributes] 5] 1 old-relfile new-relfile old-dir old-store-file new-dir new-store-file index-list new-is-working] 4 (#$ . 53487)])
#@98 List summary of project version information.
With a prefix argument, prompt for several options.
(defalias 'prcs-info #[(&optional complex) "\304 \210\203X \305\306\307\310\311$\211\312\230\203 \313\314\311\"\202/ 	\315\230\203, \313\314\311\316\311$\317P\202/ \320\321!\305\322\323\310\311$\324\325\326\311\327\330\nP\331\230\203I \332\202T \333\230\203S \334\202T \310B%+\207\324\325\326\311#\207" [complex rev-style revisions lengthiness prcs-ensure-buffer-is-live completing-read "Type of revisions to look at (TAB to complete): " (("single") ("branch") ("wildcard")) nil t "single" prcs-read-version-with-minibuffer :require-match "branch" :branch-only ".*" read-from-minibuffer "Version wildcard: " "Level of detail (TAB to complete): " (("brief") ("medium") ("long")) prcs-command "info" :skip-modeline :options "--revision=" "medium" ("--long-format") "long" ("--long-long-format")] 9 (#$ . 54454) "P"])
#@55 Like `prcs-info', but with automatic prefix argument.
(defalias 'prcs-info-with-prefix #[nil "\300\301!\207" [prcs-info t] 2 (#$ . 55379) nil])
#@20 Rekey the project.
(defalias 'prcs-rekey #[nil "\300 \210\301\302\303\304\305\306%\207" [prcs-ensure-buffer-is-live prcs-command "rekey" :skip-modeline t :display nil] 6 (#$ . 55529) nil])
(byte-code "\301\236\204\n \302B\303\304\305\"\207" [minor-mode-alist prcs-controlled-mode (prcs-controlled-mode (" " prcs-controlled-project ":" prcs-controlled-version (prcs-controlled-status prcs-controlled-status "?") prcs-controlled-path)) add-hook after-save-hook prcs-update-file-status] 3)
#@62 Whether backups were naturally inhibited on a buffer anyway.
(defvar prcs-natural-b-i nil (#$ . 56025))
#@894 Toggle (or with prefix, turn on or off acc. to value) PRCS Controlled Mode.

This minor mode is used for buffers that are to be considered under
PRCS control, including the project file itself (which is also in PRCS
Major Mode).

By default, your modeline will indicate: the project name you are
working in; the current project version; whether the file is
unmodified (no mark), modified (marked with an asterisk), or newly
added (marked with a plus sign); and what the path is to this file
within the project. E.g.:

    foo.cc  (C++ foobase:release.99*/src/foolib/ Font)

For the time being, if you want to perform any real PRCS actions,
please go to the project file (and see the documentation for
`prcs-mode'). In the future you may be able to run commands from here.

\[prcs-controlled-mode] Toggle PRCS Controlled minor mode.
\[prcs-jump-to-project-file] Go to controlling project-file.
(defalias 'prcs-controlled-mode #[(&optional toggle info) "\n\203 \306\n!\307V\202 	?\211\204 	\203 \2059 	?\2059 \310\304!\210\310\303!\210\f\2044 \311\312p\")\207" [prcs-controlled-mode old-pcm toggle prcs-natural-b-i backup-inhibited vc-make-backup-files prefix-numeric-value 0 make-local-variable t prcs-update-file-status info] 4 (#$ . 56136) "P"])
#@147 Update modeline status acc. to PRCS.
BUFFER is buffer to check;
INFO if any is existing result of `prcs-is-prcs-controlled' with
second arg true.
(defalias 'prcs-update-file-status #[(&rest #1=#:--rest--16551) "\203\f \211A@\202 p\211A@\203\" \306\307\310G\311\\D\"\210\205\212	q\210\n\2064 \312\313 \314\315#\211@\f\2115A@)6\316!\206J \317!7\3207!8\32198\322\323$:\324:\2115A@)!;\324:\2115AA)@!\325\324:\2115AA)A@!Q<6\203\252 =\203\252 \326\3246@!P>\327\326>\330\315$?>\331?TO*\202\253 \332@6\205\277 6\2115A@)?\205\277 \333AB\205A?\205\334\335\336\337\340\341\342\343\344\345\346\341\347\341\350\315\351\315\352	\353D\354;\355C\356\341\357\360&\211D?\206\361D!\206D<\203	\362\363	\"\202\362\364D\").*\207" [#1# buffer maybe-info prcs-controlled-mode info p-file signal wrong-number-of-arguments prcs-update-file-status 2 prcs-is-prcs-controlled buffer-file-name :get-descriptor-too t get-file-buffer find-file-noselect prcs-parse-prj-file-cached find :key car prcs-coerce "." "/" search :from-end 0 "" "+" prcs-command "diff" :what self :display nil :options ("--quiet") :extra-args ("--" "--brief") :save :refresh :skip-modeline :asynch :exclusive modification-check :queue :timeout :sentinel-data :sentinel prcs-update-file-status-sentinel processp message "Check on %S locked out" "What result is %S?!" x desc pbuf prj prcs-Project-Version p-v prcs-controlled-project prcs-controlled-version prcs-display-path logical-path posn prcs-controlled-path prcs-controlled-status prcs-check-if-file-modified prcs-timeout-on-modified-checks result] 29 (#$ . 57405)])
(defalias 'prcs-update-file-status-sentinel #[(process buffer exit) "\304!\203' \212q\210	\205% \n\305=\203 \306\202# \n\307=\203\" \310\202# \311\211)\207\312\313!\207" [buffer prcs-controlled-mode exit prcs-controlled-status buffer-file-name 0 "" 1 "*" "???" message "PRCS-controlled buffer no longer exists"] 2])
#@52 Find the project file (if any) controlling BUFFER.
(defalias 'prcs-find-project-file-buffer #[(&rest #1=#:--rest--16552) "\203\f \211A@\202 p\203 \303\304\305GTD\"\210\306\307	!!\211\205( \310\n!*\207" [#1# buffer pfile-name signal wrong-number-of-arguments prcs-find-project-file-buffer prcs-is-prcs-controlled buffer-file-name get-file-buffer] 4 (#$ . 59361)])
#@65 Find the parse of the project file (if any) controlling BUFFER.
(defalias 'prcs-find-project-file-parse #[(&rest #1=#:--rest--16553) "\203\f \211A@\202 p\203 \303\304\305GTD\"\210\306	!\211\205& \307\n!*\207" [#1# buffer pbuffer signal wrong-number-of-arguments prcs-find-project-file-parse prcs-find-project-file-buffer prcs-parse-prj-file-cached] 4 (#$ . 59739)])
#@135 Find the specified ATTRIBUTE (e.g. `prcs-Files') of the project file controlling BUFFER.
Returns whole s-exp starting with ATTRIBUTE.
(defalias 'prcs-find-project-attribute #[(attribute &rest #1=#:--rest--16554) "\203\f \211A@\202 p\203 \304\305\306G\307\\D\"\210\310	!\211\205- \311\n\312\313\314\315&*\207" [#1# buffer parse attribute signal wrong-number-of-arguments prcs-find-project-attribute 2 prcs-find-project-file-parse find :test eq :key car] 8 (#$ . 60121)])
#@56 Jump to the nearest applicable project file from here.
(defalias 'prcs-jump-to-project-file #[nil "\303 \206 \304	!\206 \305	!@\211\2031 \303 \n\230\203# \306\307!\2024 \310\311\n!\206- \312\n!!\2024 \313\314!*\207" [default-directory here prj buffer-file-name prcs-is-prcs-controlled prcs-is-potentially-prcs-controlled message "Already here!" pop-to-buffer get-file-buffer find-file-noselect error "Could not find applicable project file!"] 4 (#$ . 60608) nil])
(provide 'prcs)