lisp/pcvs-parse.el

   1 ;;; pcvs-parse.el --- the CVS output parser
   2
   3 ;; Copyright (C) 1991, 92, 93, 94, 95, 96, 97, 98, 99, 2000  Free Software Foundation, Inc.
   4
   5 ;; Author: Stefan Monnier <monnier@cs.yale.edu>
   6 ;; Keywords: pcl-cvs
   7 ;; Revision: $Id: pcvs-parse.el,v 1.10 2001/09/24 16:39:23 monnier Exp $
   8
   9 ;; This file is part of GNU Emacs.
  10
  11 ;; GNU Emacs is free software; you can redistribute it and/or modify
  12 ;; it under the terms of the GNU General Public License as published by
  13 ;; the Free Software Foundation; either version 2, or (at your option)
  14 ;; any later version.
  15
  16 ;; GNU Emacs is distributed in the hope that it will be useful,
  17 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
  18 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19 ;; GNU General Public License for more details.
  20
  21 ;; You should have received a copy of the GNU General Public License
  22 ;; along with GNU Emacs; see the file COPYING.  If not, write to the
  23 ;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  24 ;; Boston, MA 02111-1307, USA.
  25
  26 ;;; Commentary:
  27
  28 ;;; Bugs:
  29
  30 ;; - when merging a modified file, if the merge says that the file already
  31 ;;   contained in the changes, it marks the file as `up-to-date' although
  32 ;;   it might still contain further changes.
  33 ;;   Example: merging a zero-change commit.
  34
  35 ;;; Code:
  36
  37 (eval-when-compile (require 'cl))
  38
  39 (require 'pcvs-util)
  40 (require 'pcvs-info)
  41
  42 ;; imported from pcvs.el
  43 (defvar cvs-execute-single-dir)
  44
  45 ;; parse vars
  46
  47 (defcustom cvs-update-prog-output-skip-regexp "$"
  48   "*A regexp that matches the end of the output from all cvs update programs.
  49 That is, output from any programs that are run by CVS (by the flag -u
  50 in the `modules' file - see cvs(5)) when `cvs update' is performed should
  51 terminate with a line that this regexp matches.  It is enough that
  52 some part of the line is matched.
  53
  54 The default (a single $) fits programs without output."
  55   :group 'pcl-cvs
  56   :type '(regexp :value "$"))
  57
  58 (defcustom cvs-parse-ignored-messages
  59   '("Executing ssh-askpass to query the password.*$"
  60     ".*Remote host denied X11 forwarding.*$")
  61   "*A list of regexps matching messages that should be ignored by the parser.
  62 Each regexp should match a whole set of lines and should hence be terminated
  63 by `$'."
  64   :group 'pcl-cvs
  65   :type '(repeat regexp))
  66
  67 ;; a few more defvars just to shut up the compiler
  68 (defvar cvs-start)
  69 (defvar cvs-current-dir)
  70 (defvar cvs-current-subdir)
  71 (defvar dont-change-disc)
  72
  73 ;;;; The parser
  74
  75 (defconst cvs-parse-known-commands
  76   '("status" "add" "commit" "update" "remove" "checkout" "ci")
  77   "List of CVS commands whose output is understood by the parser.")
  78
  79 (defun cvs-parse-buffer (parse-spec dont-change-disc &optional subdir)
  80   "Parse current buffer according to PARSE-SPEC.
  81 PARSE-SPEC is a function of no argument advancing the point and returning
  82   either a fileinfo or t (if the matched text should be ignored) or
  83   nil if it didn't match anything.
  84 DONT-CHANGE-DISC just indicates whether the command was changing the disc
  85   or not (useful to tell the difference between `cvs-examine' and `cvs-update'
  86   output.
  87 The path names should be interpreted as relative to SUBDIR (defaults
  88   to the `default-directory').
  89 Return a list of collected entries, or t if an error occurred."
  90   (goto-char (point-min))
  91   (let ((fileinfos ())
  92         (cvs-current-dir "")
  93         (case-fold-search nil)
  94         (cvs-current-subdir (or subdir "")))
  95     (while (not (or (eobp) (eq fileinfos t)))
  96       (let ((ret (cvs-parse-run-table parse-spec)))
  97         (cond
  98          ;; it matched a known information message
  99          ((cvs-fileinfo-p ret) (push ret fileinfos))
 100          ;; it didn't match anything at all (impossible)
 101          ((and (consp ret) (cvs-fileinfo-p (car ret)))
 102           (setq fileinfos (append ret fileinfos)))
 103          ((null ret) (setq fileinfos t))
 104          ;; it matched something that should be ignored
 105          (t nil))))
 106     (nreverse fileinfos)))
 107
 108
 109 ;; All those parsing macros/functions should return a success indicator
 110 (defsubst cvs-parse-msg () (buffer-substring cvs-start (1- (point))))
 111
 112 ;;(defsubst COLLECT (exp) (push exp *result*))
 113 ;;(defsubst PROG (e) t)
 114 ;;(defmacro SEQ (&rest seqs) (cons 'and seqs))
 115
 116 (defmacro cvs-match (re &rest matches)
 117   "Try to match RE and extract submatches.
 118 If RE matches, advance the point until the line after the match and
 119 then assign the variables as specified in MATCHES (via `setq')."
 120   (cons 'cvs-do-match
 121         (cons re (mapcar (lambda (match)
 122                            `(cons ',(first match) ,(second match)))
 123                          matches))))
 124
 125 (defun cvs-do-match (re &rest matches)
 126   "Internal function for the `cvs-match' macro.
 127 Match RE and if successful, execute MATCHES."
 128   ;; Is it a match?
 129   (when (looking-at re)
 130     (goto-char (match-end 0))
 131     ;; Skip the newline (unless we already are at the end of the buffer).
 132     (when (and (eolp) (< (point) (point-max))) (forward-char))
 133     ;; assign the matches
 134     (dolist (match matches t)
 135       (let ((val (cdr match)))
 136         (set (car match) (if (integerp val) (match-string val) val))))))
 137
 138 (defmacro cvs-or (&rest alts)
 139   "Try each one of the ALTS alternatives until one matches."
 140   `(let ((-cvs-parse-point (point)))
 141      ,(cons 'or
 142             (mapcar (lambda (es)
 143                       `(or ,es (ignore (goto-char -cvs-parse-point))))
 144                     alts))))
 145 (def-edebug-spec cvs-or t)
 146
 147 ;; This is how parser tables should be executed
 148 (defun cvs-parse-run-table (parse-spec)
 149   "Run PARSE-SPEC and provide sensible default behavior."
 150   (unless (bolp) (forward-line 1))      ;this should never be needed
 151   (let ((cvs-start (point)))
 152     (cvs-or
 153      (funcall parse-spec)
 154
 155      (dolist (re cvs-parse-ignored-messages)
 156        (when (cvs-match re) (return t)))
 157
 158      ;; This is a parse error.  Create a message-type fileinfo.
 159      (and
 160       (cvs-match ".*$")
 161       (cvs-create-fileinfo 'MESSAGE cvs-current-dir " "
 162                            ;; (concat " Unknown msg: '"
 163                            (cvs-parse-msg) ;; "'")
 164                            :subtype 'ERROR)))))
 165
 166 \f
 167 (defun cvs-parsed-fileinfo (type path &optional directory &rest keys)
 168   "Create a fileinfo.
 169 TYPE can either be a type symbol or a cons of the form (TYPE . SUBTYPE).
 170 PATH is the filename.
 171 DIRECTORY influences the way PATH is interpreted:
 172 - if it's a string, it denotes the directory in which PATH (which should then be
 173   a plain file name with no directory component) resides.
 174 - if it's nil, the PATH should not be trusted: if it has a directory
 175   component, use it, else, assume it is relative to the current directory.
 176 - else, the PATH should be trusted to be relative to the root
 177   directory (i.e. if there is no directory component, it means the file
 178   is inside the main directory).
 179 The remaining KEYS are passed directly to `cvs-create-fileinfo'."
 180   (let ((dir directory)
 181         (file path))
 182     ;; only trust the directory if it's a string
 183     (unless (stringp directory)
 184       ;; else, if the directory is true, the path should be trusted
 185       (setq dir (or (file-name-directory path) (if directory "")))
 186       (setq file (file-name-nondirectory path)))
 187
 188     (let ((type (if (consp type) (car type) type))
 189           (subtype (if (consp type) (cdr type))))
 190       (when dir (setq cvs-current-dir dir))
 191       (apply 'cvs-create-fileinfo type
 192              (concat cvs-current-subdir (or dir cvs-current-dir))
 193              file (cvs-parse-msg) :subtype subtype keys))))
 194 \f
 195 ;;;; CVS Process Parser Tables:
 196 ;;;;
 197 ;;;; The table for status and update could actually be merged since they
 198 ;;;; don't conflict.  But they don't overlap much either.
 199
 200 (defun cvs-parse-table ()
 201   "Table of message objects for `cvs-parse-process'."
 202   (let (c file dir path type base-rev subtype)
 203     (cvs-or
 204
 205      (cvs-parse-status)
 206      (cvs-parse-merge)
 207      (cvs-parse-commit)
 208
 209      ;; this is not necessary because the fileinfo merging will remove
 210      ;; such duplicate info and luckily the second info is the one we want.
 211      ;; (and (cvs-match "M \\(.*\\)$" (path 1))
 212      ;;      (cvs-parse-merge path))
 213
 214      ;; Normal file state indicator.
 215      (and
 216       (cvs-match "\\([MARCUPNJ?]\\) \\(.*\\)$" (c 1) (path 2))
 217       ;; M: The file is modified by the user, and untouched in the repository.
 218       ;; A: The file is "cvs add"ed, but not "cvs ci"ed.
 219       ;; R: The file is "cvs remove"ed, but not "cvs ci"ed.
 220       ;; C: Conflict
 221       ;; U: The file is copied from the repository.
 222       ;; P: The file was patched from the repository.
 223       ;; ?: Unknown file.
 224       (let ((code (aref c 0)))
 225         (cvs-parsed-fileinfo
 226          (case code
 227            (?M 'MODIFIED)
 228            (?A 'ADDED)
 229            (?R 'REMOVED)
 230            (?? 'UNKNOWN)
 231            (?C
 232             (if (not dont-change-disc) 'CONFLICT
 233               ;; This is ambiguous.  We should look for conflict markers in the
 234               ;; file to decide between CONFLICT and NEED-MERGE.  With CVS-1.10
 235               ;; servers, this should not be necessary, because they return
 236               ;; a complete merge output.
 237               (with-temp-buffer
 238                 (insert-file-contents path)
 239                 (goto-char (point-min))
 240                 (if (re-search-forward "^<<<<<<< " nil t)
 241                     'CONFLICT 'NEED-MERGE))))
 242            (?J 'NEED-MERGE)             ;not supported by standard CVS
 243            ((?U ?P)
 244             (if dont-change-disc 'NEED-UPDATE
 245               (cons 'UP-TO-DATE (if (eq code ?U) 'UPDATED 'PATCHED)))))
 246          path 'trust)))
 247
 248      (and
 249       (cvs-match "pcl-cvs: descending directory \\(.*\\)$" (dir 1))
 250       (setq cvs-current-subdir dir))
 251
 252      ;; A special cvs message
 253      (and
 254       (let ((case-fold-search t))
 255         (cvs-match "cvs[.a-z]* [a-z]+: "))
 256       (cvs-or
 257
 258        ;; CVS is descending a subdirectory
 259        ;; (status says `examining' while update says `updating')
 260        (and
 261         (cvs-match "\\(Examining\\|Updating\\) \\(.*\\)$" (dir 2))
 262         (let ((dir (if (string= "." dir) "" (file-name-as-directory dir))))
 263           (cvs-parsed-fileinfo 'DIRCHANGE "." dir)))
 264
 265        ;; [-n update] A new (or pruned) directory appeared but isn't traversed
 266        (and
 267         (cvs-match "New directory `\\(.*\\)' -- ignored$" (dir 1))
 268         (cvs-parsed-fileinfo 'MESSAGE " " (file-name-as-directory dir)))
 269
 270        ;; File removed, since it is removed (by third party) in repository.
 271        (and
 272         (cvs-or
 273          (cvs-match "warning: \\(.*\\) is not (any longer) pertinent$" (file 1))
 274          (cvs-match "\\(.*\\) is no longer in the repository$" (file 1)))
 275         (cvs-parsed-fileinfo 'DEAD file))
 276
 277        ;; [add]
 278        (and
 279         (cvs-or
 280          (cvs-match "scheduling file `\\(.*\\)' for addition.*$" (path 1))
 281          (cvs-match "re-adding file \\(.*\\) (in place of .*)$" (path 1)))
 282         (cvs-parsed-fileinfo 'ADDED path))
 283
 284        ;; [add] this will also show up as a `U <file>'
 285        (and
 286         (cvs-match "\\(.*\\), version \\(.*\\), resurrected$"
 287                    (path 1) (base-rev 2))
 288         (cvs-parsed-fileinfo '(UP-TO-DATE . RESURRECTED) path nil
 289                              :base-rev base-rev))
 290
 291        ;; [remove]
 292        (and
 293         (cvs-match "removed `\\(.*\\)'$" (path 1))
 294         (cvs-parsed-fileinfo 'DEAD path))
 295
 296        ;; [remove,merge]
 297        (and
 298         (cvs-match "scheduling `\\(.*\\)' for removal$" (file 1))
 299         (cvs-parsed-fileinfo 'REMOVED file))
 300
 301        ;; [update] File removed by you, but not cvs rm'd
 302        (and
 303         (cvs-match "warning: \\(.*\\) was lost$" (path 1))
 304         (cvs-match (concat "U " (regexp-quote path) "$"))
 305         (cvs-parsed-fileinfo (if dont-change-disc
 306                                  'MISSING
 307                                '(UP-TO-DATE . UPDATED))
 308                              path))
 309
 310        ;; Mode conflicts (rather than contents)
 311        (and
 312         (cvs-match "conflict: ")
 313         (cvs-or
 314          (cvs-match "removed \\(.*\\) was modified by second party$"
 315                     (path 1) (subtype 'REMOVED))
 316          (cvs-match "\\(.*\\) created independently by second party$"
 317                     (path 1) (subtype 'ADDED))
 318          (cvs-match "\\(.*\\) is modified but no longer in the repository$"
 319                     (path 1) (subtype 'MODIFIED)))
 320         (cvs-match (concat "C " (regexp-quote path)))
 321         (cvs-parsed-fileinfo (cons 'CONFLICT subtype) path))
 322
 323        ;; Messages that should be shown to the user
 324        (and
 325         (cvs-or
 326          (cvs-match "move away \\(.*\\); it is in the way$" (file 1))
 327          (cvs-match "warning: new-born \\(.*\\) has disappeared$" (file 1))
 328          (cvs-match "sticky tag .* for file `\\(.*\\)' is not a branch$"
 329                     (file 1)))
 330         (cvs-parsed-fileinfo 'MESSAGE file))
 331
 332        ;; File unknown.
 333        (and (cvs-match "use `.+ add' to create an entry for \\(.*\\)$" (path 1))
 334             (cvs-parsed-fileinfo 'UNKNOWN path))
 335
 336        ;; [commit]
 337        (and (cvs-match "Up-to-date check failed for `\\(.+\\)'$" (file 1))
 338             (cvs-parsed-fileinfo 'NEED-MERGE file))
 339
 340        ;; We use cvs-execute-multi-dir but cvs can't handle it
 341        ;; Probably because the cvs-client can but the cvs-server can't
 342        (and (cvs-match ".* files with '?/'? in their name.*$")
 343             (not cvs-execute-single-dir)
 344             (setq cvs-execute-single-dir t)
 345             (cvs-create-fileinfo
 346              'MESSAGE "" " "
 347              "*** Add (setq cvs-execute-single-dir t) to your .emacs ***
 348         See the FAQ file or the variable's documentation for more info."))
 349
 350        ;; Cvs waits for a lock.  Ignored: already handled by the process filter
 351        (cvs-match "\\[..:..:..\\] \\(waiting for\\|obtained\\) .*lock in .*$")
 352        ;; File you removed still exists.  Ignore (will be noted as removed).
 353        (cvs-match ".* should be removed and is still there$")
 354        ;; just a note
 355        (cvs-match "use '.+ commit' to \\sw+ th\\sw+ files? permanently$")
 356        ;; [add,status] followed by a more complete status description anyway
 357        (cvs-match "nothing known about .*$")
 358        ;; [update] problem with patch
 359        (cvs-match "checksum failure after patch to .*; will refetch$")
 360        (cvs-match "refetching unpatchable files$")
 361        ;; [commit]
 362        (cvs-match "Rebuilding administrative file database$")
 363        ;; ???
 364        (cvs-match "--> Using per-directory sticky tag `.*'")
 365
 366        ;; CVS is running a *info program.
 367        (and
 368         (cvs-match "Executing.*$")
 369         ;; Skip by any output the program may generate to stdout.
 370         ;; Note that pcl-cvs will get seriously confused if the
 371         ;; program prints anything to stderr.
 372         (re-search-forward cvs-update-prog-output-skip-regexp))))
 373
 374      (and
 375       (cvs-match "cvs[.ex]* \\[[a-z]+ aborted\\]:.*$")
 376       (cvs-parsed-fileinfo 'MESSAGE ""))
 377
 378      ;; sadly you can't do much with these since the path is in the repository
 379      (cvs-match "Directory .* added to the repository$")
 380      )))
 381
 382
 383 (defun cvs-parse-merge ()
 384   (let (path base-rev head-rev handled type)
 385     ;; A merge (maybe with a conflict).
 386     (and
 387      (cvs-match "RCS file: .*$")
 388      ;; Squirrel away info about the files that were retrieved for merging
 389      (cvs-match "retrieving revision \\([0-9.]+\\)$" (base-rev 1))
 390      (cvs-match "retrieving revision \\([0-9.]+\\)$" (head-rev 1))
 391      (cvs-match "Merging differences between [0-9.]+ and [0-9.]+ into \\(.*\\)$"
 392                 (path 1))
 393
 394      ;; eat up potential conflict warnings
 395      (cvs-or (cvs-match "\\(rcs\\)?merge:?\\( warning\\)?: \\(overlaps\\|conflicts\\) \\(or other problems \\)?during merge$" (type 'CONFLICT)) t)
 396      (cvs-or
 397       (and
 398        (cvs-match "cvs[.ex]* [a-z]+: ")
 399        (cvs-or
 400         (cvs-match "conflicts found in \\(.*\\)$" (path 1) (type 'CONFLICT))
 401         (cvs-match "could not merge .*$")
 402         (cvs-match "restoring \\(.*\\) from backup file .*$" (path 1))))
 403       t)
 404
 405      ;; Is it a succesful merge?
 406      ;; Figure out result of merging (ie, was there a conflict?)
 407      (let ((qfile (regexp-quote path)))
 408        (cvs-or
 409         ;; Conflict
 410         (and
 411          (cvs-match (concat "C \\(.*" qfile "\\)$") (path 1) (type 'CONFLICT))
 412          ;; C might be followed by a "suprious" U for non-mergeable files
 413          (cvs-or (cvs-match (concat "U \\(.*" qfile "\\)$")) t))
 414         ;; Successful merge
 415         (cvs-match (concat "M \\(.*" qfile "\\)$") (path 1))
 416         ;; The file already contained the modifications
 417         (cvs-match (concat "^\\(.*" qfile
 418                            "\\) already contains the differences between .*$")
 419                    (path 1) (type '(UP-TO-DATE . MERGED)))
 420         t)
 421        ;; FIXME: PATH might not be set yet.  Sometimes the only path
 422        ;; information is in `RCS file: ...' (yuck!!).
 423        (cvs-parsed-fileinfo (if dont-change-disc 'NEED-MERGE
 424                               (or type '(MODIFIED . MERGED))) path nil
 425                             :merge (cons base-rev head-rev))))))
 426
 427 (defun cvs-parse-status ()
 428   (let (nofile path base-rev head-rev type)
 429     (and
 430      (cvs-match
 431       "===================================================================$")
 432      (cvs-match "File: \\(no file \\)?\\(.*[^ \t]\\)[ \t]+Status: "
 433                 (nofile 1) (path 2))
 434      (cvs-or
 435       (cvs-match "Needs \\(Checkout\\|Patch\\)$"
 436                  (type (if nofile 'MISSING 'NEED-UPDATE)))
 437       (cvs-match "Up-to-date$"
 438                  (type (if nofile '(UP-TO-DATE . REMOVED) 'UP-TO-DATE)))
 439       (cvs-match "File had conflicts on merge$" (type 'MODIFIED))
 440       (cvs-match ".*[Cc]onflict.*$"     (type 'CONFLICT))
 441       (cvs-match "Locally Added$"               (type 'ADDED))
 442       (cvs-match "Locally Removed$"     (type 'REMOVED))
 443       (cvs-match "Locally Modified$"    (type 'MODIFIED))
 444       (cvs-match "Needs Merge$"         (type 'NEED-MERGE))
 445       (cvs-match "Unknown$"             (type 'UNKNOWN)))
 446      (cvs-match "$")
 447      (cvs-or
 448       (cvs-match " *Version:[ \t]*\\([0-9.]+\\).*$" (base-rev 1))
 449       ;; NOTE: there's no date on the end of the following for server mode...
 450       (cvs-match " *Working revision:[ \t]*-?\\([0-9.]+\\).*$" (base-rev 1))
 451       ;; Let's not get all worked up if the format changes a bit
 452       (cvs-match " *Working revision:.*$"))
 453      (cvs-or
 454       (cvs-match " *RCS Version:[ \t]*\\([0-9.]+\\)[ \t]*.*$" (head-rev 1))
 455       (cvs-match " *Repository revision:[ \t]*\\([0-9.]+\\)[ \t]*\\(.*\\)$"
 456                  (head-rev 1))
 457       (cvs-match " *Repository revision:.*"))
 458      (cvs-or
 459       (and;;sometimes those fields are missing
 460        (cvs-match " *Sticky Tag:[ \t]*\\(.*\\)$") ; FIXME: use it
 461        (cvs-match " *Sticky Date:[ \t]*\\(.*\\)$") ; FIXME: use it
 462        (cvs-match " *Sticky Options:[ \t]*\\(.*\\)$")) ; FIXME: use it
 463       t)
 464      (cvs-match "$")
 465      ;; ignore the tags-listing in the case of `status -v'
 466      (cvs-or (cvs-match " *Existing Tags:\n\\(\t.*\n\\)*$") t)
 467      (cvs-parsed-fileinfo type path nil
 468                           :base-rev base-rev
 469                           :head-rev head-rev))))
 470
 471 (defun cvs-parse-commit ()
 472   (let (path base-rev subtype)
 473     (cvs-or
 474
 475      (and
 476       (cvs-match "\\(Checking in\\|Removing\\) \\(.*\\);$" (path 2))
 477       (cvs-match ".*,v  <--  .*$")
 478       (cvs-or
 479        ;; deletion
 480        (cvs-match "new revision: delete; previous revision: \\([0-9.]*\\)$"
 481                   (subtype 'REMOVED) (base-rev 1))
 482        ;; addition
 483        (cvs-match "initial revision: \\([0-9.]*\\)$"
 484                   (subtype 'ADDED) (base-rev 1))
 485        ;; update
 486        (cvs-match "new revision: \\([0-9.]*\\); previous revision: .*$"
 487                   (subtype 'COMMITTED) (base-rev 1)))
 488       (cvs-match "done$")
 489       (progn
 490         ;; Try to remove the temp files used by VC.
 491         (vc-delete-automatic-version-backups (expand-file-name path))
 492         ;; it's important here not to rely on the default directory management
 493         ;; because `cvs commit' might begin by a series of Examining messages
 494         ;; so the processing of the actual checkin messages might begin with
 495         ;; a `current-dir' set to something different from ""
 496         (cvs-parsed-fileinfo (cons 'UP-TO-DATE subtype) path 'trust
 497                              :base-rev base-rev)))
 498
 499      ;; useless message added before the actual addition: ignored
 500      (cvs-match "RCS file: .*\ndone$"))))
 501
 502
 503 (provide 'pcvs-parse)
 504
 505 ;;; pcvs-parse.el ends here