+;; * working-revision (file) OK

+;; - mode-line-string (file) OK

+;; - init-revision (file) NOT NEEDED

+;; * find-revision (file rev buffer) OK

+;; - steal-lock (file &optional revision) NOT NEEDED

+;; - show-log-entry (revision) OK

+;; - revision-completion-table (files) NEEDED?

+;; - previous-revision (file rev) OK

+;; - next-revision (file rev) OK

+ 'repository)

+ (when dir (cd dir))

+ (vc-git--out-ok "ls-files" "-c" "-z" "--" name))

+ (string= (substring str 0 (1+ (length name)))

+ (concat name "\0")))))))))

+ ;; FIXME: This can't set 'ignored yet

+ (vc-git--call nil "add" "--refresh" "--" (file-relative-name file))

+ (if (and diff (string-match ":[0-7]\\{6\\} [0-7]\\{6\\} [0-9a-f]\\{40\\} [0-9a-f]\\{40\\} [ADMU]\0[^\0]+\0"

+ diff))

+(defun vc-git--ls-files-state (state &rest args)

+ "Set state to STATE on all files found with git-ls-files ARGS."

+ (apply 'vc-git-command (current-buffer) nil nil "ls-files" "-z" args)

+ (let ((start (point)))

+ (while (search-forward "\0" nil t)

+ (let ((file (expand-file-name

+ (buffer-substring-no-properties start (1- (point))))))

+ (vc-file-setprop file 'vc-backend (if state 'Git 'none))

+ (vc-file-setprop file 'vc-state state))

+ (setq start (point))))))

+

+(defun vc-git-dir-state (dir)

+ "Git-specific version of `dir-state'."

+ (vc-git--ls-files-state 'up-to-date "-c")

+ (vc-git--ls-files-state 'edited "-m")

+ (vc-git--ls-files-state 'removed "-d")

+ (vc-git--ls-files-state 'ignored "-o" "-i" "--exclude-standard")

+ (vc-git--ls-files-state nil "-o" "--exclude-standard"))

+

+(defun vc-git-working-revision (file)

+ "Git-specific version of `vc-working-revision'."

+ (vc-git--out-ok "symbolic-ref" "HEAD")))))

+(defun vc-git-mode-line-string (file)

+ "Return string for placement into the modeline for FILE."

+ (let* ((branch (vc-git-working-revision file))

+ (def-ml (vc-default-mode-line-string 'Git file))

+ (help-echo (get-text-property 0 'help-echo def-ml)))

+ (if (zerop (length branch))

+ (propertize

+ (concat def-ml "!")

+ 'help-echo (concat help-echo "\nNo current branch (detached HEAD)"))

+ (propertize def-ml

+ 'help-echo (concat help-echo "\nCurrent branch: " branch)))))

+

+(defun vc-git-find-revision (file rev buffer)

+ `((,log-view-message-re (1 'change-log-acknowledgement))

+ (,log-view-file-re (1 'change-log-file-face)))

+ ;; Handle the case:

+ ;; user: foo@bar

+ '(("^Author:[ \t]+\\([A-Za-z0-9_.+-]+@[A-Za-z0-9_.-]+\\)"

+ (1 'change-log-email))

+ ;; Handle the case:

+ ;; user: FirstName LastName <foo@bar>

+ ("^Author:[ \t]+\\([^<(]+?\\)[ \t]*[(<]\\([A-Za-z0-9_.+-]+@[A-Za-z0-9_.-]+\\)[>)]"

+ (1 'change-log-name)

+ (2 'change-log-email))

+ ("^ +\\(?:\\(?:[Aa]cked\\|[Ss]igned-[Oo]ff\\)-[Bb]y:\\)[ \t]+\\([A-Za-z0-9_.+-]+@[A-Za-z0-9_.-]+\\)"

+ (1 'change-log-name))

+ ("^ +\\(?:\\(?:[Aa]cked\\|[Ss]igned-[Oo]ff\\)-[Bb]y:\\)[ \t]+\\([^<(]+?\\)[ \t]*[(<]\\([A-Za-z0-9_.+-]+@[A-Za-z0-9_.-]+\\)[>)]"

+ (1 'change-log-name)

+ (2 'change-log-email))

+ ("^Merge: \\([0-9a-z]+\\) \\([0-9a-z]+\\)"

+ (1 'change-log-acknowledgement)

+ (2 'change-log-acknowledgement))

+ ("^Date: \\(.+\\)" (1 'change-log-date))

+ ("^summary:[ \t]+\\(.+\\)" (1 'log-view-message))))))

+

+(defun vc-git-show-log-entry (revision)

+ "Move to the log entry for REVISION.

+REVISION may have the form BRANCH, BRANCH~N,

+or BRANCH^ (where \"^\" can be repeated)."

+ (goto-char (point-min))

+ (search-forward "\ncommit" nil t

+ (cond ((string-match "~\\([0-9]\\)$" revision)

+ (1+ (string-to-number (match-string 1 revision))))

+ ((string-match "\\^+$" revision)

+ (1+ (length (match-string 0 revision))))

+ (t nil)))

+ (beginning-of-line))

+ (vc-git-command buf 1 files "diff-tree" "--exit-code" "-p"

+ rev1 rev2 "--")

+ (vc-git-command buf 1 files "diff-index" "--exit-code" "-p"

+ (or rev1 "HEAD") "--"))))

+(defun vc-git-revision-table (files)

+ ;; What about `files'?!? --Stef

+(defun vc-git-revision-completion-table (files)

+ (lexical-let ((files files)

+ table (lambda () (vc-git-revision-table files))))

+ (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)

+ (apply #'encode-time (mapcar (lambda (match)

+ (string-to-number (match-string match)))

+ '(6 5 4 3 2 1 7))))))

+ (save-excursion

+ (move-beginning-of-line 1)

+ (and (looking-at "[0-9a-f]+")

+ (buffer-substring-no-properties (match-beginning 0) (match-end 0)))))

+(defun vc-git-previous-revision (file rev)

+ "Git-specific version of `vc-previous-revision'."

+ (vc-git--out-ok "rev-list" "-2" rev "--" file)

+ (point)

+ (1- (point-max))))))))

+(defun vc-git-next-revision (file rev)

+ "Git-specific version of `vc-next-revision'."

+ (file (file-name-nondirectory file))

+ (current-rev

+ (with-temp-buffer

+ (and

+ (vc-git--out-ok "rev-list" "-1" rev "--" file)

+ (goto-char (point-max))

+ (bolp)

+ (zerop (forward-line -1))

+ (bobp)

+ (buffer-substring-no-properties

+ (point)

+ (1- (point-max)))))))

+ (vc-git--out-ok "rev-list" "HEAD" "--" file)

+(defun vc-git--call (buffer command &rest args)

+ ;; We don't need to care the arguments. If there is a file name, it

+ ;; is always a relative one. This works also for remote

+ ;; directories.

+ (apply 'process-file "git" nil buffer nil command args))

+

+(defun vc-git--out-ok (command &rest args)

+ (zerop (apply 'vc-git--call '(t nil) command args)))

+

+ (unless (apply 'vc-git--out-ok

+ (append args (list (file-relative-name

+ file))))

+ (vc-git--out-ok "name-rev" "--name-only" "--tags" commit)