code.delx.au - gnu-emacs/blob - lisp/vc/vc-git.el

   1 ;;; vc-git.el --- VC backend for the git version control system -*- lexical-binding: t -*-
   2
   3 ;; Copyright (C) 2006-2016 Free Software Foundation, Inc.
   4
   5 ;; Author: Alexandre Julliard <julliard@winehq.org>
   6 ;; Keywords: vc tools
   7 ;; Package: vc
   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 3 of the License, or
  14 ;; (at your option) 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.  If not, see <http://www.gnu.org/licenses/>.
  23
  24 ;;; Commentary:
  25
  26 ;; This file contains a VC backend for the git version control
  27 ;; system.
  28 ;;
  29
  30 ;;; Installation:
  31
  32 ;; To install: put this file on the load-path and add Git to the list
  33 ;; of supported backends in `vc-handled-backends'; the following line,
  34 ;; placed in your init file, will accomplish this:
  35 ;;
  36 ;;     (add-to-list 'vc-handled-backends 'Git)
  37
  38 ;;; Todo:
  39 ;;  - check if more functions could use vc-git-command instead
  40 ;;     of start-process.
  41 ;;  - changelog generation
  42
  43 ;; Implement the rest of the vc interface. See the comment at the
  44 ;; beginning of vc.el. The current status is:
  45 ;; ("??" means: "figure out what to do about it")
  46 ;;
  47 ;; FUNCTION NAME                                   STATUS
  48 ;; BACKEND PROPERTIES
  49 ;; * revision-granularity                          OK
  50 ;; STATE-QUERYING FUNCTIONS
  51 ;; * registered (file)                             OK
  52 ;; * state (file)                                  OK
  53 ;; - dir-status-files (dir files uf)               OK
  54 ;; * working-revision (file)                       OK
  55 ;; * checkout-model (files)                        OK
  56 ;; - mode-line-string (file)                       OK
  57 ;; STATE-CHANGING FUNCTIONS
  58 ;; * create-repo ()                                OK
  59 ;; * register (files &optional rev comment)        OK
  60 ;; - responsible-p (file)                          OK
  61 ;; - receive-file (file rev)                       NOT NEEDED
  62 ;; - unregister (file)                             OK
  63 ;; * checkin (files rev comment)                   OK
  64 ;; * find-revision (file rev buffer)               OK
  65 ;; * checkout (file &optional rev)                 OK
  66 ;; * revert (file &optional contents-done)         OK
  67 ;; - merge-file (file rev1 rev2)            It would be possible to merge
  68 ;;                                          changes into a single file, but
  69 ;;                                          when committing they wouldn't
  70 ;;                                          be identified as a merge
  71 ;;                                          by git, so it's probably
  72 ;;                                          not a good idea.
  73 ;; - merge-news (file)                      see `merge-file'
  74 ;; - steal-lock (file &optional revision)          NOT NEEDED
  75 ;; HISTORY FUNCTIONS
  76 ;; * print-log (files buffer &optional shortlog start-revision limit)   OK
  77 ;; - log-view-mode ()                              OK
  78 ;; - show-log-entry (revision)                     OK
  79 ;; - comment-history (file)                        ??
  80 ;; - update-changelog (files)                      COULD BE SUPPORTED
  81 ;; * diff (file &optional rev1 rev2 buffer async)  OK
  82 ;; - revision-completion-table (files)             OK
  83 ;; - annotate-command (file buf &optional rev)     OK
  84 ;; - annotate-time ()                              OK
  85 ;; - annotate-current-time ()                      NOT NEEDED
  86 ;; - annotate-extract-revision-at-line ()          OK
  87 ;; TAG SYSTEM
  88 ;; - create-tag (dir name branchp)                 OK
  89 ;; - retrieve-tag (dir name update)                OK
  90 ;; MISCELLANEOUS
  91 ;; - make-version-backups-p (file)                 NOT NEEDED
  92 ;; - previous-revision (file rev)                  OK
  93 ;; - next-revision (file rev)                      OK
  94 ;; - check-headers ()                              COULD BE SUPPORTED
  95 ;; - delete-file (file)                            OK
  96 ;; - rename-file (old new)                         OK
  97 ;; - find-file-hook ()                             OK
  98 ;; - conflicted-files                              OK
  99
 100 ;;; Code:
 101
 102 (eval-when-compile
 103   (require 'cl-lib)
 104   (require 'vc)
 105   (require 'vc-dir)
 106   (require 'grep))
 107
 108 (defgroup vc-git nil
 109   "VC Git backend."
 110   :version "24.1"
 111   :group 'vc)
 112
 113 (defcustom vc-git-diff-switches t
 114   "String or list of strings specifying switches for Git diff under VC.
 115 If nil, use the value of `vc-diff-switches'.  If t, use no switches."
 116   :type '(choice (const :tag "Unspecified" nil)
 117                  (const :tag "None" t)
 118                  (string :tag "Argument String")
 119                  (repeat :tag "Argument List" :value ("") string))
 120   :version "23.1")
 121
 122 (defcustom vc-git-annotate-switches nil
 123   "String or list of strings specifying switches for Git blame under VC.
 124 If nil, use the value of `vc-annotate-switches'.  If t, use no switches."
 125   :type '(choice (const :tag "Unspecified" nil)
 126                  (const :tag "None" t)
 127                  (string :tag "Argument String")
 128                  (repeat :tag "Argument List" :value ("") string))
 129   :version "25.1")
 130
 131 (defcustom vc-git-resolve-conflicts t
 132   "When non-nil, mark conflicted file as resolved upon saving.
 133 That is performed after all conflict markers in it have been
 134 removed.  If the value is `unstage-maybe', and no merge is in
 135 progress, then after the last conflict is resolved, also clear
 136 the staging area."
 137   :type '(choice (const :tag "Don't resolve" nil)
 138                  (const :tag "Resolve" t)
 139                  (const :tag "Resolve and maybe unstage all files"
 140                         unstage-maybe))
 141   :version "25.1")
 142
 143 (defcustom vc-git-program "git"
 144   "Name of the Git executable (excluding any arguments)."
 145   :version "24.1"
 146   :type 'string)
 147
 148 (defcustom vc-git-root-log-format
 149   '("%d%h..: %an %ad %s"
 150     ;; The first shy group matches the characters drawn by --graph.
 151     ;; We use numbered groups because `log-view-message-re' wants the
 152     ;; revision number to be group 1.
 153     "^\\(?:[*/\\| ]+ \\)?\\(?2: ([^)]+)\\)?\\(?1:[0-9a-z]+\\)..: \
 154 \\(?3:.*?\\)[ \t]+\\(?4:[0-9]\\{4\\}-[0-9]\\{2\\}-[0-9]\\{2\\}\\)"
 155     ((1 'log-view-message-face)
 156      (2 'change-log-list nil lax)
 157      (3 'change-log-name)
 158      (4 'change-log-date)))
 159   "Git log format for `vc-print-root-log'.
 160 This should be a list (FORMAT REGEXP KEYWORDS), where FORMAT is a
 161 format string (which is passed to \"git log\" via the argument
 162 \"--pretty=tformat:FORMAT\"), REGEXP is a regular expression
 163 matching the resulting Git log output, and KEYWORDS is a list of
 164 `font-lock-keywords' for highlighting the Log View buffer."
 165   :type '(list string string (repeat sexp))
 166   :version "24.1")
 167
 168 (defcustom vc-git-commits-coding-system 'utf-8
 169   "Default coding system for sending commit log messages to Git.
 170
 171 Should be consistent with the Git config value i18n.commitEncoding,
 172 and should also be consistent with `locale-coding-system'."
 173   :type '(coding-system :tag "Coding system to encode Git commit logs")
 174   :version "25.1")
 175
 176 (defcustom vc-git-log-output-coding-system 'utf-8
 177   "Default coding system for receiving log output from Git.
 178
 179 Should be consistent with the Git config value i18n.logOutputEncoding."
 180   :type '(coding-system :tag "Coding system to decode Git log output")
 181   :version "25.1")
 182
 183 ;; History of Git commands.
 184 (defvar vc-git-history nil)
 185
 186 ;;; BACKEND PROPERTIES
 187
 188 (defun vc-git-revision-granularity () 'repository)
 189 (defun vc-git-checkout-model (_files) 'implicit)
 190
 191 ;;; STATE-QUERYING FUNCTIONS
 192
 193 ;;;###autoload (defun vc-git-registered (file)
 194 ;;;###autoload   "Return non-nil if FILE is registered with git."
 195 ;;;###autoload   (if (vc-find-root file ".git")       ; Short cut.
 196 ;;;###autoload       (progn
 197 ;;;###autoload         (load "vc-git" nil t)
 198 ;;;###autoload         (vc-git-registered file))))
 199
 200 (defun vc-git-registered (file)
 201   "Check whether FILE is registered with git."
 202   (let ((dir (vc-git-root file)))
 203     (when dir
 204       (with-temp-buffer
 205         (let* (process-file-side-effects
 206                ;; Do not use the `file-name-directory' here: git-ls-files
 207                ;; sometimes fails to return the correct status for relative
 208                ;; path specs.
 209                ;; See also: http://marc.info/?l=git&m=125787684318129&w=2
 210                (name (file-relative-name file dir))
 211                (str (ignore-errors
 212                       (cd dir)
 213                       (vc-git--out-ok "ls-files" "-c" "-z" "--" name)
 214                       ;; If result is empty, use ls-tree to check for deleted
 215                       ;; file.
 216                       (when (eq (point-min) (point-max))
 217                         (vc-git--out-ok "ls-tree" "--name-only" "-z" "HEAD"
 218                                         "--" name))
 219                       (buffer-string))))
 220           (and str
 221                (> (length str) (length name))
 222                (string= (substring str 0 (1+ (length name)))
 223                         (concat name "\0"))))))))
 224
 225 (defun vc-git--state-code (code)
 226   "Convert from a string to a added/deleted/modified state."
 227   (pcase (string-to-char code)
 228     (?M 'edited)
 229     (?A 'added)
 230     (?D 'removed)
 231     (?U 'edited)     ;; FIXME
 232     (?T 'edited)))   ;; FIXME
 233
 234 (defun vc-git-state (file)
 235   "Git-specific version of `vc-state'."
 236   ;; FIXME: This can't set 'ignored or 'conflict yet
 237   ;; The 'ignored state could be detected with `git ls-files -i -o
 238   ;; --exclude-standard` It also can't set 'needs-update or
 239   ;; 'needs-merge. The rough equivalent would be that upstream branch
 240   ;; for current branch is in fast-forward state i.e. current branch
 241   ;; is direct ancestor of corresponding upstream branch, and the file
 242   ;; was modified upstream.  But we can't check that without a network
 243   ;; operation.
 244   ;; This assumes that status is known to be not `unregistered' because
 245   ;; we've been successfully dispatched here from `vc-state', that
 246   ;; means `vc-git-registered' returned t earlier once.  Bug#11757
 247   (let ((diff (vc-git--run-command-string
 248                file "diff-index" "-p" "--raw" "-z" "HEAD" "--")))
 249     (if (and diff
 250              (string-match ":[0-7]\\{6\\} [0-7]\\{6\\} [0-9a-f]\\{40\\} [0-9a-f]\\{40\\} \\([ADMUT]\\)\0[^\0]+\0\\(.*\n.\\)?"
 251                            diff))
 252         (let ((diff-letter (match-string 1 diff)))
 253           (if (not (match-beginning 2))
 254               ;; Empty diff: file contents is the same as the HEAD
 255               ;; revision, but timestamps are different (eg, file
 256               ;; was "touch"ed).  Update timestamp in index:
 257               (prog1 'up-to-date
 258                 (vc-git--call nil "add" "--refresh" "--"
 259                               (file-relative-name file)))
 260             (vc-git--state-code diff-letter)))
 261       (if (vc-git--empty-db-p) 'added 'up-to-date))))
 262
 263 (defun vc-git-working-revision (_file)
 264   "Git-specific version of `vc-working-revision'."
 265   (let (process-file-side-effects)
 266     (vc-git--rev-parse "HEAD")))
 267
 268 (defun vc-git--symbolic-ref (file)
 269   (or
 270    (vc-file-getprop file 'vc-git-symbolic-ref)
 271    (let* (process-file-side-effects
 272           (str (vc-git--run-command-string nil "symbolic-ref" "HEAD")))
 273      (vc-file-setprop file 'vc-git-symbolic-ref
 274                       (if str
 275                           (if (string-match "^\\(refs/heads/\\)?\\(.+\\)$" str)
 276                               (match-string 2 str)
 277                             str))))))
 278
 279 (defun vc-git-mode-line-string (file)
 280   "Return a string for `vc-mode-line' to put in the mode line for FILE."
 281   (let* ((rev (vc-working-revision file))
 282          (disp-rev (or (vc-git--symbolic-ref file)
 283                        (substring rev 0 7)))
 284          (def-ml (vc-default-mode-line-string 'Git file))
 285          (help-echo (get-text-property 0 'help-echo def-ml))
 286          (face   (get-text-property 0 'face def-ml)))
 287     (propertize (replace-regexp-in-string (concat rev "\\'") disp-rev def-ml t t)
 288                 'face face
 289                 'help-echo (concat help-echo "\nCurrent revision: " rev))))
 290
 291 (cl-defstruct (vc-git-extra-fileinfo
 292             (:copier nil)
 293             (:constructor vc-git-create-extra-fileinfo
 294                           (old-perm new-perm &optional rename-state orig-name))
 295             (:conc-name vc-git-extra-fileinfo->))
 296   old-perm new-perm   ;; Permission flags.
 297   rename-state        ;; Rename or copy state.
 298   orig-name)          ;; Original name for renames or copies.
 299
 300 (defun vc-git-escape-file-name (name)
 301   "Escape a file name if necessary."
 302   (if (string-match "[\n\t\"\\]" name)
 303       (concat "\""
 304               (mapconcat (lambda (c)
 305                    (pcase c
 306                      (?\n "\\n")
 307                      (?\t "\\t")
 308                      (?\\ "\\\\")
 309                      (?\" "\\\"")
 310                      (_ (char-to-string c))))
 311                  name "")
 312               "\"")
 313     name))
 314
 315 (defun vc-git-file-type-as-string (old-perm new-perm)
 316   "Return a string describing the file type based on its permissions."
 317   (let* ((old-type (lsh (or old-perm 0) -9))
 318          (new-type (lsh (or new-perm 0) -9))
 319          (str (pcase new-type
 320                 (?\100  ;; File.
 321                  (pcase old-type
 322                    (?\100 nil)
 323                    (?\120 "   (type change symlink -> file)")
 324                    (?\160 "   (type change subproject -> file)")))
 325                  (?\120  ;; Symlink.
 326                   (pcase old-type
 327                     (?\100 "   (type change file -> symlink)")
 328                     (?\160 "   (type change subproject -> symlink)")
 329                     (_ "   (symlink)")))
 330                   (?\160  ;; Subproject.
 331                    (pcase old-type
 332                      (?\100 "   (type change file -> subproject)")
 333                      (?\120 "   (type change symlink -> subproject)")
 334                      (_ "   (subproject)")))
 335                   (?\110 nil)  ;; Directory (internal, not a real git state).
 336                   (?\000  ;; Deleted or unknown.
 337                    (pcase old-type
 338                      (?\120 "   (symlink)")
 339                      (?\160 "   (subproject)")))
 340                   (_ (format "   (unknown type %o)" new-type)))))
 341     (cond (str (propertize str 'face 'font-lock-comment-face))
 342           ((eq new-type ?\110) "/")
 343           (t ""))))
 344
 345 (defun vc-git-rename-as-string (state extra)
 346   "Return a string describing the copy or rename associated with INFO,
 347 or an empty string if none."
 348   (let ((rename-state (when extra
 349                         (vc-git-extra-fileinfo->rename-state extra))))
 350     (if rename-state
 351         (propertize
 352          (concat "   ("
 353                  (if (eq rename-state 'copy) "copied from "
 354                    (if (eq state 'added) "renamed from "
 355                      "renamed to "))
 356                  (vc-git-escape-file-name
 357                   (vc-git-extra-fileinfo->orig-name extra))
 358                  ")")
 359          'face 'font-lock-comment-face)
 360       "")))
 361
 362 (defun vc-git-permissions-as-string (old-perm new-perm)
 363   "Format a permission change as string."
 364   (propertize
 365    (if (or (not old-perm)
 366            (not new-perm)
 367            (eq 0 (logand ?\111 (logxor old-perm new-perm))))
 368        "  "
 369      (if (eq 0 (logand ?\111 old-perm)) "+x" "-x"))
 370   'face 'font-lock-type-face))
 371
 372 (defun vc-git-dir-printer (info)
 373   "Pretty-printer for the vc-dir-fileinfo structure."
 374   (let* ((isdir (vc-dir-fileinfo->directory info))
 375          (state (if isdir "" (vc-dir-fileinfo->state info)))
 376          (extra (vc-dir-fileinfo->extra info))
 377          (old-perm (when extra (vc-git-extra-fileinfo->old-perm extra)))
 378          (new-perm (when extra (vc-git-extra-fileinfo->new-perm extra))))
 379     (insert
 380      "  "
 381      (propertize (format "%c" (if (vc-dir-fileinfo->marked info) ?* ? ))
 382                  'face 'font-lock-type-face)
 383      "  "
 384      (propertize
 385       (format "%-12s" state)
 386       'face (cond ((eq state 'up-to-date) 'font-lock-builtin-face)
 387                   ((eq state 'missing) 'font-lock-warning-face)
 388                   (t 'font-lock-variable-name-face))
 389       'mouse-face 'highlight)
 390      "  " (vc-git-permissions-as-string old-perm new-perm)
 391      "    "
 392      (propertize (vc-git-escape-file-name (vc-dir-fileinfo->name info))
 393                  'face (if isdir 'font-lock-comment-delimiter-face
 394                          'font-lock-function-name-face)
 395                  'help-echo
 396                  (if isdir
 397                      "Directory\nVC operations can be applied to it\nmouse-3: Pop-up menu"
 398                    "File\nmouse-3: Pop-up menu")
 399                  'keymap vc-dir-filename-mouse-map
 400                  'mouse-face 'highlight)
 401      (vc-git-file-type-as-string old-perm new-perm)
 402      (vc-git-rename-as-string state extra))))
 403
 404 (defun vc-git-after-dir-status-stage (stage files update-function)
 405   "Process sentinel for the various dir-status stages."
 406   (let (next-stage result)
 407     (goto-char (point-min))
 408     (pcase stage
 409       (`update-index
 410        (setq next-stage (if (vc-git--empty-db-p) 'ls-files-added 'diff-index)))
 411       (`ls-files-added
 412        (setq next-stage 'ls-files-unknown)
 413        (while (re-search-forward "\\([0-7]\\{6\\}\\) [0-9a-f]\\{40\\} 0\t\\([^\0]+\\)\0" nil t)
 414          (let ((new-perm (string-to-number (match-string 1) 8))
 415                (name (match-string 2)))
 416            (push (list name 'added (vc-git-create-extra-fileinfo 0 new-perm))
 417                  result))))
 418       (`ls-files-up-to-date
 419        (setq next-stage 'ls-files-unknown)
 420        (while (re-search-forward "\\([0-7]\\{6\\}\\) [0-9a-f]\\{40\\} 0\t\\([^\0]+\\)\0" nil t)
 421          (let ((perm (string-to-number (match-string 1) 8))
 422                (name (match-string 2)))
 423            (push (list name 'up-to-date
 424                        (vc-git-create-extra-fileinfo perm perm))
 425                  result))))
 426       (`ls-files-unknown
 427        (when files (setq next-stage 'ls-files-ignored))
 428        (while (re-search-forward "\\([^\0]*?\\)\0" nil t 1)
 429          (push (list (match-string 1) 'unregistered
 430                      (vc-git-create-extra-fileinfo 0 0))
 431                result)))
 432       (`ls-files-ignored
 433        (while (re-search-forward "\\([^\0]*?\\)\0" nil t 1)
 434          (push (list (match-string 1) 'ignored
 435                      (vc-git-create-extra-fileinfo 0 0))
 436                result)))
 437       (`diff-index
 438        (setq next-stage (if files 'ls-files-up-to-date 'ls-files-unknown))
 439        (while (re-search-forward
 440                ":\\([0-7]\\{6\\}\\) \\([0-7]\\{6\\}\\) [0-9a-f]\\{40\\} [0-9a-f]\\{40\\} \\(\\([ADMUT]\\)\0\\([^\0]+\\)\\|\\([CR]\\)[0-9]*\0\\([^\0]+\\)\0\\([^\0]+\\)\\)\0"
 441                nil t 1)
 442          (let ((old-perm (string-to-number (match-string 1) 8))
 443                (new-perm (string-to-number (match-string 2) 8))
 444                (state (or (match-string 4) (match-string 6)))
 445                (name (or (match-string 5) (match-string 7)))
 446                (new-name (match-string 8)))
 447            (if new-name  ; Copy or rename.
 448                (if (eq ?C (string-to-char state))
 449                    (push (list new-name 'added
 450                                (vc-git-create-extra-fileinfo old-perm new-perm
 451                                                              'copy name))
 452                          result)
 453                  (push (list name 'removed
 454                              (vc-git-create-extra-fileinfo 0 0
 455                                                            'rename new-name))
 456                        result)
 457                  (push (list new-name 'added
 458                              (vc-git-create-extra-fileinfo old-perm new-perm
 459                                                            'rename name))
 460                        result))
 461              (push (list name (vc-git--state-code state)
 462                          (vc-git-create-extra-fileinfo old-perm new-perm))
 463                    result))))))
 464     (when result
 465       (setq result (nreverse result))
 466       (when files
 467         (dolist (entry result) (setq files (delete (car entry) files)))
 468         (unless files (setq next-stage nil))))
 469     (when (or result (not next-stage))
 470       (funcall update-function result next-stage))
 471     (when next-stage
 472       (vc-git-dir-status-goto-stage next-stage files update-function))))
 473
 474 ;; Follows vc-git-command (or vc-do-async-command), which uses vc-do-command
 475 ;; from vc-dispatcher.
 476 (declare-function vc-exec-after "vc-dispatcher" (code))
 477 ;; Follows vc-exec-after.
 478 (declare-function vc-set-async-update "vc-dispatcher" (process-buffer))
 479
 480 (defun vc-git-dir-status-goto-stage (stage files update-function)
 481   (erase-buffer)
 482   (pcase stage
 483     (`update-index
 484      (if files
 485          (vc-git-command (current-buffer) 'async files "add" "--refresh" "--")
 486        (vc-git-command (current-buffer) 'async nil
 487                        "update-index" "--refresh")))
 488     (`ls-files-added
 489      (vc-git-command (current-buffer) 'async files
 490                      "ls-files" "-z" "-c" "-s" "--"))
 491     (`ls-files-up-to-date
 492      (vc-git-command (current-buffer) 'async files
 493                      "ls-files" "-z" "-c" "-s" "--"))
 494     (`ls-files-unknown
 495      (vc-git-command (current-buffer) 'async files
 496                      "ls-files" "-z" "-o" "--directory"
 497                      "--no-empty-directory" "--exclude-standard" "--"))
 498     (`ls-files-ignored
 499      (vc-git-command (current-buffer) 'async files
 500                      "ls-files" "-z" "-o" "-i" "--directory"
 501                      "--no-empty-directory" "--exclude-standard" "--"))
 502     ;; --relative added in Git 1.5.5.
 503     (`diff-index
 504      (vc-git-command (current-buffer) 'async files
 505                      "diff-index" "--relative" "-z" "-M" "HEAD" "--")))
 506   (vc-run-delayed
 507    (vc-git-after-dir-status-stage stage files update-function)))
 508
 509 (defun vc-git-dir-status-files (_dir files update-function)
 510   "Return a list of (FILE STATE EXTRA) entries for DIR."
 511   ;; Further things that would have to be fixed later:
 512   ;; - how to handle unregistered directories
 513   ;; - how to support vc-dir on a subdir of the project tree
 514   (vc-git-dir-status-goto-stage 'update-index files update-function))
 515
 516 (defvar vc-git-stash-map
 517   (let ((map (make-sparse-keymap)))
 518     ;; Turn off vc-dir marking
 519     (define-key map [mouse-2] 'ignore)
 520
 521     (define-key map [down-mouse-3] 'vc-git-stash-menu)
 522     (define-key map "\C-k" 'vc-git-stash-delete-at-point)
 523     (define-key map "=" 'vc-git-stash-show-at-point)
 524     (define-key map "\C-m" 'vc-git-stash-show-at-point)
 525     (define-key map "A" 'vc-git-stash-apply-at-point)
 526     (define-key map "P" 'vc-git-stash-pop-at-point)
 527     (define-key map "S" 'vc-git-stash-snapshot)
 528     map))
 529
 530 (defvar vc-git-stash-menu-map
 531   (let ((map (make-sparse-keymap "Git Stash")))
 532     (define-key map [de]
 533       '(menu-item "Delete Stash" vc-git-stash-delete-at-point
 534                   :help "Delete the current stash"))
 535     (define-key map [ap]
 536       '(menu-item "Apply Stash" vc-git-stash-apply-at-point
 537                   :help "Apply the current stash and keep it in the stash list"))
 538     (define-key map [po]
 539       '(menu-item "Apply and Remove Stash (Pop)" vc-git-stash-pop-at-point
 540                   :help "Apply the current stash and remove it"))
 541     (define-key map [sh]
 542       '(menu-item "Show Stash" vc-git-stash-show-at-point
 543                   :help "Show the contents of the current stash"))
 544     map))
 545
 546 (defun vc-git-dir-extra-headers (dir)
 547   (let ((str (with-output-to-string
 548                (with-current-buffer standard-output
 549                  (vc-git--out-ok "symbolic-ref" "HEAD"))))
 550         (stash (vc-git-stash-list))
 551         (stash-help-echo "Use M-x vc-git-stash to create stashes.")
 552         branch remote remote-url)
 553     (if (string-match "^\\(refs/heads/\\)?\\(.+\\)$" str)
 554         (progn
 555           (setq branch (match-string 2 str))
 556           (setq remote
 557                 (with-output-to-string
 558                   (with-current-buffer standard-output
 559                     (vc-git--out-ok "config"
 560                                     (concat "branch." branch ".remote")))))
 561           (when (string-match "\\([^\n]+\\)" remote)
 562             (setq remote (match-string 1 remote)))
 563           (when remote
 564             (setq remote-url
 565                   (with-output-to-string
 566                     (with-current-buffer standard-output
 567                       (vc-git--out-ok "config"
 568                                       (concat "remote." remote ".url"))))))
 569           (when (string-match "\\([^\n]+\\)" remote-url)
 570             (setq remote-url (match-string 1 remote-url))))
 571       (setq branch "not (detached HEAD)"))
 572     ;; FIXME: maybe use a different face when nothing is stashed.
 573     (concat
 574      (propertize "Branch     : " 'face 'font-lock-type-face)
 575      (propertize branch
 576                  'face 'font-lock-variable-name-face)
 577      (when remote
 578        (concat
 579         "\n"
 580         (propertize "Remote     : " 'face 'font-lock-type-face)
 581         (propertize remote-url
 582                     'face 'font-lock-variable-name-face)))
 583      "\n"
 584      ;; For now just a heading, key bindings can be added later for various bisect actions
 585      (when (file-exists-p (expand-file-name ".git/BISECT_START" (vc-git-root dir)))
 586        (propertize  "Bisect     : in progress\n" 'face 'font-lock-warning-face))
 587      (when (file-exists-p (expand-file-name ".git/rebase-apply" (vc-git-root dir)))
 588        (propertize  "Rebase     : in progress\n" 'face 'font-lock-warning-face))
 589      (if stash
 590        (concat
 591         (propertize "Stash      :\n" 'face 'font-lock-type-face
 592                     'help-echo stash-help-echo)
 593         (mapconcat
 594          (lambda (x)
 595            (propertize x
 596                        'face 'font-lock-variable-name-face
 597                        'mouse-face 'highlight
 598                        'help-echo "mouse-3: Show stash menu\nRET: Show stash\nA: Apply stash\nP: Apply and remove stash (pop)\nC-k: Delete stash"
 599                        'keymap vc-git-stash-map))
 600          stash "\n"))
 601        (concat
 602         (propertize "Stash      : " 'face 'font-lock-type-face
 603                     'help-echo stash-help-echo)
 604         (propertize "Nothing stashed"
 605                     'help-echo stash-help-echo
 606                     'face 'font-lock-variable-name-face))))))
 607
 608 (defun vc-git-branches ()
 609   "Return the existing branches, as a list of strings.
 610 The car of the list is the current branch."
 611   (with-temp-buffer
 612     (vc-git--call t "branch")
 613     (goto-char (point-min))
 614     (let (current-branch branches)
 615       (while (not (eobp))
 616         (when (looking-at "^\\([ *]\\) \\(.+\\)$")
 617           (if (string-equal (match-string 1) "*")
 618               (setq current-branch (match-string 2))
 619             (push (match-string 2) branches)))
 620         (forward-line 1))
 621       (cons current-branch (nreverse branches)))))
 622
 623 ;;; STATE-CHANGING FUNCTIONS
 624
 625 (defun vc-git-create-repo ()
 626   "Create a new Git repository."
 627   (vc-git-command nil 0 nil "init"))
 628
 629 (defun vc-git-register (files &optional _comment)
 630   "Register FILES into the git version-control system."
 631   (let (flist dlist)
 632     (dolist (crt files)
 633       (if (file-directory-p crt)
 634           (push crt dlist)
 635         (push crt flist)))
 636     (when flist
 637       (vc-git-command nil 0 flist "update-index" "--add" "--"))
 638     (when dlist
 639       (vc-git-command nil 0 dlist "add"))))
 640
 641 (defalias 'vc-git-responsible-p 'vc-git-root)
 642
 643 (defun vc-git-unregister (file)
 644   (vc-git-command nil 0 file "rm" "-f" "--cached" "--"))
 645
 646 (declare-function log-edit-mode "log-edit" ())
 647 (declare-function log-edit-toggle-header "log-edit" (header value))
 648 (declare-function log-edit-extract-headers "log-edit" (headers string))
 649 (declare-function log-edit-set-header "log-edit" (header value &optional toggle))
 650
 651 (defun vc-git-log-edit-toggle-signoff ()
 652   "Toggle whether to add the \"Signed-off-by\" line at the end of
 653 the commit message."
 654   (interactive)
 655   (log-edit-toggle-header "Sign-Off" "yes"))
 656
 657 (defun vc-git-log-edit-toggle-amend ()
 658   "Toggle whether this will amend the previous commit.
 659 If toggling on, also insert its message into the buffer."
 660   (interactive)
 661   (when (log-edit-toggle-header "Amend" "yes")
 662     (goto-char (point-max))
 663     (unless (bolp) (insert "\n"))
 664     (insert (with-output-to-string
 665               (vc-git-command
 666                standard-output 1 nil
 667                "log" "--max-count=1" "--pretty=format:%B" "HEAD")))
 668     (save-excursion
 669       (rfc822-goto-eoh)
 670       (forward-line 1)
 671       (let ((pt (point)))
 672         (and (zerop (forward-line 1))
 673              (looking-at "\n\\|\\'")
 674              (let ((summary (buffer-substring-no-properties pt (1- (point)))))
 675                (skip-chars-forward " \n")
 676                (delete-region pt (point))
 677                (log-edit-set-header "Summary" summary)))))))
 678
 679 (defvar vc-git-log-edit-mode-map
 680   (let ((map (make-sparse-keymap "Git-Log-Edit")))
 681     (define-key map "\C-c\C-s" 'vc-git-log-edit-toggle-signoff)
 682     (define-key map "\C-c\C-e" 'vc-git-log-edit-toggle-amend)
 683     map))
 684
 685 (define-derived-mode vc-git-log-edit-mode log-edit-mode "Log-Edit/git"
 686   "Major mode for editing Git log messages.
 687 It is based on `log-edit-mode', and has Git-specific extensions.")
 688
 689 (defun vc-git-checkin (files comment &optional _rev)
 690   (let* ((file1 (or (car files) default-directory))
 691          (root (vc-git-root file1))
 692          (default-directory (expand-file-name root))
 693          (only (or (cdr files)
 694                    (not (equal root (abbreviate-file-name file1)))))
 695          (pcsw coding-system-for-write)
 696          (coding-system-for-write
 697           ;; On MS-Windows, we must encode command-line arguments in
 698           ;; the system codepage.
 699           (if (eq system-type 'windows-nt)
 700               locale-coding-system
 701             (or coding-system-for-write vc-git-commits-coding-system)))
 702          (msg-file
 703           ;; On MS-Windows, pass the commit log message through a
 704           ;; file, to work around the limitation that command-line
 705           ;; arguments must be in the system codepage, and therefore
 706           ;; might not support the non-ASCII characters in the log
 707           ;; message.
 708           (if (eq system-type 'windows-nt) (make-temp-file "git-msg"))))
 709     (cl-flet ((boolean-arg-fn
 710                (argument)
 711                (lambda (value) (when (equal value "yes") (list argument)))))
 712       ;; When operating on the whole tree, better pass "-a" than ".", since "."
 713       ;; fails when we're committing a merge.
 714       (apply 'vc-git-command nil 0 (if only files)
 715              (nconc (if msg-file (list "commit" "-F" msg-file)
 716                       (list "commit" "-m"))
 717                     (let ((args
 718                            (log-edit-extract-headers
 719                             `(("Author" . "--author")
 720                               ("Date" . "--date")
 721                               ("Amend" . ,(boolean-arg-fn "--amend"))
 722                               ("Sign-Off" . ,(boolean-arg-fn "--signoff")))
 723                             comment)))
 724                       (when msg-file
 725                         (let ((coding-system-for-write
 726                                (or pcsw vc-git-commits-coding-system)))
 727                           (write-region (car args) nil msg-file))
 728                         (setq args (cdr args)))
 729                       args)
 730                     (if only (list "--only" "--") '("-a")))))
 731     (if (and msg-file (file-exists-p msg-file)) (delete-file msg-file))))
 732
 733 (defun vc-git-find-revision (file rev buffer)
 734   (let* (process-file-side-effects
 735          (coding-system-for-read 'binary)
 736          (coding-system-for-write 'binary)
 737          (fullname
 738           (let ((fn (vc-git--run-command-string
 739                      file "ls-files" "-z" "--full-name" "--")))
 740             ;; ls-files does not return anything when looking for a
 741             ;; revision of a file that has been renamed or removed.
 742             (if (string= fn "")
 743                 (file-relative-name file (vc-git-root default-directory))
 744               (substring fn 0 -1)))))
 745     (vc-git-command
 746      buffer 0
 747      nil
 748      "cat-file" "blob" (concat (if rev rev "HEAD") ":" fullname))))
 749
 750 (defun vc-git-find-ignore-file (file)
 751   "Return the git ignore file that controls FILE."
 752   (expand-file-name ".gitignore"
 753                     (vc-git-root file)))
 754
 755 (defun vc-git-checkout (file &optional rev)
 756   (vc-git-command nil 0 file "checkout" (or rev "HEAD")))
 757
 758 (defun vc-git-revert (file &optional contents-done)
 759   "Revert FILE to the version stored in the git repository."
 760   (if contents-done
 761       (vc-git-command nil 0 file "update-index" "--")
 762     (vc-git-command nil 0 file "reset" "-q" "--")
 763     (vc-git-command nil nil file "checkout" "-q" "--")))
 764
 765 (defvar vc-git-error-regexp-alist
 766   '(("^ \\(.+\\) |" 1 nil nil 0))
 767   "Value of `compilation-error-regexp-alist' in *vc-git* buffers.")
 768
 769 ;; To be called via vc-pull from vc.el, which requires vc-dispatcher.
 770 (declare-function vc-compilation-mode "vc-dispatcher" (backend))
 771
 772 (defun vc-git--pushpull (command prompt)
 773   "Run COMMAND (a string; either push or pull) on the current Git branch.
 774 If PROMPT is non-nil, prompt for the Git command to run."
 775   (let* ((root (vc-git-root default-directory))
 776          (buffer (format "*vc-git : %s*" (expand-file-name root)))
 777          (git-program vc-git-program)
 778          args)
 779     ;; If necessary, prompt for the exact command.
 780     ;; TODO if pushing, prompt if no default push location - cf bzr.
 781     (when prompt
 782       (setq args (split-string
 783                   (read-shell-command
 784                    (format "Git %s command: " command)
 785                    (format "%s %s" git-program command)
 786                    'vc-git-history)
 787                   " " t))
 788       (setq git-program (car  args)
 789             command     (cadr args)
 790             args        (cddr args)))
 791     (require 'vc-dispatcher)
 792     (apply 'vc-do-async-command buffer root git-program command args)
 793     (with-current-buffer buffer (vc-run-delayed (vc-compilation-mode 'git)))
 794     (vc-set-async-update buffer)))
 795
 796 (defun vc-git-pull (prompt)
 797   "Pull changes into the current Git branch.
 798 Normally, this runs \"git pull\".  If PROMPT is non-nil, prompt
 799 for the Git command to run."
 800   (vc-git--pushpull "pull" prompt))
 801
 802 (defun vc-git-push (prompt)
 803   "Push changes from the current Git branch.
 804 Normally, this runs \"git push\".  If PROMPT is non-nil, prompt
 805 for the Git command to run."
 806   (vc-git--pushpull "push" prompt))
 807
 808 (defun vc-git-merge-branch ()
 809   "Merge changes into the current Git branch.
 810 This prompts for a branch to merge from."
 811   (let* ((root (vc-git-root default-directory))
 812          (buffer (format "*vc-git : %s*" (expand-file-name root)))
 813          (branches (cdr (vc-git-branches)))
 814          (merge-source
 815           (completing-read "Merge from branch: "
 816                            (if (or (member "FETCH_HEAD" branches)
 817                                    (not (file-readable-p
 818                                          (expand-file-name ".git/FETCH_HEAD"
 819                                                            root))))
 820                                branches
 821                              (cons "FETCH_HEAD" branches))
 822                            nil t)))
 823     (apply 'vc-do-async-command buffer root vc-git-program "merge"
 824            (list merge-source))
 825     (with-current-buffer buffer (vc-run-delayed (vc-compilation-mode 'git)))
 826     (vc-set-async-update buffer)))
 827
 828 (defun vc-git-conflicted-files (directory)
 829   "Return the list of files with conflicts in DIRECTORY."
 830   (let* ((status
 831           (vc-git--run-command-string directory "status" "--porcelain" "--"))
 832          (lines (when status (split-string status "\n" 'omit-nulls)))
 833          files)
 834     ;; TODO: Look into reimplementing `vc-git-state', as well as
 835     ;; `vc-git-dir-status-files', based on this output, thus making the
 836     ;; extra process call in `vc-git-find-file-hook' unnecessary.
 837     (dolist (line lines files)
 838       (when (string-match "\\([ MADRCU?!][ MADRCU?!]\\) \\(.+\\)\\(?: -> \\(.+\\)\\)?"
 839                           line)
 840         (let ((state (match-string 1 line))
 841               (file (match-string 2 line)))
 842           ;; See git-status(1).
 843           (when (member state '("AU" "UD" "UA" ;; "DD"
 844                                 "DU" "AA" "UU"))
 845             (push (expand-file-name file directory) files)))))))
 846
 847 (defun vc-git-resolve-when-done ()
 848   "Call \"git add\" if the conflict markers have been removed."
 849   (save-excursion
 850     (goto-char (point-min))
 851     (unless (re-search-forward "^<<<<<<< " nil t)
 852       (vc-git-command nil 0 buffer-file-name "add")
 853       (unless (or
 854                (not (eq vc-git-resolve-conflicts 'unstage-maybe))
 855                ;; Doing a merge, so bug#20292 doesn't apply.
 856                (file-exists-p (expand-file-name ".git/MERGE_HEAD"
 857                                                 (vc-git-root buffer-file-name)))
 858                (vc-git-conflicted-files (vc-git-root buffer-file-name)))
 859         (vc-git-command nil 0 nil "reset"))
 860       ;; Remove the hook so that it is not called multiple times.
 861       (remove-hook 'after-save-hook 'vc-git-resolve-when-done t))))
 862
 863 (defun vc-git-find-file-hook ()
 864   "Activate `smerge-mode' if there is a conflict."
 865   (when (and buffer-file-name
 866              ;; FIXME
 867              ;; 1) the net result is to call git twice per file.
 868              ;; 2) v-g-c-f is documented to take a directory.
 869              ;; http://lists.gnu.org/archive/html/emacs-devel/2014-01/msg01126.html
 870              (vc-git-conflicted-files buffer-file-name)
 871              (save-excursion
 872                (goto-char (point-min))
 873                (re-search-forward "^<<<<<<< " nil 'noerror)))
 874     (vc-file-setprop buffer-file-name 'vc-state 'conflict)
 875     (smerge-start-session)
 876     (when vc-git-resolve-conflicts
 877       (add-hook 'after-save-hook 'vc-git-resolve-when-done nil 'local))
 878     (vc-message-unresolved-conflicts buffer-file-name)))
 879
 880 ;;; HISTORY FUNCTIONS
 881
 882 (autoload 'vc-setup-buffer "vc-dispatcher")
 883
 884 (defun vc-git-print-log (files buffer &optional shortlog start-revision limit)
 885   "Print commit log associated with FILES into specified BUFFER.
 886 If SHORTLOG is non-nil, use a short format based on `vc-git-root-log-format'.
 887 \(This requires at least Git version 1.5.6, for the --graph option.)
 888 If START-REVISION is non-nil, it is the newest revision to show.
 889 If LIMIT is non-nil, show no more than this many entries."
 890   (let ((coding-system-for-read
 891          (or coding-system-for-read vc-git-log-output-coding-system)))
 892     ;; `vc-do-command' creates the buffer, but we need it before running
 893     ;; the command.
 894     (vc-setup-buffer buffer)
 895     ;; If the buffer exists from a previous invocation it might be
 896     ;; read-only.
 897     (let ((inhibit-read-only t))
 898       (with-current-buffer
 899           buffer
 900         (apply 'vc-git-command buffer
 901                'async files
 902                (append
 903                 '("log" "--no-color")
 904                 (when shortlog
 905                   `("--graph" "--decorate" "--date=short"
 906                     ,(format "--pretty=tformat:%s"
 907                              (car vc-git-root-log-format))
 908                     "--abbrev-commit"))
 909                 (when limit (list "-n" (format "%s" limit)))
 910                 (when start-revision (list start-revision))
 911                 '("--")))))))
 912
 913 (defun vc-git-log-outgoing (buffer remote-location)
 914   (interactive)
 915   (vc-git-command
 916    buffer 0 nil
 917    "log"
 918    "--no-color" "--graph" "--decorate" "--date=short"
 919    (format "--pretty=tformat:%s" (car vc-git-root-log-format))
 920    "--abbrev-commit"
 921    (concat (if (string= remote-location "")
 922                "@{upstream}"
 923              remote-location)
 924            "..HEAD")))
 925
 926 (defun vc-git-log-incoming (buffer remote-location)
 927   (interactive)
 928   (vc-git-command nil 0 nil "fetch")
 929   (vc-git-command
 930    buffer 0 nil
 931    "log"
 932    "--no-color" "--graph" "--decorate" "--date=short"
 933    (format "--pretty=tformat:%s" (car vc-git-root-log-format))
 934    "--abbrev-commit"
 935    (concat "HEAD.." (if (string= remote-location "")
 936                         "@{upstream}"
 937                       remote-location))))
 938
 939 (defvar log-view-message-re)
 940 (defvar log-view-file-re)
 941 (defvar log-view-font-lock-keywords)
 942 (defvar log-view-per-file-logs)
 943 (defvar log-view-expanded-log-entry-function)
 944
 945 (define-derived-mode vc-git-log-view-mode log-view-mode "Git-Log-View"
 946   (require 'add-log) ;; We need the faces add-log.
 947   ;; Don't have file markers, so use impossible regexp.
 948   (set (make-local-variable 'log-view-file-re) "\\`a\\`")
 949   (set (make-local-variable 'log-view-per-file-logs) nil)
 950   (set (make-local-variable 'log-view-message-re)
 951        (if (not (eq vc-log-view-type 'long))
 952            (cadr vc-git-root-log-format)
 953          "^commit *\\([0-9a-z]+\\)"))
 954   ;; Allow expanding short log entries.
 955   (when (eq vc-log-view-type 'short)
 956     (setq truncate-lines t)
 957     (set (make-local-variable 'log-view-expanded-log-entry-function)
 958          'vc-git-expanded-log-entry))
 959   (set (make-local-variable 'log-view-font-lock-keywords)
 960        (if (not (eq vc-log-view-type 'long))
 961            (list (cons (nth 1 vc-git-root-log-format)
 962                        (nth 2 vc-git-root-log-format)))
 963          (append
 964           `((,log-view-message-re (1 'change-log-acknowledgment)))
 965           ;; Handle the case:
 966           ;; user: foo@bar
 967           '(("^Author:[ \t]+\\([A-Za-z0-9_.+-]+@[A-Za-z0-9_.-]+\\)"
 968              (1 'change-log-email))
 969             ;; Handle the case:
 970             ;; user: FirstName LastName <foo@bar>
 971             ("^Author:[ \t]+\\([^<(]+?\\)[ \t]*[(<]\\([A-Za-z0-9_.+-]+@[A-Za-z0-9_.-]+\\)[>)]"
 972              (1 'change-log-name)
 973              (2 'change-log-email))
 974             ("^ +\\(?:\\(?:[Aa]cked\\|[Ss]igned-[Oo]ff\\)-[Bb]y:\\)[ \t]+\\([A-Za-z0-9_.+-]+@[A-Za-z0-9_.-]+\\)"
 975              (1 'change-log-name))
 976             ("^ +\\(?:\\(?:[Aa]cked\\|[Ss]igned-[Oo]ff\\)-[Bb]y:\\)[ \t]+\\([^<(]+?\\)[ \t]*[(<]\\([A-Za-z0-9_.+-]+@[A-Za-z0-9_.-]+\\)[>)]"
 977              (1 'change-log-name)
 978              (2 'change-log-email))
 979             ("^Merge: \\([0-9a-z]+\\) \\([0-9a-z]+\\)"
 980              (1 'change-log-acknowledgment)
 981              (2 'change-log-acknowledgment))
 982             ("^Date:   \\(.+\\)" (1 'change-log-date))
 983             ("^summary:[ \t]+\\(.+\\)" (1 'log-view-message)))))))
 984
 985
 986 (defun vc-git-show-log-entry (revision)
 987   "Move to the log entry for REVISION.
 988 REVISION may have the form BRANCH, BRANCH~N,
 989 or BRANCH^ (where \"^\" can be repeated)."
 990   (goto-char (point-min))
 991   (prog1
 992       (when revision
 993         (search-forward
 994          (format "\ncommit %s" revision) nil t
 995          (cond ((string-match "~\\([0-9]\\)\\'" revision)
 996                 (1+ (string-to-number (match-string 1 revision))))
 997                ((string-match "\\^+\\'" revision)
 998                 (1+ (length (match-string 0 revision))))
 999                (t nil))))
1000     (beginning-of-line)))
1001
1002 (defun vc-git-expanded-log-entry (revision)
1003   (with-temp-buffer
1004     (apply 'vc-git-command t nil nil (list "log" revision "-1" "--"))
1005     (goto-char (point-min))
1006     (unless (eobp)
1007       ;; Indent the expanded log entry.
1008       (indent-region (point-min) (point-max) 2)
1009       (buffer-string))))
1010
1011 (defun vc-git-region-history (file buffer lfrom lto)
1012   ;; The "git log" command below interprets the line numbers as applying
1013   ;; to the HEAD version of the file, not to the current state of the file.
1014   ;; So we need to look at all the local changes and adjust lfrom/lto
1015   ;; accordingly.
1016   ;; FIXME: Maybe this should be done in vc.el (i.e. for all backends), but
1017   ;; since Git is the only backend to support this operation so far, it's hard
1018   ;; to tell.
1019   (with-temp-buffer
1020     (vc-call-backend 'git 'diff file "HEAD" nil (current-buffer))
1021     (goto-char (point-min))
1022     (let ((last-offset 0)
1023           (from-offset nil)
1024           (to-offset nil))
1025       (while (re-search-forward
1026               "^@@ -\\([0-9]+\\),\\([0-9]+\\) \\+\\([0-9]+\\),\\([0-9]+\\) @@" nil t)
1027         (let ((headno (string-to-number (match-string 1)))
1028               (headcnt (string-to-number (match-string 2)))
1029               (curno (string-to-number (match-string 3)))
1030               (curcnt (string-to-number (match-string 4))))
1031           (cl-assert (equal (- curno headno) last-offset))
1032           (and (null from-offset) (> curno lfrom)
1033                (setq from-offset last-offset))
1034           (and (null to-offset) (> curno lto)
1035                (setq to-offset last-offset))
1036           (setq last-offset
1037                 (- (+ curno curcnt) (+ headno headcnt)))))
1038       (setq lto (- lto (or to-offset last-offset)))
1039       (setq lfrom (- lfrom (or to-offset last-offset)))))
1040   (vc-git-command buffer 'async nil "log" "-p" ;"--follow" ;FIXME: not supported?
1041                   (format "-L%d,%d:%s" lfrom lto (file-relative-name file))))
1042
1043 (require 'diff-mode)
1044
1045 (defvar vc-git-region-history-mode-map
1046   (let ((map (make-composed-keymap
1047               nil (make-composed-keymap
1048                    (list diff-mode-map vc-git-log-view-mode-map)))))
1049     map))
1050
1051 (defvar vc-git--log-view-long-font-lock-keywords nil)
1052 (defvar font-lock-keywords)
1053 (defvar vc-git-region-history-font-lock-keywords
1054   `((vc-git-region-history-font-lock)))
1055
1056 (defun vc-git-region-history-font-lock (limit)
1057   (let ((in-diff (save-excursion
1058                    (beginning-of-line)
1059                    (or (looking-at "^\\(?:diff\\|commit\\)\\>")
1060                        (re-search-backward "^\\(?:diff\\|commit\\)\\>" nil t))
1061                    (eq ?d (char-after (match-beginning 0))))))
1062     (while
1063         (let ((end (save-excursion
1064                      (if (re-search-forward "\n\\(diff\\|commit\\)\\>"
1065                                             limit t)
1066                          (match-beginning 1)
1067                        limit))))
1068           (let ((font-lock-keywords (if in-diff diff-font-lock-keywords
1069                                       vc-git--log-view-long-font-lock-keywords)))
1070             (font-lock-fontify-keywords-region (point) end))
1071           (goto-char end)
1072           (prog1 (< (point) limit)
1073             (setq in-diff (eq ?d (char-after))))))
1074     nil))
1075
1076 (define-derived-mode vc-git-region-history-mode
1077     vc-git-log-view-mode "Git-Region-History"
1078   "Major mode to browse Git's \"log -p\" output."
1079   (setq-local vc-git--log-view-long-font-lock-keywords
1080               log-view-font-lock-keywords)
1081   (setq-local font-lock-defaults
1082               (cons 'vc-git-region-history-font-lock-keywords
1083                     (cdr font-lock-defaults))))
1084
1085
1086 (autoload 'vc-switches "vc")
1087
1088 (defun vc-git-diff (files &optional rev1 rev2 buffer _async)
1089   "Get a difference report using Git between two revisions of FILES."
1090   (let (process-file-side-effects
1091         (command "diff-tree"))
1092     (if rev2
1093         ;; Diffing against the empty tree.
1094         (unless rev1 (setq rev1 "4b825dc642cb6eb9a060e54bf8d69288fbee4904"))
1095       (setq command "diff-index")
1096       (unless rev1 (setq rev1 "HEAD")))
1097     (if vc-git-diff-switches
1098         (apply #'vc-git-command (or buffer "*vc-diff*")
1099                1 ; bug#21969
1100                files
1101                command
1102                "--exit-code"
1103                (append (vc-switches 'git 'diff)
1104                        (list "-p" (or rev1 "HEAD") rev2 "--")))
1105       (vc-git-command (or buffer "*vc-diff*") 1 files
1106                       "difftool" "--exit-code" "--no-prompt" "-x"
1107                       (concat "diff "
1108                               (mapconcat 'identity
1109                                          (vc-switches nil 'diff) " "))
1110                       rev1 rev2 "--"))))
1111
1112 (defun vc-git-revision-table (_files)
1113   ;; What about `files'?!?  --Stef
1114   (let (process-file-side-effects
1115         (table (list "HEAD")))
1116     (with-temp-buffer
1117       (vc-git-command t nil nil "for-each-ref" "--format=%(refname)")
1118       (goto-char (point-min))
1119       (while (re-search-forward "^refs/\\(heads\\|tags\\|remotes\\)/\\(.*\\)$"
1120                                 nil t)
1121         (push (match-string 2) table)))
1122     table))
1123
1124 (defun vc-git-revision-completion-table (files)
1125   (letrec ((table (lazy-completion-table
1126                    table (lambda () (vc-git-revision-table files)))))
1127     table))
1128
1129 (defun vc-git-annotate-command (file buf &optional rev)
1130   (let ((name (file-relative-name file)))
1131     (apply #'vc-git-command buf 'async nil "blame" "--date=short"
1132            (append (vc-switches 'git 'annotate)
1133                    (list rev "--" name)))))
1134
1135 (declare-function vc-annotate-convert-time "vc-annotate" (&optional time))
1136
1137 (defun vc-git-annotate-time ()
1138   (and (re-search-forward "^[0-9a-f^]+[^()]+(.*?\\([0-9]+\\)-\\([0-9]+\\)-\\([0-9]+\\) \\(:?\\([0-9]+\\):\\([0-9]+\\):\\([0-9]+\\) \\([-+0-9]+\\)\\)? *[0-9]+) " nil t)
1139        (vc-annotate-convert-time
1140         (apply #'encode-time (mapcar (lambda (match)
1141                                        (if (match-beginning match)
1142                                            (string-to-number (match-string match))
1143                                          0))
1144                                      '(6 5 4 3 2 1 7))))))
1145
1146 (defun vc-git-annotate-extract-revision-at-line ()
1147   (save-excursion
1148     (beginning-of-line)
1149     (when (looking-at "\\^?\\([0-9a-f]+\\) \\(\\([^(]+\\) \\)?")
1150       (let ((revision (match-string-no-properties 1)))
1151         (if (match-beginning 2)
1152             (let ((fname (match-string-no-properties 3)))
1153               ;; Remove trailing whitespace from the file name.
1154               (when (string-match " +\\'" fname)
1155                 (setq fname (substring fname 0 (match-beginning 0))))
1156               (cons revision
1157                     (expand-file-name fname (vc-git-root default-directory))))
1158           revision)))))
1159
1160 ;;; TAG SYSTEM
1161
1162 (defun vc-git-create-tag (dir name branchp)
1163   (let ((default-directory dir))
1164     (and (vc-git-command nil 0 nil "update-index" "--refresh")
1165          (if branchp
1166              (vc-git-command nil 0 nil "checkout" "-b" name)
1167            (vc-git-command nil 0 nil "tag" name)))))
1168
1169 (defun vc-git-retrieve-tag (dir name _update)
1170   (let ((default-directory dir))
1171     (vc-git-command nil 0 nil "checkout" name)
1172     ;; FIXME: update buffers if `update' is true
1173     ))
1174
1175
1176 ;;; MISCELLANEOUS
1177
1178 (defun vc-git-previous-revision (file rev)
1179   "Git-specific version of `vc-previous-revision'."
1180   (if file
1181       (let* ((fname (file-relative-name file))
1182              (prev-rev (with-temp-buffer
1183                          (and
1184                           (vc-git--out-ok "rev-list" "-2" rev "--" fname)
1185                           (goto-char (point-max))
1186                           (bolp)
1187                           (zerop (forward-line -1))
1188                           (not (bobp))
1189                           (buffer-substring-no-properties
1190                            (point)
1191                            (1- (point-max)))))))
1192         (or (vc-git-symbolic-commit prev-rev) prev-rev))
1193     ;; We used to use "^" here, but that fails on MS-Windows if git is
1194     ;; invoked via a batch file, in which case cmd.exe strips the "^"
1195     ;; because it is a special character for cmd which process-file
1196     ;; does not (and cannot) quote.
1197     (vc-git--rev-parse (concat rev "~1"))))
1198
1199 (defun vc-git--rev-parse (rev)
1200   (with-temp-buffer
1201     (and
1202      (vc-git--out-ok "rev-parse" rev)
1203      (buffer-substring-no-properties (point-min) (+ (point-min) 40)))))
1204
1205 (defun vc-git-next-revision (file rev)
1206   "Git-specific version of `vc-next-revision'."
1207   (let* ((default-directory (file-name-directory
1208                              (expand-file-name file)))
1209          (file (file-name-nondirectory file))
1210          (current-rev
1211           (with-temp-buffer
1212             (and
1213              (vc-git--out-ok "rev-list" "-1" rev "--" file)
1214              (goto-char (point-max))
1215              (bolp)
1216              (zerop (forward-line -1))
1217              (bobp)
1218              (buffer-substring-no-properties
1219               (point)
1220               (1- (point-max))))))
1221          (next-rev
1222           (and current-rev
1223                (with-temp-buffer
1224                  (and
1225                   (vc-git--out-ok "rev-list" "HEAD" "--" file)
1226                   (goto-char (point-min))
1227                   (search-forward current-rev nil t)
1228                   (zerop (forward-line -1))
1229                   (buffer-substring-no-properties
1230                    (point)
1231                    (progn (forward-line 1) (1- (point)))))))))
1232     (or (vc-git-symbolic-commit next-rev) next-rev)))
1233
1234 (defun vc-git-delete-file (file)
1235   (vc-git-command nil 0 file "rm" "-f" "--"))
1236
1237 (defun vc-git-rename-file (old new)
1238   (vc-git-command nil 0 (list old new) "mv" "-f" "--"))
1239
1240 (defvar vc-git-extra-menu-map
1241   (let ((map (make-sparse-keymap)))
1242     (define-key map [git-grep]
1243       '(menu-item "Git grep..." vc-git-grep
1244                   :help "Run the `git grep' command"))
1245     (define-key map [git-sn]
1246       '(menu-item "Stash a Snapshot" vc-git-stash-snapshot
1247                   :help "Stash the current state of the tree and keep the current state"))
1248     (define-key map [git-st]
1249       '(menu-item "Create Stash..." vc-git-stash
1250                   :help "Stash away changes"))
1251     (define-key map [git-ss]
1252       '(menu-item "Show Stash..." vc-git-stash-show
1253                   :help "Show stash contents"))
1254     map))
1255
1256 (defun vc-git-extra-menu () vc-git-extra-menu-map)
1257
1258 (defun vc-git-extra-status-menu () vc-git-extra-menu-map)
1259
1260 (defun vc-git-root (file)
1261   (or (vc-file-getprop file 'git-root)
1262       (vc-file-setprop file 'git-root (vc-find-root file ".git"))))
1263
1264 ;; grep-compute-defaults autoloads grep.
1265 (declare-function grep-read-regexp "grep" ())
1266 (declare-function grep-read-files "grep" (regexp))
1267 (declare-function grep-expand-template "grep"
1268                  (template &optional regexp files dir excl))
1269
1270 ;; Derived from `lgrep'.
1271 (defun vc-git-grep (regexp &optional files dir)
1272   "Run git grep, searching for REGEXP in FILES in directory DIR.
1273 The search is limited to file names matching shell pattern FILES.
1274 FILES may use abbreviations defined in `grep-files-aliases', e.g.
1275 entering `ch' is equivalent to `*.[ch]'.
1276
1277 With \\[universal-argument] prefix, you can edit the constructed shell command line
1278 before it is executed.
1279 With two \\[universal-argument] prefixes, directly edit and run `grep-command'.
1280
1281 Collect output in a buffer.  While git grep runs asynchronously, you
1282 can use \\[next-error] (M-x next-error), or \\<grep-mode-map>\\[compile-goto-error] \
1283 in the grep output buffer,
1284 to go to the lines where grep found matches.
1285
1286 This command shares argument histories with \\[rgrep] and \\[grep]."
1287   (interactive
1288    (progn
1289      (grep-compute-defaults)
1290      (cond
1291       ((equal current-prefix-arg '(16))
1292        (list (read-from-minibuffer "Run: " "git grep"
1293                                    nil nil 'grep-history)
1294              nil))
1295       (t (let* ((regexp (grep-read-regexp))
1296                 (files (grep-read-files regexp))
1297                 (dir (read-directory-name "In directory: "
1298                                           nil default-directory t)))
1299            (list regexp files dir))))))
1300   (require 'grep)
1301   (when (and (stringp regexp) (> (length regexp) 0))
1302     (let ((command regexp))
1303       (if (null files)
1304           (if (string= command "git grep")
1305               (setq command nil))
1306         (setq dir (file-name-as-directory (expand-file-name dir)))
1307         (setq command
1308               (grep-expand-template "git --no-pager grep -n -e <R> -- <F>"
1309                                     regexp files))
1310         (when command
1311           (if (equal current-prefix-arg '(4))
1312               (setq command
1313                     (read-from-minibuffer "Confirm: "
1314                                           command nil nil 'grep-history))
1315             (add-to-history 'grep-history command))))
1316       (when command
1317         (let ((default-directory dir)
1318               (compilation-environment (cons "PAGER=" compilation-environment)))
1319           ;; Setting process-setup-function makes exit-message-function work
1320           ;; even when async processes aren't supported.
1321           (compilation-start command 'grep-mode))
1322         (if (eq next-error-last-buffer (current-buffer))
1323             (setq default-directory dir))))))
1324
1325 ;; Everywhere but here, follows vc-git-command, which uses vc-do-command
1326 ;; from vc-dispatcher.
1327 (autoload 'vc-resynch-buffer "vc-dispatcher")
1328
1329 (defun vc-git-stash (name)
1330   "Create a stash."
1331   (interactive "sStash name: ")
1332   (let ((root (vc-git-root default-directory)))
1333     (when root
1334       (vc-git--call nil "stash" "save" name)
1335       (vc-resynch-buffer root t t))))
1336
1337 (defun vc-git-stash-show (name)
1338   "Show the contents of stash NAME."
1339   (interactive "sStash name: ")
1340   (vc-setup-buffer "*vc-git-stash*")
1341   (vc-git-command "*vc-git-stash*" 'async nil "stash" "show" "-p" name)
1342   (set-buffer "*vc-git-stash*")
1343   (diff-mode)
1344   (setq buffer-read-only t)
1345   (pop-to-buffer (current-buffer)))
1346
1347 (defun vc-git-stash-apply (name)
1348   "Apply stash NAME."
1349   (interactive "sApply stash: ")
1350   (vc-git-command "*vc-git-stash*" 0 nil "stash" "apply" "-q" name)
1351   (vc-resynch-buffer (vc-git-root default-directory) t t))
1352
1353 (defun vc-git-stash-pop (name)
1354   "Pop stash NAME."
1355   (interactive "sPop stash: ")
1356   (vc-git-command "*vc-git-stash*" 0 nil "stash" "pop" "-q" name)
1357   (vc-resynch-buffer (vc-git-root default-directory) t t))
1358
1359 (defun vc-git-stash-snapshot ()
1360   "Create a stash with the current tree state."
1361   (interactive)
1362   (vc-git--call nil "stash" "save"
1363                 (let ((ct (current-time)))
1364                   (concat
1365                    (format-time-string "Snapshot on %Y-%m-%d" ct)
1366                    (format-time-string " at %H:%M" ct))))
1367   (vc-git-command "*vc-git-stash*" 0 nil "stash" "apply" "-q" "stash@{0}")
1368   (vc-resynch-buffer (vc-git-root default-directory) t t))
1369
1370 (defun vc-git-stash-list ()
1371   (delete
1372    ""
1373    (split-string
1374     (replace-regexp-in-string
1375      "^stash@" "             " (vc-git--run-command-string nil "stash" "list"))
1376     "\n")))
1377
1378 (defun vc-git-stash-get-at-point (point)
1379   (save-excursion
1380     (goto-char point)
1381     (beginning-of-line)
1382     (if (looking-at "^ +\\({[0-9]+}\\):")
1383         (match-string 1)
1384       (error "Cannot find stash at point"))))
1385
1386 ;; vc-git-stash-delete-at-point must be called from a vc-dir buffer.
1387 (declare-function vc-dir-refresh "vc-dir" ())
1388
1389 (defun vc-git-stash-delete-at-point ()
1390   (interactive)
1391   (let ((stash (vc-git-stash-get-at-point (point))))
1392     (when (y-or-n-p (format "Remove stash %s ? " stash))
1393       (vc-git--run-command-string nil "stash" "drop" (format "stash@%s" stash))
1394       (vc-dir-refresh))))
1395
1396 (defun vc-git-stash-show-at-point ()
1397   (interactive)
1398   (vc-git-stash-show (format "stash@%s" (vc-git-stash-get-at-point (point)))))
1399
1400 (defun vc-git-stash-apply-at-point ()
1401   (interactive)
1402   (let (vc-dir-buffers) ; Small optimization.
1403     (vc-git-stash-apply (format "stash@%s" (vc-git-stash-get-at-point (point)))))
1404   (vc-dir-refresh))
1405
1406 (defun vc-git-stash-pop-at-point ()
1407   (interactive)
1408   (let (vc-dir-buffers) ; Likewise.
1409     (vc-git-stash-pop (format "stash@%s" (vc-git-stash-get-at-point (point)))))
1410   (vc-dir-refresh))
1411
1412 (defun vc-git-stash-menu (e)
1413   (interactive "e")
1414   (vc-dir-at-event e (popup-menu vc-git-stash-menu-map e)))
1415
1416 \f
1417 ;;; Internal commands
1418
1419 (defun vc-git-command (buffer okstatus file-or-list &rest flags)
1420   "A wrapper around `vc-do-command' for use in vc-git.el.
1421 The difference to vc-do-command is that this function always invokes
1422 `vc-git-program'."
1423   (let ((coding-system-for-read
1424          (or coding-system-for-read vc-git-log-output-coding-system))
1425         (coding-system-for-write
1426          (or coding-system-for-write vc-git-commits-coding-system)))
1427     (apply 'vc-do-command (or buffer "*vc*") okstatus vc-git-program
1428            ;; http://debbugs.gnu.org/16897
1429            (unless (and (not (cdr-safe file-or-list))
1430                         (let ((file (or (car-safe file-or-list)
1431                                         file-or-list)))
1432                           (and file
1433                                (eq ?/ (aref file (1- (length file))))
1434                                (equal file (vc-git-root file)))))
1435              file-or-list)
1436            (cons "--no-pager" flags))))
1437
1438 (defun vc-git--empty-db-p ()
1439   "Check if the git db is empty (no commit done yet)."
1440   (let (process-file-side-effects)
1441     (not (eq 0 (vc-git--call nil "rev-parse" "--verify" "HEAD")))))
1442
1443 (defun vc-git--call (buffer command &rest args)
1444   ;; We don't need to care the arguments.  If there is a file name, it
1445   ;; is always a relative one.  This works also for remote
1446   ;; directories.  We enable `inhibit-null-byte-detection', otherwise
1447   ;; Tramp's eol conversion might be confused.
1448   (let ((inhibit-null-byte-detection t)
1449         (coding-system-for-read
1450          (or coding-system-for-read vc-git-log-output-coding-system))
1451         (coding-system-for-write
1452          (or coding-system-for-write vc-git-commits-coding-system))
1453         (process-environment (cons "PAGER=" process-environment)))
1454     (apply 'process-file vc-git-program nil buffer nil command args)))
1455
1456 (defun vc-git--out-ok (command &rest args)
1457   (zerop (apply 'vc-git--call '(t nil) command args)))
1458
1459 (defun vc-git--run-command-string (file &rest args)
1460   "Run a git command on FILE and return its output as string.
1461 FILE can be nil."
1462   (let* ((ok t)
1463          (str (with-output-to-string
1464                 (with-current-buffer standard-output
1465                   (unless (apply 'vc-git--out-ok
1466                                  (if file
1467                                      (append args (list (file-relative-name
1468                                                          file)))
1469                                    args))
1470                     (setq ok nil))))))
1471     (and ok str)))
1472
1473 (defun vc-git-symbolic-commit (commit)
1474   "Translate COMMIT string into symbolic form.
1475 Returns nil if not possible."
1476   (and commit
1477        (let ((name (with-temp-buffer
1478                      (and
1479                       (vc-git--out-ok "name-rev" "--name-only" commit)
1480                       (goto-char (point-min))
1481                       (= (forward-line 2) 1)
1482                       (bolp)
1483                       (buffer-substring-no-properties (point-min)
1484                                                       (1- (point-max)))))))
1485          (and name (not (string= name "undefined")) name))))
1486
1487 (provide 'vc-git)
1488
1489 ;;; vc-git.el ends here