git-diff-index
git-diff-tree
git-describe
+git-fast-export
git-fast-import
git-fetch
git-fetch--tool
info: git.info
install: man
- $(INSTALL) -d -m755 $(DESTDIR)$(man1dir)
- $(INSTALL) -d -m755 $(DESTDIR)$(man5dir)
- $(INSTALL) -d -m755 $(DESTDIR)$(man7dir)
- $(INSTALL) -m644 $(DOC_MAN1) $(DESTDIR)$(man1dir)
- $(INSTALL) -m644 $(DOC_MAN5) $(DESTDIR)$(man5dir)
- $(INSTALL) -m644 $(DOC_MAN7) $(DESTDIR)$(man7dir)
+ $(INSTALL) -d -m 755 $(DESTDIR)$(man1dir)
+ $(INSTALL) -d -m 755 $(DESTDIR)$(man5dir)
+ $(INSTALL) -d -m 755 $(DESTDIR)$(man7dir)
+ $(INSTALL) -m 644 $(DOC_MAN1) $(DESTDIR)$(man1dir)
+ $(INSTALL) -m 644 $(DOC_MAN5) $(DESTDIR)$(man5dir)
+ $(INSTALL) -m 644 $(DOC_MAN7) $(DESTDIR)$(man7dir)
install-info: info
- $(INSTALL) -d -m755 $(DESTDIR)$(infodir)
- $(INSTALL) -m644 git.info $(DESTDIR)$(infodir)
+ $(INSTALL) -d -m 755 $(DESTDIR)$(infodir)
+ $(INSTALL) -m 644 git.info $(DESTDIR)$(infodir)
if test -r $(DESTDIR)$(infodir)/dir; then \
$(INSTALL_INFO) --info-dir=$(DESTDIR)$(infodir) git.info ;\
else \
$(cmds_txt): cmd-list.made
-cmd-list.made: cmd-list.perl $(MAN1_TXT)
+cmd-list.made: cmd-list.perl ../command-list.txt $(MAN1_TXT)
$(RM) $@
- perl ./cmd-list.perl
+ perl ./cmd-list.perl ../command-list.txt
date >$@
git.7 git.html: git.txt
--- /dev/null
+GIT v1.5.3.7 Release Notes
+==========================
+
+Fixes since v1.5.3.6
+--------------------
+
+ * git-send-email added 8-bit contents to the payload without
+ marking it as 8-bit in a CTE header.
+
+ * "git-bundle create a.bndl HEAD" dereferenced the symref and
+ did not record the ref as 'HEAD'; this prevented a bundle
+ from being used as a normal source of git-clone.
+
+ * The code to reject nonsense command line of the form
+ "git-commit -a paths..." and "git-commit --interactive
+ paths..." were broken.
+
+ * Adding a signature that is not ASCII-only to an original
+ commit that is ASCII-only would make the result non-ASCII.
+ "git-format-patch -s" did not mark such a message correctly
+ with MIME encoding header.
+
+ * git-add sometimes did not mark the resulting index entry
+ stat-clean. This affected only cases when adding the
+ contents with the same length as the previously staged
+ contents, and the previous staging made the index entry
+ "racily clean".
+
+ * git-commit did not honor GIT_INDEX_FILE the user had in the
+ environment.
+
+ * When checking out a revision, git-checkout did not report where the
+ updated HEAD is if you happened to have a file called HEAD in the
+ work tree.
+
+ * "git-rev-list --objects" mishandled a tree that points at a
+ submodule.
+
+ * "git cvsimport" was not ready for packed refs that "git gc" can
+ produce and gave incorrect results.
+
+ * Many scripted Porcelains were confused when you happened to have a
+ file called "HEAD" in your work tree.
+
+Also it contains updates to the user manual and documentation.
GIT v1.5.4 Release Notes
========================
+Removal
+-------
+
+ * "git svnimport" was removed in favor of "git svn". It is still there
+ in the source tree (contrib/examples) but unsupported.
+
+
+Deprecation notices
+-------------------
+
+ * Next feature release of git (this change is scheduled for v1.5.5 but
+ it could slip) will by default install dashed form of commands
+ (e.g. "git-commit") outside of users' normal $PATH, and will install
+ only selected commands ("git" itself, and "gitk") in $PATH. This
+ implies:
+
+ - Using dashed form of git commands (e.g. "git-commit") from the
+ command line has been informally deprecated since early 2006, but
+ now it officially is, and will be removed in the future. Use
+ dashless form (e.g. "git commit") instead.
+
+ - Using dashed from from your scripts, without first prepending the
+ return value from "git --exec-path" to the scripts' PATH, has been
+ informally deprecated since early 2006, but now it officially is.
+
+ - Use of dashed form with "PATH=$(git --exec-path):$PATH; export
+ PATH" early in your script is not deprecated with this change.
+
+ Users are strongly encouraged to adjust their habits and scripts now
+ to prepare for this.
+
+ * The post-receive hook was introduced in March 2007 to supersede
+ post-update hook, primarily to overcome the command line length
+ limitation of the latter. Use of post-update hook will be deprecated
+ in future versions of git, perhaps in v1.5.5.
+
+ * "git lost-found" was deprecated in favor of "git fsck"'s --lost-found
+ option, and will be removed in the future.
+
+ * "git peek-remote" is deprecated, as "git ls-remote" was written in C
+ and works for all transports, and will be removed in the future.
+
+
Updates since v1.5.3
--------------------
* Comes with much improved gitk.
- * "progress display" from many commands are a lot nicer to the
- eye. Transfer commands show throughput data.
+ * Comes with "git gui" 0.9.1 with i18n.
+
+ * gitk is now merged as a subdirectory of git.git project, in
+ preparation for its i18n.
+
+ * progress display from many commands are a lot nicer to the eye.
+ Transfer commands show throughput data.
+
+ * many commands that pay attention to per-directory .gitignore now do
+ so lazily, which makes the usual case go much faster.
+
+ * Output processing for '--pretty=format:<user format>' has been
+ optimized.
+
+ * Rename detection of diff family, while detecting exact matches, has
+ been greatly optimized.
- * git-reset is now built-in and its output can be squelched with -q.
+ * Rename detection of diff family tries to make more naturally looking
+ pairing. Earlier if more than one identical rename sources were
+ found in the preimage, they were picked pretty much at random.
- * git-send-email can optionally talk over ssmtp and use SMTP-AUTH.
+ * Value "true" for color.diff and color.status configuration used to
+ mean "always" (even when the output is not going to a terminal).
+ This has been corrected to mean the same thing as "auto".
+
+ * HTTP proxy can be specified per remote repository using
+ remote.*.httpproxy configuration, or global http.proxy configuration
+ variable.
+
+ * Various Perforce importer updates.
+
+ * Example update and post-receive hooks have been improved.
- * git-rebase learned --whitespace option.
+ * Any command that wants to take a commit object name can now use
+ ":/string" syntax to name a commit.
- * git-remote knows --mirror mode.
+ * "git reset" is now built-in and its output can be squelched with -q.
- * git-merge can call the "post-merge" hook.
+ * "git send-email" can optionally talk over ssmtp and use SMTP-AUTH.
- * git-pack-objects can optionally run deltification with multiple threads.
+ * "git rebase" learned --whitespace option.
- * git-archive can optionally substitute keywords in files marked with
+ * In "git rebase", when you decide not to replay a particular change
+ after the command stopped with a conflict, you can say "git rebase
+ --skip" without first running "git reset --hard", as the command now
+ runs it for you.
+
+ * "git rebase --interactive" mode can now work on detached HEAD.
+
+ * "git rebase" now detaches head during its operation, so after a
+ successful "git rebase" operation, the reflog entry branch@{1} for
+ the current branch points at the commit before the rebase was
+ started.
+
+ * "git rebase -i" also triggers rerere to help your repeated merges.
+
+ * "git merge" can call the "post-merge" hook.
+
+ * "git pack-objects" can optionally run deltification with multiple
+ threads.
+
+ * "git archive" can optionally substitute keywords in files marked with
export-subst attribute.
- * git-for-each-ref learned %(xxxdate:<dateformat>) syntax to
- show the various date fields in different formats.
+ * "git cherry-pick" made a misguided attempt to repeat the original
+ command line in the generated log message, when told to cherry-pick a
+ commit by naming a tag that points at it. It does not anymore.
- * git-gc --auto is a low-impact way to automatically run a
- variant of git-repack that does not lose unreferenced objects
- (read: safer than the usual one) after the user accumulates
- too many loose objects.
+ * "git for-each-ref" learned %(xxxdate:<dateformat>) syntax to show the
+ various date fields in different formats.
+
+ * "git gc --auto" is a low-impact way to automatically run a variant of
+ "git repack" that does not lose unreferenced objects (read: safer
+ than the usual one) after the user accumulates too many loose
+ objects.
+
+ * "git clean" has been rewritten in C.
* You need to explicitly set clean.requireForce to "false" to allow
- git-clean without -f to do any damage (lack of the configuration
- variable used to mean "do not require", but we now use the safer
- default).
+ "git clean" without -f to do any damage (lack of the configuration
+ variable used to mean "do not require -f option to lose untracked
+ files", but we now use the safer default).
- * git-push has been rewritten in C.
+ * "git push" learned --dry-run option to show what would happen if a
+ push is run.
- * git-push learned --dry-run option to show what would happen
- if a push is run.
+ * "git push" does not update a tracking ref on the local side when the
+ remote refused to update the corresponding ref.
- * git-remote learned "rm" subcommand.
+ * "git push" learned --mirror option. This is to push the local refs
+ one-to-one to the remote, and deletes refs from the remote that do
+ not exist anymore in the repository on the pushing side.
- * git-rebase --interactive mode can now work on detached HEAD.
+ * "git push" can remove a corrupt ref at the remote site with the usual
+ ":ref" refspec.
- * git-cvsserver can be run via git-shell.
+ * "git remote" knows --mirror mode. This is to set up configuration to
+ push into a remote repository to store local branch heads to the same
+ branch on the remote side, and remove branch heads locally removed
+ from local repository at the same time. Suitable for pushing into a
+ back-up repository.
- * git-am and git-rebase are far less verbose.
+ * "git remote" learned "rm" subcommand.
- * git-pull learned to pass --[no-]ff option to underlying git-merge.
+ * "git cvsserver" can be run via "git shell".
- * Various Perforce importer updates.
+ * "git am" and "git rebase" are far less verbose.
- * git-lost-found was deprecated in favor of git-fsck's --lost-found
- option.
+ * "git pull" learned to pass --[no-]ff option to underlying "git
+ merge".
- * "git log" learned --early-output option to help interactive
- GUI implementations.
+ * "git pull --rebase" is a different way to integrate what you fetched
+ into your current branch.
- * git-svnimport was removed in favor of git-svn.
+ * "git fast-export" produces datastream that can be fed to fast-import
+ to reproduce the history recorded in a git repository.
- * git-bisect learned "skip" action to mark untestable commits.
+ * "git commit --allow-empty" allows you to create a single-parent
+ commit that records the same tree as its parent, overriding the usual
+ safety valve.
- * git-format-patch learned "format.numbered" configuration variable
- to automatically turn --numbered option on when more than one
- commits are formatted.
+ * "git commit --amend" can amend a merge that does not change the tree
+ from its first parent.
- * git-ls-files learned "--exclude-standard" to use the canned
- set of exclude files.
+ * "git stash random-text" does not create a new stash anymore. It was
+ a UI mistake. Use "git stash save random-text", or "git stash"
+ (without extra args) for that.
- * git-rebase now detaches head during its operation, so after a
- successful "git rebase" operation, the reflog entry branch@{1}
- for the current branch points at the commit before the rebase
- was started.
+ * "git prune --expire <time>" can exempt young loose objects from
+ getting pruned.
- * "git-tag -a -f existing" begins the editor session using the
- existing annotation message.
+ * "git branch --contains <commit>" can list branches that are
+ descendants of a given commit.
- * "git cvsexportcommit" learned -w option to specify and switch
- to the CVS working directory.
+ * "git log" learned --early-output option to help interactive GUI
+ implementations.
- * "git checkout" from a subdirectory learned to use "../path"
- to allow checking out a path outside the current directory
- without cd'ing up.
+ * "git bisect" learned "skip" action to mark untestable commits.
- * Output processing for '--pretty=format:<user format>' has
- been optimized.
+ * "git format-patch" learned "format.numbered" configuration variable
+ to automatically turn --numbered option on when more than one commits
+ are formatted.
- * Rename detection diff family, while detecting exact matches,
- has been greatly optimized.
+ * "git ls-files" learned "--exclude-standard" to use the canned set of
+ exclude files.
- * Example update and post-receive hooks have been improved.
+ * "git tag -a -f existing" begins the editor session using the existing
+ annotation message.
+
+ * "git tag -m one -m bar" (multiple -m options) behaves similarly to
+ "git commit"; the parameters to -m options are formatted as separate
+ paragraphs.
+
+ * "git cvsexportcommit" learned -w option to specify and switch to the
+ CVS working directory.
+
+ * "git checkout" from a subdirectory learned to use "../path" to allow
+ checking out a path outside the current directory without cd'ing up.
+
+ * "git send-email --dry-run" shows full headers for easier diagnosis.
+
+ * "git merge-ours" is now built-in.
+
+ * "git svn" learned "info" and "show-externals" subcommands.
+
+ * "git svn" run from a subdirectory failed to read settings from the
+ .git/config.
+
+ * "git svn" learned --use-log-author option, which picks up more
+ descriptive name from From: and Signed-off-by: lines in the commit
+ message.
+
+ * "git status" from a subdirectory now shows relative paths which makes
+ copy-and-pasting for git-checkout/git-add/git-rm easier.
+
+ * "git checkout" from and to detached HEAD leaves a bit more
+ information in the reflog.
* In addition there are quite a few internal clean-ups. Notably
All of the fixes in v1.5.3 maintenance series are included in
this release, unless otherwise noted.
- * git-svn talking with the SVN over http will correctly quote branch
- and project names.
+These fixes are only in v1.5.4 and not backported to v1.5.3 maintenance
+series.
- * "git rev-list --objects A..B" choked when the lower boundary
- of the range involved a subproject. This fix is also queued
- for 'maint' (but not in there yet).
+ * "git svn" talking with the SVN over http will correctly quote branch
+ and project names.
--
exec >/var/tmp/1
-O=v1.5.3.6-727-g5d3d1ca
+O=v1.5.3.7-1003-gf38ca7c
echo O=`git describe refs/heads/master`
git shortlog --no-merges $O..refs/heads/master ^refs/heads/maint
}
if (my ($verify_name, $text) = ($description =~ /^($name) - (.*)/)) {
print $out "gitlink:$name\[1\]::\n\t";
- if ($attr) {
- print $out "($attr) ";
+ if ($attr =~ / deprecated /) {
+ print $out "(deprecated) ";
}
print $out "$text.\n\n";
}
}
my %cmds = ();
-while (<DATA>) {
+for (sort <>) {
next if /^#/;
chomp;
my ($name, $cat, $attr) = /^(\S+)\s+(.*?)(?:\s+(.*))?$/;
- push @{$cmds{$cat}}, [$name, $attr];
+ $attr = '' unless defined $attr;
+ push @{$cmds{$cat}}, [$name, " $attr "];
}
for my $cat (qw(ancillaryinterrogators
rename "$out+", "$out";
}
}
-
-# The following list is sorted with "sort -d" to make it easier
-# to find entry in the resulting git.html manual page.
-__DATA__
-git-add mainporcelain
-git-am mainporcelain
-git-annotate ancillaryinterrogators
-git-apply plumbingmanipulators
-git-archimport foreignscminterface
-git-archive mainporcelain
-git-bisect mainporcelain
-git-blame ancillaryinterrogators
-git-branch mainporcelain
-git-bundle mainporcelain
-git-cat-file plumbinginterrogators
-git-check-attr purehelpers
-git-checkout mainporcelain
-git-checkout-index plumbingmanipulators
-git-check-ref-format purehelpers
-git-cherry ancillaryinterrogators
-git-cherry-pick mainporcelain
-git-citool mainporcelain
-git-clean mainporcelain
-git-clone mainporcelain
-git-commit mainporcelain
-git-commit-tree plumbingmanipulators
-git-config ancillarymanipulators
-git-count-objects ancillaryinterrogators
-git-cvsexportcommit foreignscminterface
-git-cvsimport foreignscminterface
-git-cvsserver foreignscminterface
-git-daemon synchingrepositories
-git-describe mainporcelain
-git-diff mainporcelain
-git-diff-files plumbinginterrogators
-git-diff-index plumbinginterrogators
-git-diff-tree plumbinginterrogators
-git-fast-import ancillarymanipulators
-git-fetch mainporcelain
-git-fetch-pack synchingrepositories
-git-filter-branch ancillarymanipulators
-git-fmt-merge-msg purehelpers
-git-for-each-ref plumbinginterrogators
-git-format-patch mainporcelain
-git-fsck ancillaryinterrogators
-git-gc mainporcelain
-git-get-tar-commit-id ancillaryinterrogators
-git-grep mainporcelain
-git-gui mainporcelain
-git-hash-object plumbingmanipulators
-git-http-fetch synchelpers
-git-http-push synchelpers
-git-imap-send foreignscminterface
-git-index-pack plumbingmanipulators
-git-init mainporcelain
-git-instaweb ancillaryinterrogators
-gitk mainporcelain
-git-log mainporcelain
-git-lost-found ancillarymanipulators deprecated
-git-ls-files plumbinginterrogators
-git-ls-remote plumbinginterrogators
-git-ls-tree plumbinginterrogators
-git-mailinfo purehelpers
-git-mailsplit purehelpers
-git-merge mainporcelain
-git-merge-base plumbinginterrogators
-git-merge-file plumbingmanipulators
-git-merge-index plumbingmanipulators
-git-merge-one-file purehelpers
-git-mergetool ancillarymanipulators
-git-merge-tree ancillaryinterrogators
-git-mktag plumbingmanipulators
-git-mktree plumbingmanipulators
-git-mv mainporcelain
-git-name-rev plumbinginterrogators
-git-pack-objects plumbingmanipulators
-git-pack-redundant plumbinginterrogators
-git-pack-refs ancillarymanipulators
-git-parse-remote synchelpers
-git-patch-id purehelpers
-git-peek-remote purehelpers
-git-prune ancillarymanipulators
-git-prune-packed plumbingmanipulators
-git-pull mainporcelain
-git-push mainporcelain
-git-quiltimport foreignscminterface
-git-read-tree plumbingmanipulators
-git-rebase mainporcelain
-git-receive-pack synchelpers
-git-reflog ancillarymanipulators
-git-relink ancillarymanipulators
-git-remote ancillarymanipulators
-git-repack ancillarymanipulators
-git-request-pull foreignscminterface
-git-rerere ancillaryinterrogators
-git-reset mainporcelain
-git-revert mainporcelain
-git-rev-list plumbinginterrogators
-git-rev-parse ancillaryinterrogators
-git-rm mainporcelain
-git-runstatus ancillaryinterrogators
-git-send-email foreignscminterface
-git-send-pack synchingrepositories
-git-shell synchelpers
-git-shortlog mainporcelain
-git-show mainporcelain
-git-show-branch ancillaryinterrogators
-git-show-index plumbinginterrogators
-git-show-ref plumbinginterrogators
-git-sh-setup purehelpers
-git-stash mainporcelain
-git-status mainporcelain
-git-stripspace purehelpers
-git-submodule mainporcelain
-git-svn foreignscminterface
-git-symbolic-ref plumbingmanipulators
-git-tag mainporcelain
-git-tar-tree plumbinginterrogators deprecated
-git-unpack-file plumbinginterrogators
-git-unpack-objects plumbingmanipulators
-git-update-index plumbingmanipulators
-git-update-ref plumbingmanipulators
-git-update-server-info synchingrepositories
-git-upload-archive synchelpers
-git-upload-pack synchelpers
-git-var plumbinginterrogators
-git-verify-pack plumbinginterrogators
-git-verify-tag ancillaryinterrogators
-git-whatchanged ancillaryinterrogators
-git-write-tree plumbingmanipulators
option values containing whitespace characters are currently not
supported.
+branch.<name>.rebase::
+ When true, rebase the branch <name> on top of the fetched branch,
+ instead of merging the default branch from the default remote.
+ *NOTE*: this is a possibly dangerous operation; do *not* use
+ it unless you understand the implications (see gitlink:git-rebase[1]
+ for details).
+
clean.requireForce::
A boolean to make git-clean do nothing unless given -f
or -n. Defaults to true.
rerere.enabled::
Activate recording of resolved conflicts, so that identical
conflict hunks can be resolved automatically, should they
- be encountered again. See gitlink:git-rerere[1].
+ be encountered again. gitlink:git-rerere[1] command is by
+ default enabled, but can be disabled by setting this option to
+ false.
gitcvs.enabled::
Whether the CVS server interface is enabled for this repository.
is one of "ext" and "pserver") to make them apply only for the given
access method.
+http.proxy::
+ Override the HTTP proxy, normally configured using the 'http_proxy'
+ environment variable (see gitlink:curl[1]). This can be overridden
+ on a per-remote basis; see remote.<name>.proxy
+
http.sslVerify::
Whether to verify the SSL certificate when fetching or pushing
over HTTPS. Can be overridden by the 'GIT_SSL_NO_VERIFY' environment
The URL of a remote repository. See gitlink:git-fetch[1] or
gitlink:git-push[1].
+remote.<name>.proxy::
+ For remotes that require curl (http, https and ftp), the URL to
+ the proxy to use for that remote. Set to the empty string to
+ disable proxying for that remote.
+
remote.<name>.fetch::
The default set of "refspec" for gitlink:git-fetch[1]. See
gitlink:git-fetch[1].
[verse]
'git-branch' [--color | --no-color] [-r | -a]
[-v [--abbrev=<length> | --no-abbrev]]
+ [--contains <commit>]
'git-branch' [--track | --no-track] [-l] [-f] <branchname> [<start-point>]
'git-branch' (-m | -M) [<oldbranch>] <newbranch>
'git-branch' (-d | -D) [-r] <branchname>...
will be shown, the current branch will be highlighted with an asterisk.
Option `-r` causes the remote-tracking branches to be listed,
and option `-a` shows both.
+With `--contains <commit>`, shows only the branches that
+contains the named commit (in other words, the branches whose
+tip commits are descendant of the named commit).
In its second form, a new branch named <branchname> will be created.
It will start out with a head equal to the one given as <start-point>.
With a `-d` or `-D` option, `<branchname>` will be deleted. You may
specify more than one branch for deletion. If the branch currently
-has a reflog then the reflog will also be deleted. Use -r together with -d
-to delete remote-tracking branches.
+has a reflog then the reflog will also be deleted.
+
+Use -r together with -d to delete remote-tracking branches. Note, that it
+only makes sense to delete remote-tracking branches if they no longer exist
+in remote repository or if gitlink:git-fetch[1] was configured not to fetch
+them again. See also 'prune' subcommand of gitlink:git-remote[1] for way to
+clean up all obsolete remote-tracking branches.
OPTIONS
-------
-d::
- Delete a branch. The branch must be fully merged.
+ Delete a branch. The branch must be fully merged in HEAD.
-D::
- Delete a branch irrespective of its index status.
+ Delete a branch irrespective of its merged status.
-l::
Create the branch's reflog. This activates recording of
$ git branch -D test <2>
------------
+
-<1> Delete remote-tracking branches "todo", "html", "man"
-<2> Delete "test" branch even if the "master" branch does not have all
-commits from test branch.
+<1> Delete remote-tracking branches "todo", "html", "man". Next 'fetch' or
+'pull' will create them again unless you configure them not to. See
+gitlink:git-fetch[1].
+<2> Delete "test" branch even if the "master" branch (or whichever branch is
+currently checked out) does not have all commits from test branch.
Notes
[verse]
'git-commit' [-a | --interactive] [-s] [-v] [-u]
[(-c | -C) <commit> | -F <file> | -m <msg> | --amend]
- [--no-verify] [-e] [--author <author>]
+ [--
allow-empty] [--no-verify] [-e] [--author <author>]
[--] [[-i | -o ]<file>...]
DESCRIPTION
This option bypasses the pre-commit hook.
See also link:hooks.html[hooks].
+--allow-empty::
+ Usually recording a commit that has the exact same tree as its
+ sole parent commit is a mistake, and the command prevents you
+ from making such a commit. This option bypasses the safety, and
+ is primarily for use by foreign scm interface scripts.
+
-e|--edit::
The message taken from file with `-F`, command line with
`-m`, and from file with `-C` are usually used as the
'git-config' [<file-option>] --rename-section old_name new_name
'git-config' [<file-option>] --remove-section name
'git-config' [<file-option>] [-z|--null] -l | --list
+'git-config' [<file-option>] --get-color name [default]
DESCRIPTION
-----------
output without getting confused e.g. by values that
contain line breaks.
+--get-color name default::
+
+ Find the color configured for `name` (e.g. `color.diff.new`) and
+ output it as the ANSI color escape sequence to the standard
+ output. The optional `default` parameter is used instead, if
+ there is no color configured for `name`.
[[FILES]]
FILES
% git config core.gitproxy '"proxy-command" for example.com'
------------
+An example to use customized color from the configuration in your
+script:
+
+------------
+#!/bin/sh
+WS=$(git config --get-color color.diff.whitespace "blue reverse")
+RESET=$(git config --get-color "" "reset")
+echo "${WS}your whitespace color or blue reverse${RESET}"
+------------
include::config.txt[]
--- /dev/null
+git-fast-export(1)
+==================
+
+NAME
+----
+git-fast-export - Git data exporter
+
+
+SYNOPSIS
+--------
+'git-fast-export [options]' | 'git-fast-import'
+
+DESCRIPTION
+-----------
+This program dumps the given revisions in a form suitable to be piped
+into gitlink:git-fast-import[1].
+
+You can use it as a human readable bundle replacement (see
+gitlink:git-bundle[1]), or as a kind of an interactive
+gitlink:git-filter-branch[1].
+
+
+OPTIONS
+-------
+--progress=<n>::
+ Insert 'progress' statements every <n> objects, to be shown by
+ gitlink:git-fast-import[1] during import.
+
+--signed-tags=(verbatim|warn|strip|abort)::
+ Specify how to handle signed tags. Since any transformation
+ after the export can change the tag names (which can also happen
+ when excluding revisions) the signatures will not match.
++
+When asking to 'abort' (which is the default), this program will die
+when encountering a signed tag. With 'strip', the tags will be made
+unsigned, with 'verbatim', they will be silently exported
+and with 'warn', they will be exported, but you will see a warning.
+
+
+EXAMPLES
+--------
+
+-------------------------------------------------------------------
+$ git fast-export --all | (cd /empty/repository && git fast-import)
+-------------------------------------------------------------------
+
+This will export the whole repository and import it into the existing
+empty repository. Except for reencoding commits that are not in
+UTF-8, it would be a one-to-one mirror.
+
+-----------------------------------------------------
+$ git fast-export master~5..master |
+ sed "s|refs/heads/master|refs/heads/other|" |
+ git fast-import
+-----------------------------------------------------
+
+This makes a new branch called 'other' from 'master~5..master'
+(i.e. if 'master' has linear history, it will take the last 5 commits).
+
+Note that this assumes that none of the blobs and commit messages
+referenced by that revision range contains the string
+'refs/heads/master'.
+
+
+Limitations
+-----------
+
+Since gitlink:git-fast-import[1] cannot tag trees, you will not be
+able to export the linux-2.6.git repository completely, as it contains
+a tag referencing a tree instead of a commit.
+
+
+Author
+------
+Written by Johannes E. Schindelin <johannes.schindelin@gmx.de>.
+
+Documentation
+--------------
+Documentation by Johannes E. Schindelin <johannes.schindelin@gmx.de>.
+
+GIT
+---
+Part of the gitlink:git[7] suite
--- /dev/null
+git-help(1)
+===========
+
+NAME
+----
+git-help - display help information about git
+
+SYNOPSIS
+--------
+'git help' [-a|--all] [COMMAND]
+
+DESCRIPTION
+-----------
+
+With no options and no COMMAND given, the synopsis of the 'git'
+command and a list of the most commonly used git commands are printed
+on the standard output.
+
+If the option '--all' or '-a' is given, then all available commands are
+printed on the standard output.
+
+If a git command is named, a manual page for that command is brought
+up. The 'man' program is used by default for this purpose.
+
+Note that 'git --help ...' is identical as 'git help ...' because the
+former is internally converted into the latter.
+
+OPTIONS
+-------
+-a|--all::
+
+ Prints all the available commands on the standard output. This
+ option superseeds any other option.
+
+Author
+------
+Written by Junio C Hamano <gitster@pobox.com> and the git-list
+<git@vger.kernel.org>.
+
+Documentation
+-------------
+Initial documentation was part of the gitlink:git[7] man page.
+Christian Couder <chriscool@tuxfamily.org> extracted and rewrote it a
+little. Maintenance is done by the git-list <git@vger.kernel.org>.
+
+GIT
+---
+Part of the gitlink:git[7] suite
DESCRIPTION
-----------
-Lists the references the remote repository has, and optionally
-stores them in the local repository under the same name.
+This command is deprecated; use `git-ls-remote` instead.
OPTIONS
-------
SYNOPSIS
--------
-'git-prune' [-n] [--] [<head>...]
+'git-prune' [-n] [--expire <expire>] [--] [<head>...]
DESCRIPTION
-----------
\--::
Do not interpret any more arguments as options.
+\--expire <time>::
+ Only expire loose objects older than <time>.
+
<head>...::
In addition to objects
reachable from any of our references, keep objects
include::merge-strategies.txt[]
+\--rebase::
+ Instead of a merge, perform a rebase after fetching.
+ *NOTE:* This is a potentially _dangerous_ mode of operation.
+ It rewrites history, which does not bode well when you
+ published that history already. Do *not* use this option
+ unless you have read gitlink:git-rebase[1] carefully.
+
+\--no-rebase::
+ Override earlier \--rebase.
+
DEFAULT BEHAVIOUR
-----------------
Instead of naming each ref to push, specifies that all
refs under `$GIT_DIR/refs/heads/` be pushed.
+\--mirror::
+ Instead of naming each ref to push, specifies that all
+ refs under `$GIT_DIR/refs/heads/` and `$GIT_DIR/refs/tags/`
+ be mirrored to the remote repository. Newly created local
+ refs will be pushed to the remote end, locally updated refs
+ will be force updated on the remote end, and deleted refs
+ will be removed from the remote end.
+
\--dry-run::
Do everything except actually send the updates.
initial manual merge, and later by noticing the same automerge
results and applying the previously recorded hand resolution.
-[NOTE]
-You need to set the config variable rerere.enabled to enable this
-command.
-
COMMANDS
--------
and the destination side (after the colon). The ref to be
pushed is determined by finding a match that matches the source
side, and where it is pushed is determined by using the
-destination side.
+destination side. The rules used to match a ref are the same
+rules used by gitlink:git-rev-parse[1] to resolve a symbolic ref
+name.
- It is an error if <src> does not match exactly one of the
local refs.
Typing "git tag" without arguments, also lists all tags.
-m <msg>::
- Use the given tag message (instead of prompting)
+ Use the given tag message (instead of prompting).
+ If multiple `-m` options are given, there values are
+ concatenated as separate paragraphs.
-F <file>::
Take the tag message from the given file. Use '-' to
* link:v1.5.3/git.html[documentation for release 1.5.3]
* release notes for
+ link:RelNotes-1.5.3.7.txt[1.5.3.7],
link:RelNotes-1.5.3.6.txt[1.5.3.6],
link:RelNotes-1.5.3.5.txt[1.5.3.5],
link:RelNotes-1.5.3.4.txt[1.5.3.4],
--help::
Prints the synopsis and a list of the most commonly used
- commands. If a git command is named this option will bring up
- the man-page for that command. If the option '--all' or '-a' is
- given then all available commands are printed.
+ commands. If the option '--all' or '-a' is given then all
+ available commands are printed. If a git command is named this
+ option will bring up the manual page for that command.
--exec-path::
Path to wherever your core git programs are installed.
-------
* git's founding father is Linus Torvalds <torvalds@osdl.org>.
* The current git nurse is Junio C Hamano <gitster@pobox.com>.
-* The git potty was written by Andres Ericsson <ae@op5.se>.
+* The git potty was written by Andre
as Ericsson <ae@op5.se>.
* General upbringing is handled by the git-list <git@vger.kernel.org>.
Documentation
--- /dev/null
+From: Junio C Hamano <gitster@pobox.com>
+Date: Wed, 21 Nov 2007 16:32:55 -0800
+Subject: Addendum to "MaintNotes"
+Abstract: Imagine that git development is racing along as usual, when our friendly
+ neighborhood maintainer is struck down by a wayward bus. Out of the
+ hordes of suckers (loyal developers), you have been tricked (chosen) to
+ step up as the new maintainer. This howto will show you "how to" do it.
+
+The maintainer's git time is spent on three activities.
+
+ - Communication (60%)
+
+ Mailing list discussions on general design, fielding user
+ questions, diagnosing bug reports; reviewing, commenting on,
+ suggesting alternatives to, and rejecting patches.
+
+ - Integration (30%)
+
+ Applying new patches from the contributors while spotting and
+ correcting minor mistakes, shuffling the integration and
+ testing branches, pushing the results out, cutting the
+ releases, and making announcements.
+
+ - Own development (10%)
+
+ Scratching my own itch and sending proposed patch series out.
+
+The policy on Integration is informally mentioned in "A Note
+from the maintainer" message, which is periodically posted to
+this mailing list after each feature release is made.
+
+The policy.
+
+ - Feature releases are numbered as vX.Y.Z and are meant to
+ contain bugfixes and enhancements in any area, including
+ functionality, performance and usability, without regression.
+
+ - Maintenance releases are numbered as vX.Y.Z.W and are meant
+ to contain only bugfixes for the corresponding vX.Y.Z feature
+ release and earlier maintenance releases vX.Y.Z.V (V < W).
+
+ - 'master' branch is used to prepare for the next feature
+ release. In other words, at some point, the tip of 'master'
+ branch is tagged with vX.Y.Z.
+
+ - 'maint' branch is used to prepare for the next maintenance
+ release. After the feature release vX.Y.Z is made, the tip
+ of 'maint' branch is set to that release, and bugfixes will
+ accumulate on the branch, and at some point, the tip of the
+ branch is tagged with vX.Y.Z.1, vX.Y.Z.2, and so on.
+
+ - 'next' branch is used to publish changes (both enhancements
+ and fixes) that (1) have worthwhile goal, (2) are in a fairly
+ good shape suitable for everyday use, (3) but have not yet
+ demonstrated to be regression free. New changes are tested
+ in 'next' before merged to 'master'.
+
+ - 'pu' branch is used to publish other proposed changes that do
+ not yet pass the criteria set for 'next'.
+
+ - The tips of 'master', 'maint' and 'next' branches will always
+ fast forward, to allow people to build their own
+ customization on top of them.
+
+ - Usually 'master' contains all of 'maint', 'next' contains all
+ of 'master' and 'pu' contains all of 'next'.
+
+ - The tip of 'master' is meant to be more stable than any
+ tagged releases, and the users are encouraged to follow it.
+
+ - The 'next' branch is where new action takes place, and the
+ users are encouraged to test it so that regressions and bugs
+ are found before new topics are merged to 'master'.
+
+
+A typical git day for the maintainer implements the above policy
+by doing the following:
+
+ - Scan mailing list and #git channel log. Respond with review
+ comments, suggestions etc. Kibitz. Collect potentially
+ usable patches from the mailing list. Patches about a single
+ topic go to one mailbox (I read my mail in Gnus, and type
+ \C-o to save/append messages in files in mbox format).
+
+ - Review the patches in the saved mailboxes. Edit proposed log
+ message for typofixes and clarifications, and add Acks
+ collected from the list. Edit patch to incorporate "Oops,
+ that should have been like this" fixes from the discussion.
+
+ - Classify the collected patches and handle 'master' and
+ 'maint' updates:
+
+ - Obviously correct fixes that pertain to the tip of 'maint'
+ are directly applied to 'maint'.
+
+ - Obviously correct fixes that pertain to the tip of 'master'
+ are directly applied to 'master'.
+
+ This step is done with "git am".
+
+ $ git checkout master ;# or "git checkout maint"
+ $ git am -3 -s mailbox
+ $ make test
+
+ - Merge downwards (maint->master):
+
+ $ git checkout master
+ $ git merge maint
+ $ make test
+
+ - Review the last issue of "What's cooking" message, review the
+ topics scheduled for merging upwards (topic->master and
+ topic->maint), and merge.
+
+ $ git checkout master ;# or "git checkout maint"
+ $ git merge ai/topic ;# or "git merge ai/maint-topic"
+ $ git log -p ORIG_HEAD.. ;# final review
+ $ git diff ORIG_HEAD.. ;# final review
+ $ make test ;# final review
+ $ git branch -d ai/topic ;# or "git branch -d ai/maint-topic"
+
+ - Merge downwards (maint->master) if needed:
+
+ $ git checkout master
+ $ git merge maint
+ $ make test
+
+ - Merge downwards (master->next) if needed:
+
+ $ git checkout next
+ $ git merge master
+ $ make test
+
+ - Handle the remaining patches:
+
+ - Anything unobvious that is applicable to 'master' (in other
+ words, does not depend on anything that is still in 'next'
+ and not in 'master') is applied to a new topic branch that
+ is forked from the tip of 'master'. This includes both
+ enhancements and unobvious fixes to 'master'. A topic
+ branch is named as ai/topic where "ai" is typically
+ author's initial and "topic" is a descriptive name of the
+ topic (in other words, "what's the series is about").
+
+ - An unobvious fix meant for 'maint' is applied to a new
+ topic branch that is forked from the tip of 'maint'. The
+ topic is named as ai/maint-topic.
+
+ - Changes that pertain to an existing topic are applied to
+ the branch, but:
+
+ - obviously correct ones are applied first;
+
+ - questionable ones are discarded or applied to near the tip;
+
+ - Replacement patches to an existing topic are accepted only
+ for commits not in 'next'.
+
+ The above except the "replacement" are all done with:
+
+ $ git am -3 -s mailbox
+
+ while patch replacement is often done by:
+
+ $ git format-patch ai/topic~$n..ai/topic ;# export existing
+
+ then replace some parts with the new patch, and reapplying:
+
+ $ git reset --hard ai/topic~$n
+ $ git am -3 -s 000*.txt
+
+ The full test suite is always run for 'maint' and 'master'
+ after patch application; for topic branches the tests are run
+ as time permits.
+
+ - Update "What's cooking" message to review the updates to
+ existing topics, newly added topics and graduated topics.
+
+ This step is helped with Meta/UWC script (where Meta/ contains
+ a checkout of the 'todo' branch).
+
+ - Merge topics to 'next'. For each branch whose tip is not
+ merged to 'next', one of three things can happen:
+
+ - The commits are all next-worthy; merge the topic to next:
+
+ $ git checkout next
+ $ git merge ai/topic ;# or "git merge ai/maint-topic"
+ $ make test
+
+ - The new parts are of mixed quality, but earlier ones are
+ next-worthy; merge the early parts to next:
+
+ $ git checkout next
+ $ git merge ai/topic~2 ;# the tip two are dubious
+ $ make test
+
+ - Nothing is next-worthy; do not do anything.
+
+ - Rebase topics that do not have any commit in next yet. This
+ step is optional but sometimes is worth doing when an old
+ series that is not in next can take advantage of low-level
+ framework change that is merged to 'master' already.
+
+ $ git rebase master ai/topic
+
+ This step is helped with Meta/git-topic.perl script to
+ identify which topic is rebaseable. There also is a
+ pre-rebase hook to make sure that topics that are already in
+ 'next' are not rebased beyond the merged commit.
+
+ - Rebuild "pu" to merge the tips of topics not in 'next'.
+
+ $ git checkout pu
+ $ git reset --hard next
+ $ git merge ai/topic ;# repeat for all remaining topics
+ $ make test
+
+ This step is helped with Meta/PU script
+
+ - Push four integration branches to a private repository at
+ k.org and run "make test" on all of them.
+
+ - Push four integration branches to /pub/scm/git/git.git at
+ k.org. This triggers its post-update hook which:
+
+ (1) runs "git pull" in $HOME/git-doc/ repository to pull
+ 'master' just pushed out;
+
+ (2) runs "make doc" in $HOME/git-doc/, install the generated
+ documentation in staging areas, which are separate
+ repositories that have html and man branches checked
+ out.
+
+ (3) runs "git commit" in the staging areas, and run "git
+ push" back to /pub/scm/git/git.git/ to update the html
+ and man branches.
+
+ (4) installs generated documentation to /pub/software/scm/git/docs/
+ to be viewed from http://www.kernel.org/
+
+ - Fetch html and man branches back from k.org, and push four
+ integration branches and the two documentation branches to
+ repo.or.cz
+
+
+Some observations to be made.
+
+ * Each topic is tested individually, and also together with
+ other topics cooking in 'next'. Until it matures, none part
+ of it is merged to 'master'.
+
+ * A topic already in 'next' can get fixes while still in
+ 'next'. Such a topic will have many merges to 'next' (in
+ other words, "git log --first-parent next" will show many
+ "Merge ai/topic to next" for the same topic.
+
+ * An unobvious fix for 'maint' is cooked in 'next' and then
+ merged to 'master' to make extra sure it is Ok and then
+ merged to 'maint'.
+
+ * Even when 'next' becomes empty (in other words, all topics
+ prove stable and are merged to 'master' and "git diff master
+ next" shows empty), it has tons of merge commits that will
+ never be in 'master'.
+
+ * In principle, "git log --first-parent master..next" should
+ show nothing but merges (in practice, there are fixup commits
+ and reverts that are not merges).
+
+ * Commits near the tip of a topic branch that are not in 'next'
+ are fair game to be discarded, replaced or rewritten.
+ Commits already merged to 'next' will not be.
+
+ * Being in the 'next' branch is not a guarantee for a topic to
+ be included in the next feature release. Being in the
+ 'master' branch typically is.
The initial clone may be time-consuming for a large project, but you
will only need to clone once.
-The clone command creates a new directory named after the project
-("git" or "linux-2.6" in the examples above). After you cd into this
+The clone command creates a new directory named after the project ("git"
+or "linux-2.6" in the examples above). After you cd into this
directory, you will see that it contains a copy of the project files,
-together with a special top-level directory named ".git", which
-contains all the information about the history of the project.
+called the <<def_working_tree,working tree>>, together with a special
+top-level directory named ".git", which contains all the information
+about the history of the project.
[[how-to-check-out]]
How to check out a different version of a project
interrelated snapshots of the project's contents. In git each such
version is called a <<def_commit,commit>>.
-A single git repository may contain multiple branches. It keeps track
-of them by keeping a list of <<def_head,heads>> which reference the
+Those snapshots aren't necessarily all arranged in a single line from
+oldest to newest; instead, work may simultaneously proceed along
+parallel lines of development, called <def_branch,branches>>, which may
+merge and diverge.
+
+A single git repository can track development on multiple branches. It
+does this by keeping a list of <<def_head,heads>> which reference the
latest commit on each branch; the gitlink:git-branch[1] command shows
you the list of branch heads:
conflicts manually, just as in the case of <<resolving-a-merge,
resolving a merge>>.
-[[fixing-a-mistake-by-editing-history]]
-Fixing a mistake by editing history
+[[fixing-a-mistake-by-rewriting-history]]
+Fixing a mistake by rewriting history
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
If the problematic commit is the most recent commit, and you have not
been merged into another branch; use gitlink:git-revert[1] instead in
that case.
-It is also possible to edit commits further back in the history, but
+It is also possible to replace commits further back in the history, but
this is an advanced topic to be left for
<<cleaning-up-history,another chapter>>.
git-gc when run without any options), it is not safe to prune while
other git operations are in progress in the same repository.
+If gitlink:git-fsck[1] complains about sha1 mismatches or missing
+objects, you may have a much more serious problem; your best option is
+probably restoring from backups. See
+<<recovering-from-repository-corruption>> for a detailed discussion.
+
[[recovering-lost-changes]]
Recovering lost changes
~~~~~~~~~~~~~~~~~~~~~~~
$ git push ssh://yourserver.com/~you/proj.git master
-------------------------------------------------
-As with git-fetch, git-push will complain if this does not result in
-a <<fast-forwards,fast forward>>. Normally this is a sign of
-something wrong. However, if you are sure you know what you're
-doing, you may force git-push to perform the update anyway by
-preceding the branch name by a plus sign:
-
--------------------------------------------------
-$ git push ssh://yourserver.com/~you/proj.git +master
--------------------------------------------------
+As with git-fetch, git-push will complain if this does not result in a
+<<fast-forwards,fast forward>>; see the following section for details on
+handling this case.
Note that the target of a "push" is normally a
<<def_bare_repository,bare>> repository. You can also push to a
and remote.<name>.push options in gitlink:git-config[1] for
details.
+[[forcing-push]]
+What to do when a push fails
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+If a push would not result in a <<fast-forwards,fast forward>> of the
+remote branch, then it will fail with an error like:
+
+-------------------------------------------------
+error: remote 'refs/heads/master' is not an ancestor of
+ local 'refs/heads/master'.
+ Maybe you are not up-to-date and need to pull first?
+error: failed to push to 'ssh://yourserver.com/~you/proj.git'
+-------------------------------------------------
+
+This can happen, for example, if you:
+
+ - use `git reset --hard` to remove already-published commits, or
+ - use `git commit --amend` to replace already-published commits
+ (as in <<fixing-a-mistake-by-rewriting-history>>), or
+ - use `git rebase` to rebase any already-published commits (as
+ in <<using-git-rebase>>).
+
+You may force git-push to perform the update anyway by preceding the
+branch name with a plus sign:
+
+-------------------------------------------------
+$ git push ssh://yourserver.com/~you/proj.git +master
+-------------------------------------------------
+
+Normally whenever a branch head in a public repository is modified, it
+is modified to point to a descendent of the commit that it pointed to
+before. By forcing a push in this situation, you break that convention.
+(See <<problems-with-rewriting-history>>.)
+
+Nevertheless, this is a common practice for people that need a simple
+way to publish a work-in-progress patch series, and it is an acceptable
+compromise as long as you warn other developers that this is how you
+intend to manage the branch.
+
+It's also possible for a push to fail in this way when other people have
+the right to push to the same repository. In that case, the correct
+solution is to retry the push after first updating your work by either a
+pull or a fetch followed by a rebase; see the
+<<setting-up-a-shared-repository,next section>> and
+link:cvs-migration.html[git for CVS users] for more.
+
[[setting-up-a-shared-repository]]
Setting up a shared repository
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
$ git rebase --abort
-------------------------------------------------
-[[modifying-one-commit]]
-Modifying a single commit
+[[rewriting-one-commit]]
+Rewriting a single commit
-------------------------
-We saw in <<fixing-a-mistake-by-editing-history>> that you can replace the
+We saw in <<fixing-a-mistake-by-rewriting-history>> that you can replace the
most recent commit using
-------------------------------------------------
which will replace the old commit by a new commit incorporating your
changes, giving you a chance to edit the old commit message first.
-You can also use a combination of this and gitlink:git-rebase[1] to edit
-commits further back in your history. First, tag the problematic commit with
+You can also use a combination of this and gitlink:git-rebase[1] to
+replace a commit further back in your history and recreate the
+intervening changes on top of it. First, tag the problematic commit
+with
-------------------------------------------------
$ git tag bad mywork~5
contrast, running "git prune" while somebody is actively changing the
repository is a *BAD* idea).
+[[recovering-from-repository-corruption]]
+Recovering from repository corruption
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+By design, git treats data trusted to it with caution. However, even in
+the absence of bugs in git itself, it is still possible that hardware or
+operating system errors could corrupt data.
+
+The first defense against such problems is backups. You can back up a
+git directory using clone, or just using cp, tar, or any other backup
+mechanism.
+
+As a last resort, you can search for the corrupted objects and attempt
+to replace them by hand. Back up your repository before attempting this
+in case you corrupt things even more in the process.
+
+We'll assume that the problem is a single missing or corrupted blob,
+which is sometimes a solveable problem. (Recovering missing trees and
+especially commits is *much* harder).
+
+Before starting, verify that there is corruption, and figure out where
+it is with gitlink:git-fsck[1]; this may be time-consuming.
+
+Assume the output looks like this:
+
+------------------------------------------------
+$ git-fsck --full
+broken link from tree 2d9263c6d23595e7cb2a21e5ebbb53655278dff8
+ to blob 4b9458b3786228369c63936db65827de3cc06200
+missing blob 4b9458b3786228369c63936db65827de3cc06200
+------------------------------------------------
+
+(Typically there will be some "dangling object" messages too, but they
+aren't interesting.)
+
+Now you know that blob 4b9458b3 is missing, and that the tree 2d9263c6
+points to it. If you could find just one copy of that missing blob
+object, possibly in some other repository, you could move it into
+.git/objects/4b/9458b3... and be done. Suppose you can't. You can
+still examine the tree that pointed to it with gitlink:git-ls-tree[1],
+which might output something like:
+
+------------------------------------------------
+$ git ls-tree 2d9263c6d23595e7cb2a21e5ebbb53655278dff8
+100644 blob 8d14531846b95bfa3564b58ccfb7913a034323b8 .gitignore
+100644 blob ebf9bf84da0aab5ed944264a5db2a65fe3a3e883 .mailmap
+100644 blob ca442d313d86dc67e0a2e5d584b465bd382cbf5c COPYING
+...
+100644 blob 4b9458b3786228369c63936db65827de3cc06200 myfile
+...
+------------------------------------------------
+
+So now you know that the missing blob was the data for a file named
+"myfile". And chances are you can also identify the directory--let's
+say it's in "somedirectory". If you're lucky the missing copy might be
+the same as the copy you have checked out in your working tree at
+"somedirectory/myfile"; you can test whether that's right with
+gitlink:git-hash-object[1]:
+
+------------------------------------------------
+$ git hash-object -w somedirectory/myfile
+------------------------------------------------
+
+which will create and store a blob object with the contents of
+somedirectory/myfile, and output the sha1 of that object. if you're
+extremely lucky it might be 4b9458b3786228369c63936db65827de3cc06200, in
+which case you've guessed right, and the corruption is fixed!
+
+Otherwise, you need more information. How do you tell which version of
+the file has been lost?
+
+The easiest way to do this is with:
+
+------------------------------------------------
+$ git log --raw --all --full-history -- somedirectory/myfile
+------------------------------------------------
+
+Because you're asking for raw output, you'll now get something like
+
+------------------------------------------------
+commit abc
+Author:
+Date:
+...
+:100644 100644 4b9458b... newsha... M somedirectory/myfile
+
+
+commit xyz
+Author:
+Date:
+
+...
+:100644 100644 oldsha... 4b9458b... M somedirectory/myfile
+------------------------------------------------
+
+This tells you that the immediately preceding version of the file was
+"newsha", and that the immediately following version was "oldsha".
+You also know the commit messages that went with the change from oldsha
+to 4b9458b and with the change from 4b9458b to newsha.
+
+If you've been committing small enough changes, you may now have a good
+shot at reconstructing the contents of the in-between state 4b9458b.
+
+If you can do that, you can now recreate the missing object with
+
+------------------------------------------------
+$ git hash-object -w <recreated-file>
+------------------------------------------------
+
+and your repository is good again!
+
+(Btw, you could have ignored the fsck, and started with doing a
+
+------------------------------------------------
+$ git log --raw --all
+------------------------------------------------
+
+and just looked for the sha of the missing object (4b9458b..) in that
+whole thing. It's up to you - git does *have* a lot of information, it is
+just missing one particular blob version.
+
[[the-index]]
The index
-----------
NOTE! A `--remove` flag does 'not' mean that subsequent filenames will
necessarily be removed: if the files still exist in your directory
structure, the index will be updated with their new status, not
-removed. The only thing `--remove` means is that update-cache will be
+removed. The only thing `--remove` means is that update-index will be
considering a removed file to be a valid thing, and if the file really
does not exist any more, it will update the index accordingly.
Alternates, clone -reference, etc.
-git unpack-objects -r for recovery
+More on recovery from repository corruption. See:
+ http://marc.theaimsgroup.com/?l=git&m=117263864820799&w=2
+ http://marc.theaimsgroup.com/?l=git&m=117147855503798&w=2
+ http://marc.theaimsgroup.com/?l=git&m=117147855503798&w=2
# times (my ext3 doesn't).
#
# Define USE_STDEV below if you want git to care about the underlying device
-# change being considered an inode change from the update-cache perspective.
+# change being considered an inode change from the update-index perspective.
#
# Define ASCIIDOC8 if you want to format documentation with AsciiDoc 8
#
SCRIPT_SH = \
git-bisect.sh git-checkout.sh \
- git-clean.sh git-clone.sh \
- git-ls-remote.sh \
+ git-clone.sh \
git-merge-one-file.sh git-mergetool.sh git-parse-remote.sh \
git-pull.sh git-rebase.sh git-rebase--interactive.sh \
git-repack.sh git-request-pull.sh \
git-fast-import$X \
git-daemon$X \
git-merge-index$X git-mktag$X git-mktree$X git-patch-id$X \
- git-peek-remote$X git-receive-pack$X \
+ git-receive-pack$X \
git-send-pack$X git-shell$X \
git-show-index$X \
git-unpack-file$X \
BUILT_INS = \
git-format-patch$X git-show$X git-whatchanged$X git-cherry$X \
git-get-tar-commit-id$X git-init$X git-repo-config$X \
- git-fsck-objects$X git-cherry-pick$X git-status$X\
+ git-fsck-objects$X git-cherry-pick$X git-peek-remote$X git-status$X \
$(patsubst builtin-%.o,git-%$X,$(BUILTIN_OBJS))
# what 'all' will build and 'install' will install, in gitexecdir
# what 'all' will build but not install in gitexecdir
OTHER_PROGRAMS = git$X gitweb/gitweb.cgi
-ifndef NO_TCLTK
-OTHER_PROGRAMS += gitk-wish
-endif
# Set paths to tools early so that they can be used for version tests.
ifndef SHELL_PATH
builtin-check-attr.o \
builtin-checkout-index.o \
builtin-check-ref-format.o \
+ builtin-clean.o \
builtin-commit.o \
builtin-commit-tree.o \
builtin-count-objects.o \
builtin-diff-files.o \
builtin-diff-index.o \
builtin-diff-tree.o \
+ builtin-fast-export.o \
builtin-fetch.o \
builtin-fetch-pack.o \
builtin-fetch--tool.o \
builtin-log.o \
builtin-ls-files.o \
builtin-ls-tree.o \
+ builtin-ls-remote.o \
builtin-mailinfo.o \
builtin-mailsplit.o \
builtin-merge-base.o \
builtin-push.o \
builtin-read-tree.o \
builtin-reflog.o \
+ builtin-send-pack.o \
builtin-config.o \
builtin-rerere.o \
builtin-reset.o \
LIBS = $(GITLIBS) $(EXTLIBS)
BASIC_CFLAGS += -DSHA1_HEADER='$(SHA1_HEADER_SQ)' \
- -DETC_GITCONFIG='"$(ETC_GITCONFIG_SQ)"' $(COMPAT_CFLAGS)
+ $(COMPAT_CFLAGS)
LIB_OBJS += $(COMPAT_OBJS)
ALL_CFLAGS += $(BASIC_CFLAGS)
all::
ifndef NO_TCLTK
$(QUIET_SUBDIR0)git-gui $(QUIET_SUBDIR1) all
+ $(QUIET_SUBDIR0)gitk-git $(QUIET_SUBDIR1) all
endif
$(QUIET_SUBDIR0)perl $(QUIET_SUBDIR1) PERL_PATH='$(PERL_PATH_SQ)' prefix='$(prefix_SQ)' all
$(QUIET_SUBDIR0)templates $(QUIET_SUBDIR1)
strip: $(PROGRAMS) git$X
$(STRIP) $(STRIP_OPTS) $(PROGRAMS) git$X
-gitk-wish: gitk GIT-GUI-VARS
- $(QUIET_GEN)$(RM) $@ $@+ && \
- sed -e '1,3s|^exec .* "$$0"|exec $(subst |,'\|',$(TCLTK_PATH_SQ)) "$$0"|' <gitk >$@+ && \
- chmod +x $@+ && \
- mv -f $@+ $@
-
git.o: git.c common-cmds.h GIT-CFLAGS
$(QUIET_CC)$(CC) -DGIT_VERSION='"$(GIT_VERSION)"' \
$(ALL_CFLAGS) -c $(filter %.c,$^)
$(BUILT_INS): git$X
$(QUIET_BUILT_IN)$(RM) $@ && ln git$X $@
-common-cmds.h: ./generate-cmdlist.sh
+common-cmds.h: ./generate-cmdlist.sh command-list.txt
common-cmds.h: $(wildcard Documentation/git-*.txt)
$(QUIET_GEN)./generate-cmdlist.sh > $@+ && mv $@+ $@
builtin-init-db.o: builtin-init-db.c GIT-CFLAGS
$(QUIET_CC)$(CC) -o $*.o -c $(ALL_CFLAGS) -DDEFAULT_GIT_TEMPLATE_DIR='"$(template_dir_SQ)"' $<
+config.o: config.c GIT-CFLAGS
+ $(QUIET_CC)$(CC) -o $*.o -c $(ALL_CFLAGS) -DETC_GITCONFIG='"$(ETC_GITCONFIG_SQ)"' $<
+
http.o: http.c GIT-CFLAGS
$(QUIET_CC)$(CC) -o $*.o -c $(ALL_CFLAGS) -DGIT_USER_AGENT='"git/$(GIT_VERSION)"' $<
### Installation rules
install: all
- $(INSTALL) -d -m755 '$(DESTDIR_SQ)$(bindir_SQ)'
- $(INSTALL) -d -m755 '$(DESTDIR_SQ)$(gitexecdir_SQ)'
+ $(INSTALL) -d -m 755 '$(DESTDIR_SQ)$(bindir_SQ)'
+ $(INSTALL) -d -m 755 '$(DESTDIR_SQ)$(gitexecdir_SQ)'
$(INSTALL) $(ALL_PROGRAMS) '$(DESTDIR_SQ)$(gitexecdir_SQ)'
$(INSTALL) git$X '$(DESTDIR_SQ)$(bindir_SQ)'
$(MAKE) -C templates DESTDIR='$(DESTDIR_SQ)' install
$(MAKE) -C perl prefix='$(prefix_SQ)' install
ifndef NO_TCLTK
- $(INSTALL) gitk-wish '$(DESTDIR_SQ)$(bindir_SQ)'/gitk
+ $(MAKE) -C gitk-git install
$(MAKE) -C git-gui install
endif
if test 'z$(bindir_SQ)' != 'z$(gitexecdir_SQ)'; \
$(MAKE) -C templates/ clean
$(MAKE) -C t/ clean
ifndef NO_TCLTK
- $(RM) gitk-wish
+ $(MAKE) -C gitk-git clean
$(MAKE) -C git-gui clean
endif
$(RM) GIT-VERSION-FILE GIT-CFLAGS GIT-GUI-VARS
esac ; \
test -f "Documentation/$$v.txt" || \
echo "no doc: $$v"; \
- sed -e '1,/^__DATA__/d' Documentation/cmd-list.perl | \
+ sed -e '/^#/d' command-list.txt | \
grep -q "^$$v[ ]" || \
case "$$v" in \
git) ;; \
esac ; \
done; \
( \
- sed -e '1,/^__DATA__/d' \
+ sed -e '/^#/d' \
-e 's/[ ].*//' \
- -e 's/^/listed /' Documentation/cmd-list.perl; \
+ -e 's/^/listed /' command-list.txt; \
ls -1 Documentation/git*txt | \
sed -e 's|Documentation/|documented |' \
-e 's/\.txt//'; \
case "$$how,$$cmd" in \
*,git-citool | \
*,git-gui | \
+ *,git-help | \
documented,gitattributes | \
documented,gitignore | \
documented,gitmodules | \
struct ref_list {
int index, alloc, maxwidth;
struct ref_item *list;
+ struct commit_list *with_commit;
int kinds;
};
+static int has_commit(const unsigned char *sha1, struct commit_list *with_commit)
+{
+ struct commit *commit;
+
+ if (!with_commit)
+ return 1;
+ commit = lookup_commit_reference_gently(sha1, 1);
+ if (!commit)
+ return 0;
+ while (with_commit) {
+ struct commit *other;
+
+ other = with_commit->item;
+ with_commit = with_commit->next;
+ if (in_merge_bases(other, &commit, 1))
+ return 1;
+ }
+ return 0;
+}
+
static int append_ref(const char *refname, const unsigned char *sha1, int flags, void *cb_data)
{
struct ref_list *ref_list = (struct ref_list*)(cb_data);
refname += 10;
}
+ /* Filter with with_commit if specified */
+ if (!has_commit(sha1, ref_list->with_commit))
+ return 0;
+
/* Don't add types the caller doesn't want */
if ((kind & ref_list->kinds) == 0)
return 0;
}
}
-static void print_ref_list(int kinds, int detached, int verbose, int abbrev)
+static void print_ref_list(int kinds, int detached, int verbose, int abbrev, struct commit_list *with_commit)
{
int i;
struct ref_list ref_list;
memset(&ref_list, 0, sizeof(ref_list));
ref_list.kinds = kinds;
+ ref_list.with_commit = with_commit;
for_each_ref(append_ref, &ref_list);
qsort(ref_list.list, ref_list.index, sizeof(struct ref_item), ref_cmp);
detached = (detached && (kinds & REF_LOCAL_BRANCH));
- if (detached) {
+ if (detached && has_commit(head_sha1, with_commit)) {
struct ref_item item;
item.name = xstrdup("(no branch)");
item.kind = REF_LOCAL_BRANCH;
die("Branch is renamed, but update of config-file failed");
}
+static int opt_parse_with_commit(const struct option *opt, const char *arg, int unset)
+{
+ unsigned char sha1[20];
+ struct commit *commit;
+
+ if (!arg)
+ return -1;
+ if (get_sha1(arg, sha1))
+ die("malformed object name %s", arg);
+ commit = lookup_commit_reference(sha1);
+ if (!commit)
+ die("no such commit %s", arg);
+ commit_list_insert(commit, opt->value);
+ return 0;
+}
+
int cmd_branch(int argc, const char **argv, const char *prefix)
{
int delete = 0, rename = 0, force_create = 0;
int verbose = 0, abbrev = DEFAULT_ABBREV, detached = 0;
int reflog = 0, track;
int kinds = REF_LOCAL_BRANCH;
+ struct commit_list *with_commit = NULL;
struct option options[] = {
OPT_GROUP("Generic options"),
OPT_BOOLEAN( 0 , "color", &branch_use_color, "use colored output"),
OPT_SET_INT('r', NULL, &kinds, "act on remote-tracking branches",
REF_REMOTE_BRANCH),
+ OPT_CALLBACK(0, "contains", &with_commit, "commit",
+ "print only branches that contain the commit",
+ opt_parse_with_commit),
+ {
+ OPTION_CALLBACK, 0, "with", &with_commit, "commit",
+ "print only branches that contain the commit",
+ PARSE_OPT_HIDDEN, opt_parse_with_commit,
+ },
OPT__ABBREV(&abbrev),
OPT_GROUP("Specific git-branch actions:"),
if (delete)
return delete_branches(argc, argv, delete > 1, kinds);
else if (argc == 0)
- print_ref_list(kinds, detached, verbose, abbrev);
+ print_ref_list(kinds, detached, verbose, abbrev, with_commit);
else if (rename && (argc == 1))
rename_branch(head, argv[0], rename > 1);
else if (rename && (argc == 2))
--- /dev/null
+/*
+ * "git clean" builtin command
+ *
+ * Copyright (C) 2007 Shawn Bohrer
+ *
+ * Based on git-clean.sh by Pavel Roskin
+ */
+
+#include "builtin.h"
+#include "cache.h"
+#include "dir.h"
+#include "parse-options.h"
+
+static int force = -1; /* unset */
+
+static const char *const builtin_clean_usage[] = {
+ "git-clean [-d] [-f] [-n] [-q] [-x | -X] [--] <paths>...",
+ NULL
+};
+
+static int git_clean_config(const char *var, const char *value)
+{
+ if (!strcmp(var, "clean.requireforce"))
+ force = !git_config_bool(var, value);
+ return git_default_config(var, value);
+}
+
+int cmd_clean(int argc, const char **argv, const char *prefix)
+{
+ int j;
+ int show_only = 0, remove_directories = 0, quiet = 0, ignored = 0;
+ int ignored_only = 0, baselen = 0, config_set = 0;
+ struct strbuf directory;
+ struct dir_struct dir;
+ const char *path, *base;
+ static const char **pathspec;
+ struct option options[] = {
+ OPT__QUIET(&quiet),
+ OPT__DRY_RUN(&show_only),
+ OPT_BOOLEAN('f', NULL, &force, "force"),
+ OPT_BOOLEAN('d', NULL, &remove_directories,
+ "remove whole directories"),
+ OPT_BOOLEAN('x', NULL, &ignored, "remove ignored files, too"),
+ OPT_BOOLEAN('X', NULL, &ignored_only,
+ "remove only ignored files"),
+ OPT_END()
+ };
+
+ git_config(git_clean_config);
+ if (force < 0)
+ force = 0;
+ else
+ config_set = 1;
+
+ argc = parse_options(argc, argv, options, builtin_clean_usage, 0);
+
+ memset(&dir, 0, sizeof(dir));
+ if (ignored_only)
+ dir.show_ignored = 1;
+
+ if (ignored && ignored_only)
+ die("-x and -X cannot be used together");
+
+ if (!show_only && !force)
+ die("clean.requireForce%s set and -n or -f not given; "
+ "refusing to clean", config_set ? "" : " not");
+
+ dir.show_other_directories = 1;
+
+ if (!ignored)
+ setup_standard_excludes(&dir);
+
+ pathspec = get_pathspec(prefix, argv);
+ read_cache();
+
+ /*
+ * Calculate common prefix for the pathspec, and
+ * use that to optimize the directory walk
+ */
+ baselen = common_prefix(pathspec);
+ path = ".";
+ base = "";
+ if (baselen)
+ path = base = xmemdupz(*pathspec, baselen);
+ read_directory(&dir, path, base, baselen, pathspec);
+ strbuf_init(&directory, 0);
+
+ for (j = 0; j < dir.nr; ++j) {
+ struct dir_entry *ent = dir.entries[j];
+ int len, pos, specs;
+ struct cache_entry *ce;
+ struct stat st;
+ char *seen;
+
+ /*
+ * Remove the '/' at the end that directory
+ * walking adds for directory entries.
+ */
+ len = ent->len;
+ if (len && ent->name[len-1] == '/')
+ len--;
+ pos = cache_name_pos(ent->name, len);
+ if (0 <= pos)
+ continue; /* exact match */
+ pos = -pos - 1;
+ if (pos < active_nr) {
+ ce = active_cache[pos];
+ if (ce_namelen(ce) == len &&
+ !memcmp(ce->name, ent->name, len))
+ continue; /* Yup, this one exists unmerged */
+ }
+
+ if (!lstat(ent->name, &st) && (S_ISDIR(st.st_mode))) {
+ int matched_path = 0;
+ strbuf_addstr(&directory, ent->name);
+ if (pathspec) {
+ for (specs =0; pathspec[specs]; ++specs)
+ /* nothing */;
+ seen = xcalloc(specs, 1);
+ /* Check if directory was explictly passed as
+ * pathspec. If so we want to remove it */
+ if (match_pathspec(pathspec, ent->name, ent->len,
+ baselen, seen))
+ matched_path = 1;
+ free(seen);
+ }
+ if (show_only && (remove_directories || matched_path)) {
+ printf("Would remove %s\n", directory.buf);
+ } else if (quiet && (remove_directories || matched_path)) {
+ remove_dir_recursively(&directory, 0);
+ } else if (remove_directories || matched_path) {
+ printf("Removing %s\n", directory.buf);
+ remove_dir_recursively(&directory, 0);
+ } else if (show_only) {
+ printf("Would not remove %s\n", directory.buf);
+ } else {
+ printf("Not removing %s\n", directory.buf);
+ }
+ strbuf_reset(&directory);
+ } else {
+ if (show_only) {
+ printf("Would remove %s\n", ent->name);
+ continue;
+ } else if (!quiet) {
+ printf("Removing %s\n", ent->name);
+ }
+ unlink(ent->name);
+ }
+ }
+
+ strbuf_release(&directory);
+ return 0;
+}
#include "builtin.h"
#include "cache.h"
+#include "color.h"
static const char git_config_set_usage[] =
-"git-config [ --global | --system | [ -f | --file ] config-file ] [ --bool | --int ] [ -z | --null ] [--get | --get-all | --get-regexp | --replace-all | --add | --unset | --unset-all] name [value [value_regex]] | --rename-section old_name new_name | --remove-section name | --list";
+"git-config [ --global | --system | [ -f | --file ] config-file ] [ --bool | --int ] [ -z | --null ] [--get | --get-all | --get-regexp | --replace-all | --add | --unset | --unset-all] name [value [value_regex]] | --rename-section old_name new_name | --remove-section name | --list | --get-color var [default]";
static char *key;
static regex_t *key_regexp;
local = repo_config = xstrdup(git_path("config"));
if (home)
global = xstrdup(mkpath("%s/.gitconfig", home));
- system_wide = ETC_GITCONFIG;
+ system_wide = git_etc_gitconfig();
}
key = xstrdup(key_);
return normalized;
}
+static int get_color_found;
+static const char *get_color_slot;
+static char parsed_color[COLOR_MAXLEN];
+
+static int git_get_color_config(const char *var, const char *value)
+{
+ if (!strcmp(var, get_color_slot)) {
+ color_parse(value, var, parsed_color);
+ get_color_found = 1;
+ }
+ return 0;
+}
+
+static int get_color(int argc, const char **argv)
+{
+ /*
+ * grab the color setting for the given slot from the configuration,
+ * or parse the default value if missing, and return ANSI color
+ * escape sequence.
+ *
+ * e.g.
+ * git config --get-color color.diff.whitespace "blue reverse"
+ */
+ const char *def_color = NULL;
+
+ switch (argc) {
+ default:
+ usage(git_config_set_usage);
+ case 2:
+ def_color = argv[1];
+ /* fallthru */
+ case 1:
+ get_color_slot = argv[0];
+ break;
+ }
+
+ get_color_found = 0;
+ parsed_color[0] = '\0';
+ git_config(git_get_color_config);
+
+ if (!get_color_found && def_color)
+ color_parse(def_color, "command line", parsed_color);
+
+ fputs(parsed_color, stdout);
+ return 0;
+}
+
int cmd_config(int argc, const char **argv, const char *prefix)
{
int nongit = 0;
}
}
else if (!strcmp(argv[1], "--system"))
- setenv(CONFIG_ENVIRONMENT, ETC_GITCONFIG, 1);
+ setenv(CONFIG_ENVIRONMENT, git_etc_gitconfig(), 1);
else if (!strcmp(argv[1], "--file") || !strcmp(argv[1], "-f")) {
if (argc < 3)
usage(git_config_set_usage);
return 1;
}
return 0;
- }
- else
+ } else if (!strcmp(argv[1], "--get-color")) {
+ return get_color(argc-2, argv+2);
+ } else
break;
argc--;
argv++;
--- /dev/null
+/*
+ * "git fast-export" builtin command
+ *
+ * Copyright (C) 2007 Johannes E. Schindelin
+ */
+#include "builtin.h"
+#include "cache.h"
+#include "commit.h"
+#include "object.h"
+#include "tag.h"
+#include "diff.h"
+#include "diffcore.h"
+#include "log-tree.h"
+#include "revision.h"
+#include "decorate.h"
+#include "path-list.h"
+#include "utf8.h"
+#include "parse-options.h"
+
+static const char *fast_export_usage[] = {
+ "git-fast-export [rev-list-opts]",
+ NULL
+};
+
+static int progress;
+static enum { VERBATIM, WARN, STRIP, ABORT } signed_tag_mode = ABORT;
+
+static int parse_opt_signed_tag_mode(const struct option *opt,
+ const char *arg, int unset)
+{
+ if (unset || !strcmp(arg, "abort"))
+ signed_tag_mode = ABORT;
+ else if (!strcmp(arg, "verbatim") || !strcmp(arg, "ignore"))
+ signed_tag_mode = VERBATIM;
+ else if (!strcmp(arg, "warn"))
+ signed_tag_mode = WARN;
+ else if (!strcmp(arg, "strip"))
+ signed_tag_mode = STRIP;
+ else
+ return error("Unknown signed-tag mode: %s", arg);
+ return 0;
+}
+
+static struct decoration idnums;
+static uint32_t last_idnum;
+
+static int has_unshown_parent(struct commit *commit)
+{
+ struct commit_list *parent;
+
+ for (parent = commit->parents; parent; parent = parent->next)
+ if (!(parent->item->object.flags & SHOWN) &&
+ !(parent->item->object.flags & UNINTERESTING))
+ return 1;
+ return 0;
+}
+
+/* Since intptr_t is C99, we do not use it here */
+static void mark_object(struct object *object)
+{
+ last_idnum++;
+ add_decoration(&idnums, object, ((uint32_t *)NULL) + last_idnum);
+}
+
+static int get_object_mark(struct object *object)
+{
+ void *decoration = lookup_decoration(&idnums, object);
+ if (!decoration)
+ return 0;
+ return (uint32_t *)decoration - (uint32_t *)NULL;
+}
+
+static void show_progress(void)
+{
+ static int counter = 0;
+ if (!progress)
+ return;
+ if ((++counter % progress) == 0)
+ printf("progress %d objects\n", counter);
+}
+
+static void handle_object(const unsigned char *sha1)
+{
+ unsigned long size;
+ enum object_type type;
+ char *buf;
+ struct object *object;
+
+ if (is_null_sha1(sha1))
+ return;
+
+ object = parse_object(sha1);
+ if (!object)
+ die ("Could not read blob %s", sha1_to_hex(sha1));
+
+ if (object->flags & SHOWN)
+ return;
+
+ buf = read_sha1_file(sha1, &type, &size);
+ if (!buf)
+ die ("Could not read blob %s", sha1_to_hex(sha1));
+
+ mark_object(object);
+
+ printf("blob\nmark :%d\ndata %lu\n", last_idnum, size);
+ if (fwrite(buf, size, 1, stdout) != 1)
+ die ("Could not write blob %s", sha1_to_hex(sha1));
+ printf("\n");
+
+ show_progress();
+
+ object->flags |= SHOWN;
+ free(buf);
+}
+
+static void show_filemodify(struct diff_queue_struct *q,
+ struct diff_options *options, void *data)
+{
+ int i;
+ for (i = 0; i < q->nr; i++) {
+ struct diff_filespec *spec = q->queue[i]->two;
+ if (is_null_sha1(spec->sha1))
+ printf("D %s\n", spec->path);
+ else {
+ struct object *object = lookup_object(spec->sha1);
+ printf("M 0%06o :%d %s\n", spec->mode,
+ get_object_mark(object), spec->path);
+ }
+ }
+}
+
+static const char *find_encoding(const char *begin, const char *end)
+{
+ const char *needle = "\nencoding ";
+ char *bol, *eol;
+
+ bol = memmem(begin, end ? end - begin : strlen(begin),
+ needle, strlen(needle));
+ if (!bol)
+ return git_commit_encoding;
+ bol += strlen(needle);
+ eol = strchrnul(bol, '\n');
+ *eol = '\0';
+ return bol;
+}
+
+static void handle_commit(struct commit *commit, struct rev_info *rev)
+{
+ int saved_output_format = rev->diffopt.output_format;
+ const char *author, *author_end, *committer, *committer_end;
+ const char *encoding, *message;
+ char *reencoded = NULL;
+ struct commit_list *p;
+ int i;
+
+ rev->diffopt.output_format = DIFF_FORMAT_CALLBACK;
+
+ parse_commit(commit);
+ author = strstr(commit->buffer, "\nauthor ");
+ if (!author)
+ die ("Could not find author in commit %s",
+ sha1_to_hex(commit->object.sha1));
+ author++;
+ author_end = strchrnul(author, '\n');
+ committer = strstr(author_end, "\ncommitter ");
+ if (!committer)
+ die ("Could not find committer in commit %s",
+ sha1_to_hex(commit->object.sha1));
+ committer++;
+ committer_end = strchrnul(committer, '\n');
+ message = strstr(committer_end, "\n\n");
+ encoding = find_encoding(committer_end, message);
+ if (message)
+ message += 2;
+
+ if (commit->parents) {
+ parse_commit(commit->parents->item);
+ diff_tree_sha1(commit->parents->item->tree->object.sha1,
+ commit->tree->object.sha1, "", &rev->diffopt);
+ }
+ else
+ diff_root_tree_sha1(commit->tree->object.sha1,
+ "", &rev->diffopt);
+
+ for (i = 0; i < diff_queued_diff.nr; i++)
+ handle_object(diff_queued_diff.queue[i]->two->sha1);
+
+ mark_object(&commit->object);
+ if (!is_encoding_utf8(encoding))
+ reencoded = reencode_string(message, "UTF-8", encoding);
+ printf("commit %s\nmark :%d\n%.*s\n%.*s\ndata %u\n%s",
+ (const char *)commit->util, last_idnum,
+ (int)(author_end - author), author,
+ (int)(committer_end - committer), committer,
+ (unsigned)(reencoded
+ ? strlen(reencoded) : message
+ ? strlen(message) : 0),
+ reencoded ? reencoded : message ? message : "");
+ if (reencoded)
+ free(reencoded);
+
+ for (i = 0, p = commit->parents; p; p = p->next) {
+ int mark = get_object_mark(&p->item->object);
+ if (!mark)
+ continue;
+ if (i == 0)
+ printf("from :%d\n", mark);
+ else if (i == 1)
+ printf("merge :%d", mark);
+ else
+ printf(" :%d", mark);
+ i++;
+ }
+ if (i > 1)
+ printf("\n");
+
+ log_tree_diff_flush(rev);
+ rev->diffopt.output_format = saved_output_format;
+
+ printf("\n");
+
+ show_progress();
+}
+
+static void handle_tail(struct object_array *commits, struct rev_info *revs)
+{
+ struct commit *commit;
+ while (commits->nr) {
+ commit = (struct commit *)commits->objects[commits->nr - 1].item;
+ if (has_unshown_parent(commit))
+ return;
+ handle_commit(commit, revs);
+ commits->nr--;
+ }
+}
+
+static void handle_tag(const char *name, struct tag *tag)
+{
+ unsigned long size;
+ enum object_type type;
+ char *buf;
+ const char *tagger, *tagger_end, *message;
+ size_t message_size = 0;
+
+ buf = read_sha1_file(tag->object.sha1, &type, &size);
+ if (!buf)
+ die ("Could not read tag %s", sha1_to_hex(tag->object.sha1));
+ message = memmem(buf, size, "\n\n", 2);
+ if (message) {
+ message += 2;
+ message_size = strlen(message);
+ }
+ tagger = memmem(buf, message ? message - buf : size, "\ntagger ", 8);
+ if (!tagger)
+ die ("No tagger for tag %s", sha1_to_hex(tag->object.sha1));
+ tagger++;
+ tagger_end = strchrnul(tagger, '\n');
+
+ /* handle signed tags */
+ if (message) {
+ const char *signature = strstr(message,
+ "\n-----BEGIN PGP SIGNATURE-----\n");
+ if (signature)
+ switch(signed_tag_mode) {
+ case ABORT:
+ die ("Encountered signed tag %s; use "
+ "--signed-tag=<mode> to handle it.",
+ sha1_to_hex(tag->object.sha1));
+ case WARN:
+ warning ("Exporting signed tag %s",
+ sha1_to_hex(tag->object.sha1));
+ /* fallthru */
+ case VERBATIM:
+ break;
+ case STRIP:
+ message_size = signature + 1 - message;
+ break;
+ }
+ }
+
+ if (!prefixcmp(name, "refs/tags/"))
+ name += 10;
+ printf("tag %s\nfrom :%d\n%.*s\ndata %d\n%.*s\n",
+ name, get_object_mark(tag->tagged),
+ (int)(tagger_end - tagger), tagger,
+ (int)message_size, (int)message_size, message ? message : "");
+}
+
+static void get_tags_and_duplicates(struct object_array *pending,
+ struct path_list *extra_refs)
+{
+ struct tag *tag;
+ int i;
+
+ for (i = 0; i < pending->nr; i++) {
+ struct object_array_entry *e = pending->objects + i;
+ unsigned char sha1[20];
+ struct commit *commit = commit;
+ char *full_name;
+
+ if (dwim_ref(e->name, strlen(e->name), sha1, &full_name) != 1)
+ continue;
+
+ switch (e->item->type) {
+ case OBJ_COMMIT:
+ commit = (struct commit *)e->item;
+ break;
+ case OBJ_TAG:
+ tag = (struct tag *)e->item;
+ while (tag && tag->object.type == OBJ_TAG) {
+ path_list_insert(full_name, extra_refs)->util = tag;
+ tag = (struct tag *)tag->tagged;
+ }
+ if (!tag)
+ die ("Tag %s points nowhere?", e->name);
+ switch(tag->object.type) {
+ case OBJ_COMMIT:
+ commit = (struct commit *)tag;
+ break;
+ case OBJ_BLOB:
+ handle_object(tag->object.sha1);
+ continue;
+ }
+ break;
+ default:
+ die ("Unexpected object of type %s",
+ typename(e->item->type));
+ }
+ if (commit->util)
+ /* more than one name for the same object */
+ path_list_insert(full_name, extra_refs)->util = commit;
+ else
+ commit->util = full_name;
+ }
+}
+
+static void handle_tags_and_duplicates(struct path_list *extra_refs)
+{
+ struct commit *commit;
+ int i;
+
+ for (i = extra_refs->nr - 1; i >= 0; i--) {
+ const char *name = extra_refs->items[i].path;
+ struct object *object = extra_refs->items[i].util;
+ switch (object->type) {
+ case OBJ_TAG:
+ handle_tag(name, (struct tag *)object);
+ break;
+ case OBJ_COMMIT:
+ /* create refs pointing to already seen commits */
+ commit = (struct commit *)object;
+ printf("reset %s\nfrom :%d\n\n", name,
+ get_object_mark(&commit->object));
+ show_progress();
+ break;
+ }
+ }
+}
+
+int cmd_fast_export(int argc, const char **argv, const char *prefix)
+{
+ struct rev_info revs;
+ struct object_array commits = { 0, 0, NULL };
+ struct path_list extra_refs = { NULL, 0, 0, 0 };
+ struct commit *commit;
+ struct option options[] = {
+ OPT_INTEGER(0, "progress", &progress,
+ "show progress after <n> objects"),
+ OPT_CALLBACK(0, "signed-tags", &signed_tag_mode, "mode",
+ "select handling of signed tags",
+ parse_opt_signed_tag_mode),
+ OPT_END()
+ };
+
+ /* we handle encodings */
+ git_config(git_default_config);
+
+ init_revisions(&revs, prefix);
+ argc = setup_revisions(argc, argv, &revs, NULL);
+ argc = parse_options(argc, argv, options, fast_export_usage, 0);
+ if (argc > 1)
+ usage_with_options (fast_export_usage, options);
+
+ get_tags_and_duplicates(&revs.pending, &extra_refs);
+
+ prepare_revision_walk(&revs);
+ revs.diffopt.format_callback = show_filemodify;
+ DIFF_OPT_SET(&revs.diffopt, RECURSIVE);
+ while ((commit = get_revision(&revs))) {
+ if (has_unshown_parent(commit)) {
+ struct commit_list *parent = commit->parents;
+ add_object_array(&commit->object, NULL, &commits);
+ for (; parent; parent = parent->next)
+ if (!parent->item->util)
+ parent->item->util = commit->util;
+ }
+ else {
+ handle_commit(commit, &revs);
+ handle_tail(&commits, &revs);
+ }
+ }
+
+ handle_tags_and_duplicates(&extra_refs);
+
+ return 0;
+}
if (!strcmp("append-fetch-head", argv[1])) {
int result;
FILE *fp;
+ char *filename;
if (argc != 8)
return error("append-fetch-head takes 6 args");
- fp = fopen(git_path("FETCH_HEAD"), "a");
+ filename = git_path("FETCH_HEAD");
+ fp = fopen(filename, "a");
+ if (!fp)
+ return error("cannot open %s: %s\n", filename, strerror(errno));
result = append_fetch_head(fp, argv[2], argv[3],
argv[4], argv[5],
argv[6], !!argv[7][0],
if (!strcmp("native-store", argv[1])) {
int result;
FILE *fp;
+ char *filename;
if (argc != 5)
return error("fetch-native-store takes 3 args");
- fp = fopen(git_path("FETCH_HEAD"), "a");
+ filename = git_path("FETCH_HEAD");
+ fp = fopen(filename, "a");
+ if (!fp)
+ return error("cannot open %s: %s\n", filename, strerror(errno));
result = fetch_native_store(fp, argv[2], argv[3], argv[4],
verbose, force);
fclose(fp);
{
int *xd = data;
- close(xd[1]);
return recv_sideband("fetch-pack", xd[0], fd, 2);
}
-static void setup_sideband(int fd[2], int xd[2], struct async *demux)
-{
- if (!use_sideband) {
- fd[0] = xd[0];
- fd[1] = xd[1];
- return;
- }
- /* xd[] is talking with upload-pack; subprocess reads from
- * xd[0], spits out band#2 to stderr, and feeds us band#1
- * through demux->out.
- */
- demux->proc = sideband_demux;
- demux->data = xd;
- if (start_async(demux))
- die("fetch-pack: unable to fork off sideband demultiplexer");
- close(xd[0]);
- fd[0] = demux->out;
- fd[1] = xd[1];
-}
-
static int get_pack(int xd[2], char **pack_lockfile)
{
struct async demux;
- int fd[2];
const char *argv[20];
char keep_arg[256];
char hdr_arg[256];
int do_keep = args.keep_pack;
struct child_process cmd;
- setup_sideband(fd, xd, &demux);
+ memset(&demux, 0, sizeof(demux));
+ if (use_sideband) {
+ /* xd[] is talking with upload-pack; subprocess reads from
+ * xd[0], spits out band#2 to stderr, and feeds us band#1
+ * through demux->out.
+ */
+ demux.proc = sideband_demux;
+ demux.data = xd;
+ if (start_async(&demux))
+ die("fetch-pack: unable to fork off sideband"
+ " demultiplexer");
+ }
+ else
+ demux.out = xd[0];
memset(&cmd, 0, sizeof(cmd));
cmd.argv = argv;
if (!args.keep_pack && unpack_limit) {
struct pack_header header;
- if (read_pack_header(fd[0], &header))
+ if (read_pack_header(demux.out, &header))
die("protocol error: bad pack header");
snprintf(hdr_arg, sizeof(hdr_arg), "--pack_header=%u,%u",
ntohl(header.hdr_version), ntohl(header.hdr_entries));
*av++ = hdr_arg;
*av++ = NULL;
- cmd.in = fd[0];
+ cmd.in = demux.out;
cmd.git_cmd = 1;
if (start_command(&cmd))
die("fetch-pack: unable to fork off %s", argv[0]);
- close(fd[1]);
if (do_keep && pack_lockfile)
*pack_lockfile = index_pack_lockfile(cmd.out);
static int append, force, tags, no_tags, update_head_ok, verbose, quiet;
static const char *depth;
-static char *default_rla = NULL;
+static struct strbuf default_rla = STRBUF_INIT;
static struct transport *transport;
static void unlock_pack(void)
}
static void add_merge_config(struct ref **head,
- struct ref *remote_refs,
+ const struct ref *remote_refs,
struct branch *branch,
struct ref ***tail)
{
struct ref *ref_map = NULL;
struct ref **tail = &ref_map;
- struct ref *remote_refs = transport_get_remote_refs(transport);
+ const struct ref *remote_refs = transport_get_remote_refs(transport);
if (ref_count || tags) {
for (i = 0; i < ref_count; i++) {
static struct ref_lock *lock;
if (!rla)
- rla = default_rla;
+ rla = default_rla.buf;
snprintf(msg, sizeof(msg), "%s: %s", rla, action);
lock = lock_any_ref_for_update(ref->name,
check_old ? ref->old_sha1 : NULL, 0);
}
}
-static void store_updated_refs(const char *url, struct ref *ref_map)
+static int store_updated_refs(const char *url, struct ref *ref_map)
{
FILE *fp;
struct commit *commit;
char note[1024];
const char *what, *kind;
struct ref *rm;
+ char *filename = git_path("FETCH_HEAD");
- fp = fopen(git_path("FETCH_HEAD"), "a");
+ fp = fopen(filename, "a");
+ if (!fp)
+ return error("cannot open %s: %s\n", filename, strerror(errno));
for (rm = ref_map; rm; rm = rm->next) {
struct ref *ref = NULL;
}
}
fclose(fp);
+ return 0;
}
/*
if (ret)
ret = transport_fetch_refs(transport, ref_map);
if (!ret)
- store_updated_refs(transport->url, ref_map);
+ ret |= store_updated_refs(transport->url, ref_map);
transport_unlock_pack(transport);
return ret;
}
struct path_list new_refs = { NULL, 0, 0, 1 };
char *ref_name;
int ref_name_len;
- unsigned char *ref_sha1;
- struct ref *tag_ref;
+ const unsigned char *ref_sha1;
+ const struct ref *tag_ref;
struct ref *rm = NULL;
struct ref *ref_map = NULL;
struct ref **tail = &ref_map;
- struct ref *ref;
+ const struct ref *ref;
for_each_ref(add_existing, &existing_refs);
for (ref = transport_get_remote_refs(transport); ref; ref = ref->next) {
die("Don't know how to fetch from %s", transport->url);
/* if not appending, truncate FETCH_HEAD */
- if (!append)
- fclose(fopen(git_path("FETCH_HEAD"), "w"));
+ if (!append) {
+ char *filename = git_path("FETCH_HEAD");
+ FILE *fp = fopen(filename, "w");
+ if (!fp)
+ return error("cannot open %s: %s\n", filename, strerror(errno));
+ fclose(fp);
+ }
ref_map = get_ref_map(transport, refs, ref_count, tags, &autotags);
int cmd_fetch(int argc, const char **argv, const char *prefix)
{
struct remote *remote;
- int i, j, rla_offset;
+ int i;
static const char **refs = NULL;
int ref_nr = 0;
- int cmd_len = 0;
const char *upload_pack = NULL;
int keep = 0;
+ /* Record the command line for the reflog */
+ strbuf_addstr(&default_rla, "fetch");
+ for (i = 1; i < argc; i++)
+ strbuf_addf(&default_rla, " %s", argv[i]);
+
for (i = 1; i < argc; i++) {
const char *arg = argv[i];
- cmd_len += strlen(arg);
if (arg[0] != '-')
break;
usage(fetch_usage);
}
- for (j = i; j < argc; j++)
- cmd_len += strlen(argv[j]);
-
- default_rla = xmalloc(cmd_len + 5 + argc + 1);
- sprintf(default_rla, "fetch");
- rla_offset = strlen(default_rla);
- for (j = 1; j < argc; j++) {
- sprintf(default_rla + rla_offset, " %s", argv[j]);
- rla_offset += strlen(argv[j]) + 1;
- }
-
if (i == argc)
remote = remote_get(NULL);
else
*/
#include "cache.h"
#include "builtin.h"
+#include "exec_cmd.h"
#ifndef DEFAULT_GIT_TEMPLATE_DIR
#define DEFAULT_GIT_TEMPLATE_DIR "/usr/share/git-core/templates"
int template_len;
DIR *dir;
- if (!template_dir) {
+ if (!template_dir)
template_dir = getenv(TEMPLATE_DIR_ENVIRONMENT);
- if (!template_dir)
- template_dir = DEFAULT_GIT_TEMPLATE_DIR;
+ if (!template_dir) {
+ /*
+ * if the hard-coded template is relative, it is
+ * interpreted relative to the exec_dir
+ */
+ template_dir = DEFAULT_GIT_TEMPLATE_DIR;
+ if (!is_absolute_path(template_dir)) {
+ const char *exec_path = git_exec_path();
+ template_dir = prefix_path(exec_path, strlen(exec_path),
+ template_dir);
+ }
}
strcpy(template_path, template_dir);
template_len = strlen(template_path);
--- /dev/null
+#include "builtin.h"
+#include "cache.h"
+#include "transport.h"
+#include "remote.h"
+
+static const char ls_remote_usage[] =
+"git-ls-remote [--upload-pack=<git-upload-pack>] [<host>:]<directory>";
+
+int cmd_ls_remote(int argc, const char **argv, const char *prefix)
+{
+ int i;
+ const char *dest = NULL;
+ int nongit = 0;
+ unsigned flags = 0;
+ const char *uploadpack = NULL;
+
+ struct remote *remote;
+ struct transport *transport;
+ const struct ref *ref;
+
+ setup_git_directory_gently(&nongit);
+
+ for (i = 1; i < argc; i++) {
+ const char *arg = argv[i];
+
+ if (*arg == '-') {
+ if (!prefixcmp(arg, "--upload-pack=")) {
+ uploadpack = arg + 14;
+ continue;
+ }
+ if (!prefixcmp(arg, "--exec=")) {
+ uploadpack = arg + 7;
+ continue;
+ }
+ if (!strcmp("--tags", arg)) {
+ flags |= REF_TAGS;
+ continue;
+ }
+ if (!strcmp("--heads", arg)) {
+ flags |= REF_HEADS;
+ continue;
+ }
+ if (!strcmp("--refs", arg)) {
+ flags |= REF_NORMAL;
+ continue;
+ }
+ usage(ls_remote_usage);
+ }
+ dest = arg;
+ break;
+ }
+
+ if (!dest || i != argc - 1)
+ usage(ls_remote_usage);
+
+ remote = nongit ? NULL : remote_get(dest);
+ if (remote && !remote->url_nr)
+ die("remote %s has no configured URL", dest);
+ transport = transport_get(remote, remote ? remote->url[0] : dest);
+ if (uploadpack != NULL)
+ transport_set_option(transport, TRANS_OPT_UPLOADPACK, uploadpack);
+
+ ref = transport_get_remote_refs(transport);
+
+ if (!ref)
+ return 1;
+
+ while (ref) {
+ if (check_ref_type(ref, flags))
+ printf("%s %s\n", sha1_to_hex(ref->old_sha1), ref->name);
+ ref = ref->next;
+ }
+ return 0;
+}
static const char prune_usage[] = "git-prune [-n]";
static int show_only;
+static unsigned long expire;
static int prune_object(char *path, const char *filename, const unsigned char *sha1)
{
+ const char *fullpath = mkpath("%s/%s", path, filename);
+ if (expire) {
+ struct stat st;
+ if (lstat(fullpath, &st))
+ return error("Could not stat '%s'", fullpath);
+ if (st.st_mtime > expire)
+ return 0;
+ }
if (show_only) {
enum object_type type = sha1_object_info(sha1, NULL);
printf("%s %s\n", sha1_to_hex(sha1),
(type > 0) ? typename(type) : "unknown");
} else
- unlink(mkpath("%s/%s", path, filename));
+ unlink(fullpath);
return 0;
}
show_only = 1;
continue;
}
+ if (!strcmp(arg, "--expire")) {
+ if (++i < argc) {
+ expire = approxidate(argv[i]);
+ continue;
+ }
+ }
+ else if (!prefixcmp(arg, "--expire=")) {
+ expire = approxidate(arg + 9);
+ continue;
+ }
usage(prune_usage);
}
#include "parse-options.h"
static const char * const push_usage[] = {
- "git-push [--all] [--dry-run] [--tags] [--receive-pack=<git-receive-pack>] [--repo=all] [-f | --force] [-v] [<repository> <refspec>...]",
+ "git-push [--all | --mirror] [--dry-run] [--tags] [--receive-pack=<git-receive-pack>] [--repo=all] [-f | --force] [-v] [<repository> <refspec>...]",
NULL,
};
strcat(tag, refs[i]);
ref = tag;
}
+ if (!strcmp("HEAD", ref)) {
+ unsigned char sha1_dummy[20];
+ ref = resolve_ref(ref, sha1_dummy, 1, NULL);
+ if (!ref)
+ die("HEAD cannot be resolved.");
+ if (prefixcmp(ref, "refs/heads/"))
+ die("HEAD cannot be resolved to branch.");
+ ref = xstrdup(ref + 11);
+ }
add_refspec(ref);
}
}
{
int flags = 0;
int all = 0;
+ int mirror = 0;
int dry_run = 0;
int force = 0;
int tags = 0;
OPT__VERBOSE(&verbose),
OPT_STRING( 0 , "repo", &repo, "repository", "repository"),
OPT_BOOLEAN( 0 , "all", &all, "push all refs"),
+ OPT_BOOLEAN( 0 , "mirror", &mirror, "mirror all refs"),
OPT_BOOLEAN( 0 , "tags", &tags, "push tags"),
OPT_BOOLEAN( 0 , "dry-run", &dry_run, "dry run"),
OPT_BOOLEAN('f', "force", &force, "force updates"),
add_refspec("refs/tags/*");
if (all)
flags |= TRANSPORT_PUSH_ALL;
+ if (mirror)
+ flags |= (TRANSPORT_PUSH_MIRROR|TRANSPORT_PUSH_FORCE);
if (argc > 0) {
repo = argv[0];
set_refspecs(argv + 1, argc - 1);
}
- if ((flags & TRANSPORT_PUSH_ALL) && refspec)
+ if ((flags & (TRANSPORT_PUSH_ALL|TRANSPORT_PUSH_MIRROR)) && refspec)
+ usage_with_options(push_usage, options);
+
+ if ((flags & (TRANSPORT_PUSH_ALL|TRANSPORT_PUSH_MIRROR)) ==
+ (TRANSPORT_PUSH_ALL|TRANSPORT_PUSH_MIRROR)) {
+ error("--all and --mirror are incompatible");
usage_with_options(push_usage, options);
+ }
return do_push(repo, flags);
}
keep_dashdash ? PARSE_OPT_KEEP_DASHDASH : 0);
strbuf_addf(&parsed, " --");
- sq_quote_argv(&parsed, argv, argc, 0);
+ sq_quote_argv(&parsed, argv, 0);
puts(parsed.buf);
return 0;
}
NULL
};
-static int edit, no_replay, no_commit, needed_deref, mainline;
+static int edit, no_replay, no_commit, mainline;
static enum { REVERT, CHERRY_PICK } action;
static struct commit *commit;
if (commit->object.type == OBJ_TAG) {
commit = (struct commit *)
deref_tag((struct object *)commit, arg, strlen(arg));
- needed_deref = 1;
}
if (commit->object.type != OBJ_COMMIT)
die ("'%s' does not point to a commit", arg);
return run_command_v_opt(argv, RUN_COMMAND_NO_STDIN | RUN_GIT_CMD);
}
+static char *help_msg(const unsigned char *sha1)
+{
+ static char helpbuf[1024];
+ char *msg = getenv("GIT_CHERRY_PICK_HELP");
+
+ if (msg)
+ return msg;
+
+ strcpy(helpbuf, " After resolving the conflicts,\n"
+ "mark the corrected paths with 'git add <paths>' "
+ "or 'git rm <paths>' and commit the result.");
+
+ if (action == CHERRY_PICK) {
+ sprintf(helpbuf + strlen(helpbuf),
+ "\nWhen commiting, use the option "
+ "'-c %s' to retain authorship and message.",
+ find_unique_abbrev(sha1, DEFAULT_ABBREV));
+ }
+ return helpbuf;
+}
+
static int revert_or_cherry_pick(int argc, const char **argv)
{
unsigned char head[20];
add_to_msg(")\n");
}
}
- if (needed_deref) {
- add_to_msg("(original 'git ");
- add_to_msg(me);
- add_to_msg("' arguments: ");
- for (i = 0; i < argc; i++) {
- if (i)
- add_to_msg(" ");
- add_to_msg(argv[i]);
- }
- add_to_msg(")\n");
- }
if (merge_recursive(sha1_to_hex(base->object.sha1),
sha1_to_hex(head), "HEAD",
}
if (close(msg_fd) || commit_lock_file(&msg_file) < 0)
die ("Error wrapping up %s", defmsg);
- fprintf(stderr, "Automatic %s failed. "
- "After resolving the conflicts,\n"
- "mark the corrected paths with 'git add <paths>' "
- "and commit the result.\n", me);
- if (action == CHERRY_PICK) {
- fprintf(stderr, "When commiting, use the option "
- "'-c %s' to retain authorship and message.\n",
- find_unique_abbrev(commit->object.sha1,
- DEFAULT_ABBREV));
- }
+ fprintf(stderr, "Automatic %s failed.%s\n",
+ me, help_msg(commit->object.sha1));
exit(1);
}
if (close(msg_fd) || commit_lock_file(&msg_file) < 0)
--- /dev/null
+#include "cache.h"
+#include "commit.h"
+#include "tag.h"
+#include "refs.h"
+#include "pkt-line.h"
+#include "run-command.h"
+#include "remote.h"
+#include "send-pack.h"
+
+static const char send_pack_usage[] =
+"git-send-pack [--all | --mirror] [--dry-run] [--force] [--receive-pack=<git-receive-pack>] [--verbose] [--thin] [<host>:]<directory> [<ref>...]\n"
+" --all and explicit <ref> specification are mutually exclusive.";
+
+static struct send_pack_args args = {
+ /* .receivepack = */ "git-receive-pack",
+};
+
+/*
+ * Make a pack stream and spit it out into file descriptor fd
+ */
+static int pack_objects(int fd, struct ref *refs)
+{
+ /*
+ * The child becomes pack-objects --revs; we feed
+ * the revision parameters to it via its stdin and
+ * let its stdout go back to the other end.
+ */
+ const char *argv[] = {
+ "pack-objects",
+ "--all-progress",
+ "--revs",
+ "--stdout",
+ NULL,
+ NULL,
+ };
+ struct child_process po;
+
+ if (args.use_thin_pack)
+ argv[4] = "--thin";
+ memset(&po, 0, sizeof(po));
+ po.argv = argv;
+ po.in = -1;
+ po.out = fd;
+ po.git_cmd = 1;
+ if (start_command(&po))
+ die("git-pack-objects failed (%s)", strerror(errno));
+
+ /*
+ * We feed the pack-objects we just spawned with revision
+ * parameters by writing to the pipe.
+ */
+ while (refs) {
+ char buf[42];
+
+ if (!is_null_sha1(refs->old_sha1) &&
+ has_sha1_file(refs->old_sha1)) {
+ memcpy(buf + 1, sha1_to_hex(refs->old_sha1), 40);
+ buf[0] = '^';
+ buf[41] = '\n';
+ if (!write_or_whine(po.in, buf, 42,
+ "send-pack: send refs"))
+ break;
+ }
+ if (!is_null_sha1(refs->new_sha1)) {
+ memcpy(buf, sha1_to_hex(refs->new_sha1), 40);
+ buf[40] = '\n';
+ if (!write_or_whine(po.in, buf, 41,
+ "send-pack: send refs"))
+ break;
+ }
+ refs = refs->next;
+ }
+
+ if (finish_command(&po))
+ return error("pack-objects died with strange error");
+ return 0;
+}
+
+static void unmark_and_free(struct commit_list *list, unsigned int mark)
+{
+ while (list) {
+ struct commit_list *temp = list;
+ temp->item->object.flags &= ~mark;
+ list = temp->next;
+ free(temp);
+ }
+}
+
+static int ref_newer(const unsigned char *new_sha1,
+ const unsigned char *old_sha1)
+{
+ struct object *o;
+ struct commit *old, *new;
+ struct commit_list *list, *used;
+ int found = 0;
+
+ /* Both new and old must be commit-ish and new is descendant of
+ * old. Otherwise we require --force.
+ */
+ o = deref_tag(parse_object(old_sha1), NULL, 0);
+ if (!o || o->type != OBJ_COMMIT)
+ return 0;
+ old = (struct commit *) o;
+
+ o = deref_tag(parse_object(new_sha1), NULL, 0);
+ if (!o || o->type != OBJ_COMMIT)
+ return 0;
+ new = (struct commit *) o;
+
+ if (parse_commit(new) < 0)
+ return 0;
+
+ used = list = NULL;
+ commit_list_insert(new, &list);
+ while (list) {
+ new = pop_most_recent_commit(&list, 1);
+ commit_list_insert(new, &used);
+ if (new == old) {
+ found = 1;
+ break;
+ }
+ }
+ unmark_and_free(list, 1);
+ unmark_and_free(used, 1);
+ return found;
+}
+
+static struct ref *local_refs, **local_tail;
+static struct ref *remote_refs, **remote_tail;
+
+static int one_local_ref(const char *refname, const unsigned char *sha1, int flag, void *cb_data)
+{
+ struct ref *ref;
+ int len = strlen(refname) + 1;
+ ref = xcalloc(1, sizeof(*ref) + len);
+ hashcpy(ref->new_sha1, sha1);
+ memcpy(ref->name, refname, len);
+ *local_tail = ref;
+ local_tail = &ref->next;
+ return 0;
+}
+
+static void get_local_heads(void)
+{
+ local_tail = &local_refs;
+ for_each_ref(one_local_ref, NULL);
+}
+
+static int receive_status(int in, struct ref *refs)
+{
+ struct ref *hint;
+ char line[1000];
+ int ret = 0;
+ int len = packet_read_line(in, line, sizeof(line));
+ if (len < 10 || memcmp(line, "unpack ", 7))
+ return error("did not receive remote status");
+ if (memcmp(line, "unpack ok\n", 10)) {
+ char *p = line + strlen(line) - 1;
+ if (*p == '\n')
+ *p = '\0';
+ error("unpack failed: %s", line + 7);
+ ret = -1;
+ }
+ hint = NULL;
+ while (1) {
+ char *refname;
+ char *msg;
+ len = packet_read_line(in, line, sizeof(line));
+ if (!len)
+ break;
+ if (len < 3 ||
+ (memcmp(line, "ok ", 3) && memcmp(line, "ng ", 3))) {
+ fprintf(stderr, "protocol error: %s\n", line);
+ ret = -1;
+ break;
+ }
+
+ line[strlen(line)-1] = '\0';
+ refname = line + 3;
+ msg = strchr(refname, ' ');
+ if (msg)
+ *msg++ = '\0';
+
+ /* first try searching at our hint, falling back to all refs */
+ if (hint)
+ hint = find_ref_by_name(hint, refname);
+ if (!hint)
+ hint = find_ref_by_name(refs, refname);
+ if (!hint) {
+ warning("remote reported status on unknown ref: %s",
+ refname);
+ continue;
+ }
+ if (hint->status != REF_STATUS_EXPECTING_REPORT) {
+ warning("remote reported status on unexpected ref: %s",
+ refname);
+ continue;
+ }
+
+ if (line[0] == 'o' && line[1] == 'k')
+ hint->status = REF_STATUS_OK;
+ else {
+ hint->status = REF_STATUS_REMOTE_REJECT;
+ ret = -1;
+ }
+ if (msg)
+ hint->remote_status = xstrdup(msg);
+ /* start our next search from the next ref */
+ hint = hint->next;
+ }
+ return ret;
+}
+
+static void update_tracking_ref(struct remote *remote, struct ref *ref)
+{
+ struct refspec rs;
+
+ if (ref->status != REF_STATUS_OK)
+ return;
+
+ rs.src = ref->name;
+ rs.dst = NULL;
+
+ if (!remote_find_tracking(remote, &rs)) {
+ if (args.verbose)
+ fprintf(stderr, "updating local tracking ref '%s'\n", rs.dst);
+ if (ref->deletion) {
+ if (delete_ref(rs.dst, NULL))
+ error("Failed to delete");
+ } else
+ update_ref("update by push", rs.dst,
+ ref->new_sha1, NULL, 0, 0);
+ free(rs.dst);
+ }
+}
+
+static const char *prettify_ref(const struct ref *ref)
+{
+ const char *name = ref->name;
+ return name + (
+ !prefixcmp(name, "refs/heads/") ? 11 :
+ !prefixcmp(name, "refs/tags/") ? 10 :
+ !prefixcmp(name, "refs/remotes/") ? 13 :
+ 0);
+}
+
+#define SUMMARY_WIDTH (2 * DEFAULT_ABBREV + 3)
+
+static void print_ref_status(char flag, const char *summary, struct ref *to, struct ref *from, const char *msg)
+{
+ fprintf(stderr, " %c %-*s ", flag, SUMMARY_WIDTH, summary);
+ if (from)
+ fprintf(stderr, "%s -> %s", prettify_ref(from), prettify_ref(to));
+ else
+ fputs(prettify_ref(to), stderr);
+ if (msg) {
+ fputs(" (", stderr);
+ fputs(msg, stderr);
+ fputc(')', stderr);
+ }
+ fputc('\n', stderr);
+}
+
+static const char *status_abbrev(unsigned char sha1[20])
+{
+ const char *abbrev;
+ abbrev = find_unique_abbrev(sha1, DEFAULT_ABBREV);
+ return abbrev ? abbrev : sha1_to_hex(sha1);
+}
+
+static void print_ok_ref_status(struct ref *ref)
+{
+ if (ref->deletion)
+ print_ref_status('-', "[deleted]", ref, NULL, NULL);
+ else if (is_null_sha1(ref->old_sha1))
+ print_ref_status('*',
+ (!prefixcmp(ref->name, "refs/tags/") ? "[new tag]" :
+ "[new branch]"),
+ ref, ref->peer_ref, NULL);
+ else {
+ char quickref[84];
+ char type;
+ const char *msg;
+
+ strcpy(quickref, status_abbrev(ref->old_sha1));
+ if (ref->nonfastforward) {
+ strcat(quickref, "...");
+ type = '+';
+ msg = "forced update";
+ } else {
+ strcat(quickref, "..");
+ type = ' ';
+ msg = NULL;
+ }
+ strcat(quickref, status_abbrev(ref->new_sha1));
+
+ print_ref_status(type, quickref, ref, ref->peer_ref, msg);
+ }
+}
+
+static int print_one_push_status(struct ref *ref, const char *dest, int count)
+{
+ if (!count)
+ fprintf(stderr, "To %s\n", dest);
+
+ switch(ref->status) {
+ case REF_STATUS_NONE:
+ print_ref_status('X', "[no match]", ref, NULL, NULL);
+ break;
+ case REF_STATUS_REJECT_NODELETE:
+ print_ref_status('!', "[rejected]", ref, NULL,
+ "remote does not support deleting refs");
+ break;
+ case REF_STATUS_UPTODATE:
+ print_ref_status('=', "[up to date]", ref,
+ ref->peer_ref, NULL);
+ break;
+ case REF_STATUS_REJECT_NONFASTFORWARD:
+ print_ref_status('!', "[rejected]", ref, ref->peer_ref,
+ "non-fast forward");
+ break;
+ case REF_STATUS_REMOTE_REJECT:
+ print_ref_status('!', "[remote rejected]", ref,
+ ref->deletion ? NULL : ref->peer_ref,
+ ref->remote_status);
+ break;
+ case REF_STATUS_EXPECTING_REPORT:
+ print_ref_status('!', "[remote failure]", ref,
+ ref->deletion ? NULL : ref->peer_ref,
+ "remote failed to report status");
+ break;
+ case REF_STATUS_OK:
+ print_ok_ref_status(ref);
+ break;
+ }
+
+ return 1;
+}
+
+static void print_push_status(const char *dest, struct ref *refs)
+{
+ struct ref *ref;
+ int n = 0;
+
+ if (args.verbose) {
+ for (ref = refs; ref; ref = ref->next)
+ if (ref->status == REF_STATUS_UPTODATE)
+ n += print_one_push_status(ref, dest, n);
+ }
+
+ for (ref = refs; ref; ref = ref->next)
+ if (ref->status == REF_STATUS_OK)
+ n += print_one_push_status(ref, dest, n);
+
+ for (ref = refs; ref; ref = ref->next) {
+ if (ref->status != REF_STATUS_NONE &&
+ ref->status != REF_STATUS_UPTODATE &&
+ ref->status != REF_STATUS_OK)
+ n += print_one_push_status(ref, dest, n);
+ }
+}
+
+static int refs_pushed(struct ref *ref)
+{
+ for (; ref; ref = ref->next) {
+ switch(ref->status) {
+ case REF_STATUS_NONE:
+ case REF_STATUS_UPTODATE:
+ break;
+ default:
+ return 1;
+ }
+ }
+ return 0;
+}
+
+static int do_send_pack(int in, int out, struct remote *remote, const char *dest, int nr_refspec, const char **refspec)
+{
+ struct ref *ref;
+ int new_refs;
+ int ask_for_status_report = 0;
+ int allow_deleting_refs = 0;
+ int expect_status_report = 0;
+ int flags = MATCH_REFS_NONE;
+ int ret;
+
+ if (args.send_all)
+ flags |= MATCH_REFS_ALL;
+ if (args.send_mirror)
+ flags |= MATCH_REFS_MIRROR;
+
+ /* No funny business with the matcher */
+ remote_tail = get_remote_heads(in, &remote_refs, 0, NULL, REF_NORMAL);
+ get_local_heads();
+
+ /* Does the other end support the reporting? */
+ if (server_supports("report-status"))
+ ask_for_status_report = 1;
+ if (server_supports("delete-refs"))
+ allow_deleting_refs = 1;
+
+ /* match them up */
+ if (!remote_tail)
+ remote_tail = &remote_refs;
+ if (match_refs(local_refs, remote_refs, &remote_tail,
+ nr_refspec, refspec, flags))
+ return -1;
+
+ if (!remote_refs) {
+ fprintf(stderr, "No refs in common and none specified; doing nothing.\n"
+ "Perhaps you should specify a branch such as 'master'.\n");
+ return 0;
+ }
+
+ /*
+ * Finally, tell the other end!
+ */
+ new_refs = 0;
+ for (ref = remote_refs; ref; ref = ref->next) {
+ const unsigned char *new_sha1;
+
+ if (!ref->peer_ref) {
+ if (!args.send_mirror)
+ continue;
+ new_sha1 = null_sha1;
+ }
+ else
+ new_sha1 = ref->peer_ref->new_sha1;
+
+
+ ref->deletion = is_null_sha1(new_sha1);
+ if (ref->deletion && !allow_deleting_refs) {
+ ref->status = REF_STATUS_REJECT_NODELETE;
+ continue;
+ }
+ if (!ref->deletion &&
+ !hashcmp(ref->old_sha1, new_sha1)) {
+ ref->status = REF_STATUS_UPTODATE;
+ continue;
+ }
+
+ /* This part determines what can overwrite what.
+ * The rules are:
+ *
+ * (0) you can always use --force or +A:B notation to
+ * selectively force individual ref pairs.
+ *
+ * (1) if the old thing does not exist, it is OK.
+ *
+ * (2) if you do not have the old thing, you are not allowed
+ * to overwrite it; you would not know what you are losing
+ * otherwise.
+ *
+ * (3) if both new and old are commit-ish, and new is a
+ * descendant of old, it is OK.
+ *
+ * (4) regardless of all of the above, removing :B is
+ * always allowed.
+ */
+
+ ref->nonfastforward =
+ !ref->deletion &&
+ !is_null_sha1(ref->old_sha1) &&
+ (!has_sha1_file(ref->old_sha1)
+ || !ref_newer(new_sha1, ref->old_sha1));
+
+ if (ref->nonfastforward && !ref->force && !args.force_update) {
+ ref->status = REF_STATUS_REJECT_NONFASTFORWARD;
+ continue;
+ }
+
+ hashcpy(ref->new_sha1, new_sha1);
+ if (!ref->deletion)
+ new_refs++;
+
+ if (!args.dry_run) {
+ char *old_hex = sha1_to_hex(ref->old_sha1);
+ char *new_hex = sha1_to_hex(ref->new_sha1);
+
+ if (ask_for_status_report) {
+ packet_write(out, "%s %s %s%c%s",
+ old_hex, new_hex, ref->name, 0,
+ "report-status");
+ ask_for_status_report = 0;
+ expect_status_report = 1;
+ }
+ else
+ packet_write(out, "%s %s %s",
+ old_hex, new_hex, ref->name);
+ }
+ ref->status = expect_status_report ?
+ REF_STATUS_EXPECTING_REPORT :
+ REF_STATUS_OK;
+ }
+
+ packet_flush(out);
+ if (new_refs && !args.dry_run) {
+ if (pack_objects(out, remote_refs) < 0) {
+ close(out);
+ return -1;
+ }
+ }
+ close(out);
+
+ if (expect_status_report)
+ ret = receive_status(in, remote_refs);
+ else
+ ret = 0;
+
+ print_push_status(dest, remote_refs);
+
+ if (!args.dry_run && remote) {
+ for (ref = remote_refs; ref; ref = ref->next)
+ update_tracking_ref(remote, ref);
+ }
+
+ if (!refs_pushed(remote_refs))
+ fprintf(stderr, "Everything up-to-date\n");
+ if (ret < 0)
+ return ret;
+ for (ref = remote_refs; ref; ref = ref->next) {
+ switch (ref->status) {
+ case REF_STATUS_NONE:
+ case REF_STATUS_UPTODATE:
+ case REF_STATUS_OK:
+ break;
+ default:
+ return -1;
+ }
+ }
+ return 0;
+}
+
+static void verify_remote_names(int nr_heads, const char **heads)
+{
+ int i;
+
+ for (i = 0; i < nr_heads; i++) {
+ const char *remote = strchr(heads[i], ':');
+
+ remote = remote ? (remote + 1) : heads[i];
+ switch (check_ref_format(remote)) {
+ case 0: /* ok */
+ case -2: /* ok but a single level -- that is fine for
+ * a match pattern.
+ */
+ case -3: /* ok but ends with a pattern-match character */
+ continue;
+ }
+ die("remote part of refspec is not a valid name in %s",
+ heads[i]);
+ }
+}
+
+int cmd_send_pack(int argc, const char **argv, const char *prefix)
+{
+ int i, nr_heads = 0;
+ const char **heads = NULL;
+ const char *remote_name = NULL;
+ struct remote *remote = NULL;
+ const char *dest = NULL;
+
+ argv++;
+ for (i = 1; i < argc; i++, argv++) {
+ const char *arg = *argv;
+
+ if (*arg == '-') {
+ if (!prefixcmp(arg, "--receive-pack=")) {
+ args.receivepack = arg + 15;
+ continue;
+ }
+ if (!prefixcmp(arg, "--exec=")) {
+ args.receivepack = arg + 7;
+ continue;
+ }
+ if (!prefixcmp(arg, "--remote=")) {
+ remote_name = arg + 9;
+ continue;
+ }
+ if (!strcmp(arg, "--all")) {
+ args.send_all = 1;
+ continue;
+ }
+ if (!strcmp(arg, "--dry-run")) {
+ args.dry_run = 1;
+ continue;
+ }
+ if (!strcmp(arg, "--mirror")) {
+ args.send_mirror = 1;
+ continue;
+ }
+ if (!strcmp(arg, "--force")) {
+ args.force_update = 1;
+ continue;
+ }
+ if (!strcmp(arg, "--verbose")) {
+ args.verbose = 1;
+ continue;
+ }
+ if (!strcmp(arg, "--thin")) {
+ args.use_thin_pack = 1;
+ continue;
+ }
+ usage(send_pack_usage);
+ }
+ if (!dest) {
+ dest = arg;
+ continue;
+ }
+ heads = (const char **) argv;
+ nr_heads = argc - i;
+ break;
+ }
+ if (!dest)
+ usage(send_pack_usage);
+ /*
+ * --all and --mirror are incompatible; neither makes sense
+ * with any refspecs.
+ */
+ if ((heads && (args.send_all || args.send_mirror)) ||
+ (args.send_all && args.send_mirror))
+ usage(send_pack_usage);
+
+ if (remote_name) {
+ remote = remote_get(remote_name);
+ if (!remote_has_url(remote, dest)) {
+ die("Destination %s is not a uri for %s",
+ dest, remote_name);
+ }
+ }
+
+ return send_pack(&args, dest, remote, nr_heads, heads);
+}
+
+int send_pack(struct send_pack_args *my_args,
+ const char *dest, struct remote *remote,
+ int nr_heads, const char **heads)
+{
+ int fd[2], ret;
+ struct child_process *conn;
+
+ memcpy(&args, my_args, sizeof(args));
+
+ verify_remote_names(nr_heads, heads);
+
+ conn = git_connect(fd, dest, args.receivepack, args.verbose ? CONNECT_VERBOSE : 0);
+ ret = do_send_pack(fd[0], fd[1], remote, dest, nr_heads, heads);
+ close(fd[0]);
+ close(fd[1]);
+ ret |= finish_connect(conn);
+ return !!ret;
+}
#include "refs.h"
#include "tag.h"
#include "run-command.h"
-
-static const char builtin_tag_usage[] =
- "git-tag [-n [<num>]] -l [<pattern>] | [-a | -s | -u <key-id>] [-f | -d | -v] [-m <msg> | -F <file>] <tagname> [<head>]";
+#include "parse-options.h"
+
+static const char * const git_tag_usage[] = {
+ "git-tag [-a|-s|-u <key-id>] [-f] [-m <msg>|-F <file>] <tagname> [<head>]",
+ "git-tag -d <tagname>...",
+ "git-tag [-n [<num>]] -l [<pattern>]",
+ "git-tag -v <tagname>...",
+ NULL
+};
static char signingkey[1000];
static void create_tag(const unsigned char *object, const char *tag,
struct strbuf *buf, int message, int sign,
- unsigned char *prev, unsigned char *result)
+ unsigned char *prev, unsigned char *result)
{
enum object_type type;
char header_buf[1024];
die("unable to write tag file");
}
+struct msg_arg {
+ int given;
+ struct strbuf buf;
+};
+
+static int parse_msg_arg(const struct option *opt, const char *arg, int unset)
+{
+ struct msg_arg *msg = opt->value;
+
+ if (!arg)
+ return -1;
+ if (msg->buf.len)
+ strbuf_addstr(&(msg->buf), "\n\n");
+ strbuf_addstr(&(msg->buf), arg);
+ msg->given = 1;
+ return 0;
+}
+
int cmd_tag(int argc, const char **argv, const char *prefix)
{
struct strbuf buf;
unsigned char object[20], prev[20];
- int annotate = 0, sign = 0, force = 0, lines = 0, message = 0;
char ref[PATH_MAX];
const char *object_ref, *tag;
- int i;
struct ref_lock *lock;
+ int annotate = 0, sign = 0, force = 0, lines = 0,
+ delete = 0, verify = 0;
+ char *list = NULL, *msgfile = NULL, *keyid = NULL;
+ const char *no_pattern = "NO_PATTERN";
+ struct msg_arg msg = { 0, STRBUF_INIT };
+ struct option options[] = {
+ { OPTION_STRING, 'l', NULL, &list, "pattern", "list tag names",
+ PARSE_OPT_OPTARG, NULL, (intptr_t) no_pattern },
+ { OPTION_INTEGER, 'n', NULL, &lines, NULL,
+ "print n lines of each tag message",
+ PARSE_OPT_OPTARG, NULL, 1 },
+ OPT_BOOLEAN('d', NULL, &delete, "delete tags"),
+ OPT_BOOLEAN('v', NULL, &verify, "verify tags"),
+
+ OPT_GROUP("Tag creation options"),
+ OPT_BOOLEAN('a', NULL, &annotate,
+ "annotated tag, needs a message"),
+ OPT_CALLBACK('m', NULL, &msg, "msg",
+ "message for the tag", parse_msg_arg),
+ OPT_STRING('F', NULL, &msgfile, "file", "message in a file"),
+ OPT_BOOLEAN('s', NULL, &sign, "annotated and GPG-signed tag"),
+ OPT_STRING('u', NULL, &keyid, "key-id",
+ "use another key to sign the tag"),
+ OPT_BOOLEAN('f', NULL, &force, "replace the tag if exists"),
+ OPT_END()
+ };
+
git_config(git_tag_config);
- strbuf_init(&buf, 0);
- for (i = 1; i < argc; i++) {
- const char *arg = argv[i];
+ argc = parse_options(argc, argv, options, git_tag_usage, 0);
- if (arg[0] != '-')
- break;
- if (!strcmp(arg, "-a")) {
- annotate = 1;
- continue;
- }
- if (!strcmp(arg, "-s")) {
- annotate = 1;
- sign = 1;
- continue;
- }
- if (!strcmp(arg, "-f")) {
- force = 1;
- continue;
- }
- if (!strcmp(arg, "-n")) {
- if (i + 1 == argc || *argv[i + 1] == '-')
- /* no argument */
- lines = 1;
- else
- lines = isdigit(*argv[++i]) ?
- atoi(argv[i]) : 1;
- continue;
- }
- if (!strcmp(arg, "-m")) {
- annotate = 1;
- i++;
- if (i == argc)
- die("option -m needs an argument.");
- if (message)
- die("only one -F or -m option is allowed.");
- strbuf_addstr(&buf, argv[i]);
- message = 1;
- continue;
- }
- if (!strcmp(arg, "-F")) {
- annotate = 1;
- i++;
- if (i == argc)
- die("option -F needs an argument.");
- if (message)
- die("only one -F or -m option is allowed.");
-
- if (!strcmp(argv[i], "-")) {
+ if (sign)
+ annotate = 1;
+
+ if (list)
+ return list_tags(list == no_pattern ? NULL : list, lines);
+ if (delete)
+ return for_each_tag_name(argv, delete_tag);
+ if (verify)
+ return for_each_tag_name(argv, verify_tag);
+
+ strbuf_init(&buf, 0);
+ if (msg.given || msgfile) {
+ if (msg.given && msgfile)
+ die("only one -F or -m option is allowed.");
+ annotate = 1;
+ if (msg.given)
+ strbuf_addbuf(&buf, &(msg.buf));
+ else {
+ if (!strcmp(msgfile, "-")) {
if (strbuf_read(&buf, 0, 1024) < 0)
- die("cannot read %s", argv[i]);
+ die("cannot read %s", msgfile);
} else {
- if (strbuf_read_file(&buf, argv[i], 1024) < 0)
+ if (strbuf_read_file(&buf, msgfile, 1024) < 0)
die("could not open or read '%s': %s",
- argv[i], strerror(errno));
+ msgfile, strerror(errno));
}
- message = 1;
- continue;
- }
- if (!strcmp(arg, "-u")) {
- annotate = 1;
- sign = 1;
- i++;
- if (i == argc)
- die("option -u needs an argument.");
- if (strlcpy(signingkey, argv[i], sizeof(signingkey))
- >= sizeof(signingkey))
- die("argument to option -u too long");
- continue;
}
- if (!strcmp(arg, "-l"))
- return list_tags(argv[i + 1], lines);
- if (!strcmp(arg, "-d"))
- return for_each_tag_name(argv + i + 1, delete_tag);
- if (!strcmp(arg, "-v"))
- return for_each_tag_name(argv + i + 1, verify_tag);
- usage(builtin_tag_usage);
}
- if (i == argc) {
+ if (argc == 0) {
if (annotate)
- usage(builtin_tag_usage);
+ usage_with_options(git_tag_usage, options);
return list_tags(NULL, lines);
}
- tag = argv[i++];
+ tag = argv[0];
- object_ref = i < argc ? argv[i] : "HEAD";
- if (i + 1 < argc)
+ object_ref = argc == 2 ? argv[1] : "HEAD";
+ if (argc > 2)
die("too many params");
if (get_sha1(object_ref, object))
die("tag '%s' already exists", tag);
if (annotate)
- create_tag(object, tag, &buf, message, sign, prev, object);
+ create_tag(object, tag, &buf, msg.given || msgfile,
+ sign, prev, object);
lock = lock_any_ref_for_update(ref, prev, 0);
if (!lock)
extern int cmd_check_ref_format(int argc, const char **argv, const char *prefix);
extern int cmd_cherry(int argc, const char **argv, const char *prefix);
extern int cmd_cherry_pick(int argc, const char **argv, const char *prefix);
+extern int cmd_clean(int argc, const char **argv, const char *prefix);
extern int cmd_commit(int argc, const char **argv, const char *prefix);
extern int cmd_commit_tree(int argc, const char **argv, const char *prefix);
extern int cmd_count_objects(int argc, const char **argv, const char *prefix);
extern int cmd_diff_index(int argc, const char **argv, const char *prefix);
extern int cmd_diff(int argc, const char **argv, const char *prefix);
extern int cmd_diff_tree(int argc, const char **argv, const char *prefix);
+extern int cmd_fast_export(int argc, const char **argv, const char *prefix);
extern int cmd_fetch(int argc, const char **argv, const char *prefix);
extern int cmd_fetch_pack(int argc, const char **argv, const char *prefix);
extern int cmd_fetch__tool(int argc, const char **argv, const char *prefix);
extern int cmd_log_reflog(int argc, const char **argv, const char *prefix);
extern int cmd_ls_files(int argc, const char **argv, const char *prefix);
extern int cmd_ls_tree(int argc, const char **argv, const char *prefix);
+extern int cmd_ls_remote(int argc, const char **argv, const char *prefix);
extern int cmd_mailinfo(int argc, const char **argv, const char *prefix);
extern int cmd_mailsplit(int argc, const char **argv, const char *prefix);
extern int cmd_merge_base(int argc, const char **argv, const char *prefix);
extern int cmd_rev_parse(int argc, const char **argv, const char *prefix);
extern int cmd_revert(int argc, const char **argv, const char *prefix);
extern int cmd_rm(int argc, const char **argv, const char *prefix);
+extern int cmd_send_pack(int argc, const char **argv, const char *prefix);
extern int cmd_shortlog(int argc, const char **argv, const char *prefix);
extern int cmd_show(int argc, const char **argv, const char *prefix);
extern int cmd_show_branch(int argc, const char **argv, const char *prefix);
OBJ_MAX,
};
+static inline enum object_type object_type(unsigned int mode)
+{
+ return S_ISDIR(mode) ? OBJ_TREE :
+ S_ISGITLINK(mode) ? OBJ_COMMIT :
+ OBJ_BLOB;
+}
+
#define GIT_DIR_ENVIRONMENT "GIT_DIR"
#define GIT_WORK_TREE_ENVIRONMENT "GIT_WORK_TREE"
#define DEFAULT_GIT_DIR_ENVIRONMENT ".git"
struct lock_file {
struct lock_file *next;
+ int fd;
pid_t owner;
char on_list;
char filename[PATH_MAX];
extern int dwim_ref(const char *str, int len, unsigned char *sha1, char **ref);
extern int dwim_log(const char *str, int len, unsigned char *sha1, char **ref);
+extern int refname_match(const char *abbrev_name, const char *full_name, const char **rules);
+extern const char *ref_rev_parse_rules[];
+extern const char *ref_fetch_rules[];
+
extern int create_symref(const char *ref, const char *refs_heads_master, const char *logmsg);
extern int validate_headref(const char *ref);
struct ref *next;
unsigned char old_sha1[20];
unsigned char new_sha1[20];
- unsigned char force;
- unsigned char merge;
+ unsigned int force:1,
+ merge:1,
+ nonfastforward:1,
+ deletion:1;
+ enum {
+ REF_STATUS_NONE = 0,
+ REF_STATUS_OK,
+ REF_STATUS_REJECT_NONFASTFORWARD,
+ REF_STATUS_REJECT_NODELETE,
+ REF_STATUS_UPTODATE,
+ REF_STATUS_REMOTE_REJECT,
+ REF_STATUS_EXPECTING_REPORT,
+ } status;
+ char *remote_status;
struct ref *peer_ref; /* when renaming */
char name[FLEX_ARRAY]; /* more */
};
#define REF_HEADS (1u << 1)
#define REF_TAGS (1u << 2)
+extern struct ref *find_ref_by_name(struct ref *list, const char *name);
+
#define CONNECT_VERBOSE (1u << 0)
-extern struct child_process *git_connect(int fd[2], char *url, const char *prog, int flags);
+extern struct child_process *git_connect(int fd[2], const char *url, const char *prog, int flags);
extern int finish_connect(struct child_process *conn);
extern int path_match(const char *path, int nr, char **match);
extern int get_ack(int fd, unsigned char *result_sha1);
extern int git_config_set(const char *, const char *);
extern int git_config_set_multivar(const char *, const char *, const char *, int);
extern int git_config_rename_section(const char *, const char *);
+extern const char *git_etc_gitconfig(void);
extern int check_repository_format_version(const char *var, const char *value);
#define MAX_GITNAME (1000)
/* trace.c */
extern void trace_printf(const char *format, ...);
-extern void trace_argv_printf(const char **argv, int count, const char *format, ...);
+extern void trace_argv_printf(const char **argv, const char *format, ...);
/* convert.c */
/* returns 1 if *dst was used */
int git_config_colorbool(const char *var, const char *value)
{
- if (!value)
- return 1;
- if (!strcasecmp(value, "auto")) {
- if (isatty(1) || (pager_in_use && pager_use_color)) {
- char *term = getenv("TERM");
- if (term && strcmp(term, "dumb"))
- return 1;
- }
- return 0;
+ if (value) {
+ if (!strcasecmp(value, "never"))
+ return 0;
+ if (!strcasecmp(value, "always"))
+ return 1;
+ if (!strcasecmp(value, "auto"))
+ goto auto_color;
}
- if (!strcasecmp(value, "never"))
+
+ /* Missing or explicit false to turn off colorization */
+ if (!git_config_bool(var, value))
return 0;
- if (!strcasecmp(value, "always"))
- return 1;
- return git_config_bool(var, value);
+
+ /* any normal truth value defaults to 'auto' */
+ auto_color:
+ if (isatty(1) || (pager_in_use && pager_use_color)) {
+ char *term = getenv("TERM");
+ if (term && strcmp(term, "dumb"))
+ return 1;
+ }
+ return 0;
}
static int color_vfprintf(FILE *fp, const char *color, const char *fmt,
--- /dev/null
+# List of known git commands.
+# command name category [deprecated] [common]
+git-add mainporcelain common
+git-am mainporcelain
+git-annotate ancillaryinterrogators
+git-apply plumbingmanipulators
+git-archimport foreignscminterface
+git-archive mainporcelain
+git-bisect mainporcelain common
+git-blame ancillaryinterrogators
+git-branch mainporcelain common
+git-bundle mainporcelain
+git-cat-file plumbinginterrogators
+git-check-attr purehelpers
+git-checkout mainporcelain common
+git-checkout-index plumbingmanipulators
+git-check-ref-format purehelpers
+git-cherry ancillaryinterrogators
+git-cherry-pick mainporcelain
+git-citool mainporcelain
+git-clean mainporcelain
+git-clone mainporcelain common
+git-commit mainporcelain common
+git-commit-tree plumbingmanipulators
+git-config ancillarymanipulators
+git-count-objects ancillaryinterrogators
+git-cvsexportcommit foreignscminterface
+git-cvsimport foreignscminterface
+git-cvsserver foreignscminterface
+git-daemon synchingrepositories
+git-describe mainporcelain
+git-diff mainporcelain common
+git-diff-files plumbinginterrogators
+git-diff-index plumbinginterrogators
+git-diff-tree plumbinginterrogators
+git-fast-export ancillarymanipulators
+git-fast-import ancillarymanipulators
+git-fetch mainporcelain common
+git-fetch-pack synchingrepositories
+git-filter-branch ancillarymanipulators
+git-fmt-merge-msg purehelpers
+git-for-each-ref plumbinginterrogators
+git-format-patch mainporcelain
+git-fsck ancillaryinterrogators
+git-gc mainporcelain
+git-get-tar-commit-id ancillaryinterrogators
+git-grep mainporcelain common
+git-gui mainporcelain
+git-hash-object plumbingmanipulators
+git-help ancillaryinterrogators
+git-http-fetch synchelpers
+git-http-push synchelpers
+git-imap-send foreignscminterface
+git-index-pack plumbingmanipulators
+git-init mainporcelain common
+git-instaweb ancillaryinterrogators
+gitk mainporcelain
+git-log mainporcelain common
+git-lost-found ancillarymanipulators deprecated
+git-ls-files plumbinginterrogators
+git-ls-remote plumbinginterrogators
+git-ls-tree plumbinginterrogators
+git-mailinfo purehelpers
+git-mailsplit purehelpers
+git-merge mainporcelain common
+git-merge-base plumbinginterrogators
+git-merge-file plumbingmanipulators
+git-merge-index plumbingmanipulators
+git-merge-one-file purehelpers
+git-mergetool ancillarymanipulators
+git-merge-tree ancillaryinterrogators
+git-mktag plumbingmanipulators
+git-mktree plumbingmanipulators
+git-mv mainporcelain common
+git-name-rev plumbinginterrogators
+git-pack-objects plumbingmanipulators
+git-pack-redundant plumbinginterrogators
+git-pack-refs ancillarymanipulators
+git-parse-remote synchelpers
+git-patch-id purehelpers
+git-peek-remote purehelpers deprecated
+git-prune ancillarymanipulators
+git-prune-packed plumbingmanipulators
+git-pull mainporcelain common
+git-push mainporcelain common
+git-quiltimport foreignscminterface
+git-read-tree plumbingmanipulators
+git-rebase mainporcelain common
+git-receive-pack synchelpers
+git-reflog ancillarymanipulators
+git-relink ancillarymanipulators
+git-remote ancillarymanipulators
+git-repack ancillarymanipulators
+git-request-pull foreignscminterface
+git-rerere ancillaryinterrogators
+git-reset mainporcelain common
+git-revert mainporcelain
+git-rev-list plumbinginterrogators
+git-rev-parse ancillaryinterrogators
+git-rm mainporcelain common
+git-runstatus ancillaryinterrogators
+git-send-email foreignscminterface
+git-send-pack synchingrepositories
+git-shell synchelpers
+git-shortlog mainporcelain
+git-show mainporcelain common
+git-show-branch ancillaryinterrogators
+git-show-index plumbinginterrogators
+git-show-ref plumbinginterrogators
+git-sh-setup purehelpers
+git-stash mainporcelain
+git-status mainporcelain common
+git-stripspace purehelpers
+git-submodule mainporcelain
+git-svn foreignscminterface
+git-symbolic-ref plumbingmanipulators
+git-tag mainporcelain common
+git-tar-tree plumbinginterrogators deprecated
+git-unpack-file plumbinginterrogators
+git-unpack-objects plumbingmanipulators
+git-update-index plumbingmanipulators
+git-update-ref plumbingmanipulators
+git-update-server-info synchingrepositories
+git-upload-archive synchelpers
+git-upload-pack synchelpers
+git-var plumbinginterrogators
+git-verify-pack plumbinginterrogators
+git-verify-tag ancillaryinterrogators
+git-whatchanged ancillaryinterrogators
+git-write-tree plumbingmanipulators
*
*/
#include "cache.h"
+#include "exec_cmd.h"
#define MAXNAME (256)
return ret;
}
+const char *git_etc_gitconfig(void)
+{
+ static const char *system_wide;
+ if (!system_wide) {
+ system_wide = ETC_GITCONFIG;
+ if (!is_absolute_path(system_wide)) {
+ /* interpret path relative to exec-dir */
+ const char *exec_path = git_exec_path();
+ system_wide = prefix_path(exec_path, strlen(exec_path),
+ system_wide);
+ }
+ }
+ return system_wide;
+}
+
int git_config(config_fn_t fn)
{
int ret = 0;
* config file otherwise. */
filename = getenv(CONFIG_ENVIRONMENT);
if (!filename) {
- if (!access(ETC_GITCONFIG, R_OK))
- ret += git_config_from_file(fn, ETC_GITCONFIG);
+ if (!access(git_etc_gitconfig(), R_OK))
+ ret += git_config_from_file(fn, git_etc_gitconfig());
home = getenv("HOME");
filename = getenv(CONFIG_LOCAL_ENVIRONMENT);
if (!filename)
# times (my ext3 doesn't).
#
# Define USE_STDEV below if you want git to care about the underlying device
-# change being considered an inode change from the update-cache perspective.
+# change being considered an inode change from the update-index perspective.
## Output files
return !(flags & ~REF_NORMAL);
}
+int check_ref_type(const struct ref *ref, int flags)
+{
+ return check_ref(ref->name, strlen(ref->name), flags);
+}
+
/*
* Read all the refs from the other end
*/
*
* If it returns, the connect is successful; it just dies on errors.
*/
-struct child_process *git_connect(int fd[2], char *url,
+struct child_process *git_connect(int fd[2], const char *url_orig,
const char *prog, int flags)
{
+ char *url = xstrdup(url_orig);
char *host, *path = url;
char *end;
int c;
prog, path, 0,
target_host, 0);
free(target_host);
+ free(url);
if (free_path)
free(path);
return NULL;
fd[0] = conn->out; /* read from child's stdout */
fd[1] = conn->in; /* write to child's stdin */
strbuf_release(&cmd);
+ free(url);
if (free_path)
free(path);
return conn;
_git_diff ()
{
+ local cur="${COMP_WORDS[COMP_CWORD]}"
+ case "$cur" in
+ --*)
+ __gitcomp "--cached --stat --numstat --shortstat --summary
+ --patch-with-stat --name-only --name-status --color
+ --no-color --color-words --no-renames --check
+ --full-index --binary --abbrev --diff-filter
+ --find-copies-harder --pickaxe-all --pickaxe-regex
+ --text --ignore-space-at-eol --ignore-space-change
+ --ignore-all-space --exit-code --quiet --ext-diff
+ --no-ext-diff"
+ return
+ ;;
+ esac
__git_complete_file
}
--- /dev/null
+#!/bin/sh
+#
+# Copyright (c) 2005-2006 Pavel Roskin
+#
+
+OPTIONS_KEEPDASHDASH=
+OPTIONS_SPEC="\
+git-clean [options] <paths>...
+
+Clean untracked files from the working directory
+
+When optional <paths>... arguments are given, the paths
+affected are further limited to those that match them.
+--
+d remove directories as well
+f override clean.requireForce and clean anyway
+n don't remove anything, just show what would be done
+q be quiet, only report errors
+x remove ignored files as well
+X remove only ignored files"
+
+SUBDIRECTORY_OK=Yes
+. git-sh-setup
+require_work_tree
+
+ignored=
+ignoredonly=
+cleandir=
+rmf="rm -f --"
+rmrf="rm -rf --"
+rm_refuse="echo Not removing"
+echo1="echo"
+
+disabled=$(git config --bool clean.requireForce)
+
+while test $# != 0
+do
+ case "$1" in
+ -d)
+ cleandir=1
+ ;;
+ -f)
+ disabled=false
+ ;;
+ -n)
+ disabled=false
+ rmf="echo Would remove"
+ rmrf="echo Would remove"
+ rm_refuse="echo Would not remove"
+ echo1=":"
+ ;;
+ -q)
+ echo1=":"
+ ;;
+ -x)
+ ignored=1
+ ;;
+ -X)
+ ignoredonly=1
+ ;;
+ --)
+ shift
+ break
+ ;;
+ *)
+ usage # should not happen
+ ;;
+ esac
+ shift
+done
+
+# requireForce used to default to false but now it defaults to true.
+# IOW, lack of explicit "clean.requireForce = false" is taken as
+# "clean.requireForce = true".
+case "$disabled" in
+"")
+ die "clean.requireForce not set and -n or -f not given; refusing to clean"
+ ;;
+"true")
+ die "clean.requireForce set and -n or -f not given; refusing to clean"
+ ;;
+esac
+
+if [ "$ignored,$ignoredonly" = "1,1" ]; then
+ die "-x and -X cannot be set together"
+fi
+
+if [ -z "$ignored" ]; then
+ excl="--exclude-per-directory=.gitignore"
+ excl_info= excludes_file=
+ if [ -f "$GIT_DIR/info/exclude" ]; then
+ excl_info="--exclude-from=$GIT_DIR/info/exclude"
+ fi
+ if cfg_excl=$(git config core.excludesfile) && test -f "$cfg_excl"
+ then
+ excludes_file="--exclude-from=$cfg_excl"
+ fi
+ if [ "$ignoredonly" ]; then
+ excl="$excl --ignored"
+ fi
+fi
+
+git ls-files --others --directory \
+ $excl ${excl_info:+"$excl_info"} ${excludes_file:+"$excludes_file"} \
+ -- "$@" |
+while read -r file; do
+ if [ -d "$file" -a ! -L "$file" ]; then
+ if [ -z "$cleandir" ]; then
+ $rm_refuse "$file"
+ continue
+ fi
+ $echo1 "Removing $file"
+ $rmrf "$file"
+ else
+ $echo1 "Removing $file"
+ $rmf "$file"
+ fi
+done
all=
also=
+allow_empty=f
interactive=
only=
logfile=
-a|--a|--al|--all)
all=t
;;
+ --allo|--allow|--allow-|--allow-e|--allow-em|--allow-emp|\
+ --allow-empt|--allow-empty)
+ allow_empty=t
+ ;;
--au=*|--aut=*|--auth=*|--autho=*|--author=*)
force_author="${1#*=}"
;;
# we need to check if there is anything to commit
run_status >/dev/null
fi
-if [ "$?" != "0" -a ! -f "$GIT_DIR/MERGE_HEAD" ]
-then
+case "$allow_empty,$?,$PARENTS" in
+t,* | ?,0,* | ?,*,-p' '?*-p' '?*)
+ # an explicit --allow-empty, or a merge commit can record the
+ # same tree as its parent. Otherwise having commitable paths
+ # is required.
+ ;;
+*)
rm -f "$GIT_DIR/COMMIT_EDITMSG" "$GIT_DIR/SQUASH_MSG"
use_status_color=t
run_status
exit 1
-fi
+esac
case "$no_edit" in
'')
--- /dev/null
+#!/bin/sh
+#
+
+usage () {
+ echo >&2 "usage: $0 [--heads] [--tags] [-u|--upload-pack <upload-pack>]"
+ echo >&2 " <repository> <refs>..."
+ exit 1;
+}
+
+die () {
+ echo >&2 "$*"
+ exit 1
+}
+
+exec=
+while test $# != 0
+do
+ case "$1" in
+ -h|--h|--he|--hea|--head|--heads)
+ heads=heads; shift ;;
+ -t|--t|--ta|--tag|--tags)
+ tags=tags; shift ;;
+ -u|--u|--up|--upl|--uploa|--upload|--upload-|--upload-p|--upload-pa|\
+ --upload-pac|--upload-pack)
+ shift
+ exec="--upload-pack=$1"
+ shift;;
+ -u=*|--u=*|--up=*|--upl=*|--uplo=*|--uploa=*|--upload=*|\
+ --upload-=*|--upload-p=*|--upload-pa=*|--upload-pac=*|--upload-pack=*)
+ exec=--upload-pack=$(expr "z$1" : 'z-[^=]*=\(.*\)')
+ shift;;
+ --)
+ shift; break ;;
+ -*)
+ usage ;;
+ *)
+ break ;;
+ esac
+done
+
+case "$#" in 0) usage ;; esac
+
+case ",$heads,$tags," in
+,,,) heads=heads tags=tags other=other ;;
+esac
+
+. git-parse-remote
+peek_repo="$(get_remote_url "$@")"
+shift
+
+tmp=.ls-remote-$$
+trap "rm -fr $tmp-*" 0 1 2 3 15
+tmpdir=$tmp-d
+
+case "$peek_repo" in
+http://* | https://* | ftp://* )
+ if [ -n "$GIT_SSL_NO_VERIFY" -o \
+ "`git config --bool http.sslVerify`" = false ]; then
+ curl_extra_args="-k"
+ fi
+ if [ -n "$GIT_CURL_FTP_NO_EPSV" -o \
+ "`git config --bool http.noEPSV`" = true ]; then
+ curl_extra_args="${curl_extra_args} --disable-epsv"
+ fi
+ curl -nsf $curl_extra_args --header "Pragma: no-cache" "$peek_repo/info/refs" ||
+ echo "failed slurping"
+ ;;
+
+rsync://* )
+ mkdir $tmpdir &&
+ rsync -rlq "$peek_repo/HEAD" $tmpdir &&
+ rsync -rq "$peek_repo/refs" $tmpdir || {
+ echo "failed slurping"
+ exit
+ }
+ head=$(cat "$tmpdir/HEAD") &&
+ case "$head" in
+ ref:' '*)
+ head=$(expr "z$head" : 'zref: \(.*\)') &&
+ head=$(cat "$tmpdir/$head") || exit
+ esac &&
+ echo "$head HEAD"
+ (cd $tmpdir && find refs -type f) |
+ while read path
+ do
+ tr -d '\012' <"$tmpdir/$path"
+ echo " $path"
+ done &&
+ rm -fr $tmpdir
+ ;;
+
+* )
+ if test -f "$peek_repo" ; then
+ git bundle list-heads "$peek_repo" ||
+ echo "failed slurping"
+ else
+ git-peek-remote $exec "$peek_repo" ||
+ echo "failed slurping"
+ fi
+ ;;
+esac |
+sort -t ' ' -k 2 |
+while read sha1 path
+do
+ case "$sha1" in
+ failed)
+ exit 1 ;;
+ esac
+ case "$path" in
+ refs/heads/*)
+ group=heads ;;
+ refs/tags/*)
+ group=tags ;;
+ *)
+ group=other ;;
+ esac
+ case ",$heads,$tags,$other," in
+ *,$group,*)
+ ;;
+ *)
+ continue;;
+ esac
+ case "$#" in
+ 0)
+ match=yes ;;
+ *)
+ match=no
+ for pat
+ do
+ case "/$path" in
+ */$pat )
+ match=yes
+ break ;;
+ esac
+ done
+ esac
+ case "$match" in
+ no)
+ continue ;;
+ esac
+ echo "$sha1 $path"
+done
# because the current index is what we will be committing as the
# merge result.
-git diff-index --quiet --cached HEAD || exit 2
+git diff-index --quiet --cached HEAD -- || exit 2
exit 0
{
cd "$GIT_DIR"/remotes
ls | while read f; do
- name=$(printf "$f" | tr -c "A-Za-z0-9" ".")
+ name=$(printf "$f" | tr -c "A-Za-z0-9-" ".")
sed -n \
- -e "s/^URL: \(.*\)$/remote.$name.url \1 ./p" \
- -e "s/^Pull: \(.*\)$/remote.$name.fetch \1 ^$ /p" \
- -e "s/^Push: \(.*\)$/remote.$name.push \1 ^$ /p" \
+ -e "s/^URL:[ ]*\(.*\)$/remote.$name.url \1 ./p" \
+ -e "s/^Pull:[ ]*\(.*\)$/remote.$name.fetch \1 ^$ /p" \
+ -e "s/^Push:[ ]*\(.*\)$/remote.$name.push \1 ^$ /p" \
< "$f"
done
echo done
static int is_outside_repo(const char *path, int nongit, const char *prefix)
{
int i;
- if (nongit || !strcmp(path, "-") || path[0] == '/')
+ if (nongit || !strcmp(path, "-") || is_absolute_path(path))
return 1;
if (prefixcmp(path, "../"))
return 0;
* is the default.
*/
- if (!S_ISREG(src->mode) || !S_ISREG(dst->mode))
- return 0; /* leave symlink rename alone */
+ if (S_ISREG(src->mode) != S_ISREG(dst->mode)) {
+ *merge_score_p = (int)MAX_SCORE;
+ return 1; /* even their types are different */
+ }
if (src->sha1_valid && dst->sha1_valid &&
!hashcmp(src->sha1, dst->sha1))
struct diff_filepair *p = q->queue[i];
int score;
- /* We deal only with in-place edit of non directory.
+ /*
+ * We deal only with in-place edit of blobs.
* We do not break anything else.
*/
if (DIFF_FILE_VALID(p->one) && DIFF_FILE_VALID(p->two) &&
- !S_ISDIR(p->one->mode) && !S_ISDIR(p->two->mode) &&
+ object_type(p->one->mode) == OBJ_BLOB &&
+ object_type(p->two->mode) == OBJ_BLOB &&
!strcmp(p->one->path, p->two->path)) {
if (should_break(p->one, p->two,
break_score, &score)) {
* Walk over all the destinations ...
*/
do {
- struct diff_filespec *one = dst->filespec;
+ struct diff_filespec *target = dst->filespec;
struct file_similarity *p, *best;
- int i = 100;
+ int i = 100, best_score = -1;
/*
* .. to find the best source match
*/
best = NULL;
for (p = src; p; p = p->next) {
- struct diff_filespec *two = p->filespec;
+ int score;
+ struct diff_filespec *source = p->filespec;
/* False hash collission? */
- if (hashcmp(one->sha1, two->sha1))
+ if (hashcmp(source->sha1, target->sha1))
continue;
/* Non-regular files? If so, the modes must match! */
- if (!S_ISREG(one->mode) || !S_ISREG(two->mode)) {
- if (one->mode != two->mode)
+ if (!S_ISREG(source->mode) || !S_ISREG(target->mode)) {
+ if (source->mode != target->mode)
continue;
}
- best = p;
- if (basename_same(one, two))
- break;
+ /* Give higher scores to sources that haven't been used already */
+ score = !source->rename_used;
+ score += basename_same(source, target);
+ if (score > best_score) {
+ best = p;
+ best_score = score;
+ if (score == 2)
+ break;
+ }
/* Too many identical alternatives? Pick one */
if (!--i)
}
/* cost matrix sorted by most to least similar pair */
qsort(mx, num_create * num_src, sizeof(*mx), score_compare);
+ for (i = 0; i < num_create * num_src; i++) {
+ struct diff_rename_dst *dst = &rename_dst[mx[i].dst];
+ struct diff_filespec *src;
+ if (dst->pair)
+ continue; /* already done, either exact or fuzzy. */
+ if (mx[i].score < minimum_score)
+ break; /* there is no more usable pair. */
+ src = rename_src[mx[i].src].one;
+ if (src->rename_used)
+ continue;
+ record_rename_pair(mx[i].dst, mx[i].src, mx[i].score);
+ rename_count++;
+ }
for (i = 0; i < num_create * num_src; i++) {
struct diff_rename_dst *dst = &rename_dst[mx[i].dst];
if (dst->pair)
x->flags |= EXC_FLAG_NOWILDCARD;
if (*string == '*' && no_wildcard(string+1))
x->flags |= EXC_FLAG_ENDSWITH;
- if (which->nr == which->alloc) {
- which->alloc = alloc_nr(which->alloc);
- which->excludes = xrealloc(which->excludes,
- which->alloc * sizeof(x));
- }
+ ALLOC_GROW(which->excludes, which->nr + 1, which->alloc);
which->excludes[which->nr++] = x;
}
static int add_excludes_from_file_1(const char *fname,
const char *base,
int baselen,
+ char **buf_p,
struct exclude_list *which)
{
struct stat st;
goto err;
close(fd);
+ if (buf_p)
+ *buf_p = buf;
buf[size++] = '\n';
entry = buf;
for (i = 0; i < size; i++) {
void add_excludes_from_file(struct dir_struct *dir, const char *fname)
{
- if (add_excludes_from_file_1(fname, "", 0,
+ if (add_excludes_from_file_1(fname, "", 0, NULL,
&dir->exclude_list[EXC_FILE]) < 0)
die("cannot use %s as an exclude file", fname);
}
-int push_exclude_per_directory(struct dir_struct *dir, const char *base, int baselen)
+static void prep_exclude(struct dir_struct *dir, const char *base, int baselen)
{
- char exclude_file[PATH_MAX];
- struct exclude_list *el = &dir->exclude_list[EXC_DIRS];
- int current_nr = el->nr;
-
- if (dir->exclude_per_dir) {
- memcpy(exclude_file, base, baselen);
- strcpy(exclude_file + baselen, dir->exclude_per_dir);
- add_excludes_from_file_1(exclude_file, base, baselen, el);
+ struct exclude_list *el;
+ struct exclude_stack *stk = NULL;
+ int current;
+
+ if ((!dir->exclude_per_dir) ||
+ (baselen + strlen(dir->exclude_per_dir) >= PATH_MAX))
+ return; /* too long a path -- ignore */
+
+ /* Pop the ones that are not the prefix of the path being checked. */
+ el = &dir->exclude_list[EXC_DIRS];
+ while ((stk = dir->exclude_stack) != NULL) {
+ if (stk->baselen <= baselen &&
+ !strncmp(dir->basebuf, base, stk->baselen))
+ break;
+ dir->exclude_stack = stk->prev;
+ while (stk->exclude_ix < el->nr)
+ free(el->excludes[--el->nr]);
+ free(stk->filebuf);
+ free(stk);
}
- return current_nr;
-}
-void pop_exclude_per_directory(struct dir_struct *dir, int stk)
-{
- struct exclude_list *el = &dir->exclude_list[EXC_DIRS];
+ /* Read from the parent directories and push them down. */
+ current = stk ? stk->baselen : -1;
+ while (current < baselen) {
+ struct exclude_stack *stk = xcalloc(1, sizeof(*stk));
+ const char *cp;
- while (stk < el->nr)
- free(el->excludes[--el->nr]);
+ if (current < 0) {
+ cp = base;
+ current = 0;
+ }
+ else {
+ cp = strchr(base + current + 1, '/');
+ if (!cp)
+ die("oops in prep_exclude");
+ cp++;
+ }
+ stk->prev = dir->exclude_stack;
+ stk->baselen = cp - base;
+ stk->exclude_ix = el->nr;
+ memcpy(dir->basebuf + current, base + current,
+ stk->baselen - current);
+ strcpy(dir->basebuf + stk->baselen, dir->exclude_per_dir);
+ add_excludes_from_file_1(dir->basebuf,
+ dir->basebuf, stk->baselen,
+ &stk->filebuf, el);
+ dir->exclude_stack = stk;
+ current = stk->baselen;
+ }
+ dir->basebuf[baselen] = '\0';
}
/* Scan the list and let the last match determines the fate.
const char *basename = strrchr(pathname, '/');
basename = (basename) ? basename+1 : pathname;
+ prep_exclude(dir, pathname, basename-pathname);
for (st = EXC_CMDL; st <= EXC_FILE; st++) {
switch (excluded_1(pathname, pathlen, basename, &dir->exclude_list[st])) {
case 0:
int contents = 0;
if (fdir) {
- int exclude_stk;
struct dirent *de;
char fullname[PATH_MAX + 1];
memcpy(fullname, base, baselen);
- exclude_stk = push_exclude_per_directory(dir, base, baselen);
-
while ((de = readdir(fdir)) != NULL) {
int len, dtype;
int exclude;
}
exit_early:
closedir(fdir);
-
- pop_exclude_per_directory(dir, exclude_stk);
}
return contents;
int read_directory(struct dir_struct *dir, const char *path, const char *base, int baselen, const char **pathspec)
{
struct path_simplify *simplify = create_simplify(pathspec);
- char *pp = NULL;
-
- /*
- * Make sure to do the per-directory exclude for all the
- * directories leading up to our base.
- */
- if (baselen) {
- if (dir->exclude_per_dir) {
- char *p;
- pp = xmalloc(baselen+1);
- memcpy(pp, base, baselen+1);
- p = pp;
- while (1) {
- char save = *p;
- *p = 0;
- push_exclude_per_directory(dir, pp, p-pp);
- *p++ = save;
- if (!save)
- break;
- p = strchr(p, '/');
- if (p)
- p++;
- else
- p = pp + baselen;
- }
- }
- }
read_directory_recursive(dir, path, base, baselen, 0, simplify);
free_simplify(simplify);
- free(pp);
qsort(dir->entries, dir->nr, sizeof(struct dir_entry *), cmp_name);
qsort(dir->ignored, dir->ignored_nr, sizeof(struct dir_entry *), cmp_name);
return dir->nr;
#ifndef DIR_H
#define DIR_H
-/*
- * We maintain three exclude pattern lists:
- * EXC_CMDL lists patterns explicitly given on the command line.
- * EXC_DIRS lists patterns obtained from per-directory ignore files.
- * EXC_FILE lists patterns from fallback ignore files.
- */
-#define EXC_CMDL 0
-#define EXC_DIRS 1
-#define EXC_FILE 2
-
-
struct dir_entry {
unsigned int len;
char name[FLEX_ARRAY]; /* more */
} **excludes;
};
+struct exclude_stack {
+ struct exclude_stack *prev;
+ char *filebuf;
+ int baselen;
+ int exclude_ix;
+};
+
struct dir_struct {
int nr, alloc;
int ignored_nr, ignored_alloc;
/* Exclude info */
const char *exclude_per_dir;
struct exclude_list exclude_list[3];
+ /*
+ * We maintain three exclude pattern lists:
+ * EXC_CMDL lists patterns explicitly given on the command line.
+ * EXC_DIRS lists patterns obtained from per-directory ignore files.
+ * EXC_FILE lists patterns from fallback ignore files.
+ */
+#define EXC_CMDL 0
+#define EXC_DIRS 1
+#define EXC_FILE 2
+
+ struct exclude_stack *exclude_stack;
+ char basebuf[PATH_MAX];
};
extern int common_prefix(const char **pathspec);
extern int match_pathspec(const char **pathspec, const char *name, int namelen, int prefix, char *seen);
extern int read_directory(struct dir_struct *, const char *path, const char *base, int baselen, const char **pathspec);
-extern int push_exclude_per_directory(struct dir_struct *, const char *, int);
-extern void pop_exclude_per_directory(struct dir_struct *, int);
extern int excluded(struct dir_struct *, const char *);
extern void add_excludes_from_file(struct dir_struct *, const char *fname);
tmp = argv[0];
argv[0] = cmd.buf;
- trace_argv_printf(argv, -1, "trace: exec:");
+ trace_argv_printf(argv, "trace: exec:");
/* execvp() can only ever return if it fails */
execvp(cmd.buf, (char **)argv);
static struct cmdname_help common_cmds[] = {"
-sort <<\EOF |
-add
-apply
-archive
-bisect
-branch
-checkout
-cherry-pick
-clone
-commit
-diff
-fetch
-grep
-init
-log
-merge
-mv
-prune
-pull
-push
-rebase
-reset
-revert
-rm
-show
-show-branch
-status
-tag
-EOF
+sed -n -e 's/^git-\([^ ]*\)[ ].* common.*/\1/p' command-list.txt |
+sort |
while read cmd
do
sed -n '
case "$resolved" in
'')
- files=$(git diff-index --cached --name-only HEAD) || exit
+ files=$(git diff-index --cached --name-only HEAD --) || exit
if [ "$files" ]; then
echo "Dirty index: cannot apply patches (dirty: $files)" >&2
exit 1
GIT_AUTHOR_EMAIL="$(sed -n '/^Email/ s/Email: //p' "$dotest/info")"
GIT_AUTHOR_DATE="$(sed -n '/^Date/ s/Date: //p' "$dotest/info")"
- if test -z "$GIT_AUTHOR_EMAIL"
+ if test -z "$GIT_AUTHOR_EMAIL" || test -z "$GIT_AUTHOR_DATE"
then
- echo "Patch does not have a valid e-mail address."
+ echo "Patch does not have valid authorship information."
stop_here $this
fi
case "$resolved$interactive" in
tt)
# This is used only for interactive view option.
- git diff-index -p --cached HEAD >"$dotest/patch"
+ git diff-index -p --cached HEAD -- >"$dotest/patch"
;;
esac
esac
# trust what the user has in the index file and the
# working tree.
resolved=
- git diff-index --quiet --cached HEAD && {
+ git diff-index --quiet --cached HEAD -- && {
echo "No changes - did you forget to use 'git add'?"
stop_here_user_resolve $this
}
then
# Applying the patch to an earlier tree and merging the
# result may have produced the same tree as ours.
- git diff-index --quiet --cached HEAD && {
+ git diff-index --quiet --cached HEAD -- && {
echo No changes -- Patch already applied.
go_next
continue
}
bisect_autostart() {
- test -d "$GIT_DIR/refs/bisect" || {
+ test -f "$GIT_DIR/BISECT_NAMES" || {
echo >&2 'You need to start by "git bisect start"'
if test -t 0
then
;;
refs/heads/*)
[ -s "$GIT_DIR/head-name" ] && die "won't bisect on seeked tree"
- echo "$head" | sed 's#^refs/heads/##' >"$GIT_DIR/head-name"
+ echo "${head#refs/heads/}" >"$GIT_DIR/head-name"
;;
*)
die "Bad HEAD - strange symbolic ref"
# Get rid of any old bisect state
#
bisect_clean_state
- mkdir "$GIT_DIR/refs/bisect"
#
# Check for one bad and then some good revisions.
good|skip) tag="$state"-"$rev" ;;
*) die "Bad bisect_write argument: $state" ;;
esac
- echo "$rev" >"$GIT_DIR/refs/bisect/$tag"
+ git update-ref "refs/bisect/$tag" "$rev"
echo "# $state: "$(git show-branch $rev) >>"$GIT_DIR/BISECT_LOG"
test -z "$nolog" && echo "git-bisect $state $rev" >>"$GIT_DIR/BISECT_LOG"
}
;;
*)
THEN=''
- test -d "$GIT_DIR/refs/bisect" || {
+ test -f "$GIT_DIR/BISECT_NAMES" || {
echo >&2 'You need to start by "git bisect start".'
THEN='then '
}
if expr "$_tried" : ".*[|].*" > /dev/null ; then
echo "There are only 'skip'ped commit left to test."
echo "The first bad commit could be any of:"
- echo "$_tried" | sed -e 's/[|]/\
-/g'
+ echo "$_tried" | tr '[|]' '[\012]'
echo "We cannot bisect more!"
exit 2
fi
exit_if_skipped_commits "$bisect_rev"
echo "Bisecting: $bisect_nr revisions left to test after this"
- echo "$bisect_rev" >"$GIT_DIR/refs/heads/new-bisect"
+ git branch -f new-bisect "$bisect_rev"
git checkout -q new-bisect || exit
- mv "$GIT_DIR/refs/heads/new-bisect" "$GIT_DIR/refs/heads/bisect" &&
- GIT_DIR="$GIT_DIR" git symbolic-ref HEAD refs/heads/bisect
+ git branch -M new-bisect bisect
git show-branch "$bisect_rev"
}
bisect_visualize() {
bisect_next_check fail
- not=`cd "$GIT_DIR/refs" && echo bisect/good-*`
- eval gitk bisect/bad --not $not -- $(cat "$GIT_DIR/BISECT_NAMES")
+ not=$(git for-each-ref --format='%(refname)' "refs/bisect/good-*")
+ eval gitk refs/bisect/bad --not $not -- $(cat "$GIT_DIR/BISECT_NAMES")
}
bisect_reset() {
+ test -f "$GIT_DIR/BISECT_NAMES" || {
+ echo "We are not bisecting."
+ return
+ }
case "$#" in
0) if [ -s "$GIT_DIR/head-name" ]; then
branch=`cat "$GIT_DIR/head-name"`
}
bisect_clean_state() {
- rm -fr "$GIT_DIR/refs/bisect"
- rm -f "$GIT_DIR/refs/heads/bisect"
+ # There may be some refs packed during bisection.
+ git for-each-ref --format='%(refname) %(objectname)' refs/bisect/\* refs/heads/bisect |
+ while read ref hash
+ do
+ git update-ref -d $ref $hash
+ done
rm -f "$GIT_DIR/BISECT_LOG"
rm -f "$GIT_DIR/BISECT_NAMES"
rm -f "$GIT_DIR/BISECT_RUN"
describe_detached_head () {
test -n "$quiet" || {
printf >&2 "$1 "
- GIT_PAGER= git log >&2 -1 --pretty=oneline --abbrev-commit "$2"
+ GIT_PAGER= git log >&2 -1 --pretty=oneline --abbrev-commit "$2" --
}
}
if test -n "$branch"
then
old_branch_name=`expr "z$oldbranch" : 'zrefs/heads/\(.*\)'`
- GIT_DIR="$GIT_DIR" git symbolic-ref -m "checkout: moving from $old_branch_name to $branch" HEAD "refs/heads/$branch"
+ GIT_DIR="$GIT_DIR" git symbolic-ref -m "checkout: moving from ${old_branch_name:-$old} to $branch" HEAD "refs/heads/$branch"
if test -n "$quiet"
then
true # nothing
fi
elif test -n "$detached"
then
- git update-ref --no-deref -m "checkout: moving to $arg" HEAD "$detached" ||
+ old_branch_name=`expr "z$oldbranch" : 'zrefs/heads/\(.*\)'`
+ git update-ref --no-deref -m "checkout: moving from ${old_branch_name:-$old} to $arg" HEAD "$detached" ||
die "Cannot detach HEAD"
if test -n "$detach_warn"
then
+++ /dev/null
-#!/bin/sh
-#
-# Copyright (c) 2005-2006 Pavel Roskin
-#
-
-OPTIONS_KEEPDASHDASH=
-OPTIONS_SPEC="\
-git-clean [options] <paths>...
-
-Clean untracked files from the working directory
-
-When optional <paths>... arguments are given, the paths
-affected are further limited to those that match them.
---
-d remove directories as well
-f override clean.requireForce and clean anyway
-n don't remove anything, just show what would be done
-q be quiet, only report errors
-x remove ignored files as well
-X remove only ignored files"
-
-SUBDIRECTORY_OK=Yes
-. git-sh-setup
-require_work_tree
-
-ignored=
-ignoredonly=
-cleandir=
-rmf="rm -f --"
-rmrf="rm -rf --"
-rm_refuse="echo Not removing"
-echo1="echo"
-
-disabled=$(git config --bool clean.requireForce)
-
-while test $# != 0
-do
- case "$1" in
- -d)
- cleandir=1
- ;;
- -f)
- disabled=false
- ;;
- -n)
- disabled=false
- rmf="echo Would remove"
- rmrf="echo Would remove"
- rm_refuse="echo Would not remove"
- echo1=":"
- ;;
- -q)
- echo1=":"
- ;;
- -x)
- ignored=1
- ;;
- -X)
- ignoredonly=1
- ;;
- --)
- shift
- break
- ;;
- *)
- usage # should not happen
- ;;
- esac
- shift
-done
-
-# requireForce used to default to false but now it defaults to true.
-# IOW, lack of explicit "clean.requireForce = false" is taken as
-# "clean.requireForce = true".
-case "$disabled" in
-"")
- die "clean.requireForce not set and -n or -f not given; refusing to clean"
- ;;
-"true")
- die "clean.requireForce set and -n or -f not given; refusing to clean"
- ;;
-esac
-
-if [ "$ignored,$ignoredonly" = "1,1" ]; then
- die "-x and -X cannot be set together"
-fi
-
-if [ -z "$ignored" ]; then
- excl="--exclude-per-directory=.gitignore"
- excl_info= excludes_file=
- if [ -f "$GIT_DIR/info/exclude" ]; then
- excl_info="--exclude-from=$GIT_DIR/info/exclude"
- fi
- if cfg_excl=$(git config core.excludesfile) && test -f "$cfg_excl"
- then
- excludes_file="--exclude-from=$cfg_excl"
- fi
- if [ "$ignoredonly" ]; then
- excl="$excl --ignored"
- fi
-fi
-
-git ls-files --others --directory \
- $excl ${excl_info:+"$excl_info"} ${excludes_file:+"$excludes_file"} \
- -- "$@" |
-while read -r file; do
- if [ -d "$file" -a ! -L "$file" ]; then
- if [ -z "$cleandir" ]; then
- $rm_refuse "$file"
- continue
- fi
- $echo1 "Removing $file"
- $rmrf "$file"
- else
- $echo1 "Removing $file"
- $rmf "$file"
- fi
-done
trap cleanup 0
mkdir -p "$dir" && D=$(cd "$dir" && pwd) || usage
test -n "$GIT_WORK_TREE" && mkdir -p "$GIT_WORK_TREE" &&
-W=$(cd "$GIT_WORK_TREE" && pwd) && export GIT_WORK_TREE="$W"
+W=$(cd "$GIT_WORK_TREE" && pwd) && GIT_WORK_TREE="$W" && export GIT_WORK_TREE
if test yes = "$bare" || test -n "$GIT_WORK_TREE"; then
GIT_DIR="$D"
else
#include <fnmatch.h>
#include <sys/poll.h>
#include <sys/socket.h>
+#include <sys/ioctl.h>
+#include <sys/select.h>
#include <assert.h>
#include <regex.h>
#include <netinet/in.h>
}
}
}
- if (@ARGV == 0) {
- chomp(my $module = `git-repo-config --get cvsimport.module`);
- push(@ARGV, $module);
- }
}
my $opts = "haivmkuo:d:p:r:C:z:s:M:P:A:S:L:";
getopts($opts) or usage();
usage if $opt_h;
+if (@ARGV == 0) {
+ chomp(my $module = `git-repo-config --get cvsimport.module`);
+ push(@ARGV, $module) if $? == 0;
+}
@ARGV <= 1 or usage("You can't specify more than one CVS module");
if ($opt_d) {
return $s =~ /^[a-f0-9]{40}$/;
}
-sub get_headref ($$) {
- my $name = shift;
- my $git_dir = shift;
-
- my $f = "$git_dir/$remote/$name";
- if (open(my $fh, $f)) {
- chomp(my $r = <$fh>);
- is_sha1($r) or die "Cannot get head id for $name ($r): $!";
- return $r;
- }
- die "unable to open $f: $!" unless $! == POSIX::ENOENT;
- return undef;
+sub get_headref ($) {
+ my $name = shift;
+ my $r = `git rev-parse --verify '$name' 2>/dev/null`;
+ return undef unless $? == 0;
+ chomp $r;
+ return $r;
}
-d $git_tree
$ignorebranch{'#CVSPS_NO_BRANCH'} = 1;
sub commit {
- if ($branch eq $opt_o && !$index{branch} && !get_headref($branch, $git_dir)) {
+ if ($branch eq $opt_o && !$index{branch} &&
+ !get_headref("$remote/$branch")) {
# looks like an initial commit
# use the index primed by git-init
$ENV{GIT_INDEX_FILE} = "$git_dir/index";
update_index(@old, @new);
@old = @new = ();
my $tree = write_tree();
- my $parent = get_headref($last_branch, $git_dir);
+ my $parent = get_headref("$remote/$last_branch");
print "Parent ID " . ($parent ? $parent : "(empty)") . "\n" if $opt_v;
my @commit_args;
foreach my $rx (@mergerx) {
next unless $logmsg =~ $rx && $1;
my $mparent = $1 eq 'HEAD' ? $opt_o : $1;
- if (my $sha1 = get_headref($mparent, $git_dir)) {
+ if (my $sha1 = get_headref("$remote/$mparent")) {
push @commit_args, '-p', $mparent;
print "Merge parent branch: $mparent\n" if $opt_v;
}
print STDERR "Branch $branch erroneously stems from itself -- changed ancestor to $opt_o\n";
$ancestor = $opt_o;
}
- if (-f "$git_dir/$remote/$branch") {
+ if (defined get_headref("$remote/$branch")) {
print STDERR "Branch $branch already exists!\n";
$state=11;
next;
}
- unless (open(H,"$git_dir/$remote/$ancestor")) {
+ my $id = get_headref("$remote/$ancestor");
+ if (!$id) {
print STDERR "Branch $ancestor does not exist!\n";
$ignorebranch{$branch} = 1;
$state=11;
next;
}
- chomp(my $id = <H>);
- close(H);
- unless (open(H,"> $git_dir/$remote/$branch")) {
- print STDERR "Could not create branch $branch: $!\n";
+
+ system(qw(git update-ref -m cvsimport),
+ "$remote/$branch", $id);
+ if($? != 0) {
+ print STDERR "Could not create branch $branch\n";
$ignorebranch{$branch} = 1;
$state=11;
next;
}
- print H "$id\n"
- or die "Could not write branch $branch: $!";
- close(H)
- or die "Could not write branch $branch: $!";
}
$last_branch = $branch if $branch ne $last_branch;
$state = 9;
$orig_branch = "master";
print "DONE; creating $orig_branch branch\n" if $opt_v;
system("git-update-ref", "refs/heads/master", "$remote/$opt_o")
- unless -f "$git_dir/refs/heads/master";
+ unless defined get_headref('refs/heads/master');
system("git-symbolic-ref", "$remote/HEAD", "$remote/$opt_o")
if ($opt_r && $opt_o ne 'HEAD');
system('git-update-ref', 'HEAD', "$orig_branch");
# a new branch. You can specify a number of filters to modify the commits,
# files and trees.
+# The following functions will also be available in the commit filter:
+
+functions=$(cat << \EOF
warn () {
echo "$*" >&2
}
echo "$*" >&2
exit 1
}
+EOF
+)
+
+eval "$functions"
# When piped a commit, output a script to set the ident of either
# "author" or "committer
h
s/^'$lid' \([^<]*\) <[^>]*> .*$/\1/
s/'\''/'\''\'\'\''/g
- s/.*/export GIT_'$uid'_NAME='\''&'\''/p
+ s/.*/GIT_'$uid'_NAME='\''&'\''; export GIT_'$uid'_NAME/p
g
s/^'$lid' [^<]* <\([^>]*\)> .*$/\1/
s/'\''/'\''\'\'\''/g
- s/.*/export GIT_'$uid'_EMAIL='\''&'\''/p
+ s/.*/GIT_'$uid'_EMAIL='\''&'\''; export GIT_'$uid'_EMAIL/p
g
s/^'$lid' [^<]* <[^>]*> \(.*\)$/\1/
s/'\''/'\''\'\'\''/g
- s/.*/export GIT_'$uid'_DATE='\''&'\''/p
+ s/.*/GIT_'$uid'_DATE='\''&'\''; export GIT_'$uid'_DATE/p
q
}
LANG=C LC_ALL=C sed -ne "$pick_id_script"
# Ensure non-empty id name.
- echo "[ -n \"\$GIT_${uid}_NAME\" ] || export GIT_${uid}_NAME=\"\${GIT_${uid}_EMAIL%%@*}\""
+ echo "case \"\$GIT_${uid}_NAME\" in \"\") GIT_${uid}_NAME=\"\${GIT_${uid}_EMAIL%%@*}\" && export GIT_${uid}_NAME;; esac"
}
-# This script can be sourced by the commit filter to get the functions
-test "a$SOURCE_FUNCTIONS" = a1 && return
-this_script="$(cd "$(dirname "$0")"; pwd)"/$(basename "$0")
-export this_script
-
USAGE="[--env-filter <command>] [--tree-filter <command>] \
[--index-filter <command>] [--parent-filter <command>] \
[--msg-filter <command>] [--commit-filter <command>] \
. git-sh-setup
git diff-files --quiet &&
- git diff-index --cached --quiet HEAD ||
+ git diff-index --cached --quiet HEAD -- ||
die "Cannot rewrite branch(es) with a dirty working directory."
tempdir=.git-rewrite
filter_msg="$OPTARG"
;;
--commit-filter)
- filter_commit='SOURCE_FUNCTIONS=1 . "$this_script";'" $OPTARG"
+ filter_commit="$functions; $OPTARG"
;;
--tag-name-filter)
filter_tag_name="$OPTARG"
ORIG_GIT_DIR="$GIT_DIR"
ORIG_GIT_WORK_TREE="$GIT_WORK_TREE"
ORIG_GIT_INDEX_FILE="$GIT_INDEX_FILE"
-export GIT_DIR GIT_WORK_TREE=.
+GIT_WORK_TREE=.
+export GIT_DIR GIT_WORK_TREE
# These refs should be updated if their heads were rewritten
test -s "$tempdir"/heads ||
die "Which ref do you want to rewrite?"
-export GIT_INDEX_FILE="$(pwd)/../index"
+GIT_INDEX_FILE="$(pwd)/../index"
+export GIT_INDEX_FILE
git read-tree || die "Could not seed the index"
ret=0
git read-tree -i -m $commit:"$filter_subdir"
esac || die "Could not initialize the index"
- export GIT_COMMIT=$commit
+ GIT_COMMIT=$commit
+ export GIT_COMMIT
git cat-file commit "$commit" >../commit ||
die "Cannot read commit $commit"
[ -f "../map/$sha1" ] || continue
new_sha1="$(cat "../map/$sha1")"
- export GIT_COMMIT="$sha1"
+ GIT_COMMIT="$sha1"
+ export GIT_COMMIT
new_ref="$(echo "$ref" | eval "$filter_tag_name")" ||
die "tag name filter failed: $filter_tag_name"
+++ /dev/null
-#!/bin/sh
-#
-
-usage () {
- echo >&2 "usage: $0 [--heads] [--tags] [-u|--upload-pack <upload-pack>]"
- echo >&2 " <repository> <refs>..."
- exit 1;
-}
-
-die () {
- echo >&2 "$*"
- exit 1
-}
-
-exec=
-while test $# != 0
-do
- case "$1" in
- -h|--h|--he|--hea|--head|--heads)
- heads=heads; shift ;;
- -t|--t|--ta|--tag|--tags)
- tags=tags; shift ;;
- -u|--u|--up|--upl|--uploa|--upload|--upload-|--upload-p|--upload-pa|\
- --upload-pac|--upload-pack)
- shift
- exec="--upload-pack=$1"
- shift;;
- -u=*|--u=*|--up=*|--upl=*|--uplo=*|--uploa=*|--upload=*|\
- --upload-=*|--upload-p=*|--upload-pa=*|--upload-pac=*|--upload-pack=*)
- exec=--upload-pack=$(expr "z$1" : 'z-[^=]*=\(.*\)')
- shift;;
- --)
- shift; break ;;
- -*)
- usage ;;
- *)
- break ;;
- esac
-done
-
-case "$#" in 0) usage ;; esac
-
-case ",$heads,$tags," in
-,,,) heads=heads tags=tags other=other ;;
-esac
-
-. git-parse-remote
-peek_repo="$(get_remote_url "$@")"
-shift
-
-tmp=.ls-remote-$$
-trap "rm -fr $tmp-*" 0 1 2 3 15
-tmpdir=$tmp-d
-
-case "$peek_repo" in
-http://* | https://* | ftp://* )
- if [ -n "$GIT_SSL_NO_VERIFY" -o \
- "`git config --bool http.sslVerify`" = false ]; then
- curl_extra_args="-k"
- fi
- if [ -n "$GIT_CURL_FTP_NO_EPSV" -o \
- "`git config --bool http.noEPSV`" = true ]; then
- curl_extra_args="${curl_extra_args} --disable-epsv"
- fi
- curl -nsf $curl_extra_args --header "Pragma: no-cache" "$peek_repo/info/refs" ||
- echo "failed slurping"
- ;;
-
-rsync://* )
- mkdir $tmpdir &&
- rsync -rlq "$peek_repo/HEAD" $tmpdir &&
- rsync -rq "$peek_repo/refs" $tmpdir || {
- echo "failed slurping"
- exit
- }
- head=$(cat "$tmpdir/HEAD") &&
- case "$head" in
- ref:' '*)
- head=$(expr "z$head" : 'zref: \(.*\)') &&
- head=$(cat "$tmpdir/$head") || exit
- esac &&
- echo "$head HEAD"
- (cd $tmpdir && find refs -type f) |
- while read path
- do
- tr -d '\012' <"$tmpdir/$path"
- echo " $path"
- done &&
- rm -fr $tmpdir
- ;;
-
-* )
- if test -f "$peek_repo" ; then
- git bundle list-heads "$peek_repo" ||
- echo "failed slurping"
- else
- git-peek-remote $exec "$peek_repo" ||
- echo "failed slurping"
- fi
- ;;
-esac |
-sort -t ' ' -k 2 |
-while read sha1 path
-do
- case "$sha1" in
- failed)
- exit 1 ;;
- esac
- case "$path" in
- refs/heads/*)
- group=heads ;;
- refs/tags/*)
- group=tags ;;
- *)
- group=other ;;
- esac
- case ",$heads,$tags,$other," in
- *,$group,*)
- ;;
- *)
- continue;;
- esac
- case "$#" in
- 0)
- match=yes ;;
- *)
- match=no
- for pat
- do
- case "/$path" in
- */$pat )
- match=yes
- break ;;
- esac
- done
- esac
- case "$match" in
- no)
- continue ;;
- esac
- echo "$sha1 $path"
-done
die "You are in the middle of a conflicted merge."
strategy_args= no_summary= no_commit= squash= no_ff=
+curr_branch=$(git symbolic-ref -q HEAD)
+curr_branch_short=$(echo "$curr_branch" | sed "s|refs/heads/||")
+rebase=$(git config --bool branch.$curr_branch_short.rebase)
while :
do
case "$1" in
esac
strategy_args="${strategy_args}-s $strategy "
;;
+ -r|--r|--re|--reb|--reba|--rebas|--rebase)
+ rebase=true
+ ;;
+ --no-r|--no-re|--no-reb|--no-reba|--no-rebas|--no-rebase)
+ rebase=false
+ ;;
-h|--h|--he|--hel|--help)
usage
;;
case "$merge_head" in
'')
- curr_branch=$(git symbolic-ref -q HEAD)
case $? in
0) ;;
1) echo >&2 "You are not currently on a branch; you must explicitly"
fi
merge_name=$(git fmt-merge-msg <"$GIT_DIR/FETCH_HEAD") || exit
+test true = "$rebase" && exec git-rebase $merge_head
exec git-merge $no_summary $no_commit $squash $no_ff $strategy_args \
"$merge_name" HEAD $merge_head
}
# Parse the author information
- export GIT_AUTHOR_NAME=$(sed -ne 's/Author: //p' "$tmp_info")
- export GIT_AUTHOR_EMAIL=$(sed -ne 's/Email: //p' "$tmp_info")
+ GIT_AUTHOR_NAME=$(sed -ne 's/Author: //p' "$tmp_info")
+ GIT_AUTHOR_EMAIL=$(sed -ne 's/Email: //p' "$tmp_info")
+ export GIT_AUTHOR_NAME GIT_AUTHOR_EMAIL
while test -z "$GIT_AUTHOR_EMAIL" && test -z "$GIT_AUTHOR_NAME" ; do
if [ -n "$quilt_author" ] ; then
GIT_AUTHOR_NAME="$quilt_author_name";
GIT_AUTHOR_EMAIL="$patch_author_email"
fi
done
- export GIT_AUTHOR_DATE=$(sed -ne 's/Date: //p' "$tmp_info")
- export SUBJECT=$(sed -ne 's/Subject: //p' "$tmp_info")
+ GIT_AUTHOR_DATE=$(sed -ne 's/Date: //p' "$tmp_info")
+ SUBJECT=$(sed -ne 's/Subject: //p' "$tmp_info")
+ export GIT_AUTHOR_DATE SUBJECT
if [ -z "$SUBJECT" ] ; then
SUBJECT=$(echo $patch_name | sed -e 's/.patch$//')
fi
test -f "$DOTEST"/strategy && STRATEGY="$(cat "$DOTEST"/strategy)"
test -f "$DOTEST"/verbose && VERBOSE=t
+GIT_CHERRY_PICK_HELP=" After resolving the conflicts,
+mark the corrected paths with 'git add <paths>', and
+run 'git rebase --continue'"
+export GIT_CHERRY_PICK_HELP
+
warn () {
echo "$*" >&2
}
git rev-parse --verify HEAD > /dev/null &&
git update-index --refresh &&
git diff-files --quiet &&
- git diff-index --cached --quiet HEAD ||
+ git diff-index --cached --quiet HEAD -- ||
die "Working tree is dirty"
}
die_with_patch () {
make_patch "$1"
+ git rerere
die "$2"
}
msg="$(git cat-file commit $sha1 | sed -e '1,/^$/d')"
# No point in merging the first parent, that's HEAD
new_parents=${new_parents# $first_parent}
- # NEEDSWORK: give rerere a chance
if ! GIT_AUTHOR_NAME="$GIT_AUTHOR_NAME" \
GIT_AUTHOR_EMAIL="$GIT_AUTHOR_EMAIL" \
GIT_AUTHOR_DATE="$GIT_AUTHOR_DATE" \
output git merge $STRATEGY -m "$msg" \
$new_parents
then
+ git rerere
printf "%s\n" "$msg" > "$GIT_DIR"/MERGE_MSG
die Error redoing merge $sha1
fi
git rev-parse --verify HEAD > /dev/null &&
git update-index --refresh &&
git diff-files --quiet &&
- ! git diff-index --cached --quiet HEAD &&
+ ! git diff-index --cached --quiet HEAD -- &&
. "$DOTEST"/author-script && {
test ! -f "$DOTEST"/amend || git reset --soft HEAD^
} &&
--abort)
comment_for_reflog abort
+ git rerere clear
test -d "$DOTEST" || die "No interactive rebase running"
HEADNAME=$(cat "$DOTEST"/head-name)
--skip)
comment_for_reflog skip
+ git rerere clear
test -d "$DOTEST" || die "No interactive rebase running"
output git reset --hard && do_rest
fi
cmt=`cat "$dotest/current"`
- if ! git diff-index --quiet HEAD
+ if ! git diff-index --quiet HEAD --
then
if ! git-commit -C "$cmt"
then
exit
;;
--skip)
+ git reset --hard HEAD || exit $?
if test -d "$dotest"
then
git rerere clear
# The tree must be really really clean.
git update-index --refresh || exit
-diff=$(git diff-index --cached --name-status -r HEAD)
+diff=$(git diff-index --cached --name-status -r HEAD --)
case "$diff" in
?*) echo "cannot rebase: your index is not up-to-date"
echo "$diff"
#!/bin/sh
# Copyright (c) 2007, Nanako Shiraishi
-USAGE='[ | list | show | apply | clear]'
+USAGE='[ | save | list | show | apply | clear | create ]'
SUBDIRECTORY_OK=Yes
OPTIONS_SPEC=
ref_stash=refs/stash
no_changes () {
- git diff-index --quiet --cached HEAD &&
+ git diff-index --quiet --cached HEAD -- &&
git diff-files --quiet
}
# state of the base commit
if b_commit=$(git rev-parse --verify HEAD)
then
- head=$(git log --abbrev-commit --pretty=oneline -n 1 HEAD)
+ head=$(git log --no-color --abbrev-commit --pretty=oneline -n 1 HEAD --)
else
die "You do not have the initial commit yet"
fi
list_stash () {
have_stash || return 0
- git log --pretty=oneline -g "$@" $ref_stash |
+ git log --no-color --pretty=oneline -g "$@" $ref_stash -- |
sed -n -e 's/^[.0-9a-f]* refs\///p'
}
shift
show_stash "$@"
;;
+save)
+ shift
+ save_stash "$*" && git-reset --hard
+ ;;
apply)
shift
apply_stash "$@"
fi
create_stash "$*" && echo "$w_commit"
;;
-help | usage)
- usage
- ;;
*)
- if test $# -gt 0 && test "$1" = save
+ if test $# -eq 0
then
- shift
+ save_stash && git-reset --hard
+ else
+ usage
fi
- save_stash "$*" && git-reset --hard
;;
esac
die "'$path' already exists in the index"
module_clone "$path" "$realrepo" || exit
- (unset GIT_DIR && cd "$path" && git checkout -q ${branch:+-b "$branch" "origin/$branch"}) ||
+ (unset GIT_DIR; cd "$path" && git checkout -q ${branch:+-b "$branch" "origin/$branch"}) ||
die "Unable to checkout submodule '$path'"
git add "$path" ||
die "Failed to add submodule '$path'"
module_clone "$path" "$url" || exit
subsha1=
else
- subsha1=$(unset GIT_DIR && cd "$path" &&
+ subsha1=$(unset GIT_DIR; cd "$path" &&
git rev-parse --verify HEAD) ||
die "Unable to find current revision in submodule path '$path'"
fi
if test "$subsha1" != "$sha1"
then
- (unset GIT_DIR && cd "$path" && git-fetch &&
+ (unset GIT_DIR; cd "$path" && git-fetch &&
git-checkout -q "$sha1") ||
die "Unable to checkout '$sha1' in submodule path '$path'"
set_name_rev () {
revname=$( (
- unset GIT_DIR &&
+ unset GIT_DIR
cd "$1" && {
git describe "$2" 2>/dev/null ||
git describe --tags "$2" 2>/dev/null ||
else
if test -z "$cached"
then
- sha1=$(unset GIT_DIR && cd "$path" && git rev-parse --verify HEAD)
+ sha1=$(unset GIT_DIR; cd "$path" && git rev-parse --verify HEAD)
set_name_rev "$path" "$sha1"
fi
say "+$sha1 $path$revname"
push @SVN::Git::Editor::ISA, 'SVN::Delta::Editor';
push @SVN::Git::Fetcher::ISA, 'SVN::Delta::Editor';
use Carp qw/croak/;
+use Digest::MD5;
use IO::File qw//;
use File::Basename qw/dirname basename/;
use File::Path qw/mkpath/;
foreach (qw/command command_oneline command_noisy command_output_pipe
command_input_pipe command_close_pipe/) {
for my $package ( qw(SVN::Git::Editor SVN::Git::Fetcher
- Git::SVN::Migration Git::SVN::Log Git::SVN
- Git::SVN::Util),
+ Git::SVN::Migration Git::SVN::Log Git::SVN),
__PACKAGE__) {
*{"${package}::$_"} = \&{"Git::$_"};
}
'quiet|q' => \$_q,
'repack-flags|repack-args|repack-opts=s' =>
\$Git::SVN::_repack_flags,
+ 'use-log-author' => \$Git::SVN::_use_log_author,
%remote_opts );
my ($_trunk, $_tags, $_branches, $_stdlayout);
'show-ignore' => [ \&cmd_show_ignore, "Show svn:ignore listings",
{ 'revision|r=i' => \$_revision
} ],
+ 'show-externals' => [ \&cmd_show_externals, "Show svn:externals listings",
+ { 'revision|r=i' => \$_revision
+ } ],
'multi-fetch' => [ \&cmd_multi_fetch,
"Deprecated alias for $0 fetch --all",
{ 'revision|r=s' => \$_revision, %fc_opts } ],
}
};
-my %opts = %{$cmd{$cmd}->[2]} if (defined $cmd);
-
-read_repo_config(\%opts);
-Getopt::Long::Configure('pass_through') if ($cmd && $cmd eq 'log');
-my $rv = GetOptions(%opts, 'help|H|h' => \$_help, 'version|V' => \$_version,
- 'minimize-connections' => \$Git::SVN::Migration::_minimize,
- 'id|i=s' => \$Git::SVN::default_ref_id,
- 'svn-remote|remote|R=s' => sub {
- $Git::SVN::no_reuse_existing = 1;
- $Git::SVN::default_repo_id = $_[1] });
-exit 1 if (!$rv && $cmd && $cmd ne 'log');
-
-usage(0) if $_help;
-version() if $_version;
-usage(1) unless defined $cmd;
-load_authors() if $_authors;
-
# make sure we're always running
unless ($cmd =~ /(?:clone|init|multi-init)$/) {
unless (-d $ENV{GIT_DIR}) {
$ENV{GIT_DIR} = $git_dir;
}
}
+
+my %opts = %{$cmd{$cmd}->[2]} if (defined $cmd);
+
+read_repo_config(\%opts);
+Getopt::Long::Configure('pass_through') if ($cmd && $cmd eq 'log');
+my $rv = GetOptions(%opts, 'help|H|h' => \$_help, 'version|V' => \$_version,
+ 'minimize-connections' => \$Git::SVN::Migration::_minimize,
+ 'id|i=s' => \$Git::SVN::default_ref_id,
+ 'svn-remote|remote|R=s' => sub {
+ $Git::SVN::no_reuse_existing = 1;
+ $Git::SVN::default_repo_id = $_[1] });
+exit 1 if (!$rv && $cmd && $cmd ne 'log');
+
+usage(0) if $_help;
+version() if $_version;
+usage(1) unless defined $cmd;
+load_authors() if $_authors;
+
unless ($cmd =~ /^(?:clone|init|multi-init|commit-diff)$/) {
Git::SVN::Migration::migration_check();
}
exit 1;
}
unless ($_local) {
+ # rebase will checkout for us, so no need to do it explicitly
+ $_no_checkout = 'true';
$_fetch_all ? $gs->fetch_all : $gs->fetch;
}
command_noisy(rebase_cmd(), $gs->refname);
});
}
+sub cmd_show_externals {
+ my ($url, $rev, $uuid, $gs) = working_head_info('HEAD');
+ $gs ||= Git::SVN->new;
+ my $r = (defined $_revision ? $_revision : $gs->ra->get_latest_revnum);
+ $gs->prop_walk($gs->{path}, $r, sub {
+ my ($gs, $path, $props) = @_;
+ print STDOUT "\n# $path\n";
+ my $s = $props->{'svn:externals'} or return;
+ $s =~ s/[\r\n]+/\n/g;
+ chomp $s;
+ $s =~ s#^#$path#gm;
+ print STDOUT "$s\n";
+ });
+}
+
sub cmd_create_ignore {
my ($url, $rev, $uuid, $gs) = working_head_info('HEAD');
$gs ||= Git::SVN->new;
command_output_pipe(qw(cat-file blob), "HEAD:$path");
if ($file_type eq "link") {
my $file_name = <$fh>;
- $checksum = Git::SVN::Util::md5sum("link $file_name");
+ $checksum = md5sum("link $file_name");
} else {
- $checksum = Git::SVN::Util::md5sum($fh);
+ $checksum = md5sum($fh);
}
command_close_pipe($fh, $ctx);
} elsif ($file_type eq "link") {
my $file_name =
command(qw(cat-file blob), "HEAD:$path");
$checksum =
- Git::SVN::Util::md5sum("link " . $file_name);
+ md5sum("link " . $file_name);
} else {
open FILE, "<", $path or die $!;
- $checksum = Git::SVN::Util::md5sum(\*FILE);
+ $checksum = md5sum(\*FILE);
close FILE or die $!;
}
$result .= "Checksum: " . $checksum . "\n";
return ("file", $diff_status);
}
-package Git::SVN::Util;
-use strict;
-use warnings;
-use Digest::MD5;
-
sub md5sum {
my $arg = shift;
my $ref = ref $arg;
use warnings;
use vars qw/$default_repo_id $default_ref_id $_no_metadata $_follow_parent
$_repack $_repack_flags $_use_svm_props $_head
- $_use_svnsync_props $no_reuse_existing $_minimize_url/;
+ $_use_svnsync_props $no_reuse_existing $_minimize_url
+ $_use_log_author/;
use Carp qw/croak/;
use File::Path qw/mkpath/;
use File::Copy qw/copy/;
croak "$log_entry->{revision} = $c already exists! ",
"Why are we refetching it?\n";
}
- $ENV{GIT_AUTHOR_NAME} = $ENV{GIT_COMMITTER_NAME} = $log_entry->{name};
- $ENV{GIT_AUTHOR_EMAIL} = $ENV{GIT_COMMITTER_EMAIL} =
- $log_entry->{email};
+ $ENV{GIT_AUTHOR_NAME} = $log_entry->{name};
+ $ENV{GIT_AUTHOR_EMAIL} = $log_entry->{email};
$ENV{GIT_AUTHOR_DATE} = $ENV{GIT_COMMITTER_DATE} = $log_entry->{date};
+ $ENV{GIT_COMMITTER_NAME} = (defined $log_entry->{commit_name})
+ ? $log_entry->{commit_name}
+ : $log_entry->{name};
+ $ENV{GIT_COMMITTER_EMAIL} = (defined $log_entry->{commit_email})
+ ? $log_entry->{commit_email}
+ : $log_entry->{email};
+
my $tree = $log_entry->{tree};
if (!defined $tree) {
$tree = $self->tmp_index_do(sub {
$log_entry{log} .= "\n";
my $author = $log_entry{author} = check_author($log_entry{author});
my ($name, $email) = defined $::users{$author} ? @{$::users{$author}}
- : ($author, undef);
+ : ($author, undef);
+
+ my ($commit_name, $commit_email) = ($name, $email);
+ if ($_use_log_author) {
+ if ($log_entry{log} =~ /From:\s+(.*?)\s+<(.*)>\s*\n/) {
+ ($name, $email) = ($1, $2);
+ } elsif ($log_entry{log} =~
+ /Signed-off-by:\s+(.*?)\s+<(.*)>\s*\n/) {
+ ($name, $email) = ($1, $2);
+ }
+ }
if (defined $headrev && $self->use_svm_props) {
if ($self->rewrite_root) {
die "Can't have both 'useSvmProps' and 'rewriteRoot' ",
remove_username($full_url);
$log_entry{metadata} = "$full_url\@$r $uuid";
$log_entry{svm_revision} = $r;
- $email ||= "$author\@$uuid"
+ $email ||= "$author\@$uuid";
+ $commit_email ||= "$author\@$uuid";
} elsif ($self->use_svnsync_props) {
my $full_url = $self->svnsync->{url};
$full_url .= "/$self->{path}" if length $self->{path};
remove_username($full_url);
my $uuid = $self->svnsync->{uuid};
$log_entry{metadata} = "$full_url\@$rev $uuid";
- $email ||= "$author\@$uuid"
+ $email ||= "$author\@$uuid";
+ $commit_email ||= "$author\@$uuid";
} else {
my $url = $self->metadata_url;
remove_username($url);
$log_entry{metadata} = "$url\@$rev " .
$self->ra->get_uuid;
$email ||= "$author\@" . $self->ra->get_uuid;
+ $commit_email ||= "$author\@" . $self->ra->get_uuid;
}
$log_entry{name} = $name;
$log_entry{email} = $email;
+ $log_entry{commit_name} = $commit_name;
+ $log_entry{commit_email} = $commit_email;
\%log_entry;
}
if (defined $exp) {
seek $base, 0, 0 or croak $!;
- my $got = Git::SVN::Util::md5sum($base);
+ my $got = ::md5sum($base);
die "Checksum mismatch: $fb->{path} $fb->{blob}\n",
"expected: $exp\n",
" got: $got\n" if ($got ne $exp);
if (my $fh = $fb->{fh}) {
if (defined $exp) {
seek($fh, 0, 0) or croak $!;
- my $got = Git::SVN::Util::md5sum($fh);
+ my $got = ::md5sum($fh);
if ($got ne $exp) {
die "Checksum mismatch: $path\n",
"expected: $exp\n got: $got\n";
$fh->flush == 0 or croak $!;
seek $fh, 0, 0 or croak $!;
- my $exp = Git::SVN::Util::md5sum($fh);
+ my $exp = ::md5sum($fh);
seek $fh, 0, 0 or croak $!;
my $pool = SVN::Pool->new;
strbuf_init(&buf, PATH_MAX);
strbuf_addstr(&buf, alias_string);
- sq_quote_argv(&buf, (*argv) + 1, *argcp - 1, PATH_MAX);
+ sq_quote_argv(&buf, (*argv) + 1, PATH_MAX);
free(alias_string);
alias_string = buf.buf;
}
if (!strcmp(alias_command, new_argv[0]))
die("recursive alias: %s", alias_command);
- trace_argv_printf(new_argv, count,
+ trace_argv_printf(new_argv,
"trace: alias expansion: %s =>",
alias_command);
if (p->option & NEED_WORK_TREE)
setup_work_tree();
- trace_argv_printf(argv, argc, "trace: built-in: git");
+ trace_argv_printf(argv, "trace: built-in: git");
status = p->fn(argc, argv, prefix);
if (status)
- return status;
+ return status & 0xff;
/* Somebody closed stdout? */
if (fstat(fileno(stdout), &st))
{ "check-attr", cmd_check_attr, RUN_SETUP | NEED_WORK_TREE },
{ "cherry", cmd_cherry, RUN_SETUP },
{ "cherry-pick", cmd_cherry_pick, RUN_SETUP | NEED_WORK_TREE },
+ { "clean", cmd_clean, RUN_SETUP | NEED_WORK_TREE },
{ "commit", cmd_commit, RUN_SETUP | NEED_WORK_TREE },
{ "commit-tree", cmd_commit_tree, RUN_SETUP },
{ "config", cmd_config },
{ "diff-files", cmd_diff_files },
{ "diff-index", cmd_diff_index, RUN_SETUP },
{ "diff-tree", cmd_diff_tree, RUN_SETUP },
+ { "fast-export", cmd_fast_export, RUN_SETUP },
{ "fetch", cmd_fetch, RUN_SETUP },
{ "fetch-pack", cmd_fetch_pack, RUN_SETUP },
{ "fetch--tool", cmd_fetch__tool, RUN_SETUP },
{ "log", cmd_log, RUN_SETUP | USE_PAGER },
{ "ls-files", cmd_ls_files, RUN_SETUP },
{ "ls-tree", cmd_ls_tree, RUN_SETUP },
+ { "ls-remote", cmd_ls_remote },
{ "mailinfo", cmd_mailinfo },
{ "mailsplit", cmd_mailsplit },
{ "merge-base", cmd_merge_base, RUN_SETUP },
{ "mv", cmd_mv, RUN_SETUP | NEED_WORK_TREE },
{ "name-rev", cmd_name_rev, RUN_SETUP },
{ "pack-objects", cmd_pack_objects, RUN_SETUP },
+ { "peek-remote", cmd_ls_remote },
{ "pickaxe", cmd_blame, RUN_SETUP },
{ "prune", cmd_prune, RUN_SETUP },
{ "prune-packed", cmd_prune_packed, RUN_SETUP },
{ "rev-parse", cmd_rev_parse },
{ "revert", cmd_revert, RUN_SETUP | NEED_WORK_TREE },
{ "rm", cmd_rm, RUN_SETUP },
+ { "send-pack", cmd_send_pack, RUN_SETUP },
{ "shortlog", cmd_shortlog, RUN_SETUP | USE_PAGER },
{ "show-branch", cmd_show_branch, RUN_SETUP },
{ "show", cmd_show, RUN_SETUP | USE_PAGER },
+++ /dev/null
-#!/bin/sh
-# Tcl ignores the next line -*- tcl -*- \
-exec wish "$0" -- "$@"
-
-# Copyright (C) 2005-2006 Paul Mackerras. All rights reserved.
-# This program is free software; it may be used, copied, modified
-# and distributed under the terms of the GNU General Public Licence,
-# either version 2, or (at your option) any later version.
-
-proc gitdir {} {
- global env
- if {[info exists env(GIT_DIR)]} {
- return $env(GIT_DIR)
- } else {
- return [exec git rev-parse --git-dir]
- }
-}
-
-# A simple scheduler for compute-intensive stuff.
-# The aim is to make sure that event handlers for GUI actions can
-# run at least every 50-100 ms. Unfortunately fileevent handlers are
-# run before X event handlers, so reading from a fast source can
-# make the GUI completely unresponsive.
-proc run args {
- global isonrunq runq
-
- set script $args
- if {[info exists isonrunq($script)]} return
- if {$runq eq {}} {
- after idle dorunq
- }
- lappend runq [list {} $script]
- set isonrunq($script) 1
-}
-
-proc filerun {fd script} {
- fileevent $fd readable [list filereadable $fd $script]
-}
-
-proc filereadable {fd script} {
- global runq
-
- fileevent $fd readable {}
- if {$runq eq {}} {
- after idle dorunq
- }
- lappend runq [list $fd $script]
-}
-
-proc dorunq {} {
- global isonrunq runq
-
- set tstart [clock clicks -milliseconds]
- set t0 $tstart
- while {$runq ne {}} {
- set fd [lindex $runq 0 0]
- set script [lindex $runq 0 1]
- set repeat [eval $script]
- set t1 [clock clicks -milliseconds]
- set t [expr {$t1 - $t0}]
- set runq [lrange $runq 1 end]
- if {$repeat ne {} && $repeat} {
- if {$fd eq {} || $repeat == 2} {
- # script returns 1 if it wants to be readded
- # file readers return 2 if they could do more straight away
- lappend runq [list $fd $script]
- } else {
- fileevent $fd readable [list filereadable $fd $script]
- }
- } elseif {$fd eq {}} {
- unset isonrunq($script)
- }
- set t0 $t1
- if {$t1 - $tstart >= 80} break
- }
- if {$runq ne {}} {
- after idle dorunq
- }
-}
-
-# Start off a git rev-list process and arrange to read its output
-proc start_rev_list {view} {
- global startmsecs
- global commfd leftover tclencoding datemode
- global viewargs viewfiles commitidx viewcomplete vnextroot
- global showlocalchanges commitinterest mainheadid
- global progressdirn progresscoords proglastnc curview
-
- set startmsecs [clock clicks -milliseconds]
- set commitidx($view) 0
- set viewcomplete($view) 0
- set vnextroot($view) 0
- set order "--topo-order"
- if {$datemode} {
- set order "--date-order"
- }
- if {[catch {
- set fd [open [concat | git log --no-color -z --pretty=raw $order --parents \
- --boundary $viewargs($view) "--" $viewfiles($view)] r]
- } err]} {
- error_popup "Error executing git rev-list: $err"
- exit 1
- }
- set commfd($view) $fd
- set leftover($view) {}
- if {$showlocalchanges} {
- lappend commitinterest($mainheadid) {dodiffindex}
- }
- fconfigure $fd -blocking 0 -translation lf -eofchar {}
- if {$tclencoding != {}} {
- fconfigure $fd -encoding $tclencoding
- }
- filerun $fd [list getcommitlines $fd $view]
- nowbusy $view "Reading"
- if {$view == $curview} {
- set progressdirn 1
- set progresscoords {0 0}
- set proglastnc 0
- }
-}
-
-proc stop_rev_list {} {
- global commfd curview
-
- if {![info exists commfd($curview)]} return
- set fd $commfd($curview)
- catch {
- set pid [pid $fd]
- exec kill $pid
- }
- catch {close $fd}
- unset commfd($curview)
-}
-
-proc getcommits {} {
- global phase canv curview
-
- set phase getcommits
- initlayout
- start_rev_list $curview
- show_status "Reading commits..."
-}
-
-# This makes a string representation of a positive integer which
-# sorts as a string in numerical order
-proc strrep {n} {
- if {$n < 16} {
- return [format "%x" $n]
- } elseif {$n < 256} {
- return [format "x%.2x" $n]
- } elseif {$n < 65536} {
- return [format "y%.4x" $n]
- }
- return [format "z%.8x" $n]
-}
-
-proc getcommitlines {fd view} {
- global commitlisted commitinterest
- global leftover commfd
- global displayorder commitidx viewcomplete commitrow commitdata
- global parentlist children curview hlview
- global vparentlist vdisporder vcmitlisted
- global ordertok vnextroot idpending
-
- set stuff [read $fd 500000]
- # git log doesn't terminate the last commit with a null...
- if {$stuff == {} && $leftover($view) ne {} && [eof $fd]} {
- set stuff "\0"
- }
- if {$stuff == {}} {
- if {![eof $fd]} {
- return 1
- }
- # Check if we have seen any ids listed as parents that haven't
- # appeared in the list
- foreach vid [array names idpending "$view,*"] {
- # should only get here if git log is buggy
- set id [lindex [split $vid ","] 1]
- set commitrow($vid) $commitidx($view)
- incr commitidx($view)
- if {$view == $curview} {
- lappend parentlist {}
- lappend displayorder $id
- lappend commitlisted 0
- } else {
- lappend vparentlist($view) {}
- lappend vdisporder($view) $id
- lappend vcmitlisted($view) 0
- }
- }
- set viewcomplete($view) 1
- global viewname progresscoords
- unset commfd($view)
- notbusy $view
- set progresscoords {0 0}
- adjustprogress
- # set it blocking so we wait for the process to terminate
- fconfigure $fd -blocking 1
- if {[catch {close $fd} err]} {
- set fv {}
- if {$view != $curview} {
- set fv " for the \"$viewname($view)\" view"
- }
- if {[string range $err 0 4] == "usage"} {
- set err "Gitk: error reading commits$fv:\
- bad arguments to git rev-list."
- if {$viewname($view) eq "Command line"} {
- append err \
- " (Note: arguments to gitk are passed to git rev-list\
- to allow selection of commits to be displayed.)"
- }
- } else {
- set err "Error reading commits$fv: $err"
- }
- error_popup $err
- }
- if {$view == $curview} {
- run chewcommits $view
- }
- return 0
- }
- set start 0
- set gotsome 0
- while 1 {
- set i [string first "\0" $stuff $start]
- if {$i < 0} {
- append leftover($view) [string range $stuff $start end]
- break
- }
- if {$start == 0} {
- set cmit $leftover($view)
- append cmit [string range $stuff 0 [expr {$i - 1}]]
- set leftover($view) {}
- } else {
- set cmit [string range $stuff $start [expr {$i - 1}]]
- }
- set start [expr {$i + 1}]
- set j [string first "\n" $cmit]
- set ok 0
- set listed 1
- if {$j >= 0 && [string match "commit *" $cmit]} {
- set ids [string range $cmit 7 [expr {$j - 1}]]
- if {[string match {[-<>]*} $ids]} {
- switch -- [string index $ids 0] {
- "-" {set listed 0}
- "<" {set listed 2}
- ">" {set listed 3}
- }
- set ids [string range $ids 1 end]
- }
- set ok 1
- foreach id $ids {
- if {[string length $id] != 40} {
- set ok 0
- break
- }
- }
- }
- if {!$ok} {
- set shortcmit $cmit
- if {[string length $shortcmit] > 80} {
- set shortcmit "[string range $shortcmit 0 80]..."
- }
- error_popup "Can't parse git log output: {$shortcmit}"
- exit 1
- }
- set id [lindex $ids 0]
- if {![info exists ordertok($view,$id)]} {
- set otok "o[strrep $vnextroot($view)]"
- incr vnextroot($view)
- set ordertok($view,$id) $otok
- } else {
- set otok $ordertok($view,$id)
- unset idpending($view,$id)
- }
- if {$listed} {
- set olds [lrange $ids 1 end]
- if {[llength $olds] == 1} {
- set p [lindex $olds 0]
- lappend children($view,$p) $id
- if {![info exists ordertok($view,$p)]} {
- set ordertok($view,$p) $ordertok($view,$id)
- set idpending($view,$p) 1
- }
- } else {
- set i 0
- foreach p $olds {
- if {$i == 0 || [lsearch -exact $olds $p] >= $i} {
- lappend children($view,$p) $id
- }
- if {![info exists ordertok($view,$p)]} {
- set ordertok($view,$p) "$otok[strrep $i]]"
- set idpending($view,$p) 1
- }
- incr i
- }
- }
- } else {
- set olds {}
- }
- if {![info exists children($view,$id)]} {
- set children($view,$id) {}
- }
- set commitdata($id) [string range $cmit [expr {$j + 1}] end]
- set commitrow($view,$id) $commitidx($view)
- incr commitidx($view)
- if {$view == $curview} {
- lappend parentlist $olds
- lappend displayorder $id
- lappend commitlisted $listed
- } else {
- lappend vparentlist($view) $olds
- lappend vdisporder($view) $id
- lappend vcmitlisted($view) $listed
- }
- if {[info exists commitinterest($id)]} {
- foreach script $commitinterest($id) {
- eval [string map [list "%I" $id] $script]
- }
- unset commitinterest($id)
- }
- set gotsome 1
- }
- if {$gotsome} {
- run chewcommits $view
- if {$view == $curview} {
- # update progress bar
- global progressdirn progresscoords proglastnc
- set inc [expr {($commitidx($view) - $proglastnc) * 0.0002}]
- set proglastnc $commitidx($view)
- set l [lindex $progresscoords 0]
- set r [lindex $progresscoords 1]
- if {$progressdirn} {
- set r [expr {$r + $inc}]
- if {$r >= 1.0} {
- set r 1.0
- set progressdirn 0
- }
- if {$r > 0.2} {
- set l [expr {$r - 0.2}]
- }
- } else {
- set l [expr {$l - $inc}]
- if {$l <= 0.0} {
- set l 0.0
- set progressdirn 1
- }
- set r [expr {$l + 0.2}]
- }
- set progresscoords [list $l $r]
- adjustprogress
- }
- }
- return 2
-}
-
-proc chewcommits {view} {
- global curview hlview viewcomplete
- global selectedline pending_select
-
- if {$view == $curview} {
- layoutmore
- if {$viewcomplete($view)} {
- global displayorder commitidx phase
- global numcommits startmsecs
-
- if {[info exists pending_select]} {
- set row [first_real_row]
- selectline $row 1
- }
- if {$commitidx($curview) > 0} {
- #set ms [expr {[clock clicks -milliseconds] - $startmsecs}]
- #puts "overall $ms ms for $numcommits commits"
- } else {
- show_status "No commits selected"
- }
- notbusy layout
- set phase {}
- }
- }
- if {[info exists hlview] && $view == $hlview} {
- vhighlightmore
- }
- return 0
-}
-
-proc readcommit {id} {
- if {[catch {set contents [exec git cat-file commit $id]}]} return
- parsecommit $id $contents 0
-}
-
-proc updatecommits {} {
- global viewdata curview phase displayorder ordertok idpending
- global children commitrow selectedline thickerline showneartags
-
- if {$phase ne {}} {
- stop_rev_list
- set phase {}
- }
- set n $curview
- foreach id $displayorder {
- catch {unset children($n,$id)}
- catch {unset commitrow($n,$id)}
- catch {unset ordertok($n,$id)}
- }
- foreach vid [array names idpending "$n,*"] {
- unset idpending($vid)
- }
- set curview -1
- catch {unset selectedline}
- catch {unset thickerline}
- catch {unset viewdata($n)}
- readrefs
- changedrefs
- if {$showneartags} {
- getallcommits
- }
- showview $n
-}
-
-proc parsecommit {id contents listed} {
- global commitinfo cdate
-
- set inhdr 1
- set comment {}
- set headline {}
- set auname {}
- set audate {}
- set comname {}
- set comdate {}
- set hdrend [string first "\n\n" $contents]
- if {$hdrend < 0} {
- # should never happen...
- set hdrend [string length $contents]
- }
- set header [string range $contents 0 [expr {$hdrend - 1}]]
- set comment [string range $contents [expr {$hdrend + 2}] end]
- foreach line [split $header "\n"] {
- set tag [lindex $line 0]
- if {$tag == "author"} {
- set audate [lindex $line end-1]
- set auname [lrange $line 1 end-2]
- } elseif {$tag == "committer"} {
- set comdate [lindex $line end-1]
- set comname [lrange $line 1 end-2]
- }
- }
- set headline {}
- # take the first non-blank line of the comment as the headline
- set headline [string trimleft $comment]
- set i [string first "\n" $headline]
- if {$i >= 0} {
- set headline [string range $headline 0 $i]
- }
- set headline [string trimright $headline]
- set i [string first "\r" $headline]
- if {$i >= 0} {
- set headline [string trimright [string range $headline 0 $i]]
- }
- if {!$listed} {
- # git rev-list indents the comment by 4 spaces;
- # if we got this via git cat-file, add the indentation
- set newcomment {}
- foreach line [split $comment "\n"] {
- append newcomment " "
- append newcomment $line
- append newcomment "\n"
- }
- set comment $newcomment
- }
- if {$comdate != {}} {
- set cdate($id) $comdate
- }
- set commitinfo($id) [list $headline $auname $audate \
- $comname $comdate $comment]
-}
-
-proc getcommit {id} {
- global commitdata commitinfo
-
- if {[info exists commitdata($id)]} {
- parsecommit $id $commitdata($id) 1
- } else {
- readcommit $id
- if {![info exists commitinfo($id)]} {
- set commitinfo($id) {"No commit information available"}
- }
- }
- return 1
-}
-
-proc readrefs {} {
- global tagids idtags headids idheads tagobjid
- global otherrefids idotherrefs mainhead mainheadid
-
- foreach v {tagids idtags headids idheads otherrefids idotherrefs} {
- catch {unset $v}
- }
- set refd [open [list | git show-ref -d] r]
- while {[gets $refd line] >= 0} {
- if {[string index $line 40] ne " "} continue
- set id [string range $line 0 39]
- set ref [string range $line 41 end]
- if {![string match "refs/*" $ref]} continue
- set name [string range $ref 5 end]
- if {[string match "remotes/*" $name]} {
- if {![string match "*/HEAD" $name]} {
- set headids($name) $id
- lappend idheads($id) $name
- }
- } elseif {[string match "heads/*" $name]} {
- set name [string range $name 6 end]
- set headids($name) $id
- lappend idheads($id) $name
- } elseif {[string match "tags/*" $name]} {
- # this lets refs/tags/foo^{} overwrite refs/tags/foo,
- # which is what we want since the former is the commit ID
- set name [string range $name 5 end]
- if {[string match "*^{}" $name]} {
- set name [string range $name 0 end-3]
- } else {
- set tagobjid($name) $id
- }
- set tagids($name) $id
- lappend idtags($id) $name
- } else {
- set otherrefids($name) $id
- lappend idotherrefs($id) $name
- }
- }
- catch {close $refd}
- set mainhead {}
- set mainheadid {}
- catch {
- set thehead [exec git symbolic-ref HEAD]
- if {[string match "refs/heads/*" $thehead]} {
- set mainhead [string range $thehead 11 end]
- if {[info exists headids($mainhead)]} {
- set mainheadid $headids($mainhead)
- }
- }
- }
-}
-
-# skip over fake commits
-proc first_real_row {} {
- global nullid nullid2 displayorder numcommits
-
- for {set row 0} {$row < $numcommits} {incr row} {
- set id [lindex $displayorder $row]
- if {$id ne $nullid && $id ne $nullid2} {
- break
- }
- }
- return $row
-}
-
-# update things for a head moved to a child of its previous location
-proc movehead {id name} {
- global headids idheads
-
- removehead $headids($name) $name
- set headids($name) $id
- lappend idheads($id) $name
-}
-
-# update things when a head has been removed
-proc removehead {id name} {
- global headids idheads
-
- if {$idheads($id) eq $name} {
- unset idheads($id)
- } else {
- set i [lsearch -exact $idheads($id) $name]
- if {$i >= 0} {
- set idheads($id) [lreplace $idheads($id) $i $i]
- }
- }
- unset headids($name)
-}
-
-proc show_error {w top msg} {
- message $w.m -text $msg -justify center -aspect 400
- pack $w.m -side top -fill x -padx 20 -pady 20
- button $w.ok -text OK -command "destroy $top"
- pack $w.ok -side bottom -fill x
- bind $top <Visibility> "grab $top; focus $top"
- bind $top <Key-Return> "destroy $top"
- tkwait window $top
-}
-
-proc error_popup msg {
- set w .error
- toplevel $w
- wm transient $w .
- show_error $w $w $msg
-}
-
-proc confirm_popup msg {
- global confirm_ok
- set confirm_ok 0
- set w .confirm
- toplevel $w
- wm transient $w .
- message $w.m -text $msg -justify center -aspect 400
- pack $w.m -side top -fill x -padx 20 -pady 20
- button $w.ok -text OK -command "set confirm_ok 1; destroy $w"
- pack $w.ok -side left -fill x
- button $w.cancel -text Cancel -command "destroy $w"
- pack $w.cancel -side right -fill x
- bind $w <Visibility> "grab $w; focus $w"
- tkwait window $w
- return $confirm_ok
-}
-
-proc makewindow {} {
- global canv canv2 canv3 linespc charspc ctext cflist
- global tabstop
- global findtype findtypemenu findloc findstring fstring geometry
- global entries sha1entry sha1string sha1but
- global diffcontextstring diffcontext
- global maincursor textcursor curtextcursor
- global rowctxmenu fakerowmenu mergemax wrapcomment
- global highlight_files gdttype
- global searchstring sstring
- global bgcolor fgcolor bglist fglist diffcolors selectbgcolor
- global headctxmenu progresscanv progressitem progresscoords statusw
- global fprogitem fprogcoord lastprogupdate progupdatepending
- global rprogitem rprogcoord
- global have_tk85
-
- menu .bar
- .bar add cascade -label "File" -menu .bar.file
- .bar configure -font uifont
- menu .bar.file
- .bar.file add command -label "Update" -command updatecommits
- .bar.file add command -label "Reread references" -command rereadrefs
- .bar.file add command -label "List references" -command showrefs
- .bar.file add command -label "Quit" -command doquit
- .bar.file configure -font uifont
- menu .bar.edit
- .bar add cascade -label "Edit" -menu .bar.edit
- .bar.edit add command -label "Preferences" -command doprefs
- .bar.edit configure -font uifont
-
- menu .bar.view -font uifont
- .bar add cascade -label "View" -menu .bar.view
- .bar.view add command -label "New view..." -command {newview 0}
- .bar.view add command -label "Edit view..." -command editview \
- -state disabled
- .bar.view add command -label "Delete view" -command delview -state disabled
- .bar.view add separator
- .bar.view add radiobutton -label "All files" -command {showview 0} \
- -variable selectedview -value 0
-
- menu .bar.help
- .bar add cascade -label "Help" -menu .bar.help
- .bar.help add command -label "About gitk" -command about
- .bar.help add command -label "Key bindings" -command keys
- .bar.help configure -font uifont
- . configure -menu .bar
-
- # the gui has upper and lower half, parts of a paned window.
- panedwindow .ctop -orient vertical
-
- # possibly use assumed geometry
- if {![info exists geometry(pwsash0)]} {
- set geometry(topheight) [expr {15 * $linespc}]
- set geometry(topwidth) [expr {80 * $charspc}]
- set geometry(botheight) [expr {15 * $linespc}]
- set geometry(botwidth) [expr {50 * $charspc}]
- set geometry(pwsash0) "[expr {40 * $charspc}] 2"
- set geometry(pwsash1) "[expr {60 * $charspc}] 2"
- }
-
- # the upper half will have a paned window, a scroll bar to the right, and some stuff below
- frame .tf -height $geometry(topheight) -width $geometry(topwidth)
- frame .tf.histframe
- panedwindow .tf.histframe.pwclist -orient horizontal -sashpad 0 -handlesize 4
-
- # create three canvases
- set cscroll .tf.histframe.csb
- set canv .tf.histframe.pwclist.canv
- canvas $canv \
- -selectbackground $selectbgcolor \
- -background $bgcolor -bd 0 \
- -yscrollincr $linespc -yscrollcommand "scrollcanv $cscroll"
- .tf.histframe.pwclist add $canv
- set canv2 .tf.histframe.pwclist.canv2
- canvas $canv2 \
- -selectbackground $selectbgcolor \
- -background $bgcolor -bd 0 -yscrollincr $linespc
- .tf.histframe.pwclist add $canv2
- set canv3 .tf.histframe.pwclist.canv3
- canvas $canv3 \
- -selectbackground $selectbgcolor \
- -background $bgcolor -bd 0 -yscrollincr $linespc
- .tf.histframe.pwclist add $canv3
- eval .tf.histframe.pwclist sash place 0 $geometry(pwsash0)
- eval .tf.histframe.pwclist sash place 1 $geometry(pwsash1)
-
- # a scroll bar to rule them
- scrollbar $cscroll -command {allcanvs yview} -highlightthickness 0
- pack $cscroll -side right -fill y
- bind .tf.histframe.pwclist <Configure> {resizeclistpanes %W %w}
- lappend bglist $canv $canv2 $canv3
- pack .tf.histframe.pwclist -fill both -expand 1 -side left
-
- # we have two button bars at bottom of top frame. Bar 1
- frame .tf.bar
- frame .tf.lbar -height 15
-
- set sha1entry .tf.bar.sha1
- set entries $sha1entry
- set sha1but .tf.bar.sha1label
- button $sha1but -text "SHA1 ID: " -state disabled -relief flat \
- -command gotocommit -width 8 -font uifont
- $sha1but conf -disabledforeground [$sha1but cget -foreground]
- pack .tf.bar.sha1label -side left
- entry $sha1entry -width 40 -font textfont -textvariable sha1string
- trace add variable sha1string write sha1change
- pack $sha1entry -side left -pady 2
-
- image create bitmap bm-left -data {
- #define left_width 16
- #define left_height 16
- static unsigned char left_bits[] = {
- 0x00, 0x00, 0xc0, 0x01, 0xe0, 0x00, 0x70, 0x00, 0x38, 0x00, 0x1c, 0x00,
- 0x0e, 0x00, 0xff, 0x7f, 0xff, 0x7f, 0xff, 0x7f, 0x0e, 0x00, 0x1c, 0x00,
- 0x38, 0x00, 0x70, 0x00, 0xe0, 0x00, 0xc0, 0x01};
- }
- image create bitmap bm-right -data {
- #define right_width 16
- #define right_height 16
- static unsigned char right_bits[] = {
- 0x00, 0x00, 0xc0, 0x01, 0x80, 0x03, 0x00, 0x07, 0x00, 0x0e, 0x00, 0x1c,
- 0x00, 0x38, 0xff, 0x7f, 0xff, 0x7f, 0xff, 0x7f, 0x00, 0x38, 0x00, 0x1c,
- 0x00, 0x0e, 0x00, 0x07, 0x80, 0x03, 0xc0, 0x01};
- }
- button .tf.bar.leftbut -image bm-left -command goback \
- -state disabled -width 26
- pack .tf.bar.leftbut -side left -fill y
- button .tf.bar.rightbut -image bm-right -command goforw \
- -state disabled -width 26
- pack .tf.bar.rightbut -side left -fill y
-
- # Status label and progress bar
- set statusw .tf.bar.status
- label $statusw -width 15 -relief sunken -font uifont
- pack $statusw -side left -padx 5
- set h [expr {[font metrics uifont -linespace] + 2}]
- set progresscanv .tf.bar.progress
- canvas $progresscanv -relief sunken -height $h -borderwidth 2
- set progressitem [$progresscanv create rect -1 0 0 $h -fill green]
- set fprogitem [$progresscanv create rect -1 0 0 $h -fill yellow]
- set rprogitem [$progresscanv create rect -1 0 0 $h -fill red]
- pack $progresscanv -side right -expand 1 -fill x
- set progresscoords {0 0}
- set fprogcoord 0
- set rprogcoord 0
- bind $progresscanv <Configure> adjustprogress
- set lastprogupdate [clock clicks -milliseconds]
- set progupdatepending 0
-
- # build up the bottom bar of upper window
- label .tf.lbar.flabel -text "Find " -font uifont
- button .tf.lbar.fnext -text "next" -command {dofind 1 1} -font uifont
- button .tf.lbar.fprev -text "prev" -command {dofind -1 1} -font uifont
- label .tf.lbar.flab2 -text " commit " -font uifont
- pack .tf.lbar.flabel .tf.lbar.fnext .tf.lbar.fprev .tf.lbar.flab2 \
- -side left -fill y
- set gdttype "containing:"
- set gm [tk_optionMenu .tf.lbar.gdttype gdttype \
- "containing:" \
- "touching paths:" \
- "adding/removing string:"]
- trace add variable gdttype write gdttype_change
- $gm conf -font uifont
- .tf.lbar.gdttype conf -font uifont
- pack .tf.lbar.gdttype -side left -fill y
-
- set findstring {}
- set fstring .tf.lbar.findstring
- lappend entries $fstring
- entry $fstring -width 30 -font textfont -textvariable findstring
- trace add variable findstring write find_change
- set findtype Exact
- set findtypemenu [tk_optionMenu .tf.lbar.findtype \
- findtype Exact IgnCase Regexp]
- trace add variable findtype write findcom_change
- .tf.lbar.findtype configure -font uifont
- .tf.lbar.findtype.menu configure -font uifont
- set findloc "All fields"
- tk_optionMenu .tf.lbar.findloc findloc "All fields" Headline \
- Comments Author Committer
- trace add variable findloc write find_change
- .tf.lbar.findloc configure -font uifont
- .tf.lbar.findloc.menu configure -font uifont
- pack .tf.lbar.findloc -side right
- pack .tf.lbar.findtype -side right
- pack $fstring -side left -expand 1 -fill x
-
- # Finish putting the upper half of the viewer together
- pack .tf.lbar -in .tf -side bottom -fill x
- pack .tf.bar -in .tf -side bottom -fill x
- pack .tf.histframe -fill both -side top -expand 1
- .ctop add .tf
- .ctop paneconfigure .tf -height $geometry(topheight)
- .ctop paneconfigure .tf -width $geometry(topwidth)
-
- # now build up the bottom
- panedwindow .pwbottom -orient horizontal
-
- # lower left, a text box over search bar, scroll bar to the right
- # if we know window height, then that will set the lower text height, otherwise
- # we set lower text height which will drive window height
- if {[info exists geometry(main)]} {
- frame .bleft -width $geometry(botwidth)
- } else {
- frame .bleft -width $geometry(botwidth) -height $geometry(botheight)
- }
- frame .bleft.top
- frame .bleft.mid
-
- button .bleft.top.search -text "Search" -command dosearch \
- -font uifont
- pack .bleft.top.search -side left -padx 5
- set sstring .bleft.top.sstring
- entry $sstring -width 20 -font textfont -textvariable searchstring
- lappend entries $sstring
- trace add variable searchstring write incrsearch
- pack $sstring -side left -expand 1 -fill x
- radiobutton .bleft.mid.diff -text "Diff" -font uifont \
- -command changediffdisp -variable diffelide -value {0 0}
- radiobutton .bleft.mid.old -text "Old version" -font uifont \
- -command changediffdisp -variable diffelide -value {0 1}
- radiobutton .bleft.mid.new -text "New version" -font uifont \
- -command changediffdisp -variable diffelide -value {1 0}
- label .bleft.mid.labeldiffcontext -text " Lines of context: " \
- -font uifont
- pack .bleft.mid.diff .bleft.mid.old .bleft.mid.new -side left
- spinbox .bleft.mid.diffcontext -width 5 -font textfont \
- -from 1 -increment 1 -to 10000000 \
- -validate all -validatecommand "diffcontextvalidate %P" \
- -textvariable diffcontextstring
- .bleft.mid.diffcontext set $diffcontext
- trace add variable diffcontextstring write diffcontextchange
- lappend entries .bleft.mid.diffcontext
- pack .bleft.mid.labeldiffcontext .bleft.mid.diffcontext -side left
- set ctext .bleft.ctext
- text $ctext -background $bgcolor -foreground $fgcolor \
- -state disabled -font textfont \
- -yscrollcommand scrolltext -wrap none
- if {$have_tk85} {
- $ctext conf -tabstyle wordprocessor
- }
- scrollbar .bleft.sb -command "$ctext yview"
- pack .bleft.top -side top -fill x
- pack .bleft.mid -side top -fill x
- pack .bleft.sb -side right -fill y
- pack $ctext -side left -fill both -expand 1
- lappend bglist $ctext
- lappend fglist $ctext
-
- $ctext tag conf comment -wrap $wrapcomment
- $ctext tag conf filesep -font textfontbold -back "#aaaaaa"
- $ctext tag conf hunksep -fore [lindex $diffcolors 2]
- $ctext tag conf d0 -fore [lindex $diffcolors 0]
- $ctext tag conf d1 -fore [lindex $diffcolors 1]
- $ctext tag conf m0 -fore red
- $ctext tag conf m1 -fore blue
- $ctext tag conf m2 -fore green
- $ctext tag conf m3 -fore purple
- $ctext tag conf m4 -fore brown
- $ctext tag conf m5 -fore "#009090"
- $ctext tag conf m6 -fore magenta
- $ctext tag conf m7 -fore "#808000"
- $ctext tag conf m8 -fore "#009000"
- $ctext tag conf m9 -fore "#ff0080"
- $ctext tag conf m10 -fore cyan
- $ctext tag conf m11 -fore "#b07070"
- $ctext tag conf m12 -fore "#70b0f0"
- $ctext tag conf m13 -fore "#70f0b0"
- $ctext tag conf m14 -fore "#f0b070"
- $ctext tag conf m15 -fore "#ff70b0"
- $ctext tag conf mmax -fore darkgrey
- set mergemax 16
- $ctext tag conf mresult -font textfontbold
- $ctext tag conf msep -font textfontbold
- $ctext tag conf found -back yellow
-
- .pwbottom add .bleft
- .pwbottom paneconfigure .bleft -width $geometry(botwidth)
-
- # lower right
- frame .bright
- frame .bright.mode
- radiobutton .bright.mode.patch -text "Patch" \
- -command reselectline -variable cmitmode -value "patch"
- .bright.mode.patch configure -font uifont
- radiobutton .bright.mode.tree -text "Tree" \
- -command reselectline -variable cmitmode -value "tree"
- .bright.mode.tree configure -font uifont
- grid .bright.mode.patch .bright.mode.tree -sticky ew
- pack .bright.mode -side top -fill x
- set cflist .bright.cfiles
- set indent [font measure mainfont "nn"]
- text $cflist \
- -selectbackground $selectbgcolor \
- -background $bgcolor -foreground $fgcolor \
- -font mainfont \
- -tabs [list $indent [expr {2 * $indent}]] \
- -yscrollcommand ".bright.sb set" \
- -cursor [. cget -cursor] \
- -spacing1 1 -spacing3 1
- lappend bglist $cflist
- lappend fglist $cflist
- scrollbar .bright.sb -command "$cflist yview"
- pack .bright.sb -side right -fill y
- pack $cflist -side left -fill both -expand 1
- $cflist tag configure highlight \
- -background [$cflist cget -selectbackground]
- $cflist tag configure bold -font mainfontbold
-
- .pwbottom add .bright
- .ctop add .pwbottom
-
- # restore window position if known
- if {[info exists geometry(main)]} {
- wm geometry . "$geometry(main)"
- }
-
- if {[tk windowingsystem] eq {aqua}} {
- set M1B M1
- } else {
- set M1B Control
- }
-
- bind .pwbottom <Configure> {resizecdetpanes %W %w}
- pack .ctop -fill both -expand 1
- bindall <1> {selcanvline %W %x %y}
- #bindall <B1-Motion> {selcanvline %W %x %y}
- if {[tk windowingsystem] == "win32"} {
- bind . <MouseWheel> { windows_mousewheel_redirector %W %X %Y %D }
- bind $ctext <MouseWheel> { windows_mousewheel_redirector %W %X %Y %D ; break }
- } else {
- bindall <ButtonRelease-4> "allcanvs yview scroll -5 units"
- bindall <ButtonRelease-5> "allcanvs yview scroll 5 units"
- if {[tk windowingsystem] eq "aqua"} {
- bindall <MouseWheel> {
- set delta [expr {- (%D)}]
- allcanvs yview scroll $delta units
- }
- }
- }
- bindall <2> "canvscan mark %W %x %y"
- bindall <B2-Motion> "canvscan dragto %W %x %y"
- bindkey <Home> selfirstline
- bindkey <End> sellastline
- bind . <Key-Up> "selnextline -1"
- bind . <Key-Down> "selnextline 1"
- bind . <Shift-Key-Up> "dofind -1 0"
- bind . <Shift-Key-Down> "dofind 1 0"
- bindkey <Key-Right> "goforw"
- bindkey <Key-Left> "goback"
- bind . <Key-Prior> "selnextpage -1"
- bind . <Key-Next> "selnextpage 1"
- bind . <$M1B-Home> "allcanvs yview moveto 0.0"
- bind . <$M1B-End> "allcanvs yview moveto 1.0"
- bind . <$M1B-Key-Up> "allcanvs yview scroll -1 units"
- bind . <$M1B-Key-Down> "allcanvs yview scroll 1 units"
- bind . <$M1B-Key-Prior> "allcanvs yview scroll -1 pages"
- bind . <$M1B-Key-Next> "allcanvs yview scroll 1 pages"
- bindkey <Key-Delete> "$ctext yview scroll -1 pages"
- bindkey <Key-BackSpace> "$ctext yview scroll -1 pages"
- bindkey <Key-space> "$ctext yview scroll 1 pages"
- bindkey p "selnextline -1"
- bindkey n "selnextline 1"
- bindkey z "goback"
- bindkey x "goforw"
- bindkey i "selnextline -1"
- bindkey k "selnextline 1"
- bindkey j "goback"
- bindkey l "goforw"
- bindkey b "$ctext yview scroll -1 pages"
- bindkey d "$ctext yview scroll 18 units"
- bindkey u "$ctext yview scroll -18 units"
- bindkey / {dofind 1 1}
- bindkey <Key-Return> {dofind 1 1}
- bindkey ? {dofind -1 1}
- bindkey f nextfile
- bindkey <F5> updatecommits
- bind . <$M1B-q> doquit
- bind . <$M1B-f> {dofind 1 1}
- bind . <$M1B-g> {dofind 1 0}
- bind . <$M1B-r> dosearchback
- bind . <$M1B-s> dosearch
- bind . <$M1B-equal> {incrfont 1}
- bind . <$M1B-KP_Add> {incrfont 1}
- bind . <$M1B-minus> {incrfont -1}
- bind . <$M1B-KP_Subtract> {incrfont -1}
- wm protocol . WM_DELETE_WINDOW doquit
- bind . <Button-1> "click %W"
- bind $fstring <Key-Return> {dofind 1 1}
- bind $sha1entry <Key-Return> gotocommit
- bind $sha1entry <<PasteSelection>> clearsha1
- bind $cflist <1> {sel_flist %W %x %y; break}
- bind $cflist <B1-Motion> {sel_flist %W %x %y; break}
- bind $cflist <ButtonRelease-1> {treeclick %W %x %y}
- bind $cflist <Button-3> {pop_flist_menu %W %X %Y %x %y}
-
- set maincursor [. cget -cursor]
- set textcursor [$ctext cget -cursor]
- set curtextcursor $textcursor
-
- set rowctxmenu .rowctxmenu
- menu $rowctxmenu -tearoff 0
- $rowctxmenu add command -label "Diff this -> selected" \
- -command {diffvssel 0}
- $rowctxmenu add command -label "Diff selected -> this" \
- -command {diffvssel 1}
- $rowctxmenu add command -label "Make patch" -command mkpatch
- $rowctxmenu add command -label "Create tag" -command mktag
- $rowctxmenu add command -label "Write commit to file" -command writecommit
- $rowctxmenu add command -label "Create new branch" -command mkbranch
- $rowctxmenu add command -label "Cherry-pick this commit" \
- -command cherrypick
- $rowctxmenu add command -label "Reset HEAD branch to here" \
- -command resethead
-
- set fakerowmenu .fakerowmenu
- menu $fakerowmenu -tearoff 0
- $fakerowmenu add command -label "Diff this -> selected" \
- -command {diffvssel 0}
- $fakerowmenu add command -label "Diff selected -> this" \
- -command {diffvssel 1}
- $fakerowmenu add command -label "Make patch" -command mkpatch
-# $fakerowmenu add command -label "Commit" -command {mkcommit 0}
-# $fakerowmenu add command -label "Commit all" -command {mkcommit 1}
-# $fakerowmenu add command -label "Revert local changes" -command revertlocal
-
- set headctxmenu .headctxmenu
- menu $headctxmenu -tearoff 0
- $headctxmenu add command -label "Check out this branch" \
- -command cobranch
- $headctxmenu add command -label "Remove this branch" \
- -command rmbranch
-
- global flist_menu
- set flist_menu .flistctxmenu
- menu $flist_menu -tearoff 0
- $flist_menu add command -label "Highlight this too" \
- -command {flist_hl 0}
- $flist_menu add command -label "Highlight this only" \
- -command {flist_hl 1}
-}
-
-# Windows sends all mouse wheel events to the current focused window, not
-# the one where the mouse hovers, so bind those events here and redirect
-# to the correct window
-proc windows_mousewheel_redirector {W X Y D} {
- global canv canv2 canv3
- set w [winfo containing -displayof $W $X $Y]
- if {$w ne ""} {
- set u [expr {$D < 0 ? 5 : -5}]
- if {$w == $canv || $w == $canv2 || $w == $canv3} {
- allcanvs yview scroll $u units
- } else {
- catch {
- $w yview scroll $u units
- }
- }
- }
-}
-
-# mouse-2 makes all windows scan vertically, but only the one
-# the cursor is in scans horizontally
-proc canvscan {op w x y} {
- global canv canv2 canv3
- foreach c [list $canv $canv2 $canv3] {
- if {$c == $w} {
- $c scan $op $x $y
- } else {
- $c scan $op 0 $y
- }
- }
-}
-
-proc scrollcanv {cscroll f0 f1} {
- $cscroll set $f0 $f1
- drawfrac $f0 $f1
- flushhighlights
-}
-
-# when we make a key binding for the toplevel, make sure
-# it doesn't get triggered when that key is pressed in the
-# find string entry widget.
-proc bindkey {ev script} {
- global entries
- bind . $ev $script
- set escript [bind Entry $ev]
- if {$escript == {}} {
- set escript [bind Entry <Key>]
- }
- foreach e $entries {
- bind $e $ev "$escript; break"
- }
-}
-
-# set the focus back to the toplevel for any click outside
-# the entry widgets
-proc click {w} {
- global ctext entries
- foreach e [concat $entries $ctext] {
- if {$w == $e} return
- }
- focus .
-}
-
-# Adjust the progress bar for a change in requested extent or canvas size
-proc adjustprogress {} {
- global progresscanv progressitem progresscoords
- global fprogitem fprogcoord lastprogupdate progupdatepending
- global rprogitem rprogcoord
-
- set w [expr {[winfo width $progresscanv] - 4}]
- set x0 [expr {$w * [lindex $progresscoords 0]}]
- set x1 [expr {$w * [lindex $progresscoords 1]}]
- set h [winfo height $progresscanv]
- $progresscanv coords $progressitem $x0 0 $x1 $h
- $progresscanv coords $fprogitem 0 0 [expr {$w * $fprogcoord}] $h
- $progresscanv coords $rprogitem 0 0 [expr {$w * $rprogcoord}] $h
- set now [clock clicks -milliseconds]
- if {$now >= $lastprogupdate + 100} {
- set progupdatepending 0
- update
- } elseif {!$progupdatepending} {
- set progupdatepending 1
- after [expr {$lastprogupdate + 100 - $now}] doprogupdate
- }
-}
-
-proc doprogupdate {} {
- global lastprogupdate progupdatepending
-
- if {$progupdatepending} {
- set progupdatepending 0
- set lastprogupdate [clock clicks -milliseconds]
- update
- }
-}
-
-proc savestuff {w} {
- global canv canv2 canv3 mainfont textfont uifont tabstop
- global stuffsaved findmergefiles maxgraphpct
- global maxwidth showneartags showlocalchanges
- global viewname viewfiles viewargs viewperm nextviewnum
- global cmitmode wrapcomment datetimeformat limitdiffs
- global colors bgcolor fgcolor diffcolors diffcontext selectbgcolor
-
- if {$stuffsaved} return
- if {![winfo viewable .]} return
- catch {
- set f [open "~/.gitk-new" w]
- puts $f [list set mainfont $mainfont]
- puts $f [list set textfont $textfont]
- puts $f [list set uifont $uifont]
- puts $f [list set tabstop $tabstop]
- puts $f [list set findmergefiles $findmergefiles]
- puts $f [list set maxgraphpct $maxgraphpct]
- puts $f [list set maxwidth $maxwidth]
- puts $f [list set cmitmode $cmitmode]
- puts $f [list set wrapcomment $wrapcomment]
- puts $f [list set showneartags $showneartags]
- puts $f [list set showlocalchanges $showlocalchanges]
- puts $f [list set datetimeformat $datetimeformat]
- puts $f [list set limitdiffs $limitdiffs]
- puts $f [list set bgcolor $bgcolor]
- puts $f [list set fgcolor $fgcolor]
- puts $f [list set colors $colors]
- puts $f [list set diffcolors $diffcolors]
- puts $f [list set diffcontext $diffcontext]
- puts $f [list set selectbgcolor $selectbgcolor]
-
- puts $f "set geometry(main) [wm geometry .]"
- puts $f "set geometry(topwidth) [winfo width .tf]"
- puts $f "set geometry(topheight) [winfo height .tf]"
- puts $f "set geometry(pwsash0) \"[.tf.histframe.pwclist sash coord 0]\""
- puts $f "set geometry(pwsash1) \"[.tf.histframe.pwclist sash coord 1]\""
- puts $f "set geometry(botwidth) [winfo width .bleft]"
- puts $f "set geometry(botheight) [winfo height .bleft]"
-
- puts -nonewline $f "set permviews {"
- for {set v 0} {$v < $nextviewnum} {incr v} {
- if {$viewperm($v)} {
- puts $f "{[list $viewname($v) $viewfiles($v) $viewargs($v)]}"
- }
- }
- puts $f "}"
- close $f
- file rename -force "~/.gitk-new" "~/.gitk"
- }
- set stuffsaved 1
-}
-
-proc resizeclistpanes {win w} {
- global oldwidth
- if {[info exists oldwidth($win)]} {
- set s0 [$win sash coord 0]
- set s1 [$win sash coord 1]
- if {$w < 60} {
- set sash0 [expr {int($w/2 - 2)}]
- set sash1 [expr {int($w*5/6 - 2)}]
- } else {
- set factor [expr {1.0 * $w / $oldwidth($win)}]
- set sash0 [expr {int($factor * [lindex $s0 0])}]
- set sash1 [expr {int($factor * [lindex $s1 0])}]
- if {$sash0 < 30} {
- set sash0 30
- }
- if {$sash1 < $sash0 + 20} {
- set sash1 [expr {$sash0 + 20}]
- }
- if {$sash1 > $w - 10} {
- set sash1 [expr {$w - 10}]
- if {$sash0 > $sash1 - 20} {
- set sash0 [expr {$sash1 - 20}]
- }
- }
- }
- $win sash place 0 $sash0 [lindex $s0 1]
- $win sash place 1 $sash1 [lindex $s1 1]
- }
- set oldwidth($win) $w
-}
-
-proc resizecdetpanes {win w} {
- global oldwidth
- if {[info exists oldwidth($win)]} {
- set s0 [$win sash coord 0]
- if {$w < 60} {
- set sash0 [expr {int($w*3/4 - 2)}]
- } else {
- set factor [expr {1.0 * $w / $oldwidth($win)}]
- set sash0 [expr {int($factor * [lindex $s0 0])}]
- if {$sash0 < 45} {
- set sash0 45
- }
- if {$sash0 > $w - 15} {
- set sash0 [expr {$w - 15}]
- }
- }
- $win sash place 0 $sash0 [lindex $s0 1]
- }
- set oldwidth($win) $w
-}
-
-proc allcanvs args {
- global canv canv2 canv3
- eval $canv $args
- eval $canv2 $args
- eval $canv3 $args
-}
-
-proc bindall {event action} {
- global canv canv2 canv3
- bind $canv $event $action
- bind $canv2 $event $action
- bind $canv3 $event $action
-}
-
-proc about {} {
- global uifont
- set w .about
- if {[winfo exists $w]} {
- raise $w
- return
- }
- toplevel $w
- wm title $w "About gitk"
- message $w.m -text {
-Gitk - a commit viewer for git
-
-Copyright © 2005-2006 Paul Mackerras
-
-Use and redistribute under the terms of the GNU General Public License} \
- -justify center -aspect 400 -border 2 -bg white -relief groove
- pack $w.m -side top -fill x -padx 2 -pady 2
- $w.m configure -font uifont
- button $w.ok -text Close -command "destroy $w" -default active
- pack $w.ok -side bottom
- $w.ok configure -font uifont
- bind $w <Visibility> "focus $w.ok"
- bind $w <Key-Escape> "destroy $w"
- bind $w <Key-Return> "destroy $w"
-}
-
-proc keys {} {
- global uifont
- set w .keys
- if {[winfo exists $w]} {
- raise $w
- return
- }
- if {[tk windowingsystem] eq {aqua}} {
- set M1T Cmd
- } else {
- set M1T Ctrl
- }
- toplevel $w
- wm title $w "Gitk key bindings"
- message $w.m -text "
-Gitk key bindings:
-
-<$M1T-Q> Quit
-<Home> Move to first commit
-<End> Move to last commit
-<Up>, p, i Move up one commit
-<Down>, n, k Move down one commit
-<Left>, z, j Go back in history list
-<Right>, x, l Go forward in history list
-<PageUp> Move up one page in commit list
-<PageDown> Move down one page in commit list
-<$M1T-Home> Scroll to top of commit list
-<$M1T-End> Scroll to bottom of commit list
-<$M1T-Up> Scroll commit list up one line
-<$M1T-Down> Scroll commit list down one line
-<$M1T-PageUp> Scroll commit list up one page
-<$M1T-PageDown> Scroll commit list down one page
-<Shift-Up> Find backwards (upwards, later commits)
-<Shift-Down> Find forwards (downwards, earlier commits)
-<Delete>, b Scroll diff view up one page
-<Backspace> Scroll diff view up one page
-<Space> Scroll diff view down one page
-u Scroll diff view up 18 lines
-d Scroll diff view down 18 lines
-<$M1T-F> Find
-<$M1T-G> Move to next find hit
-<Return> Move to next find hit
-/ Move to next find hit, or redo find
-? Move to previous find hit
-f Scroll diff view to next file
-<$M1T-S> Search for next hit in diff view
-<$M1T-R> Search for previous hit in diff view
-<$M1T-KP+> Increase font size
-<$M1T-plus> Increase font size
-<$M1T-KP-> Decrease font size
-<$M1T-minus> Decrease font size
-<F5> Update
-" \
- -justify left -bg white -border 2 -relief groove
- pack $w.m -side top -fill both -padx 2 -pady 2
- $w.m configure -font uifont
- button $w.ok -text Close -command "destroy $w" -default active
- pack $w.ok -side bottom
- $w.ok configure -font uifont
- bind $w <Visibility> "focus $w.ok"
- bind $w <Key-Escape> "destroy $w"
- bind $w <Key-Return> "destroy $w"
-}
-
-# Procedures for manipulating the file list window at the
-# bottom right of the overall window.
-
-proc treeview {w l openlevs} {
- global treecontents treediropen treeheight treeparent treeindex
-
- set ix 0
- set treeindex() 0
- set lev 0
- set prefix {}
- set prefixend -1
- set prefendstack {}
- set htstack {}
- set ht 0
- set treecontents() {}
- $w conf -state normal
- foreach f $l {
- while {[string range $f 0 $prefixend] ne $prefix} {
- if {$lev <= $openlevs} {
- $w mark set e:$treeindex($prefix) "end -1c"
- $w mark gravity e:$treeindex($prefix) left
- }
- set treeheight($prefix) $ht
- incr ht [lindex $htstack end]
- set htstack [lreplace $htstack end end]
- set prefixend [lindex $prefendstack end]
- set prefendstack [lreplace $prefendstack end end]
- set prefix [string range $prefix 0 $prefixend]
- incr lev -1
- }
- set tail [string range $f [expr {$prefixend+1}] end]
- while {[set slash [string first "/" $tail]] >= 0} {
- lappend htstack $ht
- set ht 0
- lappend prefendstack $prefixend
- incr prefixend [expr {$slash + 1}]
- set d [string range $tail 0 $slash]
- lappend treecontents($prefix) $d
- set oldprefix $prefix
- append prefix $d
- set treecontents($prefix) {}
- set treeindex($prefix) [incr ix]
- set treeparent($prefix) $oldprefix
- set tail [string range $tail [expr {$slash+1}] end]
- if {$lev <= $openlevs} {
- set ht 1
- set treediropen($prefix) [expr {$lev < $openlevs}]
- set bm [expr {$lev == $openlevs? "tri-rt": "tri-dn"}]
- $w mark set d:$ix "end -1c"
- $w mark gravity d:$ix left
- set str "\n"
- for {set i 0} {$i < $lev} {incr i} {append str "\t"}
- $w insert end $str
- $w image create end -align center -image $bm -padx 1 \
- -name a:$ix
- $w insert end $d [highlight_tag $prefix]
- $w mark set s:$ix "end -1c"
- $w mark gravity s:$ix left
- }
- incr lev
- }
- if {$tail ne {}} {
- if {$lev <= $openlevs} {
- incr ht
- set str "\n"
- for {set i 0} {$i < $lev} {incr i} {append str "\t"}
- $w insert end $str
- $w insert end $tail [highlight_tag $f]
- }
- lappend treecontents($prefix) $tail
- }
- }
- while {$htstack ne {}} {
- set treeheight($prefix) $ht
- incr ht [lindex $htstack end]
- set htstack [lreplace $htstack end end]
- set prefixend [lindex $prefendstack end]
- set prefendstack [lreplace $prefendstack end end]
- set prefix [string range $prefix 0 $prefixend]
- }
- $w conf -state disabled
-}
-
-proc linetoelt {l} {
- global treeheight treecontents
-
- set y 2
- set prefix {}
- while {1} {
- foreach e $treecontents($prefix) {
- if {$y == $l} {
- return "$prefix$e"
- }
- set n 1
- if {[string index $e end] eq "/"} {
- set n $treeheight($prefix$e)
- if {$y + $n > $l} {
- append prefix $e
- incr y
- break
- }
- }
- incr y $n
- }
- }
-}
-
-proc highlight_tree {y prefix} {
- global treeheight treecontents cflist
-
- foreach e $treecontents($prefix) {
- set path $prefix$e
- if {[highlight_tag $path] ne {}} {
- $cflist tag add bold $y.0 "$y.0 lineend"
- }
- incr y
- if {[string index $e end] eq "/" && $treeheight($path) > 1} {
- set y [highlight_tree $y $path]
- }
- }
- return $y
-}
-
-proc treeclosedir {w dir} {
- global treediropen treeheight treeparent treeindex
-
- set ix $treeindex($dir)
- $w conf -state normal
- $w delete s:$ix e:$ix
- set treediropen($dir) 0
- $w image configure a:$ix -image tri-rt
- $w conf -state disabled
- set n [expr {1 - $treeheight($dir)}]
- while {$dir ne {}} {
- incr treeheight($dir) $n
- set dir $treeparent($dir)
- }
-}
-
-proc treeopendir {w dir} {
- global treediropen treeheight treeparent treecontents treeindex
-
- set ix $treeindex($dir)
- $w conf -state normal
- $w image configure a:$ix -image tri-dn
- $w mark set e:$ix s:$ix
- $w mark gravity e:$ix right
- set lev 0
- set str "\n"
- set n [llength $treecontents($dir)]
- for {set x $dir} {$x ne {}} {set x $treeparent($x)} {
- incr lev
- append str "\t"
- incr treeheight($x) $n
- }
- foreach e $treecontents($dir) {
- set de $dir$e
- if {[string index $e end] eq "/"} {
- set iy $treeindex($de)
- $w mark set d:$iy e:$ix
- $w mark gravity d:$iy left
- $w insert e:$ix $str
- set treediropen($de) 0
- $w image create e:$ix -align center -image tri-rt -padx 1 \
- -name a:$iy
- $w insert e:$ix $e [highlight_tag $de]
- $w mark set s:$iy e:$ix
- $w mark gravity s:$iy left
- set treeheight($de) 1
- } else {
- $w insert e:$ix $str
- $w insert e:$ix $e [highlight_tag $de]
- }
- }
- $w mark gravity e:$ix left
- $w conf -state disabled
- set treediropen($dir) 1
- set top [lindex [split [$w index @0,0] .] 0]
- set ht [$w cget -height]
- set l [lindex [split [$w index s:$ix] .] 0]
- if {$l < $top} {
- $w yview $l.0
- } elseif {$l + $n + 1 > $top + $ht} {
- set top [expr {$l + $n + 2 - $ht}]
- if {$l < $top} {
- set top $l
- }
- $w yview $top.0
- }
-}
-
-proc treeclick {w x y} {
- global treediropen cmitmode ctext cflist cflist_top
-
- if {$cmitmode ne "tree"} return
- if {![info exists cflist_top]} return
- set l [lindex [split [$w index "@$x,$y"] "."] 0]
- $cflist tag remove highlight $cflist_top.0 "$cflist_top.0 lineend"
- $cflist tag add highlight $l.0 "$l.0 lineend"
- set cflist_top $l
- if {$l == 1} {
- $ctext yview 1.0
- return
- }
- set e [linetoelt $l]
- if {[string index $e end] ne "/"} {
- showfile $e
- } elseif {$treediropen($e)} {
- treeclosedir $w $e
- } else {
- treeopendir $w $e
- }
-}
-
-proc setfilelist {id} {
- global treefilelist cflist
-
- treeview $cflist $treefilelist($id) 0
-}
-
-image create bitmap tri-rt -background black -foreground blue -data {
- #define tri-rt_width 13
- #define tri-rt_height 13
- static unsigned char tri-rt_bits[] = {
- 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x30, 0x00, 0x70, 0x00, 0xf0, 0x00,
- 0xf0, 0x01, 0xf0, 0x00, 0x70, 0x00, 0x30, 0x00, 0x10, 0x00, 0x00, 0x00,
- 0x00, 0x00};
-} -maskdata {
- #define tri-rt-mask_width 13
- #define tri-rt-mask_height 13
- static unsigned char tri-rt-mask_bits[] = {
- 0x08, 0x00, 0x18, 0x00, 0x38, 0x00, 0x78, 0x00, 0xf8, 0x00, 0xf8, 0x01,
- 0xf8, 0x03, 0xf8, 0x01, 0xf8, 0x00, 0x78, 0x00, 0x38, 0x00, 0x18, 0x00,
- 0x08, 0x00};
-}
-image create bitmap tri-dn -background black -foreground blue -data {
- #define tri-dn_width 13
- #define tri-dn_height 13
- static unsigned char tri-dn_bits[] = {
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0x07, 0xf8, 0x03,
- 0xf0, 0x01, 0xe0, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00};
-} -maskdata {
- #define tri-dn-mask_width 13
- #define tri-dn-mask_height 13
- static unsigned char tri-dn-mask_bits[] = {
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x1f, 0xfe, 0x0f, 0xfc, 0x07,
- 0xf8, 0x03, 0xf0, 0x01, 0xe0, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00};
-}
-
-image create bitmap reficon-T -background black -foreground yellow -data {
- #define tagicon_width 13
- #define tagicon_height 9
- static unsigned char tagicon_bits[] = {
- 0x00, 0x00, 0x00, 0x00, 0xf0, 0x07, 0xf8, 0x07,
- 0xfc, 0x07, 0xf8, 0x07, 0xf0, 0x07, 0x00, 0x00, 0x00, 0x00};
-} -maskdata {
- #define tagicon-mask_width 13
- #define tagicon-mask_height 9
- static unsigned char tagicon-mask_bits[] = {
- 0x00, 0x00, 0xf0, 0x0f, 0xf8, 0x0f, 0xfc, 0x0f,
- 0xfe, 0x0f, 0xfc, 0x0f, 0xf8, 0x0f, 0xf0, 0x0f, 0x00, 0x00};
-}
-set rectdata {
- #define headicon_width 13
- #define headicon_height 9
- static unsigned char headicon_bits[] = {
- 0x00, 0x00, 0x00, 0x00, 0xf8, 0x07, 0xf8, 0x07,
- 0xf8, 0x07, 0xf8, 0x07, 0xf8, 0x07, 0x00, 0x00, 0x00, 0x00};
-}
-set rectmask {
- #define headicon-mask_width 13
- #define headicon-mask_height 9
- static unsigned char headicon-mask_bits[] = {
- 0x00, 0x00, 0xfc, 0x0f, 0xfc, 0x0f, 0xfc, 0x0f,
- 0xfc, 0x0f, 0xfc, 0x0f, 0xfc, 0x0f, 0xfc, 0x0f, 0x00, 0x00};
-}
-image create bitmap reficon-H -background black -foreground green \
- -data $rectdata -maskdata $rectmask
-image create bitmap reficon-o -background black -foreground "#ddddff" \
- -data $rectdata -maskdata $rectmask
-
-proc init_flist {first} {
- global cflist cflist_top selectedline difffilestart
-
- $cflist conf -state normal
- $cflist delete 0.0 end
- if {$first ne {}} {
- $cflist insert end $first
- set cflist_top 1
- $cflist tag add highlight 1.0 "1.0 lineend"
- } else {
- catch {unset cflist_top}
- }
- $cflist conf -state disabled
- set difffilestart {}
-}
-
-proc highlight_tag {f} {
- global highlight_paths
-
- foreach p $highlight_paths {
- if {[string match $p $f]} {
- return "bold"
- }
- }
- return {}
-}
-
-proc highlight_filelist {} {
- global cmitmode cflist
-
- $cflist conf -state normal
- if {$cmitmode ne "tree"} {
- set end [lindex [split [$cflist index end] .] 0]
- for {set l 2} {$l < $end} {incr l} {
- set line [$cflist get $l.0 "$l.0 lineend"]
- if {[highlight_tag $line] ne {}} {
- $cflist tag add bold $l.0 "$l.0 lineend"
- }
- }
- } else {
- highlight_tree 2 {}
- }
- $cflist conf -state disabled
-}
-
-proc unhighlight_filelist {} {
- global cflist
-
- $cflist conf -state normal
- $cflist tag remove bold 1.0 end
- $cflist conf -state disabled
-}
-
-proc add_flist {fl} {
- global cflist
-
- $cflist conf -state normal
- foreach f $fl {
- $cflist insert end "\n"
- $cflist insert end $f [highlight_tag $f]
- }
- $cflist conf -state disabled
-}
-
-proc sel_flist {w x y} {
- global ctext difffilestart cflist cflist_top cmitmode
-
- if {$cmitmode eq "tree"} return
- if {![info exists cflist_top]} return
- set l [lindex [split [$w index "@$x,$y"] "."] 0]
- $cflist tag remove highlight $cflist_top.0 "$cflist_top.0 lineend"
- $cflist tag add highlight $l.0 "$l.0 lineend"
- set cflist_top $l
- if {$l == 1} {
- $ctext yview 1.0
- } else {
- catch {$ctext yview [lindex $difffilestart [expr {$l - 2}]]}
- }
-}
-
-proc pop_flist_menu {w X Y x y} {
- global ctext cflist cmitmode flist_menu flist_menu_file
- global treediffs diffids
-
- stopfinding
- set l [lindex [split [$w index "@$x,$y"] "."] 0]
- if {$l <= 1} return
- if {$cmitmode eq "tree"} {
- set e [linetoelt $l]
- if {[string index $e end] eq "/"} return
- } else {
- set e [lindex $treediffs($diffids) [expr {$l-2}]]
- }
- set flist_menu_file $e
- tk_popup $flist_menu $X $Y
-}
-
-proc flist_hl {only} {
- global flist_menu_file findstring gdttype
-
- set x [shellquote $flist_menu_file]
- if {$only || $findstring eq {} || $gdttype ne "touching paths:"} {
- set findstring $x
- } else {
- append findstring " " $x
- }
- set gdttype "touching paths:"
-}
-
-# Functions for adding and removing shell-type quoting
-
-proc shellquote {str} {
- if {![string match "*\['\"\\ \t]*" $str]} {
- return $str
- }
- if {![string match "*\['\"\\]*" $str]} {
- return "\"$str\""
- }
- if {![string match "*'*" $str]} {
- return "'$str'"
- }
- return "\"[string map {\" \\\" \\ \\\\} $str]\""
-}
-
-proc shellarglist {l} {
- set str {}
- foreach a $l {
- if {$str ne {}} {
- append str " "
- }
- append str [shellquote $a]
- }
- return $str
-}
-
-proc shelldequote {str} {
- set ret {}
- set used -1
- while {1} {
- incr used
- if {![regexp -start $used -indices "\['\"\\\\ \t]" $str first]} {
- append ret [string range $str $used end]
- set used [string length $str]
- break
- }
- set first [lindex $first 0]
- set ch [string index $str $first]
- if {$first > $used} {
- append ret [string range $str $used [expr {$first - 1}]]
- set used $first
- }
- if {$ch eq " " || $ch eq "\t"} break
- incr used
- if {$ch eq "'"} {
- set first [string first "'" $str $used]
- if {$first < 0} {
- error "unmatched single-quote"
- }
- append ret [string range $str $used [expr {$first - 1}]]
- set used $first
- continue
- }
- if {$ch eq "\\"} {
- if {$used >= [string length $str]} {
- error "trailing backslash"
- }
- append ret [string index $str $used]
- continue
- }
- # here ch == "\""
- while {1} {
- if {![regexp -start $used -indices "\[\"\\\\]" $str first]} {
- error "unmatched double-quote"
- }
- set first [lindex $first 0]
- set ch [string index $str $first]
- if {$first > $used} {
- append ret [string range $str $used [expr {$first - 1}]]
- set used $first
- }
- if {$ch eq "\""} break
- incr used
- append ret [string index $str $used]
- incr used
- }
- }
- return [list $used $ret]
-}
-
-proc shellsplit {str} {
- set l {}
- while {1} {
- set str [string trimleft $str]
- if {$str eq {}} break
- set dq [shelldequote $str]
- set n [lindex $dq 0]
- set word [lindex $dq 1]
- set str [string range $str $n end]
- lappend l $word
- }
- return $l
-}
-
-# Code to implement multiple views
-
-proc newview {ishighlight} {
- global nextviewnum newviewname newviewperm uifont newishighlight
- global newviewargs revtreeargs
-
- set newishighlight $ishighlight
- set top .gitkview
- if {[winfo exists $top]} {
- raise $top
- return
- }
- set newviewname($nextviewnum) "View $nextviewnum"
- set newviewperm($nextviewnum) 0
- set newviewargs($nextviewnum) [shellarglist $revtreeargs]
- vieweditor $top $nextviewnum "Gitk view definition"
-}
-
-proc editview {} {
- global curview
- global viewname viewperm newviewname newviewperm
- global viewargs newviewargs
-
- set top .gitkvedit-$curview
- if {[winfo exists $top]} {
- raise $top
- return
- }
- set newviewname($curview) $viewname($curview)
- set newviewperm($curview) $viewperm($curview)
- set newviewargs($curview) [shellarglist $viewargs($curview)]
- vieweditor $top $curview "Gitk: edit view $viewname($curview)"
-}
-
-proc vieweditor {top n title} {
- global newviewname newviewperm viewfiles
- global uifont
-
- toplevel $top
- wm title $top $title
- label $top.nl -text "Name" -font uifont
- entry $top.name -width 20 -textvariable newviewname($n) -font uifont
- grid $top.nl $top.name -sticky w -pady 5
- checkbutton $top.perm -text "Remember this view" -variable newviewperm($n) \
- -font uifont
- grid $top.perm - -pady 5 -sticky w
- message $top.al -aspect 1000 -font uifont \
- -text "Commits to include (arguments to git rev-list):"
- grid $top.al - -sticky w -pady 5
- entry $top.args -width 50 -textvariable newviewargs($n) \
- -background white -font uifont
- grid $top.args - -sticky ew -padx 5
- message $top.l -aspect 1000 -font uifont \
- -text "Enter files and directories to include, one per line:"
- grid $top.l - -sticky w
- text $top.t -width 40 -height 10 -background white -font uifont
- if {[info exists viewfiles($n)]} {
- foreach f $viewfiles($n) {
- $top.t insert end $f
- $top.t insert end "\n"
- }
- $top.t delete {end - 1c} end
- $top.t mark set insert 0.0
- }
- grid $top.t - -sticky ew -padx 5
- frame $top.buts
- button $top.buts.ok -text "OK" -command [list newviewok $top $n] \
- -font uifont
- button $top.buts.can -text "Cancel" -command [list destroy $top] \
- -font uifont
- grid $top.buts.ok $top.buts.can
- grid columnconfigure $top.buts 0 -weight 1 -uniform a
- grid columnconfigure $top.buts 1 -weight 1 -uniform a
- grid $top.buts - -pady 10 -sticky ew
- focus $top.t
-}
-
-proc doviewmenu {m first cmd op argv} {
- set nmenu [$m index end]
- for {set i $first} {$i <= $nmenu} {incr i} {
- if {[$m entrycget $i -command] eq $cmd} {
- eval $m $op $i $argv
- break
- }
- }
-}
-
-proc allviewmenus {n op args} {
- # global viewhlmenu
-
- doviewmenu .bar.view 5 [list showview $n] $op $args
- # doviewmenu $viewhlmenu 1 [list addvhighlight $n] $op $args
-}
-
-proc newviewok {top n} {
- global nextviewnum newviewperm newviewname newishighlight
- global viewname viewfiles viewperm selectedview curview
- global viewargs newviewargs viewhlmenu
-
- if {[catch {
- set newargs [shellsplit $newviewargs($n)]
- } err]} {
- error_popup "Error in commit selection arguments: $err"
- wm raise $top
- focus $top
- return
- }
- set files {}
- foreach f [split [$top.t get 0.0 end] "\n"] {
- set ft [string trim $f]
- if {$ft ne {}} {
- lappend files $ft
- }
- }
- if {![info exists viewfiles($n)]} {
- # creating a new view
- incr nextviewnum
- set viewname($n) $newviewname($n)
- set viewperm($n) $newviewperm($n)
- set viewfiles($n) $files
- set viewargs($n) $newargs
- addviewmenu $n
- if {!$newishighlight} {
- run showview $n
- } else {
- run addvhighlight $n
- }
- } else {
- # editing an existing view
- set viewperm($n) $newviewperm($n)
- if {$newviewname($n) ne $viewname($n)} {
- set viewname($n) $newviewname($n)
- doviewmenu .bar.view 5 [list showview $n] \
- entryconf [list -label $viewname($n)]
- # doviewmenu $viewhlmenu 1 [list addvhighlight $n] \
- # entryconf [list -label $viewname($n) -value $viewname($n)]
- }
- if {$files ne $viewfiles($n) || $newargs ne $viewargs($n)} {
- set viewfiles($n) $files
- set viewargs($n) $newargs
- if {$curview == $n} {
- run updatecommits
- }
- }
- }
- catch {destroy $top}
-}
-
-proc delview {} {
- global curview viewdata viewperm hlview selectedhlview
-
- if {$curview == 0} return
- if {[info exists hlview] && $hlview == $curview} {
- set selectedhlview None
- unset hlview
- }
- allviewmenus $curview delete
- set viewdata($curview) {}
- set viewperm($curview) 0
- showview 0
-}
-
-proc addviewmenu {n} {
- global viewname viewhlmenu
-
- .bar.view add radiobutton -label $viewname($n) \
- -command [list showview $n] -variable selectedview -value $n
- #$viewhlmenu add radiobutton -label $viewname($n) \
- # -command [list addvhighlight $n] -variable selectedhlview
-}
-
-proc flatten {var} {
- global $var
-
- set ret {}
- foreach i [array names $var] {
- lappend ret $i [set $var\($i\)]
- }
- return $ret
-}
-
-proc unflatten {var l} {
- global $var
-
- catch {unset $var}
- foreach {i v} $l {
- set $var\($i\) $v
- }
-}
-
-proc showview {n} {
- global curview viewdata viewfiles
- global displayorder parentlist rowidlist rowisopt rowfinal
- global colormap rowtextx commitrow nextcolor canvxmax
- global numcommits commitlisted
- global selectedline currentid canv canvy0
- global treediffs
- global pending_select phase
- global commitidx
- global commfd
- global selectedview selectfirst
- global vparentlist vdisporder vcmitlisted
- global hlview selectedhlview commitinterest
-
- if {$n == $curview} return
- set selid {}
- if {[info exists selectedline]} {
- set selid $currentid
- set y [yc $selectedline]
- set ymax [lindex [$canv cget -scrollregion] 3]
- set span [$canv yview]
- set ytop [expr {[lindex $span 0] * $ymax}]
- set ybot [expr {[lindex $span 1] * $ymax}]
- if {$ytop < $y && $y < $ybot} {
- set yscreen [expr {$y - $ytop}]
- } else {
- set yscreen [expr {($ybot - $ytop) / 2}]
- }
- } elseif {[info exists pending_select]} {
- set selid $pending_select
- unset pending_select
- }
- unselectline
- normalline
- if {$curview >= 0} {
- set vparentlist($curview) $parentlist
- set vdisporder($curview) $displayorder
- set vcmitlisted($curview) $commitlisted
- if {$phase ne {} ||
- ![info exists viewdata($curview)] ||
- [lindex $viewdata($curview) 0] ne {}} {
- set viewdata($curview) \
- [list $phase $rowidlist $rowisopt $rowfinal]
- }
- }
- catch {unset treediffs}
- clear_display
- if {[info exists hlview] && $hlview == $n} {
- unset hlview
- set selectedhlview None
- }
- catch {unset commitinterest}
-
- set curview $n
- set selectedview $n
- .bar.view entryconf Edit* -state [expr {$n == 0? "disabled": "normal"}]
- .bar.view entryconf Delete* -state [expr {$n == 0? "disabled": "normal"}]
-
- run refill_reflist
- if {![info exists viewdata($n)]} {
- if {$selid ne {}} {
- set pending_select $selid
- }
- getcommits
- return
- }
-
- set v $viewdata($n)
- set phase [lindex $v 0]
- set displayorder $vdisporder($n)
- set parentlist $vparentlist($n)
- set commitlisted $vcmitlisted($n)
- set rowidlist [lindex $v 1]
- set rowisopt [lindex $v 2]
- set rowfinal [lindex $v 3]
- set numcommits $commitidx($n)
-
- catch {unset colormap}
- catch {unset rowtextx}
- set nextcolor 0
- set canvxmax [$canv cget -width]
- set curview $n
- set row 0
- setcanvscroll
- set yf 0
- set row {}
- set selectfirst 0
- if {$selid ne {} && [info exists commitrow($n,$selid)]} {
- set row $commitrow($n,$selid)
- # try to get the selected row in the same position on the screen
- set ymax [lindex [$canv cget -scrollregion] 3]
- set ytop [expr {[yc $row] - $yscreen}]
- if {$ytop < 0} {
- set ytop 0
- }
- set yf [expr {$ytop * 1.0 / $ymax}]
- }
- allcanvs yview moveto $yf
- drawvisible
- if {$row ne {}} {
- selectline $row 0
- } elseif {$selid ne {}} {
- set pending_select $selid
- } else {
- set row [first_real_row]
- if {$row < $numcommits} {
- selectline $row 0
- } else {
- set selectfirst 1
- }
- }
- if {$phase ne {}} {
- if {$phase eq "getcommits"} {
- show_status "Reading commits..."
- }
- run chewcommits $n
- } elseif {$numcommits == 0} {
- show_status "No commits selected"
- }
-}
-
-# Stuff relating to the highlighting facility
-
-proc ishighlighted {row} {
- global vhighlights fhighlights nhighlights rhighlights
-
- if {[info exists nhighlights($row)] && $nhighlights($row) > 0} {
- return $nhighlights($row)
- }
- if {[info exists vhighlights($row)] && $vhighlights($row) > 0} {
- return $vhighlights($row)
- }
- if {[info exists fhighlights($row)] && $fhighlights($row) > 0} {
- return $fhighlights($row)
- }
- if {[info exists rhighlights($row)] && $rhighlights($row) > 0} {
- return $rhighlights($row)
- }
- return 0
-}
-
-proc bolden {row font} {
- global canv linehtag selectedline boldrows
-
- lappend boldrows $row
- $canv itemconf $linehtag($row) -font $font
- if {[info exists selectedline] && $row == $selectedline} {
- $canv delete secsel
- set t [eval $canv create rect [$canv bbox $linehtag($row)] \
- -outline {{}} -tags secsel \
- -fill [$canv cget -selectbackground]]
- $canv lower $t
- }
-}
-
-proc bolden_name {row font} {
- global canv2 linentag selectedline boldnamerows
-
- lappend boldnamerows $row
- $canv2 itemconf $linentag($row) -font $font
- if {[info exists selectedline] && $row == $selectedline} {
- $canv2 delete secsel
- set t [eval $canv2 create rect [$canv2 bbox $linentag($row)] \
- -outline {{}} -tags secsel \
- -fill [$canv2 cget -selectbackground]]
- $canv2 lower $t
- }
-}
-
-proc unbolden {} {
- global boldrows
-
- set stillbold {}
- foreach row $boldrows {
- if {![ishighlighted $row]} {
- bolden $row mainfont
- } else {
- lappend stillbold $row
- }
- }
- set boldrows $stillbold
-}
-
-proc addvhighlight {n} {
- global hlview curview viewdata vhl_done vhighlights commitidx
-
- if {[info exists hlview]} {
- delvhighlight
- }
- set hlview $n
- if {$n != $curview && ![info exists viewdata($n)]} {
- set viewdata($n) [list getcommits {{}} 0 0 0]
- set vparentlist($n) {}
- set vdisporder($n) {}
- set vcmitlisted($n) {}
- start_rev_list $n
- }
- set vhl_done $commitidx($hlview)
- if {$vhl_done > 0} {
- drawvisible
- }
-}
-
-proc delvhighlight {} {
- global hlview vhighlights
-
- if {![info exists hlview]} return
- unset hlview
- catch {unset vhighlights}
- unbolden
-}
-
-proc vhighlightmore {} {
- global hlview vhl_done commitidx vhighlights
- global displayorder vdisporder curview
-
- set max $commitidx($hlview)
- if {$hlview == $curview} {
- set disp $displayorder
- } else {
- set disp $vdisporder($hlview)
- }
- set vr [visiblerows]
- set r0 [lindex $vr 0]
- set r1 [lindex $vr 1]
- for {set i $vhl_done} {$i < $max} {incr i} {
- set id [lindex $disp $i]
- if {[info exists commitrow($curview,$id)]} {
- set row $commitrow($curview,$id)
- if {$r0 <= $row && $row <= $r1} {
- if {![highlighted $row]} {
- bolden $row mainfontbold
- }
- set vhighlights($row) 1
- }
- }
- }
- set vhl_done $max
-}
-
-proc askvhighlight {row id} {
- global hlview vhighlights commitrow iddrawn
-
- if {[info exists commitrow($hlview,$id)]} {
- if {[info exists iddrawn($id)] && ![ishighlighted $row]} {
- bolden $row mainfontbold
- }
- set vhighlights($row) 1
- } else {
- set vhighlights($row) 0
- }
-}
-
-proc hfiles_change {} {
- global highlight_files filehighlight fhighlights fh_serial
- global highlight_paths gdttype
-
- if {[info exists filehighlight]} {
- # delete previous highlights
- catch {close $filehighlight}
- unset filehighlight
- catch {unset fhighlights}
- unbolden
- unhighlight_filelist
- }
- set highlight_paths {}
- after cancel do_file_hl $fh_serial
- incr fh_serial
- if {$highlight_files ne {}} {
- after 300 do_file_hl $fh_serial
- }
-}
-
-proc gdttype_change {name ix op} {
- global gdttype highlight_files findstring findpattern
-
- stopfinding
- if {$findstring ne {}} {
- if {$gdttype eq "containing:"} {
- if {$highlight_files ne {}} {
- set highlight_files {}
- hfiles_change
- }
- findcom_change
- } else {
- if {$findpattern ne {}} {
- set findpattern {}
- findcom_change
- }
- set highlight_files $findstring
- hfiles_change
- }
- drawvisible
- }
- # enable/disable findtype/findloc menus too
-}
-
-proc find_change {name ix op} {
- global gdttype findstring highlight_files
-
- stopfinding
- if {$gdttype eq "containing:"} {
- findcom_change
- } else {
- if {$highlight_files ne $findstring} {
- set highlight_files $findstring
- hfiles_change
- }
- }
- drawvisible
-}
-
-proc findcom_change args {
- global nhighlights boldnamerows
- global findpattern findtype findstring gdttype
-
- stopfinding
- # delete previous highlights, if any
- foreach row $boldnamerows {
- bolden_name $row mainfont
- }
- set boldnamerows {}
- catch {unset nhighlights}
- unbolden
- unmarkmatches
- if {$gdttype ne "containing:" || $findstring eq {}} {
- set findpattern {}
- } elseif {$findtype eq "Regexp"} {
- set findpattern $findstring
- } else {
- set e [string map {"*" "\\*" "?" "\\?" "\[" "\\\[" "\\" "\\\\"} \
- $findstring]
- set findpattern "*$e*"
- }
-}
-
-proc makepatterns {l} {
- set ret {}
- foreach e $l {
- set ee [string map {"*" "\\*" "?" "\\?" "\[" "\\\[" "\\" "\\\\"} $e]
- if {[string index $ee end] eq "/"} {
- lappend ret "$ee*"
- } else {
- lappend ret $ee
- lappend ret "$ee/*"
- }
- }
- return $ret
-}
-
-proc do_file_hl {serial} {
- global highlight_files filehighlight highlight_paths gdttype fhl_list
-
- if {$gdttype eq "touching paths:"} {
- if {[catch {set paths [shellsplit $highlight_files]}]} return
- set highlight_paths [makepatterns $paths]
- highlight_filelist
- set gdtargs [concat -- $paths]
- } elseif {$gdttype eq "adding/removing string:"} {
- set gdtargs [list "-S$highlight_files"]
- } else {
- # must be "containing:", i.e. we're searching commit info
- return
- }
- set cmd [concat | git diff-tree -r -s --stdin $gdtargs]
- set filehighlight [open $cmd r+]
- fconfigure $filehighlight -blocking 0
- filerun $filehighlight readfhighlight
- set fhl_list {}
- drawvisible
- flushhighlights
-}
-
-proc flushhighlights {} {
- global filehighlight fhl_list
-
- if {[info exists filehighlight]} {
- lappend fhl_list {}
- puts $filehighlight ""
- flush $filehighlight
- }
-}
-
-proc askfilehighlight {row id} {
- global filehighlight fhighlights fhl_list
-
- lappend fhl_list $id
- set fhighlights($row) -1
- puts $filehighlight $id
-}
-
-proc readfhighlight {} {
- global filehighlight fhighlights commitrow curview iddrawn
- global fhl_list find_dirn
-
- if {![info exists filehighlight]} {
- return 0
- }
- set nr 0
- while {[incr nr] <= 100 && [gets $filehighlight line] >= 0} {
- set line [string trim $line]
- set i [lsearch -exact $fhl_list $line]
- if {$i < 0} continue
- for {set j 0} {$j < $i} {incr j} {
- set id [lindex $fhl_list $j]
- if {[info exists commitrow($curview,$id)]} {
- set fhighlights($commitrow($curview,$id)) 0
- }
- }
- set fhl_list [lrange $fhl_list [expr {$i+1}] end]
- if {$line eq {}} continue
- if {![info exists commitrow($curview,$line)]} continue
- set row $commitrow($curview,$line)
- if {[info exists iddrawn($line)] && ![ishighlighted $row]} {
- bolden $row mainfontbold
- }
- set fhighlights($row) 1
- }
- if {[eof $filehighlight]} {
- # strange...
- puts "oops, git diff-tree died"
- catch {close $filehighlight}
- unset filehighlight
- return 0
- }
- if {[info exists find_dirn]} {
- run findmore
- }
- return 1
-}
-
-proc doesmatch {f} {
- global findtype findpattern
-
- if {$findtype eq "Regexp"} {
- return [regexp $findpattern $f]
- } elseif {$findtype eq "IgnCase"} {
- return [string match -nocase $findpattern $f]
- } else {
- return [string match $findpattern $f]
- }
-}
-
-proc askfindhighlight {row id} {
- global nhighlights commitinfo iddrawn
- global findloc
- global markingmatches
-
- if {![info exists commitinfo($id)]} {
- getcommit $id
- }
- set info $commitinfo($id)
- set isbold 0
- set fldtypes {Headline Author Date Committer CDate Comments}
- foreach f $info ty $fldtypes {
- if {($findloc eq "All fields" || $findloc eq $ty) &&
- [doesmatch $f]} {
- if {$ty eq "Author"} {
- set isbold 2
- break
- }
- set isbold 1
- }
- }
- if {$isbold && [info exists iddrawn($id)]} {
- if {![ishighlighted $row]} {
- bolden $row mainfontbold
- if {$isbold > 1} {
- bolden_name $row mainfontbold
- }
- }
- if {$markingmatches} {
- markrowmatches $row $id
- }
- }
- set nhighlights($row) $isbold
-}
-
-proc markrowmatches {row id} {
- global canv canv2 linehtag linentag commitinfo findloc
-
- set headline [lindex $commitinfo($id) 0]
- set author [lindex $commitinfo($id) 1]
- $canv delete match$row
- $canv2 delete match$row
- if {$findloc eq "All fields" || $findloc eq "Headline"} {
- set m [findmatches $headline]
- if {$m ne {}} {
- markmatches $canv $row $headline $linehtag($row) $m \
- [$canv itemcget $linehtag($row) -font] $row
- }
- }
- if {$findloc eq "All fields" || $findloc eq "Author"} {
- set m [findmatches $author]
- if {$m ne {}} {
- markmatches $canv2 $row $author $linentag($row) $m \
- [$canv2 itemcget $linentag($row) -font] $row
- }
- }
-}
-
-proc vrel_change {name ix op} {
- global highlight_related
-
- rhighlight_none
- if {$highlight_related ne "None"} {
- run drawvisible
- }
-}
-
-# prepare for testing whether commits are descendents or ancestors of a
-proc rhighlight_sel {a} {
- global descendent desc_todo ancestor anc_todo
- global highlight_related rhighlights
-
- catch {unset descendent}
- set desc_todo [list $a]
- catch {unset ancestor}
- set anc_todo [list $a]
- if {$highlight_related ne "None"} {
- rhighlight_none
- run drawvisible
- }
-}
-
-proc rhighlight_none {} {
- global rhighlights
-
- catch {unset rhighlights}
- unbolden
-}
-
-proc is_descendent {a} {
- global curview children commitrow descendent desc_todo
-
- set v $curview
- set la $commitrow($v,$a)
- set todo $desc_todo
- set leftover {}
- set done 0
- for {set i 0} {$i < [llength $todo]} {incr i} {
- set do [lindex $todo $i]
- if {$commitrow($v,$do) < $la} {
- lappend leftover $do
- continue
- }
- foreach nk $children($v,$do) {
- if {![info exists descendent($nk)]} {
- set descendent($nk) 1
- lappend todo $nk
- if {$nk eq $a} {
- set done 1
- }
- }
- }
- if {$done} {
- set desc_todo [concat $leftover [lrange $todo [expr {$i+1}] end]]
- return
- }
- }
- set descendent($a) 0
- set desc_todo $leftover
-}
-
-proc is_ancestor {a} {
- global curview parentlist commitrow ancestor anc_todo
-
- set v $curview
- set la $commitrow($v,$a)
- set todo $anc_todo
- set leftover {}
- set done 0
- for {set i 0} {$i < [llength $todo]} {incr i} {
- set do [lindex $todo $i]
- if {![info exists commitrow($v,$do)] || $commitrow($v,$do) > $la} {
- lappend leftover $do
- continue
- }
- foreach np [lindex $parentlist $commitrow($v,$do)] {
- if {![info exists ancestor($np)]} {
- set ancestor($np) 1
- lappend todo $np
- if {$np eq $a} {
- set done 1
- }
- }
- }
- if {$done} {
- set anc_todo [concat $leftover [lrange $todo [expr {$i+1}] end]]
- return
- }
- }
- set ancestor($a) 0
- set anc_todo $leftover
-}
-
-proc askrelhighlight {row id} {
- global descendent highlight_related iddrawn rhighlights
- global selectedline ancestor
-
- if {![info exists selectedline]} return
- set isbold 0
- if {$highlight_related eq "Descendent" ||
- $highlight_related eq "Not descendent"} {
- if {![info exists descendent($id)]} {
- is_descendent $id
- }
- if {$descendent($id) == ($highlight_related eq "Descendent")} {
- set isbold 1
- }
- } elseif {$highlight_related eq "Ancestor" ||
- $highlight_related eq "Not ancestor"} {
- if {![info exists ancestor($id)]} {
- is_ancestor $id
- }
- if {$ancestor($id) == ($highlight_related eq "Ancestor")} {
- set isbold 1
- }
- }
- if {[info exists iddrawn($id)]} {
- if {$isbold && ![ishighlighted $row]} {
- bolden $row mainfontbold
- }
- }
- set rhighlights($row) $isbold
-}
-
-# Graph layout functions
-
-proc shortids {ids} {
- set res {}
- foreach id $ids {
- if {[llength $id] > 1} {
- lappend res [shortids $id]
- } elseif {[regexp {^[0-9a-f]{40}$} $id]} {
- lappend res [string range $id 0 7]
- } else {
- lappend res $id
- }
- }
- return $res
-}
-
-proc ntimes {n o} {
- set ret {}
- set o [list $o]
- for {set mask 1} {$mask <= $n} {incr mask $mask} {
- if {($n & $mask) != 0} {
- set ret [concat $ret $o]
- }
- set o [concat $o $o]
- }
- return $ret
-}
-
-# Work out where id should go in idlist so that order-token
-# values increase from left to right
-proc idcol {idlist id {i 0}} {
- global ordertok curview
-
- set t $ordertok($curview,$id)
- if {$i >= [llength $idlist] ||
- $t < $ordertok($curview,[lindex $idlist $i])} {
- if {$i > [llength $idlist]} {
- set i [llength $idlist]
- }
- while {[incr i -1] >= 0 &&
- $t < $ordertok($curview,[lindex $idlist $i])} {}
- incr i
- } else {
- if {$t > $ordertok($curview,[lindex $idlist $i])} {
- while {[incr i] < [llength $idlist] &&
- $t >= $ordertok($curview,[lindex $idlist $i])} {}
- }
- }
- return $i
-}
-
-proc initlayout {} {
- global rowidlist rowisopt rowfinal displayorder commitlisted
- global numcommits canvxmax canv
- global nextcolor
- global parentlist
- global colormap rowtextx
- global selectfirst
-
- set numcommits 0
- set displayorder {}
- set commitlisted {}
- set parentlist {}
- set nextcolor 0
- set rowidlist {}
- set rowisopt {}
- set rowfinal {}
- set canvxmax [$canv cget -width]
- catch {unset colormap}
- catch {unset rowtextx}
- set selectfirst 1
-}
-
-proc setcanvscroll {} {
- global canv canv2 canv3 numcommits linespc canvxmax canvy0
-
- set ymax [expr {$canvy0 + ($numcommits - 0.5) * $linespc + 2}]
- $canv conf -scrollregion [list 0 0 $canvxmax $ymax]
- $canv2 conf -scrollregion [list 0 0 0 $ymax]
- $canv3 conf -scrollregion [list 0 0 0 $ymax]
-}
-
-proc visiblerows {} {
- global canv numcommits linespc
-
- set ymax [lindex [$canv cget -scrollregion] 3]
- if {$ymax eq {} || $ymax == 0} return
- set f [$canv yview]
- set y0 [expr {int([lindex $f 0] * $ymax)}]
- set r0 [expr {int(($y0 - 3) / $linespc) - 1}]
- if {$r0 < 0} {
- set r0 0
- }
- set y1 [expr {int([lindex $f 1] * $ymax)}]
- set r1 [expr {int(($y1 - 3) / $linespc) + 1}]
- if {$r1 >= $numcommits} {
- set r1 [expr {$numcommits - 1}]
- }
- return [list $r0 $r1]
-}
-
-proc layoutmore {} {
- global commitidx viewcomplete numcommits
- global uparrowlen downarrowlen mingaplen curview
-
- set show $commitidx($curview)
- if {$show > $numcommits || $viewcomplete($curview)} {
- showstuff $show $viewcomplete($curview)
- }
-}
-
-proc showstuff {canshow last} {
- global numcommits commitrow pending_select selectedline curview
- global mainheadid displayorder selectfirst
- global lastscrollset commitinterest
-
- if {$numcommits == 0} {
- global phase
- set phase "incrdraw"
- allcanvs delete all
- }
- set r0 $numcommits
- set prev $numcommits
- set numcommits $canshow
- set t [clock clicks -milliseconds]
- if {$prev < 100 || $last || $t - $lastscrollset > 500} {
- set lastscrollset $t
- setcanvscroll
- }
- set rows [visiblerows]
- set r1 [lindex $rows 1]
- if {$r1 >= $canshow} {
- set r1 [expr {$canshow - 1}]
- }
- if {$r0 <= $r1} {
- drawcommits $r0 $r1
- }
- if {[info exists pending_select] &&
- [info exists commitrow($curview,$pending_select)] &&
- $commitrow($curview,$pending_select) < $numcommits} {
- selectline $commitrow($curview,$pending_select) 1
- }
- if {$selectfirst} {
- if {[info exists selectedline] || [info exists pending_select]} {
- set selectfirst 0
- } else {
- set l [first_real_row]
- selectline $l 1
- set selectfirst 0
- }
- }
-}
-
-proc doshowlocalchanges {} {
- global curview mainheadid phase commitrow
-
- if {[info exists commitrow($curview,$mainheadid)] &&
- ($phase eq {} || $commitrow($curview,$mainheadid) < $numcommits - 1)} {
- dodiffindex
- } elseif {$phase ne {}} {
- lappend commitinterest($mainheadid) {}
- }
-}
-
-proc dohidelocalchanges {} {
- global localfrow localirow lserial
-
- if {$localfrow >= 0} {
- removerow $localfrow
- set localfrow -1
- if {$localirow > 0} {
- incr localirow -1
- }
- }
- if {$localirow >= 0} {
- removerow $localirow
- set localirow -1
- }
- incr lserial
-}
-
-# spawn off a process to do git diff-index --cached HEAD
-proc dodiffindex {} {
- global localirow localfrow lserial showlocalchanges
-
- if {!$showlocalchanges} return
- incr lserial
- set localfrow -1
- set localirow -1
- set fd [open "|git diff-index --cached HEAD" r]
- fconfigure $fd -blocking 0
- filerun $fd [list readdiffindex $fd $lserial]
-}
-
-proc readdiffindex {fd serial} {
- global localirow commitrow mainheadid nullid2 curview
- global commitinfo commitdata lserial
-
- set isdiff 1
- if {[gets $fd line] < 0} {
- if {![eof $fd]} {
- return 1
- }
- set isdiff 0
- }
- # we only need to see one line and we don't really care what it says...
- close $fd
-
- # now see if there are any local changes not checked in to the index
- if {$serial == $lserial} {
- set fd [open "|git diff-files" r]
- fconfigure $fd -blocking 0
- filerun $fd [list readdifffiles $fd $serial]
- }
-
- if {$isdiff && $serial == $lserial && $localirow == -1} {
- # add the line for the changes in the index to the graph
- set localirow $commitrow($curview,$mainheadid)
- set hl "Local changes checked in to index but not committed"
- set commitinfo($nullid2) [list $hl {} {} {} {} " $hl\n"]
- set commitdata($nullid2) "\n $hl\n"
- insertrow $localirow $nullid2
- }
- return 0
-}
-
-proc readdifffiles {fd serial} {
- global localirow localfrow commitrow mainheadid nullid curview
- global commitinfo commitdata lserial
-
- set isdiff 1
- if {[gets $fd line] < 0} {
- if {![eof $fd]} {
- return 1
- }
- set isdiff 0
- }
- # we only need to see one line and we don't really care what it says...
- close $fd
-
- if {$isdiff && $serial == $lserial && $localfrow == -1} {
- # add the line for the local diff to the graph
- if {$localirow >= 0} {
- set localfrow $localirow
- incr localirow
- } else {
- set localfrow $commitrow($curview,$mainheadid)
- }
- set hl "Local uncommitted changes, not checked in to index"
- set commitinfo($nullid) [list $hl {} {} {} {} " $hl\n"]
- set commitdata($nullid) "\n $hl\n"
- insertrow $localfrow $nullid
- }
- return 0
-}
-
-proc nextuse {id row} {
- global commitrow curview children
-
- if {[info exists children($curview,$id)]} {
- foreach kid $children($curview,$id) {
- if {![info exists commitrow($curview,$kid)]} {
- return -1
- }
- if {$commitrow($curview,$kid) > $row} {
- return $commitrow($curview,$kid)
- }
- }
- }
- if {[info exists commitrow($curview,$id)]} {
- return $commitrow($curview,$id)
- }
- return -1
-}
-
-proc prevuse {id row} {
- global commitrow curview children
-
- set ret -1
- if {[info exists children($curview,$id)]} {
- foreach kid $children($curview,$id) {
- if {![info exists commitrow($curview,$kid)]} break
- if {$commitrow($curview,$kid) < $row} {
- set ret $commitrow($curview,$kid)
- }
- }
- }
- return $ret
-}
-
-proc make_idlist {row} {
- global displayorder parentlist uparrowlen downarrowlen mingaplen
- global commitidx curview ordertok children commitrow
-
- set r [expr {$row - $mingaplen - $downarrowlen - 1}]
- if {$r < 0} {
- set r 0
- }
- set ra [expr {$row - $downarrowlen}]
- if {$ra < 0} {
- set ra 0
- }
- set rb [expr {$row + $uparrowlen}]
- if {$rb > $commitidx($curview)} {
- set rb $commitidx($curview)
- }
- set ids {}
- for {} {$r < $ra} {incr r} {
- set nextid [lindex $displayorder [expr {$r + 1}]]
- foreach p [lindex $parentlist $r] {
- if {$p eq $nextid} continue
- set rn [nextuse $p $r]
- if {$rn >= $row &&
- $rn <= $r + $downarrowlen + $mingaplen + $uparrowlen} {
- lappend ids [list $ordertok($curview,$p) $p]
- }
- }
- }
- for {} {$r < $row} {incr r} {
- set nextid [lindex $displayorder [expr {$r + 1}]]
- foreach p [lindex $parentlist $r] {
- if {$p eq $nextid} continue
- set rn [nextuse $p $r]
- if {$rn < 0 || $rn >= $row} {
- lappend ids [list $ordertok($curview,$p) $p]
- }
- }
- }
- set id [lindex $displayorder $row]
- lappend ids [list $ordertok($curview,$id) $id]
- while {$r < $rb} {
- foreach p [lindex $parentlist $r] {
- set firstkid [lindex $children($curview,$p) 0]
- if {$commitrow($curview,$firstkid) < $row} {
- lappend ids [list $ordertok($curview,$p) $p]
- }
- }
- incr r
- set id [lindex $displayorder $r]
- if {$id ne {}} {
- set firstkid [lindex $children($curview,$id) 0]
- if {$firstkid ne {} && $commitrow($curview,$firstkid) < $row} {
- lappend ids [list $ordertok($curview,$id) $id]
- }
- }
- }
- set idlist {}
- foreach idx [lsort -unique $ids] {
- lappend idlist [lindex $idx 1]
- }
- return $idlist
-}
-
-proc rowsequal {a b} {
- while {[set i [lsearch -exact $a {}]] >= 0} {
- set a [lreplace $a $i $i]
- }
- while {[set i [lsearch -exact $b {}]] >= 0} {
- set b [lreplace $b $i $i]
- }
- return [expr {$a eq $b}]
-}
-
-proc makeupline {id row rend col} {
- global rowidlist uparrowlen downarrowlen mingaplen
-
- for {set r $rend} {1} {set r $rstart} {
- set rstart [prevuse $id $r]
- if {$rstart < 0} return
- if {$rstart < $row} break
- }
- if {$rstart + $uparrowlen + $mingaplen + $downarrowlen < $rend} {
- set rstart [expr {$rend - $uparrowlen - 1}]
- }
- for {set r $rstart} {[incr r] <= $row} {} {
- set idlist [lindex $rowidlist $r]
- if {$idlist ne {} && [lsearch -exact $idlist $id] < 0} {
- set col [idcol $idlist $id $col]
- lset rowidlist $r [linsert $idlist $col $id]
- changedrow $r
- }
- }
-}
-
-proc layoutrows {row endrow} {
- global rowidlist rowisopt rowfinal displayorder
- global uparrowlen downarrowlen maxwidth mingaplen
- global children parentlist
- global commitidx viewcomplete curview commitrow
-
- set idlist {}
- if {$row > 0} {
- set rm1 [expr {$row - 1}]
- foreach id [lindex $rowidlist $rm1] {
- if {$id ne {}} {
- lappend idlist $id
- }
- }
- set final [lindex $rowfinal $rm1]
- }
- for {} {$row < $endrow} {incr row} {
- set rm1 [expr {$row - 1}]
- if {$rm1 < 0 || $idlist eq {}} {
- set idlist [make_idlist $row]
- set final 1
- } else {
- set id [lindex $displayorder $rm1]
- set col [lsearch -exact $idlist $id]
- set idlist [lreplace $idlist $col $col]
- foreach p [lindex $parentlist $rm1] {
- if {[lsearch -exact $idlist $p] < 0} {
- set col [idcol $idlist $p $col]
- set idlist [linsert $idlist $col $p]
- # if not the first child, we have to insert a line going up
- if {$id ne [lindex $children($curview,$p) 0]} {
- makeupline $p $rm1 $row $col
- }
- }
- }
- set id [lindex $displayorder $row]
- if {$row > $downarrowlen} {
- set termrow [expr {$row - $downarrowlen - 1}]
- foreach p [lindex $parentlist $termrow] {
- set i [lsearch -exact $idlist $p]
- if {$i < 0} continue
- set nr [nextuse $p $termrow]
- if {$nr < 0 || $nr >= $row + $mingaplen + $uparrowlen} {
- set idlist [lreplace $idlist $i $i]
- }
- }
- }
- set col [lsearch -exact $idlist $id]
- if {$col < 0} {
- set col [idcol $idlist $id]
- set idlist [linsert $idlist $col $id]
- if {$children($curview,$id) ne {}} {
- makeupline $id $rm1 $row $col
- }
- }
- set r [expr {$row + $uparrowlen - 1}]
- if {$r < $commitidx($curview)} {
- set x $col
- foreach p [lindex $parentlist $r] {
- if {[lsearch -exact $idlist $p] >= 0} continue
- set fk [lindex $children($curview,$p) 0]
- if {$commitrow($curview,$fk) < $row} {
- set x [idcol $idlist $p $x]
- set idlist [linsert $idlist $x $p]
- }
- }
- if {[incr r] < $commitidx($curview)} {
- set p [lindex $displayorder $r]
- if {[lsearch -exact $idlist $p] < 0} {
- set fk [lindex $children($curview,$p) 0]
- if {$fk ne {} && $commitrow($curview,$fk) < $row} {
- set x [idcol $idlist $p $x]
- set idlist [linsert $idlist $x $p]
- }
- }
- }
- }
- }
- if {$final && !$viewcomplete($curview) &&
- $row + $uparrowlen + $mingaplen + $downarrowlen
- >= $commitidx($curview)} {
- set final 0
- }
- set l [llength $rowidlist]
- if {$row == $l} {
- lappend rowidlist $idlist
- lappend rowisopt 0
- lappend rowfinal $final
- } elseif {$row < $l} {
- if {![rowsequal $idlist [lindex $rowidlist $row]]} {
- lset rowidlist $row $idlist
- changedrow $row
- }
- lset rowfinal $row $final
- } else {
- set pad [ntimes [expr {$row - $l}] {}]
- set rowidlist [concat $rowidlist $pad]
- lappend rowidlist $idlist
- set rowfinal [concat $rowfinal $pad]
- lappend rowfinal $final
- set rowisopt [concat $rowisopt [ntimes [expr {$row - $l + 1}] 0]]
- }
- }
- return $row
-}
-
-proc changedrow {row} {
- global displayorder iddrawn rowisopt need_redisplay
-
- set l [llength $rowisopt]
- if {$row < $l} {
- lset rowisopt $row 0
- if {$row + 1 < $l} {
- lset rowisopt [expr {$row + 1}] 0
- if {$row + 2 < $l} {
- lset rowisopt [expr {$row + 2}] 0
- }
- }
- }
- set id [lindex $displayorder $row]
- if {[info exists iddrawn($id)]} {
- set need_redisplay 1
- }
-}
-
-proc insert_pad {row col npad} {
- global rowidlist
-
- set pad [ntimes $npad {}]
- set idlist [lindex $rowidlist $row]
- set bef [lrange $idlist 0 [expr {$col - 1}]]
- set aft [lrange $idlist $col end]
- set i [lsearch -exact $aft {}]
- if {$i > 0} {
- set aft [lreplace $aft $i $i]
- }
- lset rowidlist $row [concat $bef $pad $aft]
- changedrow $row
-}
-
-proc optimize_rows {row col endrow} {
- global rowidlist rowisopt displayorder curview children
-
- if {$row < 1} {
- set row 1
- }
- for {} {$row < $endrow} {incr row; set col 0} {
- if {[lindex $rowisopt $row]} continue
- set haspad 0
- set y0 [expr {$row - 1}]
- set ym [expr {$row - 2}]
- set idlist [lindex $rowidlist $row]
- set previdlist [lindex $rowidlist $y0]
- if {$idlist eq {} || $previdlist eq {}} continue
- if {$ym >= 0} {
- set pprevidlist [lindex $rowidlist $ym]
- if {$pprevidlist eq {}} continue
- } else {
- set pprevidlist {}
- }
- set x0 -1
- set xm -1
- for {} {$col < [llength $idlist]} {incr col} {
- set id [lindex $idlist $col]
- if {[lindex $previdlist $col] eq $id} continue
- if {$id eq {}} {
- set haspad 1
- continue
- }
- set x0 [lsearch -exact $previdlist $id]
- if {$x0 < 0} continue
- set z [expr {$x0 - $col}]
- set isarrow 0
- set z0 {}
- if {$ym >= 0} {
- set xm [lsearch -exact $pprevidlist $id]
- if {$xm >= 0} {
- set z0 [expr {$xm - $x0}]
- }
- }
- if {$z0 eq {}} {
- # if row y0 is the first child of $id then it's not an arrow
- if {[lindex $children($curview,$id) 0] ne
- [lindex $displayorder $y0]} {
- set isarrow 1
- }
- }
- if {!$isarrow && $id ne [lindex $displayorder $row] &&
- [lsearch -exact [lindex $rowidlist [expr {$row+1}]] $id] < 0} {
- set isarrow 1
- }
- # Looking at lines from this row to the previous row,
- # make them go straight up if they end in an arrow on
- # the previous row; otherwise make them go straight up
- # or at 45 degrees.
- if {$z < -1 || ($z < 0 && $isarrow)} {
- # Line currently goes left too much;
- # insert pads in the previous row, then optimize it
- set npad [expr {-1 - $z + $isarrow}]
- insert_pad $y0 $x0 $npad
- if {$y0 > 0} {
- optimize_rows $y0 $x0 $row
- }
- set previdlist [lindex $rowidlist $y0]
- set x0 [lsearch -exact $previdlist $id]
- set z [expr {$x0 - $col}]
- if {$z0 ne {}} {
- set pprevidlist [lindex $rowidlist $ym]
- set xm [lsearch -exact $pprevidlist $id]
- set z0 [expr {$xm - $x0}]
- }
- } elseif {$z > 1 || ($z > 0 && $isarrow)} {
- # Line currently goes right too much;
- # insert pads in this line
- set npad [expr {$z - 1 + $isarrow}]
- insert_pad $row $col $npad
- set idlist [lindex $rowidlist $row]
- incr col $npad
- set z [expr {$x0 - $col}]
- set haspad 1
- }
- if {$z0 eq {} && !$isarrow && $ym >= 0} {
- # this line links to its first child on row $row-2
- set id [lindex $displayorder $ym]
- set xc [lsearch -exact $pprevidlist $id]
- if {$xc >= 0} {
- set z0 [expr {$xc - $x0}]
- }
- }
- # avoid lines jigging left then immediately right
- if {$z0 ne {} && $z < 0 && $z0 > 0} {
- insert_pad $y0 $x0 1
- incr x0
- optimize_rows $y0 $x0 $row
- set previdlist [lindex $rowidlist $y0]
- }
- }
- if {!$haspad} {
- # Find the first column that doesn't have a line going right
- for {set col [llength $idlist]} {[incr col -1] >= 0} {} {
- set id [lindex $idlist $col]
- if {$id eq {}} break
- set x0 [lsearch -exact $previdlist $id]
- if {$x0 < 0} {
- # check if this is the link to the first child
- set kid [lindex $displayorder $y0]
- if {[lindex $children($curview,$id) 0] eq $kid} {
- # it is, work out offset to child
- set x0 [lsearch -exact $previdlist $kid]
- }
- }
- if {$x0 <= $col} break
- }
- # Insert a pad at that column as long as it has a line and
- # isn't the last column
- if {$x0 >= 0 && [incr col] < [llength $idlist]} {
- set idlist [linsert $idlist $col {}]
- lset rowidlist $row $idlist
- changedrow $row
- }
- }
- }
-}
-
-proc xc {row col} {
- global canvx0 linespc
- return [expr {$canvx0 + $col * $linespc}]
-}
-
-proc yc {row} {
- global canvy0 linespc
- return [expr {$canvy0 + $row * $linespc}]
-}
-
-proc linewidth {id} {
- global thickerline lthickness
-
- set wid $lthickness
- if {[info exists thickerline] && $id eq $thickerline} {
- set wid [expr {2 * $lthickness}]
- }
- return $wid
-}
-
-proc rowranges {id} {
- global commitrow curview children uparrowlen downarrowlen
- global rowidlist
-
- set kids $children($curview,$id)
- if {$kids eq {}} {
- return {}
- }
- set ret {}
- lappend kids $id
- foreach child $kids {
- if {![info exists commitrow($curview,$child)]} break
- set row $commitrow($curview,$child)
- if {![info exists prev]} {
- lappend ret [expr {$row + 1}]
- } else {
- if {$row <= $prevrow} {
- puts "oops children out of order [shortids $id] $row < [shortids $prev] $prevrow"
- }
- # see if the line extends the whole way from prevrow to row
- if {$row > $prevrow + $uparrowlen + $downarrowlen &&
- [lsearch -exact [lindex $rowidlist \
- [expr {int(($row + $prevrow) / 2)}]] $id] < 0} {
- # it doesn't, see where it ends
- set r [expr {$prevrow + $downarrowlen}]
- if {[lsearch -exact [lindex $rowidlist $r] $id] < 0} {
- while {[incr r -1] > $prevrow &&
- [lsearch -exact [lindex $rowidlist $r] $id] < 0} {}
- } else {
- while {[incr r] <= $row &&
- [lsearch -exact [lindex $rowidlist $r] $id] >= 0} {}
- incr r -1
- }
- lappend ret $r
- # see where it starts up again
- set r [expr {$row - $uparrowlen}]
- if {[lsearch -exact [lindex $rowidlist $r] $id] < 0} {
- while {[incr r] < $row &&
- [lsearch -exact [lindex $rowidlist $r] $id] < 0} {}
- } else {
- while {[incr r -1] >= $prevrow &&
- [lsearch -exact [lindex $rowidlist $r] $id] >= 0} {}
- incr r
- }
- lappend ret $r
- }
- }
- if {$child eq $id} {
- lappend ret $row
- }
- set prev $id
- set prevrow $row
- }
- return $ret
-}
-
-proc drawlineseg {id row endrow arrowlow} {
- global rowidlist displayorder iddrawn linesegs
- global canv colormap linespc curview maxlinelen parentlist
-
- set cols [list [lsearch -exact [lindex $rowidlist $row] $id]]
- set le [expr {$row + 1}]
- set arrowhigh 1
- while {1} {
- set c [lsearch -exact [lindex $rowidlist $le] $id]
- if {$c < 0} {
- incr le -1
- break
- }
- lappend cols $c
- set x [lindex $displayorder $le]
- if {$x eq $id} {
- set arrowhigh 0
- break
- }
- if {[info exists iddrawn($x)] || $le == $endrow} {
- set c [lsearch -exact [lindex $rowidlist [expr {$le+1}]] $id]
- if {$c >= 0} {
- lappend cols $c
- set arrowhigh 0
- }
- break
- }
- incr le
- }
- if {$le <= $row} {
- return $row
- }
-
- set lines {}
- set i 0
- set joinhigh 0
- if {[info exists linesegs($id)]} {
- set lines $linesegs($id)
- foreach li $lines {
- set r0 [lindex $li 0]
- if {$r0 > $row} {
- if {$r0 == $le && [lindex $li 1] - $row <= $maxlinelen} {
- set joinhigh 1
- }
- break
- }
- incr i
- }
- }
- set joinlow 0
- if {$i > 0} {
- set li [lindex $lines [expr {$i-1}]]
- set r1 [lindex $li 1]
- if {$r1 == $row && $le - [lindex $li 0] <= $maxlinelen} {
- set joinlow 1
- }
- }
-
- set x [lindex $cols [expr {$le - $row}]]
- set xp [lindex $cols [expr {$le - 1 - $row}]]
- set dir [expr {$xp - $x}]
- if {$joinhigh} {
- set ith [lindex $lines $i 2]
- set coords [$canv coords $ith]
- set ah [$canv itemcget $ith -arrow]
- set arrowhigh [expr {$ah eq "first" || $ah eq "both"}]
- set x2 [lindex $cols [expr {$le + 1 - $row}]]
- if {$x2 ne {} && $x - $x2 == $dir} {
- set coords [lrange $coords 0 end-2]
- }
- } else {
- set coords [list [xc $le $x] [yc $le]]
- }
- if {$joinlow} {
- set itl [lindex $lines [expr {$i-1}] 2]
- set al [$canv itemcget $itl -arrow]
- set arrowlow [expr {$al eq "last" || $al eq "both"}]
- } elseif {$arrowlow} {
- if {[lsearch -exact [lindex $rowidlist [expr {$row-1}]] $id] >= 0 ||
- [lsearch -exact [lindex $parentlist [expr {$row-1}]] $id] >= 0} {
- set arrowlow 0
- }
- }
- set arrow [lindex {none first last both} [expr {$arrowhigh + 2*$arrowlow}]]
- for {set y $le} {[incr y -1] > $row} {} {
- set x $xp
- set xp [lindex $cols [expr {$y - 1 - $row}]]
- set ndir [expr {$xp - $x}]
- if {$dir != $ndir || $xp < 0} {
- lappend coords [xc $y $x] [yc $y]
- }
- set dir $ndir
- }
- if {!$joinlow} {
- if {$xp < 0} {
- # join parent line to first child
- set ch [lindex $displayorder $row]
- set xc [lsearch -exact [lindex $rowidlist $row] $ch]
- if {$xc < 0} {
- puts "oops: drawlineseg: child $ch not on row $row"
- } elseif {$xc != $x} {
- if {($arrowhigh && $le == $row + 1) || $dir == 0} {
- set d [expr {int(0.5 * $linespc)}]
- set x1 [xc $row $x]
- if {$xc < $x} {
- set x2 [expr {$x1 - $d}]
- } else {
- set x2 [expr {$x1 + $d}]
- }
- set y2 [yc $row]
- set y1 [expr {$y2 + $d}]
- lappend coords $x1 $y1 $x2 $y2
- } elseif {$xc < $x - 1} {
- lappend coords [xc $row [expr {$x-1}]] [yc $row]
- } elseif {$xc > $x + 1} {
- lappend coords [xc $row [expr {$x+1}]] [yc $row]
- }
- set x $xc
- }
- lappend coords [xc $row $x] [yc $row]
- } else {
- set xn [xc $row $xp]
- set yn [yc $row]
- lappend coords $xn $yn
- }
- if {!$joinhigh} {
- assigncolor $id
- set t [$canv create line $coords -width [linewidth $id] \
- -fill $colormap($id) -tags lines.$id -arrow $arrow]
- $canv lower $t
- bindline $t $id
- set lines [linsert $lines $i [list $row $le $t]]
- } else {
- $canv coords $ith $coords
- if {$arrow ne $ah} {
- $canv itemconf $ith -arrow $arrow
- }
- lset lines $i 0 $row
- }
- } else {
- set xo [lsearch -exact [lindex $rowidlist [expr {$row - 1}]] $id]
- set ndir [expr {$xo - $xp}]
- set clow [$canv coords $itl]
- if {$dir == $ndir} {
- set clow [lrange $clow 2 end]
- }
- set coords [concat $coords $clow]
- if {!$joinhigh} {
- lset lines [expr {$i-1}] 1 $le
- } else {
- # coalesce two pieces
- $canv delete $ith
- set b [lindex $lines [expr {$i-1}] 0]
- set e [lindex $lines $i 1]
- set lines [lreplace $lines [expr {$i-1}] $i [list $b $e $itl]]
- }
- $canv coords $itl $coords
- if {$arrow ne $al} {
- $canv itemconf $itl -arrow $arrow
- }
- }
-
- set linesegs($id) $lines
- return $le
-}
-
-proc drawparentlinks {id row} {
- global rowidlist canv colormap curview parentlist
- global idpos linespc
-
- set rowids [lindex $rowidlist $row]
- set col [lsearch -exact $rowids $id]
- if {$col < 0} return
- set olds [lindex $parentlist $row]
- set row2 [expr {$row + 1}]
- set x [xc $row $col]
- set y [yc $row]
- set y2 [yc $row2]
- set d [expr {int(0.5 * $linespc)}]
- set ymid [expr {$y + $d}]
- set ids [lindex $rowidlist $row2]
- # rmx = right-most X coord used
- set rmx 0
- foreach p $olds {
- set i [lsearch -exact $ids $p]
- if {$i < 0} {
- puts "oops, parent $p of $id not in list"
- continue
- }
- set x2 [xc $row2 $i]
- if {$x2 > $rmx} {
- set rmx $x2
- }
- set j [lsearch -exact $rowids $p]
- if {$j < 0} {
- # drawlineseg will do this one for us
- continue
- }
- assigncolor $p
- # should handle duplicated parents here...
- set coords [list $x $y]
- if {$i != $col} {
- # if attaching to a vertical segment, draw a smaller
- # slant for visual distinctness
- if {$i == $j} {
- if {$i < $col} {
- lappend coords [expr {$x2 + $d}] $y $x2 $ymid
- } else {
- lappend coords [expr {$x2 - $d}] $y $x2 $ymid
- }
- } elseif {$i < $col && $i < $j} {
- # segment slants towards us already
- lappend coords [xc $row $j] $y
- } else {
- if {$i < $col - 1} {
- lappend coords [expr {$x2 + $linespc}] $y
- } elseif {$i > $col + 1} {
- lappend coords [expr {$x2 - $linespc}] $y
- }
- lappend coords $x2 $y2
- }
- } else {
- lappend coords $x2 $y2
- }
- set t [$canv create line $coords -width [linewidth $p] \
- -fill $colormap($p) -tags lines.$p]
- $canv lower $t
- bindline $t $p
- }
- if {$rmx > [lindex $idpos($id) 1]} {
- lset idpos($id) 1 $rmx
- redrawtags $id
- }
-}
-
-proc drawlines {id} {
- global canv
-
- $canv itemconf lines.$id -width [linewidth $id]
-}
-
-proc drawcmittext {id row col} {
- global linespc canv canv2 canv3 canvy0 fgcolor curview
- global commitlisted commitinfo rowidlist parentlist
- global rowtextx idpos idtags idheads idotherrefs
- global linehtag linentag linedtag selectedline
- global canvxmax boldrows boldnamerows fgcolor nullid nullid2
-
- # listed is 0 for boundary, 1 for normal, 2 for left, 3 for right
- set listed [lindex $commitlisted $row]
- if {$id eq $nullid} {
- set ofill red
- } elseif {$id eq $nullid2} {
- set ofill green
- } else {
- set ofill [expr {$listed != 0? "blue": "white"}]
- }
- set x [xc $row $col]
- set y [yc $row]
- set orad [expr {$linespc / 3}]
- if {$listed <= 1} {
- set t [$canv create oval [expr {$x - $orad}] [expr {$y - $orad}] \
- [expr {$x + $orad - 1}] [expr {$y + $orad - 1}] \
- -fill $ofill -outline $fgcolor -width 1 -tags circle]
- } elseif {$listed == 2} {
- # triangle pointing left for left-side commits
- set t [$canv create polygon \
- [expr {$x - $orad}] $y \
- [expr {$x + $orad - 1}] [expr {$y - $orad}] \
- [expr {$x + $orad - 1}] [expr {$y + $orad - 1}] \
- -fill $ofill -outline $fgcolor -width 1 -tags circle]
- } else {
- # triangle pointing right for right-side commits
- set t [$canv create polygon \
- [expr {$x + $orad - 1}] $y \
- [expr {$x - $orad}] [expr {$y - $orad}] \
- [expr {$x - $orad}] [expr {$y + $orad - 1}] \
- -fill $ofill -outline $fgcolor -width 1 -tags circle]
- }
- $canv raise $t
- $canv bind $t <1> {selcanvline {} %x %y}
- set rmx [llength [lindex $rowidlist $row]]
- set olds [lindex $parentlist $row]
- if {$olds ne {}} {
- set nextids [lindex $rowidlist [expr {$row + 1}]]
- foreach p $olds {
- set i [lsearch -exact $nextids $p]
- if {$i > $rmx} {
- set rmx $i
- }
- }
- }
- set xt [xc $row $rmx]
- set rowtextx($row) $xt
- set idpos($id) [list $x $xt $y]
- if {[info exists idtags($id)] || [info exists idheads($id)]
- || [info exists idotherrefs($id)]} {
- set xt [drawtags $id $x $xt $y]
- }
- set headline [lindex $commitinfo($id) 0]
- set name [lindex $commitinfo($id) 1]
- set date [lindex $commitinfo($id) 2]
- set date [formatdate $date]
- set font mainfont
- set nfont mainfont
- set isbold [ishighlighted $row]
- if {$isbold > 0} {
- lappend boldrows $row
- set font mainfontbold
- if {$isbold > 1} {
- lappend boldnamerows $row
- set nfont mainfontbold
- }
- }
- set linehtag($row) [$canv create text $xt $y -anchor w -fill $fgcolor \
- -text $headline -font $font -tags text]
- $canv bind $linehtag($row) <Button-3> "rowmenu %X %Y $id"
- set linentag($row) [$canv2 create text 3 $y -anchor w -fill $fgcolor \
- -text $name -font $nfont -tags text]
- set linedtag($row) [$canv3 create text 3 $y -anchor w -fill $fgcolor \
- -text $date -font mainfont -tags text]
- if {[info exists selectedline] && $selectedline == $row} {
- make_secsel $row
- }
- set xr [expr {$xt + [font measure $font $headline]}]
- if {$xr > $canvxmax} {
- set canvxmax $xr
- setcanvscroll
- }
-}
-
-proc drawcmitrow {row} {
- global displayorder rowidlist nrows_drawn
- global iddrawn markingmatches
- global commitinfo parentlist numcommits
- global filehighlight fhighlights findpattern nhighlights
- global hlview vhighlights
- global highlight_related rhighlights
-
- if {$row >= $numcommits} return
-
- set id [lindex $displayorder $row]
- if {[info exists hlview] && ![info exists vhighlights($row)]} {
- askvhighlight $row $id
- }
- if {[info exists filehighlight] && ![info exists fhighlights($row)]} {
- askfilehighlight $row $id
- }
- if {$findpattern ne {} && ![info exists nhighlights($row)]} {
- askfindhighlight $row $id
- }
- if {$highlight_related ne "None" && ![info exists rhighlights($row)]} {
- askrelhighlight $row $id
- }
- if {![info exists iddrawn($id)]} {
- set col [lsearch -exact [lindex $rowidlist $row] $id]
- if {$col < 0} {
- puts "oops, row $row id $id not in list"
- return
- }
- if {![info exists commitinfo($id)]} {
- getcommit $id
- }
- assigncolor $id
- drawcmittext $id $row $col
- set iddrawn($id) 1
- incr nrows_drawn
- }
- if {$markingmatches} {
- markrowmatches $row $id
- }
-}
-
-proc drawcommits {row {endrow {}}} {
- global numcommits iddrawn displayorder curview need_redisplay
- global parentlist rowidlist rowfinal uparrowlen downarrowlen nrows_drawn
-
- if {$row < 0} {
- set row 0
- }
- if {$endrow eq {}} {
- set endrow $row
- }
- if {$endrow >= $numcommits} {
- set endrow [expr {$numcommits - 1}]
- }
-
- set rl1 [expr {$row - $downarrowlen - 3}]
- if {$rl1 < 0} {
- set rl1 0
- }
- set ro1 [expr {$row - 3}]
- if {$ro1 < 0} {
- set ro1 0
- }
- set r2 [expr {$endrow + $uparrowlen + 3}]
- if {$r2 > $numcommits} {
- set r2 $numcommits
- }
- for {set r $rl1} {$r < $r2} {incr r} {
- if {[lindex $rowidlist $r] ne {} && [lindex $rowfinal $r]} {
- if {$rl1 < $r} {
- layoutrows $rl1 $r
- }
- set rl1 [expr {$r + 1}]
- }
- }
- if {$rl1 < $r} {
- layoutrows $rl1 $r
- }
- optimize_rows $ro1 0 $r2
- if {$need_redisplay || $nrows_drawn > 2000} {
- clear_display
- drawvisible
- }
-
- # make the lines join to already-drawn rows either side
- set r [expr {$row - 1}]
- if {$r < 0 || ![info exists iddrawn([lindex $displayorder $r])]} {
- set r $row
- }
- set er [expr {$endrow + 1}]
- if {$er >= $numcommits ||
- ![info exists iddrawn([lindex $displayorder $er])]} {
- set er $endrow
- }
- for {} {$r <= $er} {incr r} {
- set id [lindex $displayorder $r]
- set wasdrawn [info exists iddrawn($id)]
- drawcmitrow $r
- if {$r == $er} break
- set nextid [lindex $displayorder [expr {$r + 1}]]
- if {$wasdrawn && [info exists iddrawn($nextid)]} continue
- drawparentlinks $id $r
-
- set rowids [lindex $rowidlist $r]
- foreach lid $rowids {
- if {$lid eq {}} continue
- if {[info exists lineend($lid)] && $lineend($lid) > $r} continue
- if {$lid eq $id} {
- # see if this is the first child of any of its parents
- foreach p [lindex $parentlist $r] {
- if {[lsearch -exact $rowids $p] < 0} {
- # make this line extend up to the child
- set lineend($p) [drawlineseg $p $r $er 0]
- }
- }
- } else {
- set lineend($lid) [drawlineseg $lid $r $er 1]
- }
- }
- }
-}
-
-proc drawfrac {f0 f1} {
- global canv linespc
-
- set ymax [lindex [$canv cget -scrollregion] 3]
- if {$ymax eq {} || $ymax == 0} return
- set y0 [expr {int($f0 * $ymax)}]
- set row [expr {int(($y0 - 3) / $linespc) - 1}]
- set y1 [expr {int($f1 * $ymax)}]
- set endrow [expr {int(($y1 - 3) / $linespc) + 1}]
- drawcommits $row $endrow
-}
-
-proc drawvisible {} {
- global canv
- eval drawfrac [$canv yview]
-}
-
-proc clear_display {} {
- global iddrawn linesegs need_redisplay nrows_drawn
- global vhighlights fhighlights nhighlights rhighlights
-
- allcanvs delete all
- catch {unset iddrawn}
- catch {unset linesegs}
- catch {unset vhighlights}
- catch {unset fhighlights}
- catch {unset nhighlights}
- catch {unset rhighlights}
- set need_redisplay 0
- set nrows_drawn 0
-}
-
-proc findcrossings {id} {
- global rowidlist parentlist numcommits displayorder
-
- set cross {}
- set ccross {}
- foreach {s e} [rowranges $id] {
- if {$e >= $numcommits} {
- set e [expr {$numcommits - 1}]
- }
- if {$e <= $s} continue
- for {set row $e} {[incr row -1] >= $s} {} {
- set x [lsearch -exact [lindex $rowidlist $row] $id]
- if {$x < 0} break
- set olds [lindex $parentlist $row]
- set kid [lindex $displayorder $row]
- set kidx [lsearch -exact [lindex $rowidlist $row] $kid]
- if {$kidx < 0} continue
- set nextrow [lindex $rowidlist [expr {$row + 1}]]
- foreach p $olds {
- set px [lsearch -exact $nextrow $p]
- if {$px < 0} continue
- if {($kidx < $x && $x < $px) || ($px < $x && $x < $kidx)} {
- if {[lsearch -exact $ccross $p] >= 0} continue
- if {$x == $px + ($kidx < $px? -1: 1)} {
- lappend ccross $p
- } elseif {[lsearch -exact $cross $p] < 0} {
- lappend cross $p
- }
- }
- }
- }
- }
- return [concat $ccross {{}} $cross]
-}
-
-proc assigncolor {id} {
- global colormap colors nextcolor
- global commitrow parentlist children children curview
-
- if {[info exists colormap($id)]} return
- set ncolors [llength $colors]
- if {[info exists children($curview,$id)]} {
- set kids $children($curview,$id)
- } else {
- set kids {}
- }
- if {[llength $kids] == 1} {
- set child [lindex $kids 0]
- if {[info exists colormap($child)]
- && [llength [lindex $parentlist $commitrow($curview,$child)]] == 1} {
- set colormap($id) $colormap($child)
- return
- }
- }
- set badcolors {}
- set origbad {}
- foreach x [findcrossings $id] {
- if {$x eq {}} {
- # delimiter between corner crossings and other crossings
- if {[llength $badcolors] >= $ncolors - 1} break
- set origbad $badcolors
- }
- if {[info exists colormap($x)]
- && [lsearch -exact $badcolors $colormap($x)] < 0} {
- lappend badcolors $colormap($x)
- }
- }
- if {[llength $badcolors] >= $ncolors} {
- set badcolors $origbad
- }
- set origbad $badcolors
- if {[llength $badcolors] < $ncolors - 1} {
- foreach child $kids {
- if {[info exists colormap($child)]
- && [lsearch -exact $badcolors $colormap($child)] < 0} {
- lappend badcolors $colormap($child)
- }
- foreach p [lindex $parentlist $commitrow($curview,$child)] {
- if {[info exists colormap($p)]
- && [lsearch -exact $badcolors $colormap($p)] < 0} {
- lappend badcolors $colormap($p)
- }
- }
- }
- if {[llength $badcolors] >= $ncolors} {
- set badcolors $origbad
- }
- }
- for {set i 0} {$i <= $ncolors} {incr i} {
- set c [lindex $colors $nextcolor]
- if {[incr nextcolor] >= $ncolors} {
- set nextcolor 0
- }
- if {[lsearch -exact $badcolors $c]} break
- }
- set colormap($id) $c
-}
-
-proc bindline {t id} {
- global canv
-
- $canv bind $t <Enter> "lineenter %x %y $id"
- $canv bind $t <Motion> "linemotion %x %y $id"
- $canv bind $t <Leave> "lineleave $id"
- $canv bind $t <Button-1> "lineclick %x %y $id 1"
-}
-
-proc drawtags {id x xt y1} {
- global idtags idheads idotherrefs mainhead
- global linespc lthickness
- global canv commitrow rowtextx curview fgcolor bgcolor
-
- set marks {}
- set ntags 0
- set nheads 0
- if {[info exists idtags($id)]} {
- set marks $idtags($id)
- set ntags [llength $marks]
- }
- if {[info exists idheads($id)]} {
- set marks [concat $marks $idheads($id)]
- set nheads [llength $idheads($id)]
- }
- if {[info exists idotherrefs($id)]} {
- set marks [concat $marks $idotherrefs($id)]
- }
- if {$marks eq {}} {
- return $xt
- }
-
- set delta [expr {int(0.5 * ($linespc - $lthickness))}]
- set yt [expr {$y1 - 0.5 * $linespc}]
- set yb [expr {$yt + $linespc - 1}]
- set xvals {}
- set wvals {}
- set i -1
- foreach tag $marks {
- incr i
- if {$i >= $ntags && $i < $ntags + $nheads && $tag eq $mainhead} {
- set wid [font measure mainfontbold $tag]
- } else {
- set wid [font measure mainfont $tag]
- }
- lappend xvals $xt
- lappend wvals $wid
- set xt [expr {$xt + $delta + $wid + $lthickness + $linespc}]
- }
- set t [$canv create line $x $y1 [lindex $xvals end] $y1 \
- -width $lthickness -fill black -tags tag.$id]
- $canv lower $t
- foreach tag $marks x $xvals wid $wvals {
- set xl [expr {$x + $delta}]
- set xr [expr {$x + $delta + $wid + $lthickness}]
- set font mainfont
- if {[incr ntags -1] >= 0} {
- # draw a tag
- set t [$canv create polygon $x [expr {$yt + $delta}] $xl $yt \
- $xr $yt $xr $yb $xl $yb $x [expr {$yb - $delta}] \
- -width 1 -outline black -fill yellow -tags tag.$id]
- $canv bind $t <1> [list showtag $tag 1]
- set rowtextx($commitrow($curview,$id)) [expr {$xr + $linespc}]
- } else {
- # draw a head or other ref
- if {[incr nheads -1] >= 0} {
- set col green
- if {$tag eq $mainhead} {
- set font mainfontbold
- }
- } else {
- set col "#ddddff"
- }
- set xl [expr {$xl - $delta/2}]
- $canv create polygon $x $yt $xr $yt $xr $yb $x $yb \
- -width 1 -outline black -fill $col -tags tag.$id
- if {[regexp {^(remotes/.*/|remotes/)} $tag match remoteprefix]} {
- set rwid [font measure mainfont $remoteprefix]
- set xi [expr {$x + 1}]
- set yti [expr {$yt + 1}]
- set xri [expr {$x + $rwid}]
- $canv create polygon $xi $yti $xri $yti $xri $yb $xi $yb \
- -width 0 -fill "#ffddaa" -tags tag.$id
- }
- }
- set t [$canv create text $xl $y1 -anchor w -text $tag -fill $fgcolor \
- -font $font -tags [list tag.$id text]]
- if {$ntags >= 0} {
- $canv bind $t <1> [list showtag $tag 1]
- } elseif {$nheads >= 0} {
- $canv bind $t <Button-3> [list headmenu %X %Y $id $tag]
- }
- }
- return $xt
-}
-
-proc xcoord {i level ln} {
- global canvx0 xspc1 xspc2
-
- set x [expr {$canvx0 + $i * $xspc1($ln)}]
- if {$i > 0 && $i == $level} {
- set x [expr {$x + 0.5 * ($xspc2 - $xspc1($ln))}]
- } elseif {$i > $level} {
- set x [expr {$x + $xspc2 - $xspc1($ln)}]
- }
- return $x
-}
-
-proc show_status {msg} {
- global canv fgcolor
-
- clear_display
- $canv create text 3 3 -anchor nw -text $msg -font mainfont \
- -tags text -fill $fgcolor
-}
-
-# Insert a new commit as the child of the commit on row $row.
-# The new commit will be displayed on row $row and the commits
-# on that row and below will move down one row.
-proc insertrow {row newcmit} {
- global displayorder parentlist commitlisted children
- global commitrow curview rowidlist rowisopt rowfinal numcommits
- global numcommits
- global selectedline commitidx ordertok
-
- if {$row >= $numcommits} {
- puts "oops, inserting new row $row but only have $numcommits rows"
- return
- }
- set p [lindex $displayorder $row]
- set displayorder [linsert $displayorder $row $newcmit]
- set parentlist [linsert $parentlist $row $p]
- set kids $children($curview,$p)
- lappend kids $newcmit
- set children($curview,$p) $kids
- set children($curview,$newcmit) {}
- set commitlisted [linsert $commitlisted $row 1]
- set l [llength $displayorder]
- for {set r $row} {$r < $l} {incr r} {
- set id [lindex $displayorder $r]
- set commitrow($curview,$id) $r
- }
- incr commitidx($curview)
- set ordertok($curview,$newcmit) $ordertok($curview,$p)
-
- if {$row < [llength $rowidlist]} {
- set idlist [lindex $rowidlist $row]
- if {$idlist ne {}} {
- if {[llength $kids] == 1} {
- set col [lsearch -exact $idlist $p]
- lset idlist $col $newcmit
- } else {
- set col [llength $idlist]
- lappend idlist $newcmit
- }
- }
- set rowidlist [linsert $rowidlist $row $idlist]
- set rowisopt [linsert $rowisopt $row 0]
- set rowfinal [linsert $rowfinal $row [lindex $rowfinal $row]]
- }
-
- incr numcommits
-
- if {[info exists selectedline] && $selectedline >= $row} {
- incr selectedline
- }
- redisplay
-}
-
-# Remove a commit that was inserted with insertrow on row $row.
-proc removerow {row} {
- global displayorder parentlist commitlisted children
- global commitrow curview rowidlist rowisopt rowfinal numcommits
- global numcommits
- global linesegends selectedline commitidx
-
- if {$row >= $numcommits} {
- puts "oops, removing row $row but only have $numcommits rows"
- return
- }
- set rp1 [expr {$row + 1}]
- set id [lindex $displayorder $row]
- set p [lindex $parentlist $row]
- set displayorder [lreplace $displayorder $row $row]
- set parentlist [lreplace $parentlist $row $row]
- set commitlisted [lreplace $commitlisted $row $row]
- set kids $children($curview,$p)
- set i [lsearch -exact $kids $id]
- if {$i >= 0} {
- set kids [lreplace $kids $i $i]
- set children($curview,$p) $kids
- }
- set l [llength $displayorder]
- for {set r $row} {$r < $l} {incr r} {
- set id [lindex $displayorder $r]
- set commitrow($curview,$id) $r
- }
- incr commitidx($curview) -1
-
- if {$row < [llength $rowidlist]} {
- set rowidlist [lreplace $rowidlist $row $row]
- set rowisopt [lreplace $rowisopt $row $row]
- set rowfinal [lreplace $rowfinal $row $row]
- }
-
- incr numcommits -1
-
- if {[info exists selectedline] && $selectedline > $row} {
- incr selectedline -1
- }
- redisplay
-}
-
-# Don't change the text pane cursor if it is currently the hand cursor,
-# showing that we are over a sha1 ID link.
-proc settextcursor {c} {
- global ctext curtextcursor
-
- if {[$ctext cget -cursor] == $curtextcursor} {
- $ctext config -cursor $c
- }
- set curtextcursor $c
-}
-
-proc nowbusy {what {name {}}} {
- global isbusy busyname statusw
-
- if {[array names isbusy] eq {}} {
- . config -cursor watch
- settextcursor watch
- }
- set isbusy($what) 1
- set busyname($what) $name
- if {$name ne {}} {
- $statusw conf -text $name
- }
-}
-
-proc notbusy {what} {
- global isbusy maincursor textcursor busyname statusw
-
- catch {
- unset isbusy($what)
- if {$busyname($what) ne {} &&
- [$statusw cget -text] eq $busyname($what)} {
- $statusw conf -text {}
- }
- }
- if {[array names isbusy] eq {}} {
- . config -cursor $maincursor
- settextcursor $textcursor
- }
-}
-
-proc findmatches {f} {
- global findtype findstring
- if {$findtype == "Regexp"} {
- set matches [regexp -indices -all -inline $findstring $f]
- } else {
- set fs $findstring
- if {$findtype == "IgnCase"} {
- set f [string tolower $f]
- set fs [string tolower $fs]
- }
- set matches {}
- set i 0
- set l [string length $fs]
- while {[set j [string first $fs $f $i]] >= 0} {
- lappend matches [list $j [expr {$j+$l-1}]]
- set i [expr {$j + $l}]
- }
- }
- return $matches
-}
-
-proc dofind {{dirn 1} {wrap 1}} {
- global findstring findstartline findcurline selectedline numcommits
- global gdttype filehighlight fh_serial find_dirn findallowwrap
-
- if {[info exists find_dirn]} {
- if {$find_dirn == $dirn} return
- stopfinding
- }
- focus .
- if {$findstring eq {} || $numcommits == 0} return
- if {![info exists selectedline]} {
- set findstartline [lindex [visiblerows] [expr {$dirn < 0}]]
- } else {
- set findstartline $selectedline
- }
- set findcurline $findstartline
- nowbusy finding "Searching"
- if {$gdttype ne "containing:" && ![info exists filehighlight]} {
- after cancel do_file_hl $fh_serial
- do_file_hl $fh_serial
- }
- set find_dirn $dirn
- set findallowwrap $wrap
- run findmore
-}
-
-proc stopfinding {} {
- global find_dirn findcurline fprogcoord
-
- if {[info exists find_dirn]} {
- unset find_dirn
- unset findcurline
- notbusy finding
- set fprogcoord 0
- adjustprogress
- }
-}
-
-proc findmore {} {
- global commitdata commitinfo numcommits findpattern findloc
- global findstartline findcurline displayorder
- global find_dirn gdttype fhighlights fprogcoord
- global findallowwrap
-
- if {![info exists find_dirn]} {
- return 0
- }
- set fldtypes {Headline Author Date Committer CDate Comments}
- set l $findcurline
- set moretodo 0
- if {$find_dirn > 0} {
- incr l
- if {$l >= $numcommits} {
- set l 0
- }
- if {$l <= $findstartline} {
- set lim [expr {$findstartline + 1}]
- } else {
- set lim $numcommits
- set moretodo $findallowwrap
- }
- } else {
- if {$l == 0} {
- set l $numcommits
- }
- incr l -1
- if {$l >= $findstartline} {
- set lim [expr {$findstartline - 1}]
- } else {
- set lim -1
- set moretodo $findallowwrap
- }
- }
- set n [expr {($lim - $l) * $find_dirn}]
- if {$n > 500} {
- set n 500
- set moretodo 1
- }
- set found 0
- set domore 1
- if {$gdttype eq "containing:"} {
- for {} {$n > 0} {incr n -1; incr l $find_dirn} {
- set id [lindex $displayorder $l]
- # shouldn't happen unless git log doesn't give all the commits...
- if {![info exists commitdata($id)]} continue
- if {![doesmatch $commitdata($id)]} continue
- if {![info exists commitinfo($id)]} {
- getcommit $id
- }
- set info $commitinfo($id)
- foreach f $info ty $fldtypes {
- if {($findloc eq "All fields" || $findloc eq $ty) &&
- [doesmatch $f]} {
- set found 1
- break
- }
- }
- if {$found} break
- }
- } else {
- for {} {$n > 0} {incr n -1; incr l $find_dirn} {
- set id [lindex $displayorder $l]
- if {![info exists fhighlights($l)]} {
- askfilehighlight $l $id
- if {$domore} {
- set domore 0
- set findcurline [expr {$l - $find_dirn}]
- }
- } elseif {$fhighlights($l)} {
- set found $domore
- break
- }
- }
- }
- if {$found || ($domore && !$moretodo)} {
- unset findcurline
- unset find_dirn
- notbusy finding
- set fprogcoord 0
- adjustprogress
- if {$found} {
- findselectline $l
- } else {
- bell
- }
- return 0
- }
- if {!$domore} {
- flushhighlights
- } else {
- set findcurline [expr {$l - $find_dirn}]
- }
- set n [expr {($findcurline - $findstartline) * $find_dirn - 1}]
- if {$n < 0} {
- incr n $numcommits
- }
- set fprogcoord [expr {$n * 1.0 / $numcommits}]
- adjustprogress
- return $domore
-}
-
-proc findselectline {l} {
- global findloc commentend ctext findcurline markingmatches gdttype
-
- set markingmatches 1
- set findcurline $l
- selectline $l 1
- if {$findloc == "All fields" || $findloc == "Comments"} {
- # highlight the matches in the comments
- set f [$ctext get 1.0 $commentend]
- set matches [findmatches $f]
- foreach match $matches {
- set start [lindex $match 0]
- set end [expr {[lindex $match 1] + 1}]
- $ctext tag add found "1.0 + $start c" "1.0 + $end c"
- }
- }
- drawvisible
-}
-
-# mark the bits of a headline or author that match a find string
-proc markmatches {canv l str tag matches font row} {
- global selectedline
-
- set bbox [$canv bbox $tag]
- set x0 [lindex $bbox 0]
- set y0 [lindex $bbox 1]
- set y1 [lindex $bbox 3]
- foreach match $matches {
- set start [lindex $match 0]
- set end [lindex $match 1]
- if {$start > $end} continue
- set xoff [font measure $font [string range $str 0 [expr {$start-1}]]]
- set xlen [font measure $font [string range $str 0 [expr {$end}]]]
- set t [$canv create rect [expr {$x0+$xoff}] $y0 \
- [expr {$x0+$xlen+2}] $y1 \
- -outline {} -tags [list match$l matches] -fill yellow]
- $canv lower $t
- if {[info exists selectedline] && $row == $selectedline} {
- $canv raise $t secsel
- }
- }
-}
-
-proc unmarkmatches {} {
- global markingmatches
-
- allcanvs delete matches
- set markingmatches 0
- stopfinding
-}
-
-proc selcanvline {w x y} {
- global canv canvy0 ctext linespc
- global rowtextx
- set ymax [lindex [$canv cget -scrollregion] 3]
- if {$ymax == {}} return
- set yfrac [lindex [$canv yview] 0]
- set y [expr {$y + $yfrac * $ymax}]
- set l [expr {int(($y - $canvy0) / $linespc + 0.5)}]
- if {$l < 0} {
- set l 0
- }
- if {$w eq $canv} {
- if {![info exists rowtextx($l)] || $x < $rowtextx($l)} return
- }
- unmarkmatches
- selectline $l 1
-}
-
-proc commit_descriptor {p} {
- global commitinfo
- if {![info exists commitinfo($p)]} {
- getcommit $p
- }
- set l "..."
- if {[llength $commitinfo($p)] > 1} {
- set l [lindex $commitinfo($p) 0]
- }
- return "$p ($l)\n"
-}
-
-# append some text to the ctext widget, and make any SHA1 ID
-# that we know about be a clickable link.
-proc appendwithlinks {text tags} {
- global ctext commitrow linknum curview pendinglinks
-
- set start [$ctext index "end - 1c"]
- $ctext insert end $text $tags
- set links [regexp -indices -all -inline {[0-9a-f]{40}} $text]
- foreach l $links {
- set s [lindex $l 0]
- set e [lindex $l 1]
- set linkid [string range $text $s $e]
- incr e
- $ctext tag delete link$linknum
- $ctext tag add link$linknum "$start + $s c" "$start + $e c"
- setlink $linkid link$linknum
- incr linknum
- }
-}
-
-proc setlink {id lk} {
- global curview commitrow ctext pendinglinks commitinterest
-
- if {[info exists commitrow($curview,$id)]} {
- $ctext tag conf $lk -foreground blue -underline 1
- $ctext tag bind $lk <1> [list selectline $commitrow($curview,$id) 1]
- $ctext tag bind $lk <Enter> {linkcursor %W 1}
- $ctext tag bind $lk <Leave> {linkcursor %W -1}
- } else {
- lappend pendinglinks($id) $lk
- lappend commitinterest($id) {makelink %I}
- }
-}
-
-proc makelink {id} {
- global pendinglinks
-
- if {![info exists pendinglinks($id)]} return
- foreach lk $pendinglinks($id) {
- setlink $id $lk
- }
- unset pendinglinks($id)
-}
-
-proc linkcursor {w inc} {
- global linkentercount curtextcursor
-
- if {[incr linkentercount $inc] > 0} {
- $w configure -cursor hand2
- } else {
- $w configure -cursor $curtextcursor
- if {$linkentercount < 0} {
- set linkentercount 0
- }
- }
-}
-
-proc viewnextline {dir} {
- global canv linespc
-
- $canv delete hover
- set ymax [lindex [$canv cget -scrollregion] 3]
- set wnow [$canv yview]
- set wtop [expr {[lindex $wnow 0] * $ymax}]
- set newtop [expr {$wtop + $dir * $linespc}]
- if {$newtop < 0} {
- set newtop 0
- } elseif {$newtop > $ymax} {
- set newtop $ymax
- }
- allcanvs yview moveto [expr {$newtop * 1.0 / $ymax}]
-}
-
-# add a list of tag or branch names at position pos
-# returns the number of names inserted
-proc appendrefs {pos ids var} {
- global ctext commitrow linknum curview $var maxrefs
-
- if {[catch {$ctext index $pos}]} {
- return 0
- }
- $ctext conf -state normal
- $ctext delete $pos "$pos lineend"
- set tags {}
- foreach id $ids {
- foreach tag [set $var\($id\)] {
- lappend tags [list $tag $id]
- }
- }
- if {[llength $tags] > $maxrefs} {
- $ctext insert $pos "many ([llength $tags])"
- } else {
- set tags [lsort -index 0 -decreasing $tags]
- set sep {}
- foreach ti $tags {
- set id [lindex $ti 1]
- set lk link$linknum
- incr linknum
- $ctext tag delete $lk
- $ctext insert $pos $sep
- $ctext insert $pos [lindex $ti 0] $lk
- setlink $id $lk
- set sep ", "
- }
- }
- $ctext conf -state disabled
- return [llength $tags]
-}
-
-# called when we have finished computing the nearby tags
-proc dispneartags {delay} {
- global selectedline currentid showneartags tagphase
-
- if {![info exists selectedline] || !$showneartags} return
- after cancel dispnexttag
- if {$delay} {
- after 200 dispnexttag
- set tagphase -1
- } else {
- after idle dispnexttag
- set tagphase 0
- }
-}
-
-proc dispnexttag {} {
- global selectedline currentid showneartags tagphase ctext
-
- if {![info exists selectedline] || !$showneartags} return
- switch -- $tagphase {
- 0 {
- set dtags [desctags $currentid]
- if {$dtags ne {}} {
- appendrefs precedes $dtags idtags
- }
- }
- 1 {
- set atags [anctags $currentid]
- if {$atags ne {}} {
- appendrefs follows $atags idtags
- }
- }
- 2 {
- set dheads [descheads $currentid]
- if {$dheads ne {}} {
- if {[appendrefs branch $dheads idheads] > 1
- && [$ctext get "branch -3c"] eq "h"} {
- # turn "Branch" into "Branches"
- $ctext conf -state normal
- $ctext insert "branch -2c" "es"
- $ctext conf -state disabled
- }
- }
- }
- }
- if {[incr tagphase] <= 2} {
- after idle dispnexttag
- }
-}
-
-proc make_secsel {l} {
- global linehtag linentag linedtag canv canv2 canv3
-
- if {![info exists linehtag($l)]} return
- $canv delete secsel
- set t [eval $canv create rect [$canv bbox $linehtag($l)] -outline {{}} \
- -tags secsel -fill [$canv cget -selectbackground]]
- $canv lower $t
- $canv2 delete secsel
- set t [eval $canv2 create rect [$canv2 bbox $linentag($l)] -outline {{}} \
- -tags secsel -fill [$canv2 cget -selectbackground]]
- $canv2 lower $t
- $canv3 delete secsel
- set t [eval $canv3 create rect [$canv3 bbox $linedtag($l)] -outline {{}} \
- -tags secsel -fill [$canv3 cget -selectbackground]]
- $canv3 lower $t
-}
-
-proc selectline {l isnew} {
- global canv ctext commitinfo selectedline
- global displayorder
- global canvy0 linespc parentlist children curview
- global currentid sha1entry
- global commentend idtags linknum
- global mergemax numcommits pending_select
- global cmitmode showneartags allcommits
-
- catch {unset pending_select}
- $canv delete hover
- normalline
- unsel_reflist
- stopfinding
- if {$l < 0 || $l >= $numcommits} return
- set y [expr {$canvy0 + $l * $linespc}]
- set ymax [lindex [$canv cget -scrollregion] 3]
- set ytop [expr {$y - $linespc - 1}]
- set ybot [expr {$y + $linespc + 1}]
- set wnow [$canv yview]
- set wtop [expr {[lindex $wnow 0] * $ymax}]
- set wbot [expr {[lindex $wnow 1] * $ymax}]
- set wh [expr {$wbot - $wtop}]
- set newtop $wtop
- if {$ytop < $wtop} {
- if {$ybot < $wtop} {
- set newtop [expr {$y - $wh / 2.0}]
- } else {
- set newtop $ytop
- if {$newtop > $wtop - $linespc} {
- set newtop [expr {$wtop - $linespc}]
- }
- }
- } elseif {$ybot > $wbot} {
- if {$ytop > $wbot} {
- set newtop [expr {$y - $wh / 2.0}]
- } else {
- set newtop [expr {$ybot - $wh}]
- if {$newtop < $wtop + $linespc} {
- set newtop [expr {$wtop + $linespc}]
- }
- }
- }
- if {$newtop != $wtop} {
- if {$newtop < 0} {
- set newtop 0
- }
- allcanvs yview moveto [expr {$newtop * 1.0 / $ymax}]
- drawvisible
- }
-
- make_secsel $l
-
- if {$isnew} {
- addtohistory [list selectline $l 0]
- }
-
- set selectedline $l
-
- set id [lindex $displayorder $l]
- set currentid $id
- $sha1entry delete 0 end
- $sha1entry insert 0 $id
- $sha1entry selection from 0
- $sha1entry selection to end
- rhighlight_sel $id
-
- $ctext conf -state normal
- clear_ctext
- set linknum 0
- set info $commitinfo($id)
- set date [formatdate [lindex $info 2]]
- $ctext insert end "Author: [lindex $info 1] $date\n"
- set date [formatdate [lindex $info 4]]
- $ctext insert end "Committer: [lindex $info 3] $date\n"
- if {[info exists idtags($id)]} {
- $ctext insert end "Tags:"
- foreach tag $idtags($id) {
- $ctext insert end " $tag"
- }
- $ctext insert end "\n"
- }
-
- set headers {}
- set olds [lindex $parentlist $l]
- if {[llength $olds] > 1} {
- set np 0
- foreach p $olds {
- if {$np >= $mergemax} {
- set tag mmax
- } else {
- set tag m$np
- }
- $ctext insert end "Parent: " $tag
- appendwithlinks [commit_descriptor $p] {}
- incr np
- }
- } else {
- foreach p $olds {
- append headers "Parent: [commit_descriptor $p]"
- }
- }
-
- foreach c $children($curview,$id) {
- append headers "Child: [commit_descriptor $c]"
- }
-
- # make anything that looks like a SHA1 ID be a clickable link
- appendwithlinks $headers {}
- if {$showneartags} {
- if {![info exists allcommits]} {
- getallcommits
- }
- $ctext insert end "Branch: "
- $ctext mark set branch "end -1c"
- $ctext mark gravity branch left
- $ctext insert end "\nFollows: "
- $ctext mark set follows "end -1c"
- $ctext mark gravity follows left
- $ctext insert end "\nPrecedes: "
- $ctext mark set precedes "end -1c"
- $ctext mark gravity precedes left
- $ctext insert end "\n"
- dispneartags 1
- }
- $ctext insert end "\n"
- set comment [lindex $info 5]
- if {[string first "\r" $comment] >= 0} {
- set comment [string map {"\r" "\n "} $comment]
- }
- appendwithlinks $comment {comment}
-
- $ctext tag remove found 1.0 end
- $ctext conf -state disabled
- set commentend [$ctext index "end - 1c"]
-
- init_flist "Comments"
- if {$cmitmode eq "tree"} {
- gettree $id
- } elseif {[llength $olds] <= 1} {
- startdiff $id
- } else {
- mergediff $id $l
- }
-}
-
-proc selfirstline {} {
- unmarkmatches
- selectline 0 1
-}
-
-proc sellastline {} {
- global numcommits
- unmarkmatches
- set l [expr {$numcommits - 1}]
- selectline $l 1
-}
-
-proc selnextline {dir} {
- global selectedline
- focus .
- if {![info exists selectedline]} return
- set l [expr {$selectedline + $dir}]
- unmarkmatches
- selectline $l 1
-}
-
-proc selnextpage {dir} {
- global canv linespc selectedline numcommits
-
- set lpp [expr {([winfo height $canv] - 2) / $linespc}]
- if {$lpp < 1} {
- set lpp 1
- }
- allcanvs yview scroll [expr {$dir * $lpp}] units
- drawvisible
- if {![info exists selectedline]} return
- set l [expr {$selectedline + $dir * $lpp}]
- if {$l < 0} {
- set l 0
- } elseif {$l >= $numcommits} {
- set l [expr $numcommits - 1]
- }
- unmarkmatches
- selectline $l 1
-}
-
-proc unselectline {} {
- global selectedline currentid
-
- catch {unset selectedline}
- catch {unset currentid}
- allcanvs delete secsel
- rhighlight_none
-}
-
-proc reselectline {} {
- global selectedline
-
- if {[info exists selectedline]} {
- selectline $selectedline 0
- }
-}
-
-proc addtohistory {cmd} {
- global history historyindex curview
-
- set elt [list $curview $cmd]
- if {$historyindex > 0
- && [lindex $history [expr {$historyindex - 1}]] == $elt} {
- return
- }
-
- if {$historyindex < [llength $history]} {
- set history [lreplace $history $historyindex end $elt]
- } else {
- lappend history $elt
- }
- incr historyindex
- if {$historyindex > 1} {
- .tf.bar.leftbut conf -state normal
- } else {
- .tf.bar.leftbut conf -state disabled
- }
- .tf.bar.rightbut conf -state disabled
-}
-
-proc godo {elt} {
- global curview
-
- set view [lindex $elt 0]
- set cmd [lindex $elt 1]
- if {$curview != $view} {
- showview $view
- }
- eval $cmd
-}
-
-proc goback {} {
- global history historyindex
- focus .
-
- if {$historyindex > 1} {
- incr historyindex -1
- godo [lindex $history [expr {$historyindex - 1}]]
- .tf.bar.rightbut conf -state normal
- }
- if {$historyindex <= 1} {
- .tf.bar.leftbut conf -state disabled
- }
-}
-
-proc goforw {} {
- global history historyindex
- focus .
-
- if {$historyindex < [llength $history]} {
- set cmd [lindex $history $historyindex]
- incr historyindex
- godo $cmd
- .tf.bar.leftbut conf -state normal
- }
- if {$historyindex >= [llength $history]} {
- .tf.bar.rightbut conf -state disabled
- }
-}
-
-proc gettree {id} {
- global treefilelist treeidlist diffids diffmergeid treepending
- global nullid nullid2
-
- set diffids $id
- catch {unset diffmergeid}
- if {![info exists treefilelist($id)]} {
- if {![info exists treepending]} {
- if {$id eq $nullid} {
- set cmd [list | git ls-files]
- } elseif {$id eq $nullid2} {
- set cmd [list | git ls-files --stage -t]
- } else {
- set cmd [list | git ls-tree -r $id]
- }
- if {[catch {set gtf [open $cmd r]}]} {
- return
- }
- set treepending $id
- set treefilelist($id) {}
- set treeidlist($id) {}
- fconfigure $gtf -blocking 0
- filerun $gtf [list gettreeline $gtf $id]
- }
- } else {
- setfilelist $id
- }
-}
-
-proc gettreeline {gtf id} {
- global treefilelist treeidlist treepending cmitmode diffids nullid nullid2
-
- set nl 0
- while {[incr nl] <= 1000 && [gets $gtf line] >= 0} {
- if {$diffids eq $nullid} {
- set fname $line
- } else {
- if {$diffids ne $nullid2 && [lindex $line 1] ne "blob"} continue
- set i [string first "\t" $line]
- if {$i < 0} continue
- set sha1 [lindex $line 2]
- set fname [string range $line [expr {$i+1}] end]
- if {[string index $fname 0] eq "\""} {
- set fname [lindex $fname 0]
- }
- lappend treeidlist($id) $sha1
- }
- lappend treefilelist($id) $fname
- }
- if {![eof $gtf]} {
- return [expr {$nl >= 1000? 2: 1}]
- }
- close $gtf
- unset treepending
- if {$cmitmode ne "tree"} {
- if {![info exists diffmergeid]} {
- gettreediffs $diffids
- }
- } elseif {$id ne $diffids} {
- gettree $diffids
- } else {
- setfilelist $id
- }
- return 0
-}
-
-proc showfile {f} {
- global treefilelist treeidlist diffids nullid nullid2
- global ctext commentend
-
- set i [lsearch -exact $treefilelist($diffids) $f]
- if {$i < 0} {
- puts "oops, $f not in list for id $diffids"
- return
- }
- if {$diffids eq $nullid} {
- if {[catch {set bf [open $f r]} err]} {
- puts "oops, can't read $f: $err"
- return
- }
- } else {
- set blob [lindex $treeidlist($diffids) $i]
- if {[catch {set bf [open [concat | git cat-file blob $blob] r]} err]} {
- puts "oops, error reading blob $blob: $err"
- return
- }
- }
- fconfigure $bf -blocking 0
- filerun $bf [list getblobline $bf $diffids]
- $ctext config -state normal
- clear_ctext $commentend
- $ctext insert end "\n"
- $ctext insert end "$f\n" filesep
- $ctext config -state disabled
- $ctext yview $commentend
- settabs 0
-}
-
-proc getblobline {bf id} {
- global diffids cmitmode ctext
-
- if {$id ne $diffids || $cmitmode ne "tree"} {
- catch {close $bf}
- return 0
- }
- $ctext config -state normal
- set nl 0
- while {[incr nl] <= 1000 && [gets $bf line] >= 0} {
- $ctext insert end "$line\n"
- }
- if {[eof $bf]} {
- # delete last newline
- $ctext delete "end - 2c" "end - 1c"
- close $bf
- return 0
- }
- $ctext config -state disabled
- return [expr {$nl >= 1000? 2: 1}]
-}
-
-proc mergediff {id l} {
- global diffmergeid mdifffd
- global diffids
- global parentlist
- global limitdiffs viewfiles curview
-
- set diffmergeid $id
- set diffids $id
- # this doesn't seem to actually affect anything...
- set cmd [concat | git diff-tree --no-commit-id --cc $id]
- if {$limitdiffs && $viewfiles($curview) ne {}} {
- set cmd [concat $cmd -- $viewfiles($curview)]
- }
- if {[catch {set mdf [open $cmd r]} err]} {
- error_popup "Error getting merge diffs: $err"
- return
- }
- fconfigure $mdf -blocking 0
- set mdifffd($id) $mdf
- set np [llength [lindex $parentlist $l]]
- settabs $np
- filerun $mdf [list getmergediffline $mdf $id $np]
-}
-
-proc getmergediffline {mdf id np} {
- global diffmergeid ctext cflist mergemax
- global difffilestart mdifffd
-
- $ctext conf -state normal
- set nr 0
- while {[incr nr] <= 1000 && [gets $mdf line] >= 0} {
- if {![info exists diffmergeid] || $id != $diffmergeid
- || $mdf != $mdifffd($id)} {
- close $mdf
- return 0
- }
- if {[regexp {^diff --cc (.*)} $line match fname]} {
- # start of a new file
- $ctext insert end "\n"
- set here [$ctext index "end - 1c"]
- lappend difffilestart $here
- add_flist [list $fname]
- set l [expr {(78 - [string length $fname]) / 2}]
- set pad [string range "----------------------------------------" 1 $l]
- $ctext insert end "$pad $fname $pad\n" filesep
- } elseif {[regexp {^@@} $line]} {
- $ctext insert end "$line\n" hunksep
- } elseif {[regexp {^[0-9a-f]{40}$} $line] || [regexp {^index} $line]} {
- # do nothing
- } else {
- # parse the prefix - one ' ', '-' or '+' for each parent
- set spaces {}
- set minuses {}
- set pluses {}
- set isbad 0
- for {set j 0} {$j < $np} {incr j} {
- set c [string range $line $j $j]
- if {$c == " "} {
- lappend spaces $j
- } elseif {$c == "-"} {
- lappend minuses $j
- } elseif {$c == "+"} {
- lappend pluses $j
- } else {
- set isbad 1
- break
- }
- }
- set tags {}
- set num {}
- if {!$isbad && $minuses ne {} && $pluses eq {}} {
- # line doesn't appear in result, parents in $minuses have the line
- set num [lindex $minuses 0]
- } elseif {!$isbad && $pluses ne {} && $minuses eq {}} {
- # line appears in result, parents in $pluses don't have the line
- lappend tags mresult
- set num [lindex $spaces 0]
- }
- if {$num ne {}} {
- if {$num >= $mergemax} {
- set num "max"
- }
- lappend tags m$num
- }
- $ctext insert end "$line\n" $tags
- }
- }
- $ctext conf -state disabled
- if {[eof $mdf]} {
- close $mdf
- return 0
- }
- return [expr {$nr >= 1000? 2: 1}]
-}
-
-proc startdiff {ids} {
- global treediffs diffids treepending diffmergeid nullid nullid2
-
- settabs 1
- set diffids $ids
- catch {unset diffmergeid}
- if {![info exists treediffs($ids)] ||
- [lsearch -exact $ids $nullid] >= 0 ||
- [lsearch -exact $ids $nullid2] >= 0} {
- if {![info exists treepending]} {
- gettreediffs $ids
- }
- } else {
- addtocflist $ids
- }
-}
-
-proc path_filter {filter name} {
- foreach p $filter {
- set l [string length $p]
- if {[string index $p end] eq "/"} {
- if {[string compare -length $l $p $name] == 0} {
- return 1
- }
- } else {
- if {[string compare -length $l $p $name] == 0 &&
- ([string length $name] == $l ||
- [string index $name $l] eq "/")} {
- return 1
- }
- }
- }
- return 0
-}
-
-proc addtocflist {ids} {
- global treediffs
-
- add_flist $treediffs($ids)
- getblobdiffs $ids
-}
-
-proc diffcmd {ids flags} {
- global nullid nullid2
-
- set i [lsearch -exact $ids $nullid]
- set j [lsearch -exact $ids $nullid2]
- if {$i >= 0} {
- if {[llength $ids] > 1 && $j < 0} {
- # comparing working directory with some specific revision
- set cmd [concat | git diff-index $flags]
- if {$i == 0} {
- lappend cmd -R [lindex $ids 1]
- } else {
- lappend cmd [lindex $ids 0]
- }
- } else {
- # comparing working directory with index
- set cmd [concat | git diff-files $flags]
- if {$j == 1} {
- lappend cmd -R
- }
- }
- } elseif {$j >= 0} {
- set cmd [concat | git diff-index --cached $flags]
- if {[llength $ids] > 1} {
- # comparing index with specific revision
- if {$i == 0} {
- lappend cmd -R [lindex $ids 1]
- } else {
- lappend cmd [lindex $ids 0]
- }
- } else {
- # comparing index with HEAD
- lappend cmd HEAD
- }
- } else {
- set cmd [concat | git diff-tree -r $flags $ids]
- }
- return $cmd
-}
-
-proc gettreediffs {ids} {
- global treediff treepending
-
- set treepending $ids
- set treediff {}
- if {[catch {set gdtf [open [diffcmd $ids {--no-commit-id}] r]}]} return
- fconfigure $gdtf -blocking 0
- filerun $gdtf [list gettreediffline $gdtf $ids]
-}
-
-proc gettreediffline {gdtf ids} {
- global treediff treediffs treepending diffids diffmergeid
- global cmitmode viewfiles curview limitdiffs
-
- set nr 0
- while {[incr nr] <= 1000 && [gets $gdtf line] >= 0} {
- set i [string first "\t" $line]
- if {$i >= 0} {
- set file [string range $line [expr {$i+1}] end]
- if {[string index $file 0] eq "\""} {
- set file [lindex $file 0]
- }
- lappend treediff $file
- }
- }
- if {![eof $gdtf]} {
- return [expr {$nr >= 1000? 2: 1}]
- }
- close $gdtf
- if {$limitdiffs && $viewfiles($curview) ne {}} {
- set flist {}
- foreach f $treediff {
- if {[path_filter $viewfiles($curview) $f]} {
- lappend flist $f
- }
- }
- set treediffs($ids) $flist
- } else {
- set treediffs($ids) $treediff
- }
- unset treepending
- if {$cmitmode eq "tree"} {
- gettree $diffids
- } elseif {$ids != $diffids} {
- if {![info exists diffmergeid]} {
- gettreediffs $diffids
- }
- } else {
- addtocflist $ids
- }
- return 0
-}
-
-# empty string or positive integer
-proc diffcontextvalidate {v} {
- return [regexp {^(|[1-9][0-9]*)$} $v]
-}
-
-proc diffcontextchange {n1 n2 op} {
- global diffcontextstring diffcontext
-
- if {[string is integer -strict $diffcontextstring]} {
- if {$diffcontextstring > 0} {
- set diffcontext $diffcontextstring
- reselectline
- }
- }
-}
-
-proc getblobdiffs {ids} {
- global blobdifffd diffids env
- global diffinhdr treediffs
- global diffcontext
- global limitdiffs viewfiles curview
-
- set cmd [diffcmd $ids "-p -C --no-commit-id -U$diffcontext"]
- if {$limitdiffs && $viewfiles($curview) ne {}} {
- set cmd [concat $cmd -- $viewfiles($curview)]
- }
- if {[catch {set bdf [open $cmd r]} err]} {
- puts "error getting diffs: $err"
- return
- }
- set diffinhdr 0
- fconfigure $bdf -blocking 0
- set blobdifffd($ids) $bdf
- filerun $bdf [list getblobdiffline $bdf $diffids]
-}
-
-proc setinlist {var i val} {
- global $var
-
- while {[llength [set $var]] < $i} {
- lappend $var {}
- }
- if {[llength [set $var]] == $i} {
- lappend $var $val
- } else {
- lset $var $i $val
- }
-}
-
-proc makediffhdr {fname ids} {
- global ctext curdiffstart treediffs
-
- set i [lsearch -exact $treediffs($ids) $fname]
- if {$i >= 0} {
- setinlist difffilestart $i $curdiffstart
- }
- set l [expr {(78 - [string length $fname]) / 2}]
- set pad [string range "----------------------------------------" 1 $l]
- $ctext insert $curdiffstart "$pad $fname $pad" filesep
-}
-
-proc getblobdiffline {bdf ids} {
- global diffids blobdifffd ctext curdiffstart
- global diffnexthead diffnextnote difffilestart
- global diffinhdr treediffs
-
- set nr 0
- $ctext conf -state normal
- while {[incr nr] <= 1000 && [gets $bdf line] >= 0} {
- if {$ids != $diffids || $bdf != $blobdifffd($ids)} {
- close $bdf
- return 0
- }
- if {![string compare -length 11 "diff --git " $line]} {
- # trim off "diff --git "
- set line [string range $line 11 end]
- set diffinhdr 1
- # start of a new file
- $ctext insert end "\n"
- set curdiffstart [$ctext index "end - 1c"]
- $ctext insert end "\n" filesep
- # If the name hasn't changed the length will be odd,
- # the middle char will be a space, and the two bits either
- # side will be a/name and b/name, or "a/name" and "b/name".
- # If the name has changed we'll get "rename from" and
- # "rename to" or "copy from" and "copy to" lines following this,
- # and we'll use them to get the filenames.
- # This complexity is necessary because spaces in the filename(s)
- # don't get escaped.
- set l [string length $line]
- set i [expr {$l / 2}]
- if {!(($l & 1) && [string index $line $i] eq " " &&
- [string range $line 2 [expr {$i - 1}]] eq \
- [string range $line [expr {$i + 3}] end])} {
- continue
- }
- # unescape if quoted and chop off the a/ from the front
- if {[string index $line 0] eq "\""} {
- set fname [string range [lindex $line 0] 2 end]
- } else {
- set fname [string range $line 2 [expr {$i - 1}]]
- }
- makediffhdr $fname $ids
-
- } elseif {[regexp {^@@ -([0-9]+)(,[0-9]+)? \+([0-9]+)(,[0-9]+)? @@(.*)} \
- $line match f1l f1c f2l f2c rest]} {
- $ctext insert end "$line\n" hunksep
- set diffinhdr 0
-
- } elseif {$diffinhdr} {
- if {![string compare -length 12 "rename from " $line]} {
- set fname [string range $line [expr 6 + [string first " from " $line] ] end]
- if {[string index $fname 0] eq "\""} {
- set fname [lindex $fname 0]
- }
- set i [lsearch -exact $treediffs($ids) $fname]
- if {$i >= 0} {
- setinlist difffilestart $i $curdiffstart
- }
- } elseif {![string compare -length 10 $line "rename to "] ||
- ![string compare -length 8 $line "copy to "]} {
- set fname [string range $line [expr 4 + [string first " to " $line] ] end]
- if {[string index $fname 0] eq "\""} {
- set fname [lindex $fname 0]
- }
- makediffhdr $fname $ids
- } elseif {[string compare -length 3 $line "---"] == 0} {
- # do nothing
- continue
- } elseif {[string compare -length 3 $line "+++"] == 0} {
- set diffinhdr 0
- continue
- }
- $ctext insert end "$line\n" filesep
-
- } else {
- set x [string range $line 0 0]
- if {$x == "-" || $x == "+"} {
- set tag [expr {$x == "+"}]
- $ctext insert end "$line\n" d$tag
- } elseif {$x == " "} {
- $ctext insert end "$line\n"
- } else {
- # "\ No newline at end of file",
- # or something else we don't recognize
- $ctext insert end "$line\n" hunksep
- }
- }
- }
- $ctext conf -state disabled
- if {[eof $bdf]} {
- close $bdf
- return 0
- }
- return [expr {$nr >= 1000? 2: 1}]
-}
-
-proc changediffdisp {} {
- global ctext diffelide
-
- $ctext tag conf d0 -elide [lindex $diffelide 0]
- $ctext tag conf d1 -elide [lindex $diffelide 1]
-}
-
-proc prevfile {} {
- global difffilestart ctext
- set prev [lindex $difffilestart 0]
- set here [$ctext index @0,0]
- foreach loc $difffilestart {
- if {[$ctext compare $loc >= $here]} {
- $ctext yview $prev
- return
- }
- set prev $loc
- }
- $ctext yview $prev
-}
-
-proc nextfile {} {
- global difffilestart ctext
- set here [$ctext index @0,0]
- foreach loc $difffilestart {
- if {[$ctext compare $loc > $here]} {
- $ctext yview $loc
- return
- }
- }
-}
-
-proc clear_ctext {{first 1.0}} {
- global ctext smarktop smarkbot
- global pendinglinks
-
- set l [lindex [split $first .] 0]
- if {![info exists smarktop] || [$ctext compare $first < $smarktop.0]} {
- set smarktop $l
- }
- if {![info exists smarkbot] || [$ctext compare $first < $smarkbot.0]} {
- set smarkbot $l
- }
- $ctext delete $first end
- if {$first eq "1.0"} {
- catch {unset pendinglinks}
- }
-}
-
-proc settabs {{firstab {}}} {
- global firsttabstop tabstop ctext have_tk85
-
- if {$firstab ne {} && $have_tk85} {
- set firsttabstop $firstab
- }
- set w [font measure textfont "0"]
- if {$firsttabstop != 0} {
- $ctext conf -tabs [list [expr {($firsttabstop + $tabstop) * $w}] \
- [expr {($firsttabstop + 2 * $tabstop) * $w}]]
- } elseif {$have_tk85 || $tabstop != 8} {
- $ctext conf -tabs [expr {$tabstop * $w}]
- } else {
- $ctext conf -tabs {}
- }
-}
-
-proc incrsearch {name ix op} {
- global ctext searchstring searchdirn
-
- $ctext tag remove found 1.0 end
- if {[catch {$ctext index anchor}]} {
- # no anchor set, use start of selection, or of visible area
- set sel [$ctext tag ranges sel]
- if {$sel ne {}} {
- $ctext mark set anchor [lindex $sel 0]
- } elseif {$searchdirn eq "-forwards"} {
- $ctext mark set anchor @0,0
- } else {
- $ctext mark set anchor @0,[winfo height $ctext]
- }
- }
- if {$searchstring ne {}} {
- set here [$ctext search $searchdirn -- $searchstring anchor]
- if {$here ne {}} {
- $ctext see $here
- }
- searchmarkvisible 1
- }
-}
-
-proc dosearch {} {
- global sstring ctext searchstring searchdirn
-
- focus $sstring
- $sstring icursor end
- set searchdirn -forwards
- if {$searchstring ne {}} {
- set sel [$ctext tag ranges sel]
- if {$sel ne {}} {
- set start "[lindex $sel 0] + 1c"
- } elseif {[catch {set start [$ctext index anchor]}]} {
- set start "@0,0"
- }
- set match [$ctext search -count mlen -- $searchstring $start]
- $ctext tag remove sel 1.0 end
- if {$match eq {}} {
- bell
- return
- }
- $ctext see $match
- set mend "$match + $mlen c"
- $ctext tag add sel $match $mend
- $ctext mark unset anchor
- }
-}
-
-proc dosearchback {} {
- global sstring ctext searchstring searchdirn
-
- focus $sstring
- $sstring icursor end
- set searchdirn -backwards
- if {$searchstring ne {}} {
- set sel [$ctext tag ranges sel]
- if {$sel ne {}} {
- set start [lindex $sel 0]
- } elseif {[catch {set start [$ctext index anchor]}]} {
- set start @0,[winfo height $ctext]
- }
- set match [$ctext search -backwards -count ml -- $searchstring $start]
- $ctext tag remove sel 1.0 end
- if {$match eq {}} {
- bell
- return
- }
- $ctext see $match
- set mend "$match + $ml c"
- $ctext tag add sel $match $mend
- $ctext mark unset anchor
- }
-}
-
-proc searchmark {first last} {
- global ctext searchstring
-
- set mend $first.0
- while {1} {
- set match [$ctext search -count mlen -- $searchstring $mend $last.end]
- if {$match eq {}} break
- set mend "$match + $mlen c"
- $ctext tag add found $match $mend
- }
-}
-
-proc searchmarkvisible {doall} {
- global ctext smarktop smarkbot
-
- set topline [lindex [split [$ctext index @0,0] .] 0]
- set botline [lindex [split [$ctext index @0,[winfo height $ctext]] .] 0]
- if {$doall || $botline < $smarktop || $topline > $smarkbot} {
- # no overlap with previous
- searchmark $topline $botline
- set smarktop $topline
- set smarkbot $botline
- } else {
- if {$topline < $smarktop} {
- searchmark $topline [expr {$smarktop-1}]
- set smarktop $topline
- }
- if {$botline > $smarkbot} {
- searchmark [expr {$smarkbot+1}] $botline
- set smarkbot $botline
- }
- }
-}
-
-proc scrolltext {f0 f1} {
- global searchstring
-
- .bleft.sb set $f0 $f1
- if {$searchstring ne {}} {
- searchmarkvisible 0
- }
-}
-
-proc setcoords {} {
- global linespc charspc canvx0 canvy0
- global xspc1 xspc2 lthickness
-
- set linespc [font metrics mainfont -linespace]
- set charspc [font measure mainfont "m"]
- set canvy0 [expr {int(3 + 0.5 * $linespc)}]
- set canvx0 [expr {int(3 + 0.5 * $linespc)}]
- set lthickness [expr {int($linespc / 9) + 1}]
- set xspc1(0) $linespc
- set xspc2 $linespc
-}
-
-proc redisplay {} {
- global canv
- global selectedline
-
- set ymax [lindex [$canv cget -scrollregion] 3]
- if {$ymax eq {} || $ymax == 0} return
- set span [$canv yview]
- clear_display
- setcanvscroll
- allcanvs yview moveto [lindex $span 0]
- drawvisible
- if {[info exists selectedline]} {
- selectline $selectedline 0
- allcanvs yview moveto [lindex $span 0]
- }
-}
-
-proc parsefont {f n} {
- global fontattr
-
- set fontattr($f,family) [lindex $n 0]
- set s [lindex $n 1]
- if {$s eq {} || $s == 0} {
- set s 10
- } elseif {$s < 0} {
- set s [expr {int(-$s / [winfo fpixels . 1p] + 0.5)}]
- }
- set fontattr($f,size) $s
- set fontattr($f,weight) normal
- set fontattr($f,slant) roman
- foreach style [lrange $n 2 end] {
- switch -- $style {
- "normal" -
- "bold" {set fontattr($f,weight) $style}
- "roman" -
- "italic" {set fontattr($f,slant) $style}
- }
- }
-}
-
-proc fontflags {f {isbold 0}} {
- global fontattr
-
- return [list -family $fontattr($f,family) -size $fontattr($f,size) \
- -weight [expr {$isbold? "bold": $fontattr($f,weight)}] \
- -slant $fontattr($f,slant)]
-}
-
-proc fontname {f} {
- global fontattr
-
- set n [list $fontattr($f,family) $fontattr($f,size)]
- if {$fontattr($f,weight) eq "bold"} {
- lappend n "bold"
- }
- if {$fontattr($f,slant) eq "italic"} {
- lappend n "italic"
- }
- return $n
-}
-
-proc incrfont {inc} {
- global mainfont textfont ctext canv phase cflist showrefstop
- global stopped entries fontattr
-
- unmarkmatches
- set s $fontattr(mainfont,size)
- incr s $inc
- if {$s < 1} {
- set s 1
- }
- set fontattr(mainfont,size) $s
- font config mainfont -size $s
- font config mainfontbold -size $s
- set mainfont [fontname mainfont]
- set s $fontattr(textfont,size)
- incr s $inc
- if {$s < 1} {
- set s 1
- }
- set fontattr(textfont,size) $s
- font config textfont -size $s
- font config textfontbold -size $s
- set textfont [fontname textfont]
- setcoords
- settabs
- redisplay
-}
-
-proc clearsha1 {} {
- global sha1entry sha1string
- if {[string length $sha1string] == 40} {
- $sha1entry delete 0 end
- }
-}
-
-proc sha1change {n1 n2 op} {
- global sha1string currentid sha1but
- if {$sha1string == {}
- || ([info exists currentid] && $sha1string == $currentid)} {
- set state disabled
- } else {
- set state normal
- }
- if {[$sha1but cget -state] == $state} return
- if {$state == "normal"} {
- $sha1but conf -state normal -relief raised -text "Goto: "
- } else {
- $sha1but conf -state disabled -relief flat -text "SHA1 ID: "
- }
-}
-
-proc gotocommit {} {
- global sha1string currentid commitrow tagids headids
- global displayorder numcommits curview
-
- if {$sha1string == {}
- || ([info exists currentid] && $sha1string == $currentid)} return
- if {[info exists tagids($sha1string)]} {
- set id $tagids($sha1string)
- } elseif {[info exists headids($sha1string)]} {
- set id $headids($sha1string)
- } else {
- set id [string tolower $sha1string]
- if {[regexp {^[0-9a-f]{4,39}$} $id]} {
- set matches {}
- foreach i $displayorder {
- if {[string match $id* $i]} {
- lappend matches $i
- }
- }
- if {$matches ne {}} {
- if {[llength $matches] > 1} {
- error_popup "Short SHA1 id $id is ambiguous"
- return
- }
- set id [lindex $matches 0]
- }
- }
- }
- if {[info exists commitrow($curview,$id)]} {
- selectline $commitrow($curview,$id) 1
- return
- }
- if {[regexp {^[0-9a-fA-F]{4,}$} $sha1string]} {
- set type "SHA1 id"
- } else {
- set type "Tag/Head"
- }
- error_popup "$type $sha1string is not known"
-}
-
-proc lineenter {x y id} {
- global hoverx hovery hoverid hovertimer
- global commitinfo canv
-
- if {![info exists commitinfo($id)] && ![getcommit $id]} return
- set hoverx $x
- set hovery $y
- set hoverid $id
- if {[info exists hovertimer]} {
- after cancel $hovertimer
- }
- set hovertimer [after 500 linehover]
- $canv delete hover
-}
-
-proc linemotion {x y id} {
- global hoverx hovery hoverid hovertimer
-
- if {[info exists hoverid] && $id == $hoverid} {
- set hoverx $x
- set hovery $y
- if {[info exists hovertimer]} {
- after cancel $hovertimer
- }
- set hovertimer [after 500 linehover]
- }
-}
-
-proc lineleave {id} {
- global hoverid hovertimer canv
-
- if {[info exists hoverid] && $id == $hoverid} {
- $canv delete hover
- if {[info exists hovertimer]} {
- after cancel $hovertimer
- unset hovertimer
- }
- unset hoverid
- }
-}
-
-proc linehover {} {
- global hoverx hovery hoverid hovertimer
- global canv linespc lthickness
- global commitinfo
-
- set text [lindex $commitinfo($hoverid) 0]
- set ymax [lindex [$canv cget -scrollregion] 3]
- if {$ymax == {}} return
- set yfrac [lindex [$canv yview] 0]
- set x [expr {$hoverx + 2 * $linespc}]
- set y [expr {$hovery + $yfrac * $ymax - $linespc / 2}]
- set x0 [expr {$x - 2 * $lthickness}]
- set y0 [expr {$y - 2 * $lthickness}]
- set x1 [expr {$x + [font measure mainfont $text] + 2 * $lthickness}]
- set y1 [expr {$y + $linespc + 2 * $lthickness}]
- set t [$canv create rectangle $x0 $y0 $x1 $y1 \
- -fill \#ffff80 -outline black -width 1 -tags hover]
- $canv raise $t
- set t [$canv create text $x $y -anchor nw -text $text -tags hover \
- -font mainfont]
- $canv raise $t
-}
-
-proc clickisonarrow {id y} {
- global lthickness
-
- set ranges [rowranges $id]
- set thresh [expr {2 * $lthickness + 6}]
- set n [expr {[llength $ranges] - 1}]
- for {set i 1} {$i < $n} {incr i} {
- set row [lindex $ranges $i]
- if {abs([yc $row] - $y) < $thresh} {
- return $i
- }
- }
- return {}
-}
-
-proc arrowjump {id n y} {
- global canv
-
- # 1 <-> 2, 3 <-> 4, etc...
- set n [expr {(($n - 1) ^ 1) + 1}]
- set row [lindex [rowranges $id] $n]
- set yt [yc $row]
- set ymax [lindex [$canv cget -scrollregion] 3]
- if {$ymax eq {} || $ymax <= 0} return
- set view [$canv yview]
- set yspan [expr {[lindex $view 1] - [lindex $view 0]}]
- set yfrac [expr {$yt / $ymax - $yspan / 2}]
- if {$yfrac < 0} {
- set yfrac 0
- }
- allcanvs yview moveto $yfrac
-}
-
-proc lineclick {x y id isnew} {
- global ctext commitinfo children canv thickerline curview commitrow
-
- if {![info exists commitinfo($id)] && ![getcommit $id]} return
- unmarkmatches
- unselectline
- normalline
- $canv delete hover
- # draw this line thicker than normal
- set thickerline $id
- drawlines $id
- if {$isnew} {
- set ymax [lindex [$canv cget -scrollregion] 3]
- if {$ymax eq {}} return
- set yfrac [lindex [$canv yview] 0]
- set y [expr {$y + $yfrac * $ymax}]
- }
- set dirn [clickisonarrow $id $y]
- if {$dirn ne {}} {
- arrowjump $id $dirn $y
- return
- }
-
- if {$isnew} {
- addtohistory [list lineclick $x $y $id 0]
- }
- # fill the details pane with info about this line
- $ctext conf -state normal
- clear_ctext
- settabs 0
- $ctext insert end "Parent:\t"
- $ctext insert end $id link0
- setlink $id link0
- set info $commitinfo($id)
- $ctext insert end "\n\t[lindex $info 0]\n"
- $ctext insert end "\tAuthor:\t[lindex $info 1]\n"
- set date [formatdate [lindex $info 2]]
- $ctext insert end "\tDate:\t$date\n"
- set kids $children($curview,$id)
- if {$kids ne {}} {
- $ctext insert end "\nChildren:"
- set i 0
- foreach child $kids {
- incr i
- if {![info exists commitinfo($child)] && ![getcommit $child]} continue
- set info $commitinfo($child)
- $ctext insert end "\n\t"
- $ctext insert end $child link$i
- setlink $child link$i
- $ctext insert end "\n\t[lindex $info 0]"
- $ctext insert end "\n\tAuthor:\t[lindex $info 1]"
- set date [formatdate [lindex $info 2]]
- $ctext insert end "\n\tDate:\t$date\n"
- }
- }
- $ctext conf -state disabled
- init_flist {}
-}
-
-proc normalline {} {
- global thickerline
- if {[info exists thickerline]} {
- set id $thickerline
- unset thickerline
- drawlines $id
- }
-}
-
-proc selbyid {id} {
- global commitrow curview
- if {[info exists commitrow($curview,$id)]} {
- selectline $commitrow($curview,$id) 1
- }
-}
-
-proc mstime {} {
- global startmstime
- if {![info exists startmstime]} {
- set startmstime [clock clicks -milliseconds]
- }
- return [format "%.3f" [expr {([clock click -milliseconds] - $startmstime) / 1000.0}]]
-}
-
-proc rowmenu {x y id} {
- global rowctxmenu commitrow selectedline rowmenuid curview
- global nullid nullid2 fakerowmenu mainhead
-
- stopfinding
- set rowmenuid $id
- if {![info exists selectedline]
- || $commitrow($curview,$id) eq $selectedline} {
- set state disabled
- } else {
- set state normal
- }
- if {$id ne $nullid && $id ne $nullid2} {
- set menu $rowctxmenu
- $menu entryconfigure 7 -label "Reset $mainhead branch to here"
- } else {
- set menu $fakerowmenu
- }
- $menu entryconfigure "Diff this*" -state $state
- $menu entryconfigure "Diff selected*" -state $state
- $menu entryconfigure "Make patch" -state $state
- tk_popup $menu $x $y
-}
-
-proc diffvssel {dirn} {
- global rowmenuid selectedline displayorder
-
- if {![info exists selectedline]} return
- if {$dirn} {
- set oldid [lindex $displayorder $selectedline]
- set newid $rowmenuid
- } else {
- set oldid $rowmenuid
- set newid [lindex $displayorder $selectedline]
- }
- addtohistory [list doseldiff $oldid $newid]
- doseldiff $oldid $newid
-}
-
-proc doseldiff {oldid newid} {
- global ctext
- global commitinfo
-
- $ctext conf -state normal
- clear_ctext
- init_flist "Top"
- $ctext insert end "From "
- $ctext insert end $oldid link0
- setlink $oldid link0
- $ctext insert end "\n "
- $ctext insert end [lindex $commitinfo($oldid) 0]
- $ctext insert end "\n\nTo "
- $ctext insert end $newid link1
- setlink $newid link1
- $ctext insert end "\n "
- $ctext insert end [lindex $commitinfo($newid) 0]
- $ctext insert end "\n"
- $ctext conf -state disabled
- $ctext tag remove found 1.0 end
- startdiff [list $oldid $newid]
-}
-
-proc mkpatch {} {
- global rowmenuid currentid commitinfo patchtop patchnum
-
- if {![info exists currentid]} return
- set oldid $currentid
- set oldhead [lindex $commitinfo($oldid) 0]
- set newid $rowmenuid
- set newhead [lindex $commitinfo($newid) 0]
- set top .patch
- set patchtop $top
- catch {destroy $top}
- toplevel $top
- label $top.title -text "Generate patch"
- grid $top.title - -pady 10
- label $top.from -text "From:"
- entry $top.fromsha1 -width 40 -relief flat
- $top.fromsha1 insert 0 $oldid
- $top.fromsha1 conf -state readonly
- grid $top.from $top.fromsha1 -sticky w
- entry $top.fromhead -width 60 -relief flat
- $top.fromhead insert 0 $oldhead
- $top.fromhead conf -state readonly
- grid x $top.fromhead -sticky w
- label $top.to -text "To:"
- entry $top.tosha1 -width 40 -relief flat
- $top.tosha1 insert 0 $newid
- $top.tosha1 conf -state readonly
- grid $top.to $top.tosha1 -sticky w
- entry $top.tohead -width 60 -relief flat
- $top.tohead insert 0 $newhead
- $top.tohead conf -state readonly
- grid x $top.tohead -sticky w
- button $top.rev -text "Reverse" -command mkpatchrev -padx 5
- grid $top.rev x -pady 10
- label $top.flab -text "Output file:"
- entry $top.fname -width 60
- $top.fname insert 0 [file normalize "patch$patchnum.patch"]
- incr patchnum
- grid $top.flab $top.fname -sticky w
- frame $top.buts
- button $top.buts.gen -text "Generate" -command mkpatchgo
- button $top.buts.can -text "Cancel" -command mkpatchcan
- grid $top.buts.gen $top.buts.can
- grid columnconfigure $top.buts 0 -weight 1 -uniform a
- grid columnconfigure $top.buts 1 -weight 1 -uniform a
- grid $top.buts - -pady 10 -sticky ew
- focus $top.fname
-}
-
-proc mkpatchrev {} {
- global patchtop
-
- set oldid [$patchtop.fromsha1 get]
- set oldhead [$patchtop.fromhead get]
- set newid [$patchtop.tosha1 get]
- set newhead [$patchtop.tohead get]
- foreach e [list fromsha1 fromhead tosha1 tohead] \
- v [list $newid $newhead $oldid $oldhead] {
- $patchtop.$e conf -state normal
- $patchtop.$e delete 0 end
- $patchtop.$e insert 0 $v
- $patchtop.$e conf -state readonly
- }
-}
-
-proc mkpatchgo {} {
- global patchtop nullid nullid2
-
- set oldid [$patchtop.fromsha1 get]
- set newid [$patchtop.tosha1 get]
- set fname [$patchtop.fname get]
- set cmd [diffcmd [list $oldid $newid] -p]
- # trim off the initial "|"
- set cmd [lrange $cmd 1 end]
- lappend cmd >$fname &
- if {[catch {eval exec $cmd} err]} {
- error_popup "Error creating patch: $err"
- }
- catch {destroy $patchtop}
- unset patchtop
-}
-
-proc mkpatchcan {} {
- global patchtop
-
- catch {destroy $patchtop}
- unset patchtop
-}
-
-proc mktag {} {
- global rowmenuid mktagtop commitinfo
-
- set top .maketag
- set mktagtop $top
- catch {destroy $top}
- toplevel $top
- label $top.title -text "Create tag"
- grid $top.title - -pady 10
- label $top.id -text "ID:"
- entry $top.sha1 -width 40 -relief flat
- $top.sha1 insert 0 $rowmenuid
- $top.sha1 conf -state readonly
- grid $top.id $top.sha1 -sticky w
- entry $top.head -width 60 -relief flat
- $top.head insert 0 [lindex $commitinfo($rowmenuid) 0]
- $top.head conf -state readonly
- grid x $top.head -sticky w
- label $top.tlab -text "Tag name:"
- entry $top.tag -width 60
- grid $top.tlab $top.tag -sticky w
- frame $top.buts
- button $top.buts.gen -text "Create" -command mktaggo
- button $top.buts.can -text "Cancel" -command mktagcan
- grid $top.buts.gen $top.buts.can
- grid columnconfigure $top.buts 0 -weight 1 -uniform a
- grid columnconfigure $top.buts 1 -weight 1 -uniform a
- grid $top.buts - -pady 10 -sticky ew
- focus $top.tag
-}
-
-proc domktag {} {
- global mktagtop env tagids idtags
-
- set id [$mktagtop.sha1 get]
- set tag [$mktagtop.tag get]
- if {$tag == {}} {
- error_popup "No tag name specified"
- return
- }
- if {[info exists tagids($tag)]} {
- error_popup "Tag \"$tag\" already exists"
- return
- }
- if {[catch {
- set dir [gitdir]
- set fname [file join $dir "refs/tags" $tag]
- set f [open $fname w]
- puts $f $id
- close $f
- } err]} {
- error_popup "Error creating tag: $err"
- return
- }
-
- set tagids($tag) $id
- lappend idtags($id) $tag
- redrawtags $id
- addedtag $id
- dispneartags 0
- run refill_reflist
-}
-
-proc redrawtags {id} {
- global canv linehtag commitrow idpos selectedline curview
- global canvxmax iddrawn
-
- if {![info exists commitrow($curview,$id)]} return
- if {![info exists iddrawn($id)]} return
- drawcommits $commitrow($curview,$id)
- $canv delete tag.$id
- set xt [eval drawtags $id $idpos($id)]
- $canv coords $linehtag($commitrow($curview,$id)) $xt [lindex $idpos($id) 2]
- set text [$canv itemcget $linehtag($commitrow($curview,$id)) -text]
- set xr [expr {$xt + [font measure mainfont $text]}]
- if {$xr > $canvxmax} {
- set canvxmax $xr
- setcanvscroll
- }
- if {[info exists selectedline]
- && $selectedline == $commitrow($curview,$id)} {
- selectline $selectedline 0
- }
-}
-
-proc mktagcan {} {
- global mktagtop
-
- catch {destroy $mktagtop}
- unset mktagtop
-}
-
-proc mktaggo {} {
- domktag
- mktagcan
-}
-
-proc writecommit {} {
- global rowmenuid wrcomtop commitinfo wrcomcmd
-
- set top .writecommit
- set wrcomtop $top
- catch {destroy $top}
- toplevel $top
- label $top.title -text "Write commit to file"
- grid $top.title - -pady 10
- label $top.id -text "ID:"
- entry $top.sha1 -width 40 -relief flat
- $top.sha1 insert 0 $rowmenuid
- $top.sha1 conf -state readonly
- grid $top.id $top.sha1 -sticky w
- entry $top.head -width 60 -relief flat
- $top.head insert 0 [lindex $commitinfo($rowmenuid) 0]
- $top.head conf -state readonly
- grid x $top.head -sticky w
- label $top.clab -text "Command:"
- entry $top.cmd -width 60 -textvariable wrcomcmd
- grid $top.clab $top.cmd -sticky w -pady 10
- label $top.flab -text "Output file:"
- entry $top.fname -width 60
- $top.fname insert 0 [file normalize "commit-[string range $rowmenuid 0 6]"]
- grid $top.flab $top.fname -sticky w
- frame $top.buts
- button $top.buts.gen -text "Write" -command wrcomgo
- button $top.buts.can -text "Cancel" -command wrcomcan
- grid $top.buts.gen $top.buts.can
- grid columnconfigure $top.buts 0 -weight 1 -uniform a
- grid columnconfigure $top.buts 1 -weight 1 -uniform a
- grid $top.buts - -pady 10 -sticky ew
- focus $top.fname
-}
-
-proc wrcomgo {} {
- global wrcomtop
-
- set id [$wrcomtop.sha1 get]
- set cmd "echo $id | [$wrcomtop.cmd get]"
- set fname [$wrcomtop.fname get]
- if {[catch {exec sh -c $cmd >$fname &} err]} {
- error_popup "Error writing commit: $err"
- }
- catch {destroy $wrcomtop}
- unset wrcomtop
-}
-
-proc wrcomcan {} {
- global wrcomtop
-
- catch {destroy $wrcomtop}
- unset wrcomtop
-}
-
-proc mkbranch {} {
- global rowmenuid mkbrtop
-
- set top .makebranch
- catch {destroy $top}
- toplevel $top
- label $top.title -text "Create new branch"
- grid $top.title - -pady 10
- label $top.id -text "ID:"
- entry $top.sha1 -width 40 -relief flat
- $top.sha1 insert 0 $rowmenuid
- $top.sha1 conf -state readonly
- grid $top.id $top.sha1 -sticky w
- label $top.nlab -text "Name:"
- entry $top.name -width 40
- grid $top.nlab $top.name -sticky w
- frame $top.buts
- button $top.buts.go -text "Create" -command [list mkbrgo $top]
- button $top.buts.can -text "Cancel" -command "catch {destroy $top}"
- grid $top.buts.go $top.buts.can
- grid columnconfigure $top.buts 0 -weight 1 -uniform a
- grid columnconfigure $top.buts 1 -weight 1 -uniform a
- grid $top.buts - -pady 10 -sticky ew
- focus $top.name
-}
-
-proc mkbrgo {top} {
- global headids idheads
-
- set name [$top.name get]
- set id [$top.sha1 get]
- if {$name eq {}} {
- error_popup "Please specify a name for the new branch"
- return
- }
- catch {destroy $top}
- nowbusy newbranch
- update
- if {[catch {
- exec git branch $name $id
- } err]} {
- notbusy newbranch
- error_popup $err
- } else {
- set headids($name) $id
- lappend idheads($id) $name
- addedhead $id $name
- notbusy newbranch
- redrawtags $id
- dispneartags 0
- run refill_reflist
- }
-}
-
-proc cherrypick {} {
- global rowmenuid curview commitrow
- global mainhead
-
- set oldhead [exec git rev-parse HEAD]
- set dheads [descheads $rowmenuid]
- if {$dheads ne {} && [lsearch -exact $dheads $oldhead] >= 0} {
- set ok [confirm_popup "Commit [string range $rowmenuid 0 7] is already\
- included in branch $mainhead -- really re-apply it?"]
- if {!$ok} return
- }
- nowbusy cherrypick "Cherry-picking"
- update
- # Unfortunately git-cherry-pick writes stuff to stderr even when
- # no error occurs, and exec takes that as an indication of error...
- if {[catch {exec sh -c "git cherry-pick -r $rowmenuid 2>&1"} err]} {
- notbusy cherrypick
- error_popup $err
- return
- }
- set newhead [exec git rev-parse HEAD]
- if {$newhead eq $oldhead} {
- notbusy cherrypick
- error_popup "No changes committed"
- return
- }
- addnewchild $newhead $oldhead
- if {[info exists commitrow($curview,$oldhead)]} {
- insertrow $commitrow($curview,$oldhead) $newhead
- if {$mainhead ne {}} {
- movehead $newhead $mainhead
- movedhead $newhead $mainhead
- }
- redrawtags $oldhead
- redrawtags $newhead
- }
- notbusy cherrypick
-}
-
-proc resethead {} {
- global mainheadid mainhead rowmenuid confirm_ok resettype
-
- set confirm_ok 0
- set w ".confirmreset"
- toplevel $w
- wm transient $w .
- wm title $w "Confirm reset"
- message $w.m -text \
- "Reset branch $mainhead to [string range $rowmenuid 0 7]?" \
- -justify center -aspect 1000
- pack $w.m -side top -fill x -padx 20 -pady 20
- frame $w.f -relief sunken -border 2
- message $w.f.rt -text "Reset type:" -aspect 1000
- grid $w.f.rt -sticky w
- set resettype mixed
- radiobutton $w.f.soft -value soft -variable resettype -justify left \
- -text "Soft: Leave working tree and index untouched"
- grid $w.f.soft -sticky w
- radiobutton $w.f.mixed -value mixed -variable resettype -justify left \
- -text "Mixed: Leave working tree untouched, reset index"
- grid $w.f.mixed -sticky w
- radiobutton $w.f.hard -value hard -variable resettype -justify left \
- -text "Hard: Reset working tree and index\n(discard ALL local changes)"
- grid $w.f.hard -sticky w
- pack $w.f -side top -fill x
- button $w.ok -text OK -command "set confirm_ok 1; destroy $w"
- pack $w.ok -side left -fill x -padx 20 -pady 20
- button $w.cancel -text Cancel -command "destroy $w"
- pack $w.cancel -side right -fill x -padx 20 -pady 20
- bind $w <Visibility> "grab $w; focus $w"
- tkwait window $w
- if {!$confirm_ok} return
- if {[catch {set fd [open \
- [list | sh -c "git reset --$resettype $rowmenuid 2>&1"] r]} err]} {
- error_popup $err
- } else {
- dohidelocalchanges
- filerun $fd [list readresetstat $fd]
- nowbusy reset "Resetting"
- }
-}
-
-proc readresetstat {fd} {
- global mainhead mainheadid showlocalchanges rprogcoord
-
- if {[gets $fd line] >= 0} {
- if {[regexp {([0-9]+)% \(([0-9]+)/([0-9]+)\)} $line match p m n]} {
- set rprogcoord [expr {1.0 * $m / $n}]
- adjustprogress
- }
- return 1
- }
- set rprogcoord 0
- adjustprogress
- notbusy reset
- if {[catch {close $fd} err]} {
- error_popup $err
- }
- set oldhead $mainheadid
- set newhead [exec git rev-parse HEAD]
- if {$newhead ne $oldhead} {
- movehead $newhead $mainhead
- movedhead $newhead $mainhead
- set mainheadid $newhead
- redrawtags $oldhead
- redrawtags $newhead
- }
- if {$showlocalchanges} {
- doshowlocalchanges
- }
- return 0
-}
-
-# context menu for a head
-proc headmenu {x y id head} {
- global headmenuid headmenuhead headctxmenu mainhead
-
- stopfinding
- set headmenuid $id
- set headmenuhead $head
- set state normal
- if {$head eq $mainhead} {
- set state disabled
- }
- $headctxmenu entryconfigure 0 -state $state
- $headctxmenu entryconfigure 1 -state $state
- tk_popup $headctxmenu $x $y
-}
-
-proc cobranch {} {
- global headmenuid headmenuhead mainhead headids
- global showlocalchanges mainheadid
-
- # check the tree is clean first??
- set oldmainhead $mainhead
- nowbusy checkout "Checking out"
- update
- dohidelocalchanges
- if {[catch {
- exec git checkout -q $headmenuhead
- } err]} {
- notbusy checkout
- error_popup $err
- } else {
- notbusy checkout
- set mainhead $headmenuhead
- set mainheadid $headmenuid
- if {[info exists headids($oldmainhead)]} {
- redrawtags $headids($oldmainhead)
- }
- redrawtags $headmenuid
- }
- if {$showlocalchanges} {
- dodiffindex
- }
-}
-
-proc rmbranch {} {
- global headmenuid headmenuhead mainhead
- global idheads
-
- set head $headmenuhead
- set id $headmenuid
- # this check shouldn't be needed any more...
- if {$head eq $mainhead} {
- error_popup "Cannot delete the currently checked-out branch"
- return
- }
- set dheads [descheads $id]
- if {[llength $dheads] == 1 && $idheads($dheads) eq $head} {
- # the stuff on this branch isn't on any other branch
- if {![confirm_popup "The commits on branch $head aren't on any other\
- branch.\nReally delete branch $head?"]} return
- }
- nowbusy rmbranch
- update
- if {[catch {exec git branch -D $head} err]} {
- notbusy rmbranch
- error_popup $err
- return
- }
- removehead $id $head
- removedhead $id $head
- redrawtags $id
- notbusy rmbranch
- dispneartags 0
- run refill_reflist
-}
-
-# Display a list of tags and heads
-proc showrefs {} {
- global showrefstop bgcolor fgcolor selectbgcolor
- global bglist fglist reflistfilter reflist maincursor
-
- set top .showrefs
- set showrefstop $top
- if {[winfo exists $top]} {
- raise $top
- refill_reflist
- return
- }
- toplevel $top
- wm title $top "Tags and heads: [file tail [pwd]]"
- text $top.list -background $bgcolor -foreground $fgcolor \
- -selectbackground $selectbgcolor -font mainfont \
- -xscrollcommand "$top.xsb set" -yscrollcommand "$top.ysb set" \
- -width 30 -height 20 -cursor $maincursor \
- -spacing1 1 -spacing3 1 -state disabled
- $top.list tag configure highlight -background $selectbgcolor
- lappend bglist $top.list
- lappend fglist $top.list
- scrollbar $top.ysb -command "$top.list yview" -orient vertical
- scrollbar $top.xsb -command "$top.list xview" -orient horizontal
- grid $top.list $top.ysb -sticky nsew
- grid $top.xsb x -sticky ew
- frame $top.f
- label $top.f.l -text "Filter: " -font uifont
- entry $top.f.e -width 20 -textvariable reflistfilter -font uifont
- set reflistfilter "*"
- trace add variable reflistfilter write reflistfilter_change
- pack $top.f.e -side right -fill x -expand 1
- pack $top.f.l -side left
- grid $top.f - -sticky ew -pady 2
- button $top.close -command [list destroy $top] -text "Close" \
- -font uifont
- grid $top.close -
- grid columnconfigure $top 0 -weight 1
- grid rowconfigure $top 0 -weight 1
- bind $top.list <1> {break}
- bind $top.list <B1-Motion> {break}
- bind $top.list <ButtonRelease-1> {sel_reflist %W %x %y; break}
- set reflist {}
- refill_reflist
-}
-
-proc sel_reflist {w x y} {
- global showrefstop reflist headids tagids otherrefids
-
- if {![winfo exists $showrefstop]} return
- set l [lindex [split [$w index "@$x,$y"] "."] 0]
- set ref [lindex $reflist [expr {$l-1}]]
- set n [lindex $ref 0]
- switch -- [lindex $ref 1] {
- "H" {selbyid $headids($n)}
- "T" {selbyid $tagids($n)}
- "o" {selbyid $otherrefids($n)}
- }
- $showrefstop.list tag add highlight $l.0 "$l.0 lineend"
-}
-
-proc unsel_reflist {} {
- global showrefstop
-
- if {![info exists showrefstop] || ![winfo exists $showrefstop]} return
- $showrefstop.list tag remove highlight 0.0 end
-}
-
-proc reflistfilter_change {n1 n2 op} {
- global reflistfilter
-
- after cancel refill_reflist
- after 200 refill_reflist
-}
-
-proc refill_reflist {} {
- global reflist reflistfilter showrefstop headids tagids otherrefids
- global commitrow curview commitinterest
-
- if {![info exists showrefstop] || ![winfo exists $showrefstop]} return
- set refs {}
- foreach n [array names headids] {
- if {[string match $reflistfilter $n]} {
- if {[info exists commitrow($curview,$headids($n))]} {
- lappend refs [list $n H]
- } else {
- set commitinterest($headids($n)) {run refill_reflist}
- }
- }
- }
- foreach n [array names tagids] {
- if {[string match $reflistfilter $n]} {
- if {[info exists commitrow($curview,$tagids($n))]} {
- lappend refs [list $n T]
- } else {
- set commitinterest($tagids($n)) {run refill_reflist}
- }
- }
- }
- foreach n [array names otherrefids] {
- if {[string match $reflistfilter $n]} {
- if {[info exists commitrow($curview,$otherrefids($n))]} {
- lappend refs [list $n o]
- } else {
- set commitinterest($otherrefids($n)) {run refill_reflist}
- }
- }
- }
- set refs [lsort -index 0 $refs]
- if {$refs eq $reflist} return
-
- # Update the contents of $showrefstop.list according to the
- # differences between $reflist (old) and $refs (new)
- $showrefstop.list conf -state normal
- $showrefstop.list insert end "\n"
- set i 0
- set j 0
- while {$i < [llength $reflist] || $j < [llength $refs]} {
- if {$i < [llength $reflist]} {
- if {$j < [llength $refs]} {
- set cmp [string compare [lindex $reflist $i 0] \
- [lindex $refs $j 0]]
- if {$cmp == 0} {
- set cmp [string compare [lindex $reflist $i 1] \
- [lindex $refs $j 1]]
- }
- } else {
- set cmp -1
- }
- } else {
- set cmp 1
- }
- switch -- $cmp {
- -1 {
- $showrefstop.list delete "[expr {$j+1}].0" "[expr {$j+2}].0"
- incr i
- }
- 0 {
- incr i
- incr j
- }
- 1 {
- set l [expr {$j + 1}]
- $showrefstop.list image create $l.0 -align baseline \
- -image reficon-[lindex $refs $j 1] -padx 2
- $showrefstop.list insert $l.1 "[lindex $refs $j 0]\n"
- incr j
- }
- }
- }
- set reflist $refs
- # delete last newline
- $showrefstop.list delete end-2c end-1c
- $showrefstop.list conf -state disabled
-}
-
-# Stuff for finding nearby tags
-proc getallcommits {} {
- global allcommits nextarc seeds allccache allcwait cachedarcs allcupdate
- global idheads idtags idotherrefs allparents tagobjid
-
- if {![info exists allcommits]} {
- set nextarc 0
- set allcommits 0
- set seeds {}
- set allcwait 0
- set cachedarcs 0
- set allccache [file join [gitdir] "gitk.cache"]
- if {![catch {
- set f [open $allccache r]
- set allcwait 1
- getcache $f
- }]} return
- }
-
- if {$allcwait} {
- return
- }
- set cmd [list | git rev-list --parents]
- set allcupdate [expr {$seeds ne {}}]
- if {!$allcupdate} {
- set ids "--all"
- } else {
- set refs [concat [array names idheads] [array names idtags] \
- [array names idotherrefs]]
- set ids {}
- set tagobjs {}
- foreach name [array names tagobjid] {
- lappend tagobjs $tagobjid($name)
- }
- foreach id [lsort -unique $refs] {
- if {![info exists allparents($id)] &&
- [lsearch -exact $tagobjs $id] < 0} {
- lappend ids $id
- }
- }
- if {$ids ne {}} {
- foreach id $seeds {
- lappend ids "^$id"
- }
- }
- }
- if {$ids ne {}} {
- set fd [open [concat $cmd $ids] r]
- fconfigure $fd -blocking 0
- incr allcommits
- nowbusy allcommits
- filerun $fd [list getallclines $fd]
- } else {
- dispneartags 0
- }
-}
-
-# Since most commits have 1 parent and 1 child, we group strings of
-# such commits into "arcs" joining branch/merge points (BMPs), which
-# are commits that either don't have 1 parent or don't have 1 child.
-#
-# arcnos(id) - incoming arcs for BMP, arc we're on for other nodes
-# arcout(id) - outgoing arcs for BMP
-# arcids(a) - list of IDs on arc including end but not start
-# arcstart(a) - BMP ID at start of arc
-# arcend(a) - BMP ID at end of arc
-# growing(a) - arc a is still growing
-# arctags(a) - IDs out of arcids (excluding end) that have tags
-# archeads(a) - IDs out of arcids (excluding end) that have heads
-# The start of an arc is at the descendent end, so "incoming" means
-# coming from descendents, and "outgoing" means going towards ancestors.
-
-proc getallclines {fd} {
- global allparents allchildren idtags idheads nextarc
- global arcnos arcids arctags arcout arcend arcstart archeads growing
- global seeds allcommits cachedarcs allcupdate
-
- set nid 0
- while {[incr nid] <= 1000 && [gets $fd line] >= 0} {
- set id [lindex $line 0]
- if {[info exists allparents($id)]} {
- # seen it already
- continue
- }
- set cachedarcs 0
- set olds [lrange $line 1 end]
- set allparents($id) $olds
- if {![info exists allchildren($id)]} {
- set allchildren($id) {}
- set arcnos($id) {}
- lappend seeds $id
- } else {
- set a $arcnos($id)
- if {[llength $olds] == 1 && [llength $a] == 1} {
- lappend arcids($a) $id
- if {[info exists idtags($id)]} {
- lappend arctags($a) $id
- }
- if {[info exists idheads($id)]} {
- lappend archeads($a) $id
- }
- if {[info exists allparents($olds)]} {
- # seen parent already
- if {![info exists arcout($olds)]} {
- splitarc $olds
- }
- lappend arcids($a) $olds
- set arcend($a) $olds
- unset growing($a)
- }
- lappend allchildren($olds) $id
- lappend arcnos($olds) $a
- continue
- }
- }
- foreach a $arcnos($id) {
- lappend arcids($a) $id
- set arcend($a) $id
- unset growing($a)
- }
-
- set ao {}
- foreach p $olds {
- lappend allchildren($p) $id
- set a [incr nextarc]
- set arcstart($a) $id
- set archeads($a) {}
- set arctags($a) {}
- set archeads($a) {}
- set arcids($a) {}
- lappend ao $a
- set growing($a) 1
- if {[info exists allparents($p)]} {
- # seen it already, may need to make a new branch
- if {![info exists arcout($p)]} {
- splitarc $p
- }
- lappend arcids($a) $p
- set arcend($a) $p
- unset growing($a)
- }
- lappend arcnos($p) $a
- }
- set arcout($id) $ao
- }
- if {$nid > 0} {
- global cached_dheads cached_dtags cached_atags
- catch {unset cached_dheads}
- catch {unset cached_dtags}
- catch {unset cached_atags}
- }
- if {![eof $fd]} {
- return [expr {$nid >= 1000? 2: 1}]
- }
- set cacheok 1
- if {[catch {
- fconfigure $fd -blocking 1
- close $fd
- } err]} {
- # got an error reading the list of commits
- # if we were updating, try rereading the whole thing again
- if {$allcupdate} {
- incr allcommits -1
- dropcache $err
- return
- }
- error_popup "Error reading commit topology information;\
- branch and preceding/following tag information\
- will be incomplete.\n($err)"
- set cacheok 0
- }
- if {[incr allcommits -1] == 0} {
- notbusy allcommits
- if {$cacheok} {
- run savecache
- }
- }
- dispneartags 0
- return 0
-}
-
-proc recalcarc {a} {
- global arctags archeads arcids idtags idheads
-
- set at {}
- set ah {}
- foreach id [lrange $arcids($a) 0 end-1] {
- if {[info exists idtags($id)]} {
- lappend at $id
- }
- if {[info exists idheads($id)]} {
- lappend ah $id
- }
- }
- set arctags($a) $at
- set archeads($a) $ah
-}
-
-proc splitarc {p} {
- global arcnos arcids nextarc arctags archeads idtags idheads
- global arcstart arcend arcout allparents growing
-
- set a $arcnos($p)
- if {[llength $a] != 1} {
- puts "oops splitarc called but [llength $a] arcs already"
- return
- }
- set a [lindex $a 0]
- set i [lsearch -exact $arcids($a) $p]
- if {$i < 0} {
- puts "oops splitarc $p not in arc $a"
- return
- }
- set na [incr nextarc]
- if {[info exists arcend($a)]} {
- set arcend($na) $arcend($a)
- } else {
- set l [lindex $allparents([lindex $arcids($a) end]) 0]
- set j [lsearch -exact $arcnos($l) $a]
- set arcnos($l) [lreplace $arcnos($l) $j $j $na]
- }
- set tail [lrange $arcids($a) [expr {$i+1}] end]
- set arcids($a) [lrange $arcids($a) 0 $i]
- set arcend($a) $p
- set arcstart($na) $p
- set arcout($p) $na
- set arcids($na) $tail
- if {[info exists growing($a)]} {
- set growing($na) 1
- unset growing($a)
- }
-
- foreach id $tail {
- if {[llength $arcnos($id)] == 1} {
- set arcnos($id) $na
- } else {
- set j [lsearch -exact $arcnos($id) $a]
- set arcnos($id) [lreplace $arcnos($id) $j $j $na]
- }
- }
-
- # reconstruct tags and heads lists
- if {$arctags($a) ne {} || $archeads($a) ne {}} {
- recalcarc $a
- recalcarc $na
- } else {
- set arctags($na) {}
- set archeads($na) {}
- }
-}
-
-# Update things for a new commit added that is a child of one
-# existing commit. Used when cherry-picking.
-proc addnewchild {id p} {
- global allparents allchildren idtags nextarc
- global arcnos arcids arctags arcout arcend arcstart archeads growing
- global seeds allcommits
-
- if {![info exists allcommits] || ![info exists arcnos($p)]} return
- set allparents($id) [list $p]
- set allchildren($id) {}
- set arcnos($id) {}
- lappend seeds $id
- lappend allchildren($p) $id
- set a [incr nextarc]
- set arcstart($a) $id
- set archeads($a) {}
- set arctags($a) {}
- set arcids($a) [list $p]
- set arcend($a) $p
- if {![info exists arcout($p)]} {
- splitarc $p
- }
- lappend arcnos($p) $a
- set arcout($id) [list $a]
-}
-
-# This implements a cache for the topology information.
-# The cache saves, for each arc, the start and end of the arc,
-# the ids on the arc, and the outgoing arcs from the end.
-proc readcache {f} {
- global arcnos arcids arcout arcstart arcend arctags archeads nextarc
- global idtags idheads allparents cachedarcs possible_seeds seeds growing
- global allcwait
-
- set a $nextarc
- set lim $cachedarcs
- if {$lim - $a > 500} {
- set lim [expr {$a + 500}]
- }
- if {[catch {
- if {$a == $lim} {
- # finish reading the cache and setting up arctags, etc.
- set line [gets $f]
- if {$line ne "1"} {error "bad final version"}
- close $f
- foreach id [array names idtags] {
- if {[info exists arcnos($id)] && [llength $arcnos($id)] == 1 &&
- [llength $allparents($id)] == 1} {
- set a [lindex $arcnos($id) 0]
- if {$arctags($a) eq {}} {
- recalcarc $a
- }
- }
- }
- foreach id [array names idheads] {
- if {[info exists arcnos($id)] && [llength $arcnos($id)] == 1 &&
- [llength $allparents($id)] == 1} {
- set a [lindex $arcnos($id) 0]
- if {$archeads($a) eq {}} {
- recalcarc $a
- }
- }
- }
- foreach id [lsort -unique $possible_seeds] {
- if {$arcnos($id) eq {}} {
- lappend seeds $id
- }
- }
- set allcwait 0
- } else {
- while {[incr a] <= $lim} {
- set line [gets $f]
- if {[llength $line] != 3} {error "bad line"}
- set s [lindex $line 0]
- set arcstart($a) $s
- lappend arcout($s) $a
- if {![info exists arcnos($s)]} {
- lappend possible_seeds $s
- set arcnos($s) {}
- }
- set e [lindex $line 1]
- if {$e eq {}} {
- set growing($a) 1
- } else {
- set arcend($a) $e
- if {![info exists arcout($e)]} {
- set arcout($e) {}
- }
- }
- set arcids($a) [lindex $line 2]
- foreach id $arcids($a) {
- lappend allparents($s) $id
- set s $id
- lappend arcnos($id) $a
- }
- if {![info exists allparents($s)]} {
- set allparents($s) {}
- }
- set arctags($a) {}
- set archeads($a) {}
- }
- set nextarc [expr {$a - 1}]
- }
- } err]} {
- dropcache $err
- return 0
- }
- if {!$allcwait} {
- getallcommits
- }
- return $allcwait
-}
-
-proc getcache {f} {
- global nextarc cachedarcs possible_seeds
-
- if {[catch {
- set line [gets $f]
- if {[llength $line] != 2 || [lindex $line 0] ne "1"} {error "bad version"}
- # make sure it's an integer
- set cachedarcs [expr {int([lindex $line 1])}]
- if {$cachedarcs < 0} {error "bad number of arcs"}
- set nextarc 0
- set possible_seeds {}
- run readcache $f
- } err]} {
- dropcache $err
- }
- return 0
-}
-
-proc dropcache {err} {
- global allcwait nextarc cachedarcs seeds
-
- #puts "dropping cache ($err)"
- foreach v {arcnos arcout arcids arcstart arcend growing \
- arctags archeads allparents allchildren} {
- global $v
- catch {unset $v}
- }
- set allcwait 0
- set nextarc 0
- set cachedarcs 0
- set seeds {}
- getallcommits
-}
-
-proc writecache {f} {
- global cachearc cachedarcs allccache
- global arcstart arcend arcnos arcids arcout
-
- set a $cachearc
- set lim $cachedarcs
- if {$lim - $a > 1000} {
- set lim [expr {$a + 1000}]
- }
- if {[catch {
- while {[incr a] <= $lim} {
- if {[info exists arcend($a)]} {
- puts $f [list $arcstart($a) $arcend($a) $arcids($a)]
- } else {
- puts $f [list $arcstart($a) {} $arcids($a)]
- }
- }
- } err]} {
- catch {close $f}
- catch {file delete $allccache}
- #puts "writing cache failed ($err)"
- return 0
- }
- set cachearc [expr {$a - 1}]
- if {$a > $cachedarcs} {
- puts $f "1"
- close $f
- return 0
- }
- return 1
-}
-
-proc savecache {} {
- global nextarc cachedarcs cachearc allccache
-
- if {$nextarc == $cachedarcs} return
- set cachearc 0
- set cachedarcs $nextarc
- catch {
- set f [open $allccache w]
- puts $f [list 1 $cachedarcs]
- run writecache $f
- }
-}
-
-# Returns 1 if a is an ancestor of b, -1 if b is an ancestor of a,
-# or 0 if neither is true.
-proc anc_or_desc {a b} {
- global arcout arcstart arcend arcnos cached_isanc
-
- if {$arcnos($a) eq $arcnos($b)} {
- # Both are on the same arc(s); either both are the same BMP,
- # or if one is not a BMP, the other is also not a BMP or is
- # the BMP at end of the arc (and it only has 1 incoming arc).
- # Or both can be BMPs with no incoming arcs.
- if {$a eq $b || $arcnos($a) eq {}} {
- return 0
- }
- # assert {[llength $arcnos($a)] == 1}
- set arc [lindex $arcnos($a) 0]
- set i [lsearch -exact $arcids($arc) $a]
- set j [lsearch -exact $arcids($arc) $b]
- if {$i < 0 || $i > $j} {
- return 1
- } else {
- return -1
- }
- }
-
- if {![info exists arcout($a)]} {
- set arc [lindex $arcnos($a) 0]
- if {[info exists arcend($arc)]} {
- set aend $arcend($arc)
- } else {
- set aend {}
- }
- set a $arcstart($arc)
- } else {
- set aend $a
- }
- if {![info exists arcout($b)]} {
- set arc [lindex $arcnos($b) 0]
- if {[info exists arcend($arc)]} {
- set bend $arcend($arc)
- } else {
- set bend {}
- }
- set b $arcstart($arc)
- } else {
- set bend $b
- }
- if {$a eq $bend} {
- return 1
- }
- if {$b eq $aend} {
- return -1
- }
- if {[info exists cached_isanc($a,$bend)]} {
- if {$cached_isanc($a,$bend)} {
- return 1
- }
- }
- if {[info exists cached_isanc($b,$aend)]} {
- if {$cached_isanc($b,$aend)} {
- return -1
- }
- if {[info exists cached_isanc($a,$bend)]} {
- return 0
- }
- }
-
- set todo [list $a $b]
- set anc($a) a
- set anc($b) b
- for {set i 0} {$i < [llength $todo]} {incr i} {
- set x [lindex $todo $i]
- if {$anc($x) eq {}} {
- continue
- }
- foreach arc $arcnos($x) {
- set xd $arcstart($arc)
- if {$xd eq $bend} {
- set cached_isanc($a,$bend) 1
- set cached_isanc($b,$aend) 0
- return 1
- } elseif {$xd eq $aend} {
- set cached_isanc($b,$aend) 1
- set cached_isanc($a,$bend) 0
- return -1
- }
- if {![info exists anc($xd)]} {
- set anc($xd) $anc($x)
- lappend todo $xd
- } elseif {$anc($xd) ne $anc($x)} {
- set anc($xd) {}
- }
- }
- }
- set cached_isanc($a,$bend) 0
- set cached_isanc($b,$aend) 0
- return 0
-}
-
-# This identifies whether $desc has an ancestor that is
-# a growing tip of the graph and which is not an ancestor of $anc
-# and returns 0 if so and 1 if not.
-# If we subsequently discover a tag on such a growing tip, and that
-# turns out to be a descendent of $anc (which it could, since we
-# don't necessarily see children before parents), then $desc
-# isn't a good choice to display as a descendent tag of
-# $anc (since it is the descendent of another tag which is
-# a descendent of $anc). Similarly, $anc isn't a good choice to
-# display as a ancestor tag of $desc.
-#
-proc is_certain {desc anc} {
- global arcnos arcout arcstart arcend growing problems
-
- set certain {}
- if {[llength $arcnos($anc)] == 1} {
- # tags on the same arc are certain
- if {$arcnos($desc) eq $arcnos($anc)} {
- return 1
- }
- if {![info exists arcout($anc)]} {
- # if $anc is partway along an arc, use the start of the arc instead
- set a [lindex $arcnos($anc) 0]
- set anc $arcstart($a)
- }
- }
- if {[llength $arcnos($desc)] > 1 || [info exists arcout($desc)]} {
- set x $desc
- } else {
- set a [lindex $arcnos($desc) 0]
- set x $arcend($a)
- }
- if {$x == $anc} {
- return 1
- }
- set anclist [list $x]
- set dl($x) 1
- set nnh 1
- set ngrowanc 0
- for {set i 0} {$i < [llength $anclist] && ($nnh > 0 || $ngrowanc > 0)} {incr i} {
- set x [lindex $anclist $i]
- if {$dl($x)} {
- incr nnh -1
- }
- set done($x) 1
- foreach a $arcout($x) {
- if {[info exists growing($a)]} {
- if {![info exists growanc($x)] && $dl($x)} {
- set growanc($x) 1
- incr ngrowanc
- }
- } else {
- set y $arcend($a)
- if {[info exists dl($y)]} {
- if {$dl($y)} {
- if {!$dl($x)} {
- set dl($y) 0
- if {![info exists done($y)]} {
- incr nnh -1
- }
- if {[info exists growanc($x)]} {
- incr ngrowanc -1
- }
- set xl [list $y]
- for {set k 0} {$k < [llength $xl]} {incr k} {
- set z [lindex $xl $k]
- foreach c $arcout($z) {
- if {[info exists arcend($c)]} {
- set v $arcend($c)
- if {[info exists dl($v)] && $dl($v)} {
- set dl($v) 0
- if {![info exists done($v)]} {
- incr nnh -1
- }
- if {[info exists growanc($v)]} {
- incr ngrowanc -1
- }
- lappend xl $v
- }
- }
- }
- }
- }
- }
- } elseif {$y eq $anc || !$dl($x)} {
- set dl($y) 0
- lappend anclist $y
- } else {
- set dl($y) 1
- lappend anclist $y
- incr nnh
- }
- }
- }
- }
- foreach x [array names growanc] {
- if {$dl($x)} {
- return 0
- }
- return 0
- }
- return 1
-}
-
-proc validate_arctags {a} {
- global arctags idtags
-
- set i -1
- set na $arctags($a)
- foreach id $arctags($a) {
- incr i
- if {![info exists idtags($id)]} {
- set na [lreplace $na $i $i]
- incr i -1
- }
- }
- set arctags($a) $na
-}
-
-proc validate_archeads {a} {
- global archeads idheads
-
- set i -1
- set na $archeads($a)
- foreach id $archeads($a) {
- incr i
- if {![info exists idheads($id)]} {
- set na [lreplace $na $i $i]
- incr i -1
- }
- }
- set archeads($a) $na
-}
-
-# Return the list of IDs that have tags that are descendents of id,
-# ignoring IDs that are descendents of IDs already reported.
-proc desctags {id} {
- global arcnos arcstart arcids arctags idtags allparents
- global growing cached_dtags
-
- if {![info exists allparents($id)]} {
- return {}
- }
- set t1 [clock clicks -milliseconds]
- set argid $id
- if {[llength $arcnos($id)] == 1 && [llength $allparents($id)] == 1} {
- # part-way along an arc; check that arc first
- set a [lindex $arcnos($id) 0]
- if {$arctags($a) ne {}} {
- validate_arctags $a
- set i [lsearch -exact $arcids($a) $id]
- set tid {}
- foreach t $arctags($a) {
- set j [lsearch -exact $arcids($a) $t]
- if {$j >= $i} break
- set tid $t
- }
- if {$tid ne {}} {
- return $tid
- }
- }
- set id $arcstart($a)
- if {[info exists idtags($id)]} {
- return $id
- }
- }
- if {[info exists cached_dtags($id)]} {
- return $cached_dtags($id)
- }
-
- set origid $id
- set todo [list $id]
- set queued($id) 1
- set nc 1
- for {set i 0} {$i < [llength $todo] && $nc > 0} {incr i} {
- set id [lindex $todo $i]
- set done($id) 1
- set ta [info exists hastaggedancestor($id)]
- if {!$ta} {
- incr nc -1
- }
- # ignore tags on starting node
- if {!$ta && $i > 0} {
- if {[info exists idtags($id)]} {
- set tagloc($id) $id
- set ta 1
- } elseif {[info exists cached_dtags($id)]} {
- set tagloc($id) $cached_dtags($id)
- set ta 1
- }
- }
- foreach a $arcnos($id) {
- set d $arcstart($a)
- if {!$ta && $arctags($a) ne {}} {
- validate_arctags $a
- if {$arctags($a) ne {}} {
- lappend tagloc($id) [lindex $arctags($a) end]
- }
- }
- if {$ta || $arctags($a) ne {}} {
- set tomark [list $d]
- for {set j 0} {$j < [llength $tomark]} {incr j} {
- set dd [lindex $tomark $j]
- if {![info exists hastaggedancestor($dd)]} {
- if {[info exists done($dd)]} {
- foreach b $arcnos($dd) {
- lappend tomark $arcstart($b)
- }
- if {[info exists tagloc($dd)]} {
- unset tagloc($dd)
- }
- } elseif {[info exists queued($dd)]} {
- incr nc -1
- }
- set hastaggedancestor($dd) 1
- }
- }
- }
- if {![info exists queued($d)]} {
- lappend todo $d
- set queued($d) 1
- if {![info exists hastaggedancestor($d)]} {
- incr nc
- }
- }
- }
- }
- set tags {}
- foreach id [array names tagloc] {
- if {![info exists hastaggedancestor($id)]} {
- foreach t $tagloc($id) {
- if {[lsearch -exact $tags $t] < 0} {
- lappend tags $t
- }
- }
- }
- }
- set t2 [clock clicks -milliseconds]
- set loopix $i
-
- # remove tags that are descendents of other tags
- for {set i 0} {$i < [llength $tags]} {incr i} {
- set a [lindex $tags $i]
- for {set j 0} {$j < $i} {incr j} {
- set b [lindex $tags $j]
- set r [anc_or_desc $a $b]
- if {$r == 1} {
- set tags [lreplace $tags $j $j]
- incr j -1
- incr i -1
- } elseif {$r == -1} {
- set tags [lreplace $tags $i $i]
- incr i -1
- break
- }
- }
- }
-
- if {[array names growing] ne {}} {
- # graph isn't finished, need to check if any tag could get
- # eclipsed by another tag coming later. Simply ignore any
- # tags that could later get eclipsed.
- set ctags {}
- foreach t $tags {
- if {[is_certain $t $origid]} {
- lappend ctags $t
- }
- }
- if {$tags eq $ctags} {
- set cached_dtags($origid) $tags
- } else {
- set tags $ctags
- }
- } else {
- set cached_dtags($origid) $tags
- }
- set t3 [clock clicks -milliseconds]
- if {0 && $t3 - $t1 >= 100} {
- puts "iterating descendents ($loopix/[llength $todo] nodes) took\
- [expr {$t2-$t1}]+[expr {$t3-$t2}]ms, $nc candidates left"
- }
- return $tags
-}
-
-proc anctags {id} {
- global arcnos arcids arcout arcend arctags idtags allparents
- global growing cached_atags
-
- if {![info exists allparents($id)]} {
- return {}
- }
- set t1 [clock clicks -milliseconds]
- set argid $id
- if {[llength $arcnos($id)] == 1 && [llength $allparents($id)] == 1} {
- # part-way along an arc; check that arc first
- set a [lindex $arcnos($id) 0]
- if {$arctags($a) ne {}} {
- validate_arctags $a
- set i [lsearch -exact $arcids($a) $id]
- foreach t $arctags($a) {
- set j [lsearch -exact $arcids($a) $t]
- if {$j > $i} {
- return $t
- }
- }
- }
- if {![info exists arcend($a)]} {
- return {}
- }
- set id $arcend($a)
- if {[info exists idtags($id)]} {
- return $id
- }
- }
- if {[info exists cached_atags($id)]} {
- return $cached_atags($id)
- }
-
- set origid $id
- set todo [list $id]
- set queued($id) 1
- set taglist {}
- set nc 1
- for {set i 0} {$i < [llength $todo] && $nc > 0} {incr i} {
- set id [lindex $todo $i]
- set done($id) 1
- set td [info exists hastaggeddescendent($id)]
- if {!$td} {
- incr nc -1
- }
- # ignore tags on starting node
- if {!$td && $i > 0} {
- if {[info exists idtags($id)]} {
- set tagloc($id) $id
- set td 1
- } elseif {[info exists cached_atags($id)]} {
- set tagloc($id) $cached_atags($id)
- set td 1
- }
- }
- foreach a $arcout($id) {
- if {!$td && $arctags($a) ne {}} {
- validate_arctags $a
- if {$arctags($a) ne {}} {
- lappend tagloc($id) [lindex $arctags($a) 0]
- }
- }
- if {![info exists arcend($a)]} continue
- set d $arcend($a)
- if {$td || $arctags($a) ne {}} {
- set tomark [list $d]
- for {set j 0} {$j < [llength $tomark]} {incr j} {
- set dd [lindex $tomark $j]
- if {![info exists hastaggeddescendent($dd)]} {
- if {[info exists done($dd)]} {
- foreach b $arcout($dd) {
- if {[info exists arcend($b)]} {
- lappend tomark $arcend($b)
- }
- }
- if {[info exists tagloc($dd)]} {
- unset tagloc($dd)
- }
- } elseif {[info exists queued($dd)]} {
- incr nc -1
- }
- set hastaggeddescendent($dd) 1
- }
- }
- }
- if {![info exists queued($d)]} {
- lappend todo $d
- set queued($d) 1
- if {![info exists hastaggeddescendent($d)]} {
- incr nc
- }
- }
- }
- }
- set t2 [clock clicks -milliseconds]
- set loopix $i
- set tags {}
- foreach id [array names tagloc] {
- if {![info exists hastaggeddescendent($id)]} {
- foreach t $tagloc($id) {
- if {[lsearch -exact $tags $t] < 0} {
- lappend tags $t
- }
- }
- }
- }
-
- # remove tags that are ancestors of other tags
- for {set i 0} {$i < [llength $tags]} {incr i} {
- set a [lindex $tags $i]
- for {set j 0} {$j < $i} {incr j} {
- set b [lindex $tags $j]
- set r [anc_or_desc $a $b]
- if {$r == -1} {
- set tags [lreplace $tags $j $j]
- incr j -1
- incr i -1
- } elseif {$r == 1} {
- set tags [lreplace $tags $i $i]
- incr i -1
- break
- }
- }
- }
-
- if {[array names growing] ne {}} {
- # graph isn't finished, need to check if any tag could get
- # eclipsed by another tag coming later. Simply ignore any
- # tags that could later get eclipsed.
- set ctags {}
- foreach t $tags {
- if {[is_certain $origid $t]} {
- lappend ctags $t
- }
- }
- if {$tags eq $ctags} {
- set cached_atags($origid) $tags
- } else {
- set tags $ctags
- }
- } else {
- set cached_atags($origid) $tags
- }
- set t3 [clock clicks -milliseconds]
- if {0 && $t3 - $t1 >= 100} {
- puts "iterating ancestors ($loopix/[llength $todo] nodes) took\
- [expr {$t2-$t1}]+[expr {$t3-$t2}]ms, $nc candidates left"
- }
- return $tags
-}
-
-# Return the list of IDs that have heads that are descendents of id,
-# including id itself if it has a head.
-proc descheads {id} {
- global arcnos arcstart arcids archeads idheads cached_dheads
- global allparents
-
- if {![info exists allparents($id)]} {
- return {}
- }
- set aret {}
- if {[llength $arcnos($id)] == 1 && [llength $allparents($id)] == 1} {
- # part-way along an arc; check it first
- set a [lindex $arcnos($id) 0]
- if {$archeads($a) ne {}} {
- validate_archeads $a
- set i [lsearch -exact $arcids($a) $id]
- foreach t $archeads($a) {
- set j [lsearch -exact $arcids($a) $t]
- if {$j > $i} break
- lappend aret $t
- }
- }
- set id $arcstart($a)
- }
- set origid $id
- set todo [list $id]
- set seen($id) 1
- set ret {}
- for {set i 0} {$i < [llength $todo]} {incr i} {
- set id [lindex $todo $i]
- if {[info exists cached_dheads($id)]} {
- set ret [concat $ret $cached_dheads($id)]
- } else {
- if {[info exists idheads($id)]} {
- lappend ret $id
- }
- foreach a $arcnos($id) {
- if {$archeads($a) ne {}} {
- validate_archeads $a
- if {$archeads($a) ne {}} {
- set ret [concat $ret $archeads($a)]
- }
- }
- set d $arcstart($a)
- if {![info exists seen($d)]} {
- lappend todo $d
- set seen($d) 1
- }
- }
- }
- }
- set ret [lsort -unique $ret]
- set cached_dheads($origid) $ret
- return [concat $ret $aret]
-}
-
-proc addedtag {id} {
- global arcnos arcout cached_dtags cached_atags
-
- if {![info exists arcnos($id)]} return
- if {![info exists arcout($id)]} {
- recalcarc [lindex $arcnos($id) 0]
- }
- catch {unset cached_dtags}
- catch {unset cached_atags}
-}
-
-proc addedhead {hid head} {
- global arcnos arcout cached_dheads
-
- if {![info exists arcnos($hid)]} return
- if {![info exists arcout($hid)]} {
- recalcarc [lindex $arcnos($hid) 0]
- }
- catch {unset cached_dheads}
-}
-
-proc removedhead {hid head} {
- global cached_dheads
-
- catch {unset cached_dheads}
-}
-
-proc movedhead {hid head} {
- global arcnos arcout cached_dheads
-
- if {![info exists arcnos($hid)]} return
- if {![info exists arcout($hid)]} {
- recalcarc [lindex $arcnos($hid) 0]
- }
- catch {unset cached_dheads}
-}
-
-proc changedrefs {} {
- global cached_dheads cached_dtags cached_atags
- global arctags archeads arcnos arcout idheads idtags
-
- foreach id [concat [array names idheads] [array names idtags]] {
- if {[info exists arcnos($id)] && ![info exists arcout($id)]} {
- set a [lindex $arcnos($id) 0]
- if {![info exists donearc($a)]} {
- recalcarc $a
- set donearc($a) 1
- }
- }
- }
- catch {unset cached_dtags}
- catch {unset cached_atags}
- catch {unset cached_dheads}
-}
-
-proc rereadrefs {} {
- global idtags idheads idotherrefs mainhead
-
- set refids [concat [array names idtags] \
- [array names idheads] [array names idotherrefs]]
- foreach id $refids {
- if {![info exists ref($id)]} {
- set ref($id) [listrefs $id]
- }
- }
- set oldmainhead $mainhead
- readrefs
- changedrefs
- set refids [lsort -unique [concat $refids [array names idtags] \
- [array names idheads] [array names idotherrefs]]]
- foreach id $refids {
- set v [listrefs $id]
- if {![info exists ref($id)] || $ref($id) != $v ||
- ($id eq $oldmainhead && $id ne $mainhead) ||
- ($id eq $mainhead && $id ne $oldmainhead)} {
- redrawtags $id
- }
- }
- run refill_reflist
-}
-
-proc listrefs {id} {
- global idtags idheads idotherrefs
-
- set x {}
- if {[info exists idtags($id)]} {
- set x $idtags($id)
- }
- set y {}
- if {[info exists idheads($id)]} {
- set y $idheads($id)
- }
- set z {}
- if {[info exists idotherrefs($id)]} {
- set z $idotherrefs($id)
- }
- return [list $x $y $z]
-}
-
-proc showtag {tag isnew} {
- global ctext tagcontents tagids linknum tagobjid
-
- if {$isnew} {
- addtohistory [list showtag $tag 0]
- }
- $ctext conf -state normal
- clear_ctext
- settabs 0
- set linknum 0
- if {![info exists tagcontents($tag)]} {
- catch {
- set tagcontents($tag) [exec git cat-file tag $tagobjid($tag)]
- }
- }
- if {[info exists tagcontents($tag)]} {
- set text $tagcontents($tag)
- } else {
- set text "Tag: $tag\nId: $tagids($tag)"
- }
- appendwithlinks $text {}
- $ctext conf -state disabled
- init_flist {}
-}
-
-proc doquit {} {
- global stopped
- set stopped 100
- savestuff .
- destroy .
-}
-
-proc mkfontdisp {font top which} {
- global fontattr fontpref $font
-
- set fontpref($font) [set $font]
- button $top.${font}but -text $which -font optionfont \
- -command [list choosefont $font $which]
- label $top.$font -relief flat -font $font \
- -text $fontattr($font,family) -justify left
- grid x $top.${font}but $top.$font -sticky w
-}
-
-proc choosefont {font which} {
- global fontparam fontlist fonttop fontattr
-
- set fontparam(which) $which
- set fontparam(font) $font
- set fontparam(family) [font actual $font -family]
- set fontparam(size) $fontattr($font,size)
- set fontparam(weight) $fontattr($font,weight)
- set fontparam(slant) $fontattr($font,slant)
- set top .gitkfont
- set fonttop $top
- if {![winfo exists $top]} {
- font create sample
- eval font config sample [font actual $font]
- toplevel $top
- wm title $top "Gitk font chooser"
- label $top.l -textvariable fontparam(which) -font uifont
- pack $top.l -side top
- set fontlist [lsort [font families]]
- frame $top.f
- listbox $top.f.fam -listvariable fontlist \
- -yscrollcommand [list $top.f.sb set]
- bind $top.f.fam <<ListboxSelect>> selfontfam
- scrollbar $top.f.sb -command [list $top.f.fam yview]
- pack $top.f.sb -side right -fill y
- pack $top.f.fam -side left -fill both -expand 1
- pack $top.f -side top -fill both -expand 1
- frame $top.g
- spinbox $top.g.size -from 4 -to 40 -width 4 \
- -textvariable fontparam(size) \
- -validatecommand {string is integer -strict %s}
- checkbutton $top.g.bold -padx 5 \
- -font {{Times New Roman} 12 bold} -text "B" -indicatoron 0 \
- -variable fontparam(weight) -onvalue bold -offvalue normal
- checkbutton $top.g.ital -padx 5 \
- -font {{Times New Roman} 12 italic} -text "I" -indicatoron 0 \
- -variable fontparam(slant) -onvalue italic -offvalue roman
- pack $top.g.size $top.g.bold $top.g.ital -side left
- pack $top.g -side top
- canvas $top.c -width 150 -height 50 -border 2 -relief sunk \
- -background white
- $top.c create text 100 25 -anchor center -text $which -font sample \
- -fill black -tags text
- bind $top.c <Configure> [list centertext $top.c]
- pack $top.c -side top -fill x
- frame $top.buts
- button $top.buts.ok -text "OK" -command fontok -default active \
- -font uifont
- button $top.buts.can -text "Cancel" -command fontcan -default normal \
- -font uifont
- grid $top.buts.ok $top.buts.can
- grid columnconfigure $top.buts 0 -weight 1 -uniform a
- grid columnconfigure $top.buts 1 -weight 1 -uniform a
- pack $top.buts -side bottom -fill x
- trace add variable fontparam write chg_fontparam
- } else {
- raise $top
- $top.c itemconf text -text $which
- }
- set i [lsearch -exact $fontlist $fontparam(family)]
- if {$i >= 0} {
- $top.f.fam selection set $i
- $top.f.fam see $i
- }
-}
-
-proc centertext {w} {
- $w coords text [expr {[winfo width $w] / 2}] [expr {[winfo height $w] / 2}]
-}
-
-proc fontok {} {
- global fontparam fontpref prefstop
-
- set f $fontparam(font)
- set fontpref($f) [list $fontparam(family) $fontparam(size)]
- if {$fontparam(weight) eq "bold"} {
- lappend fontpref($f) "bold"
- }
- if {$fontparam(slant) eq "italic"} {
- lappend fontpref($f) "italic"
- }
- set w $prefstop.$f
- $w conf -text $fontparam(family) -font $fontpref($f)
-
- fontcan
-}
-
-proc fontcan {} {
- global fonttop fontparam
-
- if {[info exists fonttop]} {
- catch {destroy $fonttop}
- catch {font delete sample}
- unset fonttop
- unset fontparam
- }
-}
-
-proc selfontfam {} {
- global fonttop fontparam
-
- set i [$fonttop.f.fam curselection]
- if {$i ne {}} {
- set fontparam(family) [$fonttop.f.fam get $i]
- }
-}
-
-proc chg_fontparam {v sub op} {
- global fontparam
-
- font config sample -$sub $fontparam($sub)
-}
-
-proc doprefs {} {
- global maxwidth maxgraphpct
- global oldprefs prefstop showneartags showlocalchanges
- global bgcolor fgcolor ctext diffcolors selectbgcolor
- global uifont tabstop limitdiffs
-
- set top .gitkprefs
- set prefstop $top
- if {[winfo exists $top]} {
- raise $top
- return
- }
- foreach v {maxwidth maxgraphpct showneartags showlocalchanges \
- limitdiffs tabstop} {
- set oldprefs($v) [set $v]
- }
- toplevel $top
- wm title $top "Gitk preferences"
- label $top.ldisp -text "Commit list display options"
- $top.ldisp configure -font uifont
- grid $top.ldisp - -sticky w -pady 10
- label $top.spacer -text " "
- label $top.maxwidthl -text "Maximum graph width (lines)" \
- -font optionfont
- spinbox $top.maxwidth -from 0 -to 100 -width 4 -textvariable maxwidth
- grid $top.spacer $top.maxwidthl $top.maxwidth -sticky w
- label $top.maxpctl -text "Maximum graph width (% of pane)" \
- -font optionfont
- spinbox $top.maxpct -from 1 -to 100 -width 4 -textvariable maxgraphpct
- grid x $top.maxpctl $top.maxpct -sticky w
- frame $top.showlocal
- label $top.showlocal.l -text "Show local changes" -font optionfont
- checkbutton $top.showlocal.b -variable showlocalchanges
- pack $top.showlocal.b $top.showlocal.l -side left
- grid x $top.showlocal -sticky w
-
- label $top.ddisp -text "Diff display options"
- $top.ddisp configure -font uifont
- grid $top.ddisp - -sticky w -pady 10
- label $top.tabstopl -text "Tab spacing" -font optionfont
- spinbox $top.tabstop -from 1 -to 20 -width 4 -textvariable tabstop
- grid x $top.tabstopl $top.tabstop -sticky w
- frame $top.ntag
- label $top.ntag.l -text "Display nearby tags" -font optionfont
- checkbutton $top.ntag.b -variable showneartags
- pack $top.ntag.b $top.ntag.l -side left
- grid x $top.ntag -sticky w
- frame $top.ldiff
- label $top.ldiff.l -text "Limit diffs to listed paths" -font optionfont
- checkbutton $top.ldiff.b -variable limitdiffs
- pack $top.ldiff.b $top.ldiff.l -side left
- grid x $top.ldiff -sticky w
-
- label $top.cdisp -text "Colors: press to choose"
- $top.cdisp configure -font uifont
- grid $top.cdisp - -sticky w -pady 10
- label $top.bg -padx 40 -relief sunk -background $bgcolor
- button $top.bgbut -text "Background" -font optionfont \
- -command [list choosecolor bgcolor 0 $top.bg background setbg]
- grid x $top.bgbut $top.bg -sticky w
- label $top.fg -padx 40 -relief sunk -background $fgcolor
- button $top.fgbut -text "Foreground" -font optionfont \
- -command [list choosecolor fgcolor 0 $top.fg foreground setfg]
- grid x $top.fgbut $top.fg -sticky w
- label $top.diffold -padx 40 -relief sunk -background [lindex $diffcolors 0]
- button $top.diffoldbut -text "Diff: old lines" -font optionfont \
- -command [list choosecolor diffcolors 0 $top.diffold "diff old lines" \
- [list $ctext tag conf d0 -foreground]]
- grid x $top.diffoldbut $top.diffold -sticky w
- label $top.diffnew -padx 40 -relief sunk -background [lindex $diffcolors 1]
- button $top.diffnewbut -text "Diff: new lines" -font optionfont \
- -command [list choosecolor diffcolors 1 $top.diffnew "diff new lines" \
- [list $ctext tag conf d1 -foreground]]
- grid x $top.diffnewbut $top.diffnew -sticky w
- label $top.hunksep -padx 40 -relief sunk -background [lindex $diffcolors 2]
- button $top.hunksepbut -text "Diff: hunk header" -font optionfont \
- -command [list choosecolor diffcolors 2 $top.hunksep \
- "diff hunk header" \
- [list $ctext tag conf hunksep -foreground]]
- grid x $top.hunksepbut $top.hunksep -sticky w
- label $top.selbgsep -padx 40 -relief sunk -background $selectbgcolor
- button $top.selbgbut -text "Select bg" -font optionfont \
- -command [list choosecolor selectbgcolor 0 $top.selbgsep background setselbg]
- grid x $top.selbgbut $top.selbgsep -sticky w
-
- label $top.cfont -text "Fonts: press to choose"
- $top.cfont configure -font uifont
- grid $top.cfont - -sticky w -pady 10
- mkfontdisp mainfont $top "Main font"
- mkfontdisp textfont $top "Diff display font"
- mkfontdisp uifont $top "User interface font"
-
- frame $top.buts
- button $top.buts.ok -text "OK" -command prefsok -default active
- $top.buts.ok configure -font uifont
- button $top.buts.can -text "Cancel" -command prefscan -default normal
- $top.buts.can configure -font uifont
- grid $top.buts.ok $top.buts.can
- grid columnconfigure $top.buts 0 -weight 1 -uniform a
- grid columnconfigure $top.buts 1 -weight 1 -uniform a
- grid $top.buts - - -pady 10 -sticky ew
- bind $top <Visibility> "focus $top.buts.ok"
-}
-
-proc choosecolor {v vi w x cmd} {
- global $v
-
- set c [tk_chooseColor -initialcolor [lindex [set $v] $vi] \
- -title "Gitk: choose color for $x"]
- if {$c eq {}} return
- $w conf -background $c
- lset $v $vi $c
- eval $cmd $c
-}
-
-proc setselbg {c} {
- global bglist cflist
- foreach w $bglist {
- $w configure -selectbackground $c
- }
- $cflist tag configure highlight \
- -background [$cflist cget -selectbackground]
- allcanvs itemconf secsel -fill $c
-}
-
-proc setbg {c} {
- global bglist
-
- foreach w $bglist {
- $w conf -background $c
- }
-}
-
-proc setfg {c} {
- global fglist canv
-
- foreach w $fglist {
- $w conf -foreground $c
- }
- allcanvs itemconf text -fill $c
- $canv itemconf circle -outline $c
-}
-
-proc prefscan {} {
- global oldprefs prefstop
-
- foreach v {maxwidth maxgraphpct showneartags showlocalchanges \
- limitdiffs tabstop} {
- global $v
- set $v $oldprefs($v)
- }
- catch {destroy $prefstop}
- unset prefstop
- fontcan
-}
-
-proc prefsok {} {
- global maxwidth maxgraphpct
- global oldprefs prefstop showneartags showlocalchanges
- global fontpref mainfont textfont uifont
- global limitdiffs treediffs
-
- catch {destroy $prefstop}
- unset prefstop
- fontcan
- set fontchanged 0
- if {$mainfont ne $fontpref(mainfont)} {
- set mainfont $fontpref(mainfont)
- parsefont mainfont $mainfont
- eval font configure mainfont [fontflags mainfont]
- eval font configure mainfontbold [fontflags mainfont 1]
- setcoords
- set fontchanged 1
- }
- if {$textfont ne $fontpref(textfont)} {
- set textfont $fontpref(textfont)
- parsefont textfont $textfont
- eval font configure textfont [fontflags textfont]
- eval font configure textfontbold [fontflags textfont 1]
- }
- if {$uifont ne $fontpref(uifont)} {
- set uifont $fontpref(uifont)
- parsefont uifont $uifont
- eval font configure uifont [fontflags uifont]
- }
- settabs
- if {$showlocalchanges != $oldprefs(showlocalchanges)} {
- if {$showlocalchanges} {
- doshowlocalchanges
- } else {
- dohidelocalchanges
- }
- }
- if {$limitdiffs != $oldprefs(limitdiffs)} {
- # treediffs elements are limited by path
- catch {unset treediffs}
- }
- if {$fontchanged || $maxwidth != $oldprefs(maxwidth)
- || $maxgraphpct != $oldprefs(maxgraphpct)} {
- redisplay
- } elseif {$showneartags != $oldprefs(showneartags) ||
- $limitdiffs != $oldprefs(limitdiffs)} {
- reselectline
- }
-}
-
-proc formatdate {d} {
- global datetimeformat
- if {$d ne {}} {
- set d [clock format $d -format $datetimeformat]
- }
- return $d
-}
-
-# This list of encoding names and aliases is distilled from
-# http://www.iana.org/assignments/character-sets.
-# Not all of them are supported by Tcl.
-set encoding_aliases {
- { ANSI_X3.4-1968 iso-ir-6 ANSI_X3.4-1986 ISO_646.irv:1991 ASCII
- ISO646-US US-ASCII us IBM367 cp367 csASCII }
- { ISO-10646-UTF-1 csISO10646UTF1 }
- { ISO_646.basic:1983 ref csISO646basic1983 }
- { INVARIANT csINVARIANT }
- { ISO_646.irv:1983 iso-ir-2 irv csISO2IntlRefVersion }
- { BS_4730 iso-ir-4 ISO646-GB gb uk csISO4UnitedKingdom }
- { NATS-SEFI iso-ir-8-1 csNATSSEFI }
- { NATS-SEFI-ADD iso-ir-8-2 csNATSSEFIADD }
- { NATS-DANO iso-ir-9-1 csNATSDANO }
- { NATS-DANO-ADD iso-ir-9-2 csNATSDANOADD }
- { SEN_850200_B iso-ir-10 FI ISO646-FI ISO646-SE se csISO10Swedish }
- { SEN_850200_C iso-ir-11 ISO646-SE2 se2 csISO11SwedishForNames }
- { KS_C_5601-1987 iso-ir-149 KS_C_5601-1989 KSC_5601 korean csKSC56011987 }
- { ISO-2022-KR csISO2022KR }
- { EUC-KR csEUCKR }
- { ISO-2022-JP csISO2022JP }
- { ISO-2022-JP-2 csISO2022JP2 }
- { JIS_C6220-1969-jp JIS_C6220-1969 iso-ir-13 katakana x0201-7
- csISO13JISC6220jp }
- { JIS_C6220-1969-ro iso-ir-14 jp ISO646-JP csISO14JISC6220ro }
- { IT iso-ir-15 ISO646-IT csISO15Italian }
- { PT iso-ir-16 ISO646-PT csISO16Portuguese }
- { ES iso-ir-17 ISO646-ES csISO17Spanish }
- { greek7-old iso-ir-18 csISO18Greek7Old }
- { latin-greek iso-ir-19 csISO19LatinGreek }
- { DIN_66003 iso-ir-21 de ISO646-DE csISO21German }
- { NF_Z_62-010_(1973) iso-ir-25 ISO646-FR1 csISO25French }
- { Latin-greek-1 iso-ir-27 csISO27LatinGreek1 }
- { ISO_5427 iso-ir-37 csISO5427Cyrillic }
- { JIS_C6226-1978 iso-ir-42 csISO42JISC62261978 }
- { BS_viewdata iso-ir-47 csISO47BSViewdata }
- { INIS iso-ir-49 csISO49INIS }
- { INIS-8 iso-ir-50 csISO50INIS8 }
- { INIS-cyrillic iso-ir-51 csISO51INISCyrillic }
- { ISO_5427:1981 iso-ir-54 ISO5427Cyrillic1981 }
- { ISO_5428:1980 iso-ir-55 csISO5428Greek }
- { GB_1988-80 iso-ir-57 cn ISO646-CN csISO57GB1988 }
- { GB_2312-80 iso-ir-58 chinese csISO58GB231280 }
- { NS_4551-1 iso-ir-60 ISO646-NO no csISO60DanishNorwegian
- csISO60Norwegian1 }
- { NS_4551-2 ISO646-NO2 iso-ir-61 no2 csISO61Norwegian2 }
- { NF_Z_62-010 iso-ir-69 ISO646-FR fr csISO69French }
- { videotex-suppl iso-ir-70 csISO70VideotexSupp1 }
- { PT2 iso-ir-84 ISO646-PT2 csISO84Portuguese2 }
- { ES2 iso-ir-85 ISO646-ES2 csISO85Spanish2 }
- { MSZ_7795.3 iso-ir-86 ISO646-HU hu csISO86Hungarian }
- { JIS_C6226-1983 iso-ir-87 x0208 JIS_X0208-1983 csISO87JISX0208 }
- { greek7 iso-ir-88 csISO88Greek7 }
- { ASMO_449 ISO_9036 arabic7 iso-ir-89 csISO89ASMO449 }
- { iso-ir-90 csISO90 }
- { JIS_C6229-1984-a iso-ir-91 jp-ocr-a csISO91JISC62291984a }
- { JIS_C6229-1984-b iso-ir-92 ISO646-JP-OCR-B jp-ocr-b
- csISO92JISC62991984b }
- { JIS_C6229-1984-b-add iso-ir-93 jp-ocr-b-add csISO93JIS62291984badd }
- { JIS_C6229-1984-hand iso-ir-94 jp-ocr-hand csISO94JIS62291984hand }
- { JIS_C6229-1984-hand-add iso-ir-95 jp-ocr-hand-add
- csISO95JIS62291984handadd }
- { JIS_C6229-1984-kana iso-ir-96 csISO96JISC62291984kana }
- { ISO_2033-1983 iso-ir-98 e13b csISO2033 }
- { ANSI_X3.110-1983 iso-ir-99 CSA_T500-1983 NAPLPS csISO99NAPLPS }
- { ISO_8859-1:1987 iso-ir-100 ISO_8859-1 ISO-8859-1 latin1 l1 IBM819
- CP819 csISOLatin1 }
- { ISO_8859-2:1987 iso-ir-101 ISO_8859-2 ISO-8859-2 latin2 l2 csISOLatin2 }
- { T.61-7bit iso-ir-102 csISO102T617bit }
- { T.61-8bit T.61 iso-ir-103 csISO103T618bit }
- { ISO_8859-3:1988 iso-ir-109 ISO_8859-3 ISO-8859-3 latin3 l3 csISOLatin3 }
- { ISO_8859-4:1988 iso-ir-110 ISO_8859-4 ISO-8859-4 latin4 l4 csISOLatin4 }
- { ECMA-cyrillic iso-ir-111 KOI8-E csISO111ECMACyrillic }
- { CSA_Z243.4-1985-1 iso-ir-121 ISO646-CA csa7-1 ca csISO121Canadian1 }
- { CSA_Z243.4-1985-2 iso-ir-122 ISO646-CA2 csa7-2 csISO122Canadian2 }
- { CSA_Z243.4-1985-gr iso-ir-123 csISO123CSAZ24341985gr }
- { ISO_8859-6:1987 iso-ir-127 ISO_8859-6 ISO-8859-6 ECMA-114 ASMO-708
- arabic csISOLatinArabic }
- { ISO_8859-6-E csISO88596E ISO-8859-6-E }
- { ISO_8859-6-I csISO88596I ISO-8859-6-I }
- { ISO_8859-7:1987 iso-ir-126 ISO_8859-7 ISO-8859-7 ELOT_928 ECMA-118
- greek greek8 csISOLatinGreek }
- { T.101-G2 iso-ir-128 csISO128T101G2 }
- { ISO_8859-8:1988 iso-ir-138 ISO_8859-8 ISO-8859-8 hebrew
- csISOLatinHebrew }
- { ISO_8859-8-E csISO88598E ISO-8859-8-E }
- { ISO_8859-8-I csISO88598I ISO-8859-8-I }
- { CSN_369103 iso-ir-139 csISO139CSN369103 }
- { JUS_I.B1.002 iso-ir-141 ISO646-YU js yu csISO141JUSIB1002 }
- { ISO_6937-2-add iso-ir-142 csISOTextComm }
- { IEC_P27-1 iso-ir-143 csISO143IECP271 }
- { ISO_8859-5:1988 iso-ir-144 ISO_8859-5 ISO-8859-5 cyrillic
- csISOLatinCyrillic }
- { JUS_I.B1.003-serb iso-ir-146 serbian csISO146Serbian }
- { JUS_I.B1.003-mac macedonian iso-ir-147 csISO147Macedonian }
- { ISO_8859-9:1989 iso-ir-148 ISO_8859-9 ISO-8859-9 latin5 l5 csISOLatin5 }
- { greek-ccitt iso-ir-150 csISO150 csISO150GreekCCITT }
- { NC_NC00-10:81 cuba iso-ir-151 ISO646-CU csISO151Cuba }
- { ISO_6937-2-25 iso-ir-152 csISO6937Add }
- { GOST_19768-74 ST_SEV_358-88 iso-ir-153 csISO153GOST1976874 }
- { ISO_8859-supp iso-ir-154 latin1-2-5 csISO8859Supp }
- { ISO_10367-box iso-ir-155 csISO10367Box }
- { ISO-8859-10 iso-ir-157 l6 ISO_8859-10:1992 csISOLatin6 latin6 }
- { latin-lap lap iso-ir-158 csISO158Lap }
- { JIS_X0212-1990 x0212 iso-ir-159 csISO159JISX02121990 }
- { DS_2089 DS2089 ISO646-DK dk csISO646Danish }
- { us-dk csUSDK }
- { dk-us csDKUS }
- { JIS_X0201 X0201 csHalfWidthKatakana }
- { KSC5636 ISO646-KR csKSC5636 }
- { ISO-10646-UCS-2 csUnicode }
- { ISO-10646-UCS-4 csUCS4 }
- { DEC-MCS dec csDECMCS }
- { hp-roman8 roman8 r8 csHPRoman8 }
- { macintosh mac csMacintosh }
- { IBM037 cp037 ebcdic-cp-us ebcdic-cp-ca ebcdic-cp-wt ebcdic-cp-nl
- csIBM037 }
- { IBM038 EBCDIC-INT cp038 csIBM038 }
- { IBM273 CP273 csIBM273 }
- { IBM274 EBCDIC-BE CP274 csIBM274 }
- { IBM275 EBCDIC-BR cp275 csIBM275 }
- { IBM277 EBCDIC-CP-DK EBCDIC-CP-NO csIBM277 }
- { IBM278 CP278 ebcdic-cp-fi ebcdic-cp-se csIBM278 }
- { IBM280 CP280 ebcdic-cp-it csIBM280 }
- { IBM281 EBCDIC-JP-E cp281 csIBM281 }
- { IBM284 CP284 ebcdic-cp-es csIBM284 }
- { IBM285 CP285 ebcdic-cp-gb csIBM285 }
- { IBM290 cp290 EBCDIC-JP-kana csIBM290 }
- { IBM297 cp297 ebcdic-cp-fr csIBM297 }
- { IBM420 cp420 ebcdic-cp-ar1 csIBM420 }
- { IBM423 cp423 ebcdic-cp-gr csIBM423 }
- { IBM424 cp424 ebcdic-cp-he csIBM424 }
- { IBM437 cp437 437 csPC8CodePage437 }
- { IBM500 CP500 ebcdic-cp-be ebcdic-cp-ch csIBM500 }
- { IBM775 cp775 csPC775Baltic }
- { IBM850 cp850 850 csPC850Multilingual }
- { IBM851 cp851 851 csIBM851 }
- { IBM852 cp852 852 csPCp852 }
- { IBM855 cp855 855 csIBM855 }
- { IBM857 cp857 857 csIBM857 }
- { IBM860 cp860 860 csIBM860 }
- { IBM861 cp861 861 cp-is csIBM861 }
- { IBM862 cp862 862 csPC862LatinHebrew }
- { IBM863 cp863 863 csIBM863 }
- { IBM864 cp864 csIBM864 }
- { IBM865 cp865 865 csIBM865 }
- { IBM866 cp866 866 csIBM866 }
- { IBM868 CP868 cp-ar csIBM868 }
- { IBM869 cp869 869 cp-gr csIBM869 }
- { IBM870 CP870 ebcdic-cp-roece ebcdic-cp-yu csIBM870 }
- { IBM871 CP871 ebcdic-cp-is csIBM871 }
- { IBM880 cp880 EBCDIC-Cyrillic csIBM880 }
- { IBM891 cp891 csIBM891 }
- { IBM903 cp903 csIBM903 }
- { IBM904 cp904 904 csIBBM904 }
- { IBM905 CP905 ebcdic-cp-tr csIBM905 }
- { IBM918 CP918 ebcdic-cp-ar2 csIBM918 }
- { IBM1026 CP1026 csIBM1026 }
- { EBCDIC-AT-DE csIBMEBCDICATDE }
- { EBCDIC-AT-DE-A csEBCDICATDEA }
- { EBCDIC-CA-FR csEBCDICCAFR }
- { EBCDIC-DK-NO csEBCDICDKNO }
- { EBCDIC-DK-NO-A csEBCDICDKNOA }
- { EBCDIC-FI-SE csEBCDICFISE }
- { EBCDIC-FI-SE-A csEBCDICFISEA }
- { EBCDIC-FR csEBCDICFR }
- { EBCDIC-IT csEBCDICIT }
- { EBCDIC-PT csEBCDICPT }
- { EBCDIC-ES csEBCDICES }
- { EBCDIC-ES-A csEBCDICESA }
- { EBCDIC-ES-S csEBCDICESS }
- { EBCDIC-UK csEBCDICUK }
- { EBCDIC-US csEBCDICUS }
- { UNKNOWN-8BIT csUnknown8BiT }
- { MNEMONIC csMnemonic }
- { MNEM csMnem }
- { VISCII csVISCII }
- { VIQR csVIQR }
- { KOI8-R csKOI8R }
- { IBM00858 CCSID00858 CP00858 PC-Multilingual-850+euro }
- { IBM00924 CCSID00924 CP00924 ebcdic-Latin9--euro }
- { IBM01140 CCSID01140 CP01140 ebcdic-us-37+euro }
- { IBM01141 CCSID01141 CP01141 ebcdic-de-273+euro }
- { IBM01142 CCSID01142 CP01142 ebcdic-dk-277+euro ebcdic-no-277+euro }
- { IBM01143 CCSID01143 CP01143 ebcdic-fi-278+euro ebcdic-se-278+euro }
- { IBM01144 CCSID01144 CP01144 ebcdic-it-280+euro }
- { IBM01145 CCSID01145 CP01145 ebcdic-es-284+euro }
- { IBM01146 CCSID01146 CP01146 ebcdic-gb-285+euro }
- { IBM01147 CCSID01147 CP01147 ebcdic-fr-297+euro }
- { IBM01148 CCSID01148 CP01148 ebcdic-international-500+euro }
- { IBM01149 CCSID01149 CP01149 ebcdic-is-871+euro }
- { IBM1047 IBM-1047 }
- { PTCP154 csPTCP154 PT154 CP154 Cyrillic-Asian }
- { Amiga-1251 Ami1251 Amiga1251 Ami-1251 }
- { UNICODE-1-1 csUnicode11 }
- { CESU-8 csCESU-8 }
- { BOCU-1 csBOCU-1 }
- { UNICODE-1-1-UTF-7 csUnicode11UTF7 }
- { ISO-8859-14 iso-ir-199 ISO_8859-14:1998 ISO_8859-14 latin8 iso-celtic
- l8 }
- { ISO-8859-15 ISO_8859-15 Latin-9 }
- { ISO-8859-16 iso-ir-226 ISO_8859-16:2001 ISO_8859-16 latin10 l10 }
- { GBK CP936 MS936 windows-936 }
- { JIS_Encoding csJISEncoding }
- { Shift_JIS MS_Kanji csShiftJIS }
- { Extended_UNIX_Code_Packed_Format_for_Japanese csEUCPkdFmtJapanese
- EUC-JP }
- { Extended_UNIX_Code_Fixed_Width_for_Japanese csEUCFixWidJapanese }
- { ISO-10646-UCS-Basic csUnicodeASCII }
- { ISO-10646-Unicode-Latin1 csUnicodeLatin1 ISO-10646 }
- { ISO-Unicode-IBM-1261 csUnicodeIBM1261 }
- { ISO-Unicode-IBM-1268 csUnicodeIBM1268 }
- { ISO-Unicode-IBM-1276 csUnicodeIBM1276 }
- { ISO-Unicode-IBM-1264 csUnicodeIBM1264 }
- { ISO-Unicode-IBM-1265 csUnicodeIBM1265 }
- { ISO-8859-1-Windows-3.0-Latin-1 csWindows30Latin1 }
- { ISO-8859-1-Windows-3.1-Latin-1 csWindows31Latin1 }
- { ISO-8859-2-Windows-Latin-2 csWindows31Latin2 }
- { ISO-8859-9-Windows-Latin-5 csWindows31Latin5 }
- { Adobe-Standard-Encoding csAdobeStandardEncoding }
- { Ventura-US csVenturaUS }
- { Ventura-International csVenturaInternational }
- { PC8-Danish-Norwegian csPC8DanishNorwegian }
- { PC8-Turkish csPC8Turkish }
- { IBM-Symbols csIBMSymbols }
- { IBM-Thai csIBMThai }
- { HP-Legal csHPLegal }
- { HP-Pi-font csHPPiFont }
- { HP-Math8 csHPMath8 }
- { Adobe-Symbol-Encoding csHPPSMath }
- { HP-DeskTop csHPDesktop }
- { Ventura-Math csVenturaMath }
- { Microsoft-Publishing csMicrosoftPublishing }
- { Windows-31J csWindows31J }
- { GB2312 csGB2312 }
- { Big5 csBig5 }
-}
-
-proc tcl_encoding {enc} {
- global encoding_aliases
- set names [encoding names]
- set lcnames [string tolower $names]
- set enc [string tolower $enc]
- set i [lsearch -exact $lcnames $enc]
- if {$i < 0} {
- # look for "isonnn" instead of "iso-nnn" or "iso_nnn"
- if {[regsub {^iso[-_]} $enc iso encx]} {
- set i [lsearch -exact $lcnames $encx]
- }
- }
- if {$i < 0} {
- foreach l $encoding_aliases {
- set ll [string tolower $l]
- if {[lsearch -exact $ll $enc] < 0} continue
- # look through the aliases for one that tcl knows about
- foreach e $ll {
- set i [lsearch -exact $lcnames $e]
- if {$i < 0} {
- if {[regsub {^iso[-_]} $e iso ex]} {
- set i [lsearch -exact $lcnames $ex]
- }
- }
- if {$i >= 0} break
- }
- break
- }
- }
- if {$i >= 0} {
- return [lindex $names $i]
- }
- return {}
-}
-
-# First check that Tcl/Tk is recent enough
-if {[catch {package require Tk 8.4} err]} {
- show_error {} . "Sorry, gitk cannot run with this version of Tcl/Tk.\n\
- Gitk requires at least Tcl/Tk 8.4."
- exit 1
-}
-
-# defaults...
-set datemode 0
-set wrcomcmd "git diff-tree --stdin -p --pretty"
-
-set gitencoding {}
-catch {
- set gitencoding [exec git config --get i18n.commitencoding]
-}
-if {$gitencoding == ""} {
- set gitencoding "utf-8"
-}
-set tclencoding [tcl_encoding $gitencoding]
-if {$tclencoding == {}} {
- puts stderr "Warning: encoding $gitencoding is not supported by Tcl/Tk"
-}
-
-set mainfont {Helvetica 9}
-set textfont {Courier 9}
-set uifont {Helvetica 9 bold}
-set tabstop 8
-set findmergefiles 0
-set maxgraphpct 50
-set maxwidth 16
-set revlistorder 0
-set fastdate 0
-set uparrowlen 5
-set downarrowlen 5
-set mingaplen 100
-set cmitmode "patch"
-set wrapcomment "none"
-set showneartags 1
-set maxrefs 20
-set maxlinelen 200
-set showlocalchanges 1
-set limitdiffs 1
-set datetimeformat "%Y-%m-%d %H:%M:%S"
-
-set colors {green red blue magenta darkgrey brown orange}
-set bgcolor white
-set fgcolor black
-set diffcolors {red "#00a000" blue}
-set diffcontext 3
-set selectbgcolor gray85
-
-catch {source ~/.gitk}
-
-font create optionfont -family sans-serif -size -12
-
-parsefont mainfont $mainfont
-eval font create mainfont [fontflags mainfont]
-eval font create mainfontbold [fontflags mainfont 1]
-
-parsefont textfont $textfont
-eval font create textfont [fontflags textfont]
-eval font create textfontbold [fontflags textfont 1]
-
-parsefont uifont $uifont
-eval font create uifont [fontflags uifont]
-
-# check that we can find a .git directory somewhere...
-if {[catch {set gitdir [gitdir]}]} {
- show_error {} . "Cannot find a git repository here."
- exit 1
-}
-if {![file isdirectory $gitdir]} {
- show_error {} . "Cannot find the git directory \"$gitdir\"."
- exit 1
-}
-
-set mergeonly 0
-set revtreeargs {}
-set cmdline_files {}
-set i 0
-foreach arg $argv {
- switch -- $arg {
- "" { }
- "-d" { set datemode 1 }
- "--merge" {
- set mergeonly 1
- lappend revtreeargs $arg
- }
- "--" {
- set cmdline_files [lrange $argv [expr {$i + 1}] end]
- break
- }
- default {
- lappend revtreeargs $arg
- }
- }
- incr i
-}
-
-if {$i >= [llength $argv] && $revtreeargs ne {}} {
- # no -- on command line, but some arguments (other than -d)
- if {[catch {
- set f [eval exec git rev-parse --no-revs --no-flags $revtreeargs]
- set cmdline_files [split $f "\n"]
- set n [llength $cmdline_files]
- set revtreeargs [lrange $revtreeargs 0 end-$n]
- # Unfortunately git rev-parse doesn't produce an error when
- # something is both a revision and a filename. To be consistent
- # with git log and git rev-list, check revtreeargs for filenames.
- foreach arg $revtreeargs {
- if {[file exists $arg]} {
- show_error {} . "Ambiguous argument '$arg': both revision\
- and filename"
- exit 1
- }
- }
- } err]} {
- # unfortunately we get both stdout and stderr in $err,
- # so look for "fatal:".
- set i [string first "fatal:" $err]
- if {$i > 0} {
- set err [string range $err [expr {$i + 6}] end]
- }
- show_error {} . "Bad arguments to gitk:\n$err"
- exit 1
- }
-}
-
-if {$mergeonly} {
- # find the list of unmerged files
- set mlist {}
- set nr_unmerged 0
- if {[catch {
- set fd [open "| git ls-files -u" r]
- } err]} {
- show_error {} . "Couldn't get list of unmerged files: $err"
- exit 1
- }
- while {[gets $fd line] >= 0} {
- set i [string first "\t" $line]
- if {$i < 0} continue
- set fname [string range $line [expr {$i+1}] end]
- if {[lsearch -exact $mlist $fname] >= 0} continue
- incr nr_unmerged
- if {$cmdline_files eq {} || [path_filter $cmdline_files $fname]} {
- lappend mlist $fname
- }
- }
- catch {close $fd}
- if {$mlist eq {}} {
- if {$nr_unmerged == 0} {
- show_error {} . "No files selected: --merge specified but\
- no files are unmerged."
- } else {
- show_error {} . "No files selected: --merge specified but\
- no unmerged files are within file limit."
- }
- exit 1
- }
- set cmdline_files $mlist
-}
-
-set nullid "0000000000000000000000000000000000000000"
-set nullid2 "0000000000000000000000000000000000000001"
-
-set have_tk85 [expr {[package vcompare $tk_version "8.5"] >= 0}]
-
-set runq {}
-set history {}
-set historyindex 0
-set fh_serial 0
-set nhl_names {}
-set highlight_paths {}
-set findpattern {}
-set searchdirn -forwards
-set boldrows {}
-set boldnamerows {}
-set diffelide {0 0}
-set markingmatches 0
-set linkentercount 0
-set need_redisplay 0
-set nrows_drawn 0
-set firsttabstop 0
-
-set nextviewnum 1
-set curview 0
-set selectedview 0
-set selectedhlview None
-set highlight_related None
-set highlight_files {}
-set viewfiles(0) {}
-set viewperm(0) 0
-set viewargs(0) {}
-
-set cmdlineok 0
-set stopped 0
-set stuffsaved 0
-set patchnum 0
-set localirow -1
-set localfrow -1
-set lserial 0
-setcoords
-makewindow
-# wait for the window to become visible
-tkwait visibility .
-wm title . "[file tail $argv0]: [file tail [pwd]]"
-readrefs
-
-if {$cmdline_files ne {} || $revtreeargs ne {}} {
- # create a view for the files/dirs specified on the command line
- set curview 1
- set selectedview 1
- set nextviewnum 2
- set viewname(1) "Command line"
- set viewfiles(1) $cmdline_files
- set viewargs(1) $revtreeargs
- set viewperm(1) 0
- addviewmenu 1
- .bar.view entryconf Edit* -state normal
- .bar.view entryconf Delete* -state normal
-}
-
-if {[info exists permviews]} {
- foreach v $permviews {
- set n $nextviewnum
- incr nextviewnum
- set viewname($n) [lindex $v 0]
- set viewfiles($n) [lindex $v 1]
- set viewargs($n) [lindex $v 2]
- set viewperm($n) 1
- addviewmenu $n
- }
-}
-getcommits
--- /dev/null
+# The default target of this Makefile is...
+all::
+
+prefix ?= $(HOME)
+bindir ?= $(prefix)/bin
+TCLTK_PATH ?= wish
+INSTALL ?= install
+RM ?= rm -f
+
+DESTDIR_SQ = $(subst ','\'',$(DESTDIR))
+bindir_SQ = $(subst ','\'',$(bindir))
+TCLTK_PATH_SQ = $(subst ','\'',$(TCLTK_PATH))
+
+ifndef V
+ QUIET = @
+ QUIET_GEN = $(QUIET)echo ' ' GEN $@ &&
+endif
+
+all:: gitk-wish
+install:: all
+ $(INSTALL) gitk-wish '$(DESTDIR_SQ)$(bindir_SQ)'/gitk
+clean::
+ $(RM) gitk-wish
+
+gitk-wish: gitk
+ $(QUIET_GEN)$(RM) $@ $@+ && \
+ sed -e '1,3s|^exec .* "$$0"|exec $(subst |,'\|',$(TCLTK_PATH_SQ)) "$$0"|' <gitk >$@+ && \
+ chmod +x $@+ && \
+ mv -f $@+ $@
--- /dev/null
+#!/bin/sh
+# Tcl ignores the next line -*- tcl -*- \
+exec wish "$0" -- "$@"
+
+# Copyright (C) 2005-2006 Paul Mackerras. All rights reserved.
+# This program is free software; it may be used, copied, modified
+# and distributed under the terms of the GNU General Public Licence,
+# either version 2, or (at your option) any later version.
+
+proc gitdir {} {
+ global env
+ if {[info exists env(GIT_DIR)]} {
+ return $env(GIT_DIR)
+ } else {
+ return [exec git rev-parse --git-dir]
+ }
+}
+
+# A simple scheduler for compute-intensive stuff.
+# The aim is to make sure that event handlers for GUI actions can
+# run at least every 50-100 ms. Unfortunately fileevent handlers are
+# run before X event handlers, so reading from a fast source can
+# make the GUI completely unresponsive.
+proc run args {
+ global isonrunq runq
+
+ set script $args
+ if {[info exists isonrunq($script)]} return
+ if {$runq eq {}} {
+ after idle dorunq
+ }
+ lappend runq [list {} $script]
+ set isonrunq($script) 1
+}
+
+proc filerun {fd script} {
+ fileevent $fd readable [list filereadable $fd $script]
+}
+
+proc filereadable {fd script} {
+ global runq
+
+ fileevent $fd readable {}
+ if {$runq eq {}} {
+ after idle dorunq
+ }
+ lappend runq [list $fd $script]
+}
+
+proc dorunq {} {
+ global isonrunq runq
+
+ set tstart [clock clicks -milliseconds]
+ set t0 $tstart
+ while {$runq ne {}} {
+ set fd [lindex $runq 0 0]
+ set script [lindex $runq 0 1]
+ set repeat [eval $script]
+ set t1 [clock clicks -milliseconds]
+ set t [expr {$t1 - $t0}]
+ set runq [lrange $runq 1 end]
+ if {$repeat ne {} && $repeat} {
+ if {$fd eq {} || $repeat == 2} {
+ # script returns 1 if it wants to be readded
+ # file readers return 2 if they could do more straight away
+ lappend runq [list $fd $script]
+ } else {
+ fileevent $fd readable [list filereadable $fd $script]
+ }
+ } elseif {$fd eq {}} {
+ unset isonrunq($script)
+ }
+ set t0 $t1
+ if {$t1 - $tstart >= 80} break
+ }
+ if {$runq ne {}} {
+ after idle dorunq
+ }
+}
+
+# Start off a git rev-list process and arrange to read its output
+proc start_rev_list {view} {
+ global startmsecs
+ global commfd leftover tclencoding datemode
+ global viewargs viewfiles commitidx viewcomplete vnextroot
+ global showlocalchanges commitinterest mainheadid
+ global progressdirn progresscoords proglastnc curview
+
+ set startmsecs [clock clicks -milliseconds]
+ set commitidx($view) 0
+ set viewcomplete($view) 0
+ set vnextroot($view) 0
+ set order "--topo-order"
+ if {$datemode} {
+ set order "--date-order"
+ }
+ if {[catch {
+ set fd [open [concat | git log --no-color -z --pretty=raw $order --parents \
+ --boundary $viewargs($view) "--" $viewfiles($view)] r]
+ } err]} {
+ error_popup "Error executing git rev-list: $err"
+ exit 1
+ }
+ set commfd($view) $fd
+ set leftover($view) {}
+ if {$showlocalchanges} {
+ lappend commitinterest($mainheadid) {dodiffindex}
+ }
+ fconfigure $fd -blocking 0 -translation lf -eofchar {}
+ if {$tclencoding != {}} {
+ fconfigure $fd -encoding $tclencoding
+ }
+ filerun $fd [list getcommitlines $fd $view]
+ nowbusy $view "Reading"
+ if {$view == $curview} {
+ set progressdirn 1
+ set progresscoords {0 0}
+ set proglastnc 0
+ }
+}
+
+proc stop_rev_list {} {
+ global commfd curview
+
+ if {![info exists commfd($curview)]} return
+ set fd $commfd($curview)
+ catch {
+ set pid [pid $fd]
+ exec kill $pid
+ }
+ catch {close $fd}
+ unset commfd($curview)
+}
+
+proc getcommits {} {
+ global phase canv curview
+
+ set phase getcommits
+ initlayout
+ start_rev_list $curview
+ show_status "Reading commits..."
+}
+
+# This makes a string representation of a positive integer which
+# sorts as a string in numerical order
+proc strrep {n} {
+ if {$n < 16} {
+ return [format "%x" $n]
+ } elseif {$n < 256} {
+ return [format "x%.2x" $n]
+ } elseif {$n < 65536} {
+ return [format "y%.4x" $n]
+ }
+ return [format "z%.8x" $n]
+}
+
+proc getcommitlines {fd view} {
+ global commitlisted commitinterest
+ global leftover commfd
+ global displayorder commitidx viewcomplete commitrow commitdata
+ global parentlist children curview hlview
+ global vparentlist vdisporder vcmitlisted
+ global ordertok vnextroot idpending
+
+ set stuff [read $fd 500000]
+ # git log doesn't terminate the last commit with a null...
+ if {$stuff == {} && $leftover($view) ne {} && [eof $fd]} {
+ set stuff "\0"
+ }
+ if {$stuff == {}} {
+ if {![eof $fd]} {
+ return 1
+ }
+ # Check if we have seen any ids listed as parents that haven't
+ # appeared in the list
+ foreach vid [array names idpending "$view,*"] {
+ # should only get here if git log is buggy
+ set id [lindex [split $vid ","] 1]
+ set commitrow($vid) $commitidx($view)
+ incr commitidx($view)
+ if {$view == $curview} {
+ lappend parentlist {}
+ lappend displayorder $id
+ lappend commitlisted 0
+ } else {
+ lappend vparentlist($view) {}
+ lappend vdisporder($view) $id
+ lappend vcmitlisted($view) 0
+ }
+ }
+ set viewcomplete($view) 1
+ global viewname progresscoords
+ unset commfd($view)
+ notbusy $view
+ set progresscoords {0 0}
+ adjustprogress
+ # set it blocking so we wait for the process to terminate
+ fconfigure $fd -blocking 1
+ if {[catch {close $fd} err]} {
+ set fv {}
+ if {$view != $curview} {
+ set fv " for the \"$viewname($view)\" view"
+ }
+ if {[string range $err 0 4] == "usage"} {
+ set err "Gitk: error reading commits$fv:\
+ bad arguments to git rev-list."
+ if {$viewname($view) eq "Command line"} {
+ append err \
+ " (Note: arguments to gitk are passed to git rev-list\
+ to allow selection of commits to be displayed.)"
+ }
+ } else {
+ set err "Error reading commits$fv: $err"
+ }
+ error_popup $err
+ }
+ if {$view == $curview} {
+ run chewcommits $view
+ }
+ return 0
+ }
+ set start 0
+ set gotsome 0
+ while 1 {
+ set i [string first "\0" $stuff $start]
+ if {$i < 0} {
+ append leftover($view) [string range $stuff $start end]
+ break
+ }
+ if {$start == 0} {
+ set cmit $leftover($view)
+ append cmit [string range $stuff 0 [expr {$i - 1}]]
+ set leftover($view) {}
+ } else {
+ set cmit [string range $stuff $start [expr {$i - 1}]]
+ }
+ set start [expr {$i + 1}]
+ set j [string first "\n" $cmit]
+ set ok 0
+ set listed 1
+ if {$j >= 0 && [string match "commit *" $cmit]} {
+ set ids [string range $cmit 7 [expr {$j - 1}]]
+ if {[string match {[-<>]*} $ids]} {
+ switch -- [string index $ids 0] {
+ "-" {set listed 0}
+ "<" {set listed 2}
+ ">" {set listed 3}
+ }
+ set ids [string range $ids 1 end]
+ }
+ set ok 1
+ foreach id $ids {
+ if {[string length $id] != 40} {
+ set ok 0
+ break
+ }
+ }
+ }
+ if {!$ok} {
+ set shortcmit $cmit
+ if {[string length $shortcmit] > 80} {
+ set shortcmit "[string range $shortcmit 0 80]..."
+ }
+ error_popup "Can't parse git log output: {$shortcmit}"
+ exit 1
+ }
+ set id [lindex $ids 0]
+ if {![info exists ordertok($view,$id)]} {
+ set otok "o[strrep $vnextroot($view)]"
+ incr vnextroot($view)
+ set ordertok($view,$id) $otok
+ } else {
+ set otok $ordertok($view,$id)
+ unset idpending($view,$id)
+ }
+ if {$listed} {
+ set olds [lrange $ids 1 end]
+ if {[llength $olds] == 1} {
+ set p [lindex $olds 0]
+ lappend children($view,$p) $id
+ if {![info exists ordertok($view,$p)]} {
+ set ordertok($view,$p) $ordertok($view,$id)
+ set idpending($view,$p) 1
+ }
+ } else {
+ set i 0
+ foreach p $olds {
+ if {$i == 0 || [lsearch -exact $olds $p] >= $i} {
+ lappend children($view,$p) $id
+ }
+ if {![info exists ordertok($view,$p)]} {
+ set ordertok($view,$p) "$otok[strrep $i]]"
+ set idpending($view,$p) 1
+ }
+ incr i
+ }
+ }
+ } else {
+ set olds {}
+ }
+ if {![info exists children($view,$id)]} {
+ set children($view,$id) {}
+ }
+ set commitdata($id) [string range $cmit [expr {$j + 1}] end]
+ set commitrow($view,$id) $commitidx($view)
+ incr commitidx($view)
+ if {$view == $curview} {
+ lappend parentlist $olds
+ lappend displayorder $id
+ lappend commitlisted $listed
+ } else {
+ lappend vparentlist($view) $olds
+ lappend vdisporder($view) $id
+ lappend vcmitlisted($view) $listed
+ }
+ if {[info exists commitinterest($id)]} {
+ foreach script $commitinterest($id) {
+ eval [string map [list "%I" $id] $script]
+ }
+ unset commitinterest($id)
+ }
+ set gotsome 1
+ }
+ if {$gotsome} {
+ run chewcommits $view
+ if {$view == $curview} {
+ # update progress bar
+ global progressdirn progresscoords proglastnc
+ set inc [expr {($commitidx($view) - $proglastnc) * 0.0002}]
+ set proglastnc $commitidx($view)
+ set l [lindex $progresscoords 0]
+ set r [lindex $progresscoords 1]
+ if {$progressdirn} {
+ set r [expr {$r + $inc}]
+ if {$r >= 1.0} {
+ set r 1.0
+ set progressdirn 0
+ }
+ if {$r > 0.2} {
+ set l [expr {$r - 0.2}]
+ }
+ } else {
+ set l [expr {$l - $inc}]
+ if {$l <= 0.0} {
+ set l 0.0
+ set progressdirn 1
+ }
+ set r [expr {$l + 0.2}]
+ }
+ set progresscoords [list $l $r]
+ adjustprogress
+ }
+ }
+ return 2
+}
+
+proc chewcommits {view} {
+ global curview hlview viewcomplete
+ global selectedline pending_select
+
+ if {$view == $curview} {
+ layoutmore
+ if {$viewcomplete($view)} {
+ global displayorder commitidx phase
+ global numcommits startmsecs
+
+ if {[info exists pending_select]} {
+ set row [first_real_row]
+ selectline $row 1
+ }
+ if {$commitidx($curview) > 0} {
+ #set ms [expr {[clock clicks -milliseconds] - $startmsecs}]
+ #puts "overall $ms ms for $numcommits commits"
+ } else {
+ show_status "No commits selected"
+ }
+ notbusy layout
+ set phase {}
+ }
+ }
+ if {[info exists hlview] && $view == $hlview} {
+ vhighlightmore
+ }
+ return 0
+}
+
+proc readcommit {id} {
+ if {[catch {set contents [exec git cat-file commit $id]}]} return
+ parsecommit $id $contents 0
+}
+
+proc updatecommits {} {
+ global viewdata curview phase displayorder ordertok idpending
+ global children commitrow selectedline thickerline showneartags
+
+ if {$phase ne {}} {
+ stop_rev_list
+ set phase {}
+ }
+ set n $curview
+ foreach id $displayorder {
+ catch {unset children($n,$id)}
+ catch {unset commitrow($n,$id)}
+ catch {unset ordertok($n,$id)}
+ }
+ foreach vid [array names idpending "$n,*"] {
+ unset idpending($vid)
+ }
+ set curview -1
+ catch {unset selectedline}
+ catch {unset thickerline}
+ catch {unset viewdata($n)}
+ readrefs
+ changedrefs
+ if {$showneartags} {
+ getallcommits
+ }
+ showview $n
+}
+
+proc parsecommit {id contents listed} {
+ global commitinfo cdate
+
+ set inhdr 1
+ set comment {}
+ set headline {}
+ set auname {}
+ set audate {}
+ set comname {}
+ set comdate {}
+ set hdrend [string first "\n\n" $contents]
+ if {$hdrend < 0} {
+ # should never happen...
+ set hdrend [string length $contents]
+ }
+ set header [string range $contents 0 [expr {$hdrend - 1}]]
+ set comment [string range $contents [expr {$hdrend + 2}] end]
+ foreach line [split $header "\n"] {
+ set tag [lindex $line 0]
+ if {$tag == "author"} {
+ set audate [lindex $line end-1]
+ set auname [lrange $line 1 end-2]
+ } elseif {$tag == "committer"} {
+ set comdate [lindex $line end-1]
+ set comname [lrange $line 1 end-2]
+ }
+ }
+ set headline {}
+ # take the first non-blank line of the comment as the headline
+ set headline [string trimleft $comment]
+ set i [string first "\n" $headline]
+ if {$i >= 0} {
+ set headline [string range $headline 0 $i]
+ }
+ set headline [string trimright $headline]
+ set i [string first "\r" $headline]
+ if {$i >= 0} {
+ set headline [string trimright [string range $headline 0 $i]]
+ }
+ if {!$listed} {
+ # git rev-list indents the comment by 4 spaces;
+ # if we got this via git cat-file, add the indentation
+ set newcomment {}
+ foreach line [split $comment "\n"] {
+ append newcomment " "
+ append newcomment $line
+ append newcomment "\n"
+ }
+ set comment $newcomment
+ }
+ if {$comdate != {}} {
+ set cdate($id) $comdate
+ }
+ set commitinfo($id) [list $headline $auname $audate \
+ $comname $comdate $comment]
+}
+
+proc getcommit {id} {
+ global commitdata commitinfo
+
+ if {[info exists commitdata($id)]} {
+ parsecommit $id $commitdata($id) 1
+ } else {
+ readcommit $id
+ if {![info exists commitinfo($id)]} {
+ set commitinfo($id) {"No commit information available"}
+ }
+ }
+ return 1
+}
+
+proc readrefs {} {
+ global tagids idtags headids idheads tagobjid
+ global otherrefids idotherrefs mainhead mainheadid
+
+ foreach v {tagids idtags headids idheads otherrefids idotherrefs} {
+ catch {unset $v}
+ }
+ set refd [open [list | git show-ref -d] r]
+ while {[gets $refd line] >= 0} {
+ if {[string index $line 40] ne " "} continue
+ set id [string range $line 0 39]
+ set ref [string range $line 41 end]
+ if {![string match "refs/*" $ref]} continue
+ set name [string range $ref 5 end]
+ if {[string match "remotes/*" $name]} {
+ if {![string match "*/HEAD" $name]} {
+ set headids($name) $id
+ lappend idheads($id) $name
+ }
+ } elseif {[string match "heads/*" $name]} {
+ set name [string range $name 6 end]
+ set headids($name) $id
+ lappend idheads($id) $name
+ } elseif {[string match "tags/*" $name]} {
+ # this lets refs/tags/foo^{} overwrite refs/tags/foo,
+ # which is what we want since the former is the commit ID
+ set name [string range $name 5 end]
+ if {[string match "*^{}" $name]} {
+ set name [string range $name 0 end-3]
+ } else {
+ set tagobjid($name) $id
+ }
+ set tagids($name) $id
+ lappend idtags($id) $name
+ } else {
+ set otherrefids($name) $id
+ lappend idotherrefs($id) $name
+ }
+ }
+ catch {close $refd}
+ set mainhead {}
+ set mainheadid {}
+ catch {
+ set thehead [exec git symbolic-ref HEAD]
+ if {[string match "refs/heads/*" $thehead]} {
+ set mainhead [string range $thehead 11 end]
+ if {[info exists headids($mainhead)]} {
+ set mainheadid $headids($mainhead)
+ }
+ }
+ }
+}
+
+# skip over fake commits
+proc first_real_row {} {
+ global nullid nullid2 displayorder numcommits
+
+ for {set row 0} {$row < $numcommits} {incr row} {
+ set id [lindex $displayorder $row]
+ if {$id ne $nullid && $id ne $nullid2} {
+ break
+ }
+ }
+ return $row
+}
+
+# update things for a head moved to a child of its previous location
+proc movehead {id name} {
+ global headids idheads
+
+ removehead $headids($name) $name
+ set headids($name) $id
+ lappend idheads($id) $name
+}
+
+# update things when a head has been removed
+proc removehead {id name} {
+ global headids idheads
+
+ if {$idheads($id) eq $name} {
+ unset idheads($id)
+ } else {
+ set i [lsearch -exact $idheads($id) $name]
+ if {$i >= 0} {
+ set idheads($id) [lreplace $idheads($id) $i $i]
+ }
+ }
+ unset headids($name)
+}
+
+proc show_error {w top msg} {
+ message $w.m -text $msg -justify center -aspect 400
+ pack $w.m -side top -fill x -padx 20 -pady 20
+ button $w.ok -text OK -command "destroy $top"
+ pack $w.ok -side bottom -fill x
+ bind $top <Visibility> "grab $top; focus $top"
+ bind $top <Key-Return> "destroy $top"
+ tkwait window $top
+}
+
+proc error_popup msg {
+ set w .error
+ toplevel $w
+ wm transient $w .
+ show_error $w $w $msg
+}
+
+proc confirm_popup msg {
+ global confirm_ok
+ set confirm_ok 0
+ set w .confirm
+ toplevel $w
+ wm transient $w .
+ message $w.m -text $msg -justify center -aspect 400
+ pack $w.m -side top -fill x -padx 20 -pady 20
+ button $w.ok -text OK -command "set confirm_ok 1; destroy $w"
+ pack $w.ok -side left -fill x
+ button $w.cancel -text Cancel -command "destroy $w"
+ pack $w.cancel -side right -fill x
+ bind $w <Visibility> "grab $w; focus $w"
+ tkwait window $w
+ return $confirm_ok
+}
+
+proc makewindow {} {
+ global canv canv2 canv3 linespc charspc ctext cflist
+ global tabstop
+ global findtype findtypemenu findloc findstring fstring geometry
+ global entries sha1entry sha1string sha1but
+ global diffcontextstring diffcontext
+ global maincursor textcursor curtextcursor
+ global rowctxmenu fakerowmenu mergemax wrapcomment
+ global highlight_files gdttype
+ global searchstring sstring
+ global bgcolor fgcolor bglist fglist diffcolors selectbgcolor
+ global headctxmenu progresscanv progressitem progresscoords statusw
+ global fprogitem fprogcoord lastprogupdate progupdatepending
+ global rprogitem rprogcoord
+ global have_tk85
+
+ menu .bar
+ .bar add cascade -label "File" -menu .bar.file
+ .bar configure -font uifont
+ menu .bar.file
+ .bar.file add command -label "Update" -command updatecommits
+ .bar.file add command -label "Reread references" -command rereadrefs
+ .bar.file add command -label "List references" -command showrefs
+ .bar.file add command -label "Quit" -command doquit
+ .bar.file configure -font uifont
+ menu .bar.edit
+ .bar add cascade -label "Edit" -menu .bar.edit
+ .bar.edit add command -label "Preferences" -command doprefs
+ .bar.edit configure -font uifont
+
+ menu .bar.view -font uifont
+ .bar add cascade -label "View" -menu .bar.view
+ .bar.view add command -label "New view..." -command {newview 0}
+ .bar.view add command -label "Edit view..." -command editview \
+ -state disabled
+ .bar.view add command -label "Delete view" -command delview -state disabled
+ .bar.view add separator
+ .bar.view add radiobutton -label "All files" -command {showview 0} \
+ -variable selectedview -value 0
+
+ menu .bar.help
+ .bar add cascade -label "Help" -menu .bar.help
+ .bar.help add command -label "About gitk" -command about
+ .bar.help add command -label "Key bindings" -command keys
+ .bar.help configure -font uifont
+ . configure -menu .bar
+
+ # the gui has upper and lower half, parts of a paned window.
+ panedwindow .ctop -orient vertical
+
+ # possibly use assumed geometry
+ if {![info exists geometry(pwsash0)]} {
+ set geometry(topheight) [expr {15 * $linespc}]
+ set geometry(topwidth) [expr {80 * $charspc}]
+ set geometry(botheight) [expr {15 * $linespc}]
+ set geometry(botwidth) [expr {50 * $charspc}]
+ set geometry(pwsash0) "[expr {40 * $charspc}] 2"
+ set geometry(pwsash1) "[expr {60 * $charspc}] 2"
+ }
+
+ # the upper half will have a paned window, a scroll bar to the right, and some stuff below
+ frame .tf -height $geometry(topheight) -width $geometry(topwidth)
+ frame .tf.histframe
+ panedwindow .tf.histframe.pwclist -orient horizontal -sashpad 0 -handlesize 4
+
+ # create three canvases
+ set cscroll .tf.histframe.csb
+ set canv .tf.histframe.pwclist.canv
+ canvas $canv \
+ -selectbackground $selectbgcolor \
+ -background $bgcolor -bd 0 \
+ -yscrollincr $linespc -yscrollcommand "scrollcanv $cscroll"
+ .tf.histframe.pwclist add $canv
+ set canv2 .tf.histframe.pwclist.canv2
+ canvas $canv2 \
+ -selectbackground $selectbgcolor \
+ -background $bgcolor -bd 0 -yscrollincr $linespc
+ .tf.histframe.pwclist add $canv2
+ set canv3 .tf.histframe.pwclist.canv3
+ canvas $canv3 \
+ -selectbackground $selectbgcolor \
+ -background $bgcolor -bd 0 -yscrollincr $linespc
+ .tf.histframe.pwclist add $canv3
+ eval .tf.histframe.pwclist sash place 0 $geometry(pwsash0)
+ eval .tf.histframe.pwclist sash place 1 $geometry(pwsash1)
+
+ # a scroll bar to rule them
+ scrollbar $cscroll -command {allcanvs yview} -highlightthickness 0
+ pack $cscroll -side right -fill y
+ bind .tf.histframe.pwclist <Configure> {resizeclistpanes %W %w}
+ lappend bglist $canv $canv2 $canv3
+ pack .tf.histframe.pwclist -fill both -expand 1 -side left
+
+ # we have two button bars at bottom of top frame. Bar 1
+ frame .tf.bar
+ frame .tf.lbar -height 15
+
+ set sha1entry .tf.bar.sha1
+ set entries $sha1entry
+ set sha1but .tf.bar.sha1label
+ button $sha1but -text "SHA1 ID: " -state disabled -relief flat \
+ -command gotocommit -width 8 -font uifont
+ $sha1but conf -disabledforeground [$sha1but cget -foreground]
+ pack .tf.bar.sha1label -side left
+ entry $sha1entry -width 40 -font textfont -textvariable sha1string
+ trace add variable sha1string write sha1change
+ pack $sha1entry -side left -pady 2
+
+ image create bitmap bm-left -data {
+ #define left_width 16
+ #define left_height 16
+ static unsigned char left_bits[] = {
+ 0x00, 0x00, 0xc0, 0x01, 0xe0, 0x00, 0x70, 0x00, 0x38, 0x00, 0x1c, 0x00,
+ 0x0e, 0x00, 0xff, 0x7f, 0xff, 0x7f, 0xff, 0x7f, 0x0e, 0x00, 0x1c, 0x00,
+ 0x38, 0x00, 0x70, 0x00, 0xe0, 0x00, 0xc0, 0x01};
+ }
+ image create bitmap bm-right -data {
+ #define right_width 16
+ #define right_height 16
+ static unsigned char right_bits[] = {
+ 0x00, 0x00, 0xc0, 0x01, 0x80, 0x03, 0x00, 0x07, 0x00, 0x0e, 0x00, 0x1c,
+ 0x00, 0x38, 0xff, 0x7f, 0xff, 0x7f, 0xff, 0x7f, 0x00, 0x38, 0x00, 0x1c,
+ 0x00, 0x0e, 0x00, 0x07, 0x80, 0x03, 0xc0, 0x01};
+ }
+ button .tf.bar.leftbut -image bm-left -command goback \
+ -state disabled -width 26
+ pack .tf.bar.leftbut -side left -fill y
+ button .tf.bar.rightbut -image bm-right -command goforw \
+ -state disabled -width 26
+ pack .tf.bar.rightbut -side left -fill y
+
+ # Status label and progress bar
+ set statusw .tf.bar.status
+ label $statusw -width 15 -relief sunken -font uifont
+ pack $statusw -side left -padx 5
+ set h [expr {[font metrics uifont -linespace] + 2}]
+ set progresscanv .tf.bar.progress
+ canvas $progresscanv -relief sunken -height $h -borderwidth 2
+ set progressitem [$progresscanv create rect -1 0 0 $h -fill green]
+ set fprogitem [$progresscanv create rect -1 0 0 $h -fill yellow]
+ set rprogitem [$progresscanv create rect -1 0 0 $h -fill red]
+ pack $progresscanv -side right -expand 1 -fill x
+ set progresscoords {0 0}
+ set fprogcoord 0
+ set rprogcoord 0
+ bind $progresscanv <Configure> adjustprogress
+ set lastprogupdate [clock clicks -milliseconds]
+ set progupdatepending 0
+
+ # build up the bottom bar of upper window
+ label .tf.lbar.flabel -text "Find " -font uifont
+ button .tf.lbar.fnext -text "next" -command {dofind 1 1} -font uifont
+ button .tf.lbar.fprev -text "prev" -command {dofind -1 1} -font uifont
+ label .tf.lbar.flab2 -text " commit " -font uifont
+ pack .tf.lbar.flabel .tf.lbar.fnext .tf.lbar.fprev .tf.lbar.flab2 \
+ -side left -fill y
+ set gdttype "containing:"
+ set gm [tk_optionMenu .tf.lbar.gdttype gdttype \
+ "containing:" \
+ "touching paths:" \
+ "adding/removing string:"]
+ trace add variable gdttype write gdttype_change
+ $gm conf -font uifont
+ .tf.lbar.gdttype conf -font uifont
+ pack .tf.lbar.gdttype -side left -fill y
+
+ set findstring {}
+ set fstring .tf.lbar.findstring
+ lappend entries $fstring
+ entry $fstring -width 30 -font textfont -textvariable findstring
+ trace add variable findstring write find_change
+ set findtype Exact
+ set findtypemenu [tk_optionMenu .tf.lbar.findtype \
+ findtype Exact IgnCase Regexp]
+ trace add variable findtype write findcom_change
+ .tf.lbar.findtype configure -font uifont
+ .tf.lbar.findtype.menu configure -font uifont
+ set findloc "All fields"
+ tk_optionMenu .tf.lbar.findloc findloc "All fields" Headline \
+ Comments Author Committer
+ trace add variable findloc write find_change
+ .tf.lbar.findloc configure -font uifont
+ .tf.lbar.findloc.menu configure -font uifont
+ pack .tf.lbar.findloc -side right
+ pack .tf.lbar.findtype -side right
+ pack $fstring -side left -expand 1 -fill x
+
+ # Finish putting the upper half of the viewer together
+ pack .tf.lbar -in .tf -side bottom -fill x
+ pack .tf.bar -in .tf -side bottom -fill x
+ pack .tf.histframe -fill both -side top -expand 1
+ .ctop add .tf
+ .ctop paneconfigure .tf -height $geometry(topheight)
+ .ctop paneconfigure .tf -width $geometry(topwidth)
+
+ # now build up the bottom
+ panedwindow .pwbottom -orient horizontal
+
+ # lower left, a text box over search bar, scroll bar to the right
+ # if we know window height, then that will set the lower text height, otherwise
+ # we set lower text height which will drive window height
+ if {[info exists geometry(main)]} {
+ frame .bleft -width $geometry(botwidth)
+ } else {
+ frame .bleft -width $geometry(botwidth) -height $geometry(botheight)
+ }
+ frame .bleft.top
+ frame .bleft.mid
+
+ button .bleft.top.search -text "Search" -command dosearch \
+ -font uifont
+ pack .bleft.top.search -side left -padx 5
+ set sstring .bleft.top.sstring
+ entry $sstring -width 20 -font textfont -textvariable searchstring
+ lappend entries $sstring
+ trace add variable searchstring write incrsearch
+ pack $sstring -side left -expand 1 -fill x
+ radiobutton .bleft.mid.diff -text "Diff" -font uifont \
+ -command changediffdisp -variable diffelide -value {0 0}
+ radiobutton .bleft.mid.old -text "Old version" -font uifont \
+ -command changediffdisp -variable diffelide -value {0 1}
+ radiobutton .bleft.mid.new -text "New version" -font uifont \
+ -command changediffdisp -variable diffelide -value {1 0}
+ label .bleft.mid.labeldiffcontext -text " Lines of context: " \
+ -font uifont
+ pack .bleft.mid.diff .bleft.mid.old .bleft.mid.new -side left
+ spinbox .bleft.mid.diffcontext -width 5 -font textfont \
+ -from 1 -increment 1 -to 10000000 \
+ -validate all -validatecommand "diffcontextvalidate %P" \
+ -textvariable diffcontextstring
+ .bleft.mid.diffcontext set $diffcontext
+ trace add variable diffcontextstring write diffcontextchange
+ lappend entries .bleft.mid.diffcontext
+ pack .bleft.mid.labeldiffcontext .bleft.mid.diffcontext -side left
+ set ctext .bleft.ctext
+ text $ctext -background $bgcolor -foreground $fgcolor \
+ -state disabled -font textfont \
+ -yscrollcommand scrolltext -wrap none
+ if {$have_tk85} {
+ $ctext conf -tabstyle wordprocessor
+ }
+ scrollbar .bleft.sb -command "$ctext yview"
+ pack .bleft.top -side top -fill x
+ pack .bleft.mid -side top -fill x
+ pack .bleft.sb -side right -fill y
+ pack $ctext -side left -fill both -expand 1
+ lappend bglist $ctext
+ lappend fglist $ctext
+
+ $ctext tag conf comment -wrap $wrapcomment
+ $ctext tag conf filesep -font textfontbold -back "#aaaaaa"
+ $ctext tag conf hunksep -fore [lindex $diffcolors 2]
+ $ctext tag conf d0 -fore [lindex $diffcolors 0]
+ $ctext tag conf d1 -fore [lindex $diffcolors 1]
+ $ctext tag conf m0 -fore red
+ $ctext tag conf m1 -fore blue
+ $ctext tag conf m2 -fore green
+ $ctext tag conf m3 -fore purple
+ $ctext tag conf m4 -fore brown
+ $ctext tag conf m5 -fore "#009090"
+ $ctext tag conf m6 -fore magenta
+ $ctext tag conf m7 -fore "#808000"
+ $ctext tag conf m8 -fore "#009000"
+ $ctext tag conf m9 -fore "#ff0080"
+ $ctext tag conf m10 -fore cyan
+ $ctext tag conf m11 -fore "#b07070"
+ $ctext tag conf m12 -fore "#70b0f0"
+ $ctext tag conf m13 -fore "#70f0b0"
+ $ctext tag conf m14 -fore "#f0b070"
+ $ctext tag conf m15 -fore "#ff70b0"
+ $ctext tag conf mmax -fore darkgrey
+ set mergemax 16
+ $ctext tag conf mresult -font textfontbold
+ $ctext tag conf msep -font textfontbold
+ $ctext tag conf found -back yellow
+
+ .pwbottom add .bleft
+ .pwbottom paneconfigure .bleft -width $geometry(botwidth)
+
+ # lower right
+ frame .bright
+ frame .bright.mode
+ radiobutton .bright.mode.patch -text "Patch" \
+ -command reselectline -variable cmitmode -value "patch"
+ .bright.mode.patch configure -font uifont
+ radiobutton .bright.mode.tree -text "Tree" \
+ -command reselectline -variable cmitmode -value "tree"
+ .bright.mode.tree configure -font uifont
+ grid .bright.mode.patch .bright.mode.tree -sticky ew
+ pack .bright.mode -side top -fill x
+ set cflist .bright.cfiles
+ set indent [font measure mainfont "nn"]
+ text $cflist \
+ -selectbackground $selectbgcolor \
+ -background $bgcolor -foreground $fgcolor \
+ -font mainfont \
+ -tabs [list $indent [expr {2 * $indent}]] \
+ -yscrollcommand ".bright.sb set" \
+ -cursor [. cget -cursor] \
+ -spacing1 1 -spacing3 1
+ lappend bglist $cflist
+ lappend fglist $cflist
+ scrollbar .bright.sb -command "$cflist yview"
+ pack .bright.sb -side right -fill y
+ pack $cflist -side left -fill both -expand 1
+ $cflist tag configure highlight \
+ -background [$cflist cget -selectbackground]
+ $cflist tag configure bold -font mainfontbold
+
+ .pwbottom add .bright
+ .ctop add .pwbottom
+
+ # restore window position if known
+ if {[info exists geometry(main)]} {
+ wm geometry . "$geometry(main)"
+ }
+
+ if {[tk windowingsystem] eq {aqua}} {
+ set M1B M1
+ } else {
+ set M1B Control
+ }
+
+ bind .pwbottom <Configure> {resizecdetpanes %W %w}
+ pack .ctop -fill both -expand 1
+ bindall <1> {selcanvline %W %x %y}
+ #bindall <B1-Motion> {selcanvline %W %x %y}
+ if {[tk windowingsystem] == "win32"} {
+ bind . <MouseWheel> { windows_mousewheel_redirector %W %X %Y %D }
+ bind $ctext <MouseWheel> { windows_mousewheel_redirector %W %X %Y %D ; break }
+ } else {
+ bindall <ButtonRelease-4> "allcanvs yview scroll -5 units"
+ bindall <ButtonRelease-5> "allcanvs yview scroll 5 units"
+ if {[tk windowingsystem] eq "aqua"} {
+ bindall <MouseWheel> {
+ set delta [expr {- (%D)}]
+ allcanvs yview scroll $delta units
+ }
+ }
+ }
+ bindall <2> "canvscan mark %W %x %y"
+ bindall <B2-Motion> "canvscan dragto %W %x %y"
+ bindkey <Home> selfirstline
+ bindkey <End> sellastline
+ bind . <Key-Up> "selnextline -1"
+ bind . <Key-Down> "selnextline 1"
+ bind . <Shift-Key-Up> "dofind -1 0"
+ bind . <Shift-Key-Down> "dofind 1 0"
+ bindkey <Key-Right> "goforw"
+ bindkey <Key-Left> "goback"
+ bind . <Key-Prior> "selnextpage -1"
+ bind . <Key-Next> "selnextpage 1"
+ bind . <$M1B-Home> "allcanvs yview moveto 0.0"
+ bind . <$M1B-End> "allcanvs yview moveto 1.0"
+ bind . <$M1B-Key-Up> "allcanvs yview scroll -1 units"
+ bind . <$M1B-Key-Down> "allcanvs yview scroll 1 units"
+ bind . <$M1B-Key-Prior> "allcanvs yview scroll -1 pages"
+ bind . <$M1B-Key-Next> "allcanvs yview scroll 1 pages"
+ bindkey <Key-Delete> "$ctext yview scroll -1 pages"
+ bindkey <Key-BackSpace> "$ctext yview scroll -1 pages"
+ bindkey <Key-space> "$ctext yview scroll 1 pages"
+ bindkey p "selnextline -1"
+ bindkey n "selnextline 1"
+ bindkey z "goback"
+ bindkey x "goforw"
+ bindkey i "selnextline -1"
+ bindkey k "selnextline 1"
+ bindkey j "goback"
+ bindkey l "goforw"
+ bindkey b "$ctext yview scroll -1 pages"
+ bindkey d "$ctext yview scroll 18 units"
+ bindkey u "$ctext yview scroll -18 units"
+ bindkey / {dofind 1 1}
+ bindkey <Key-Return> {dofind 1 1}
+ bindkey ? {dofind -1 1}
+ bindkey f nextfile
+ bindkey <F5> updatecommits
+ bind . <$M1B-q> doquit
+ bind . <$M1B-f> {dofind 1 1}
+ bind . <$M1B-g> {dofind 1 0}
+ bind . <$M1B-r> dosearchback
+ bind . <$M1B-s> dosearch
+ bind . <$M1B-equal> {incrfont 1}
+ bind . <$M1B-KP_Add> {incrfont 1}
+ bind . <$M1B-minus> {incrfont -1}
+ bind . <$M1B-KP_Subtract> {incrfont -1}
+ wm protocol . WM_DELETE_WINDOW doquit
+ bind . <Button-1> "click %W"
+ bind $fstring <Key-Return> {dofind 1 1}
+ bind $sha1entry <Key-Return> gotocommit
+ bind $sha1entry <<PasteSelection>> clearsha1
+ bind $cflist <1> {sel_flist %W %x %y; break}
+ bind $cflist <B1-Motion> {sel_flist %W %x %y; break}
+ bind $cflist <ButtonRelease-1> {treeclick %W %x %y}
+ bind $cflist <Button-3> {pop_flist_menu %W %X %Y %x %y}
+
+ set maincursor [. cget -cursor]
+ set textcursor [$ctext cget -cursor]
+ set curtextcursor $textcursor
+
+ set rowctxmenu .rowctxmenu
+ menu $rowctxmenu -tearoff 0
+ $rowctxmenu add command -label "Diff this -> selected" \
+ -command {diffvssel 0}
+ $rowctxmenu add command -label "Diff selected -> this" \
+ -command {diffvssel 1}
+ $rowctxmenu add command -label "Make patch" -command mkpatch
+ $rowctxmenu add command -label "Create tag" -command mktag
+ $rowctxmenu add command -label "Write commit to file" -command writecommit
+ $rowctxmenu add command -label "Create new branch" -command mkbranch
+ $rowctxmenu add command -label "Cherry-pick this commit" \
+ -command cherrypick
+ $rowctxmenu add command -label "Reset HEAD branch to here" \
+ -command resethead
+
+ set fakerowmenu .fakerowmenu
+ menu $fakerowmenu -tearoff 0
+ $fakerowmenu add command -label "Diff this -> selected" \
+ -command {diffvssel 0}
+ $fakerowmenu add command -label "Diff selected -> this" \
+ -command {diffvssel 1}
+ $fakerowmenu add command -label "Make patch" -command mkpatch
+# $fakerowmenu add command -label "Commit" -command {mkcommit 0}
+# $fakerowmenu add command -label "Commit all" -command {mkcommit 1}
+# $fakerowmenu add command -label "Revert local changes" -command revertlocal
+
+ set headctxmenu .headctxmenu
+ menu $headctxmenu -tearoff 0
+ $headctxmenu add command -label "Check out this branch" \
+ -command cobranch
+ $headctxmenu add command -label "Remove this branch" \
+ -command rmbranch
+
+ global flist_menu
+ set flist_menu .flistctxmenu
+ menu $flist_menu -tearoff 0
+ $flist_menu add command -label "Highlight this too" \
+ -command {flist_hl 0}
+ $flist_menu add command -label "Highlight this only" \
+ -command {flist_hl 1}
+}
+
+# Windows sends all mouse wheel events to the current focused window, not
+# the one where the mouse hovers, so bind those events here and redirect
+# to the correct window
+proc windows_mousewheel_redirector {W X Y D} {
+ global canv canv2 canv3
+ set w [winfo containing -displayof $W $X $Y]
+ if {$w ne ""} {
+ set u [expr {$D < 0 ? 5 : -5}]
+ if {$w == $canv || $w == $canv2 || $w == $canv3} {
+ allcanvs yview scroll $u units
+ } else {
+ catch {
+ $w yview scroll $u units
+ }
+ }
+ }
+}
+
+# mouse-2 makes all windows scan vertically, but only the one
+# the cursor is in scans horizontally
+proc canvscan {op w x y} {
+ global canv canv2 canv3
+ foreach c [list $canv $canv2 $canv3] {
+ if {$c == $w} {
+ $c scan $op $x $y
+ } else {
+ $c scan $op 0 $y
+ }
+ }
+}
+
+proc scrollcanv {cscroll f0 f1} {
+ $cscroll set $f0 $f1
+ drawfrac $f0 $f1
+ flushhighlights
+}
+
+# when we make a key binding for the toplevel, make sure
+# it doesn't get triggered when that key is pressed in the
+# find string entry widget.
+proc bindkey {ev script} {
+ global entries
+ bind . $ev $script
+ set escript [bind Entry $ev]
+ if {$escript == {}} {
+ set escript [bind Entry <Key>]
+ }
+ foreach e $entries {
+ bind $e $ev "$escript; break"
+ }
+}
+
+# set the focus back to the toplevel for any click outside
+# the entry widgets
+proc click {w} {
+ global ctext entries
+ foreach e [concat $entries $ctext] {
+ if {$w == $e} return
+ }
+ focus .
+}
+
+# Adjust the progress bar for a change in requested extent or canvas size
+proc adjustprogress {} {
+ global progresscanv progressitem progresscoords
+ global fprogitem fprogcoord lastprogupdate progupdatepending
+ global rprogitem rprogcoord
+
+ set w [expr {[winfo width $progresscanv] - 4}]
+ set x0 [expr {$w * [lindex $progresscoords 0]}]
+ set x1 [expr {$w * [lindex $progresscoords 1]}]
+ set h [winfo height $progresscanv]
+ $progresscanv coords $progressitem $x0 0 $x1 $h
+ $progresscanv coords $fprogitem 0 0 [expr {$w * $fprogcoord}] $h
+ $progresscanv coords $rprogitem 0 0 [expr {$w * $rprogcoord}] $h
+ set now [clock clicks -milliseconds]
+ if {$now >= $lastprogupdate + 100} {
+ set progupdatepending 0
+ update
+ } elseif {!$progupdatepending} {
+ set progupdatepending 1
+ after [expr {$lastprogupdate + 100 - $now}] doprogupdate
+ }
+}
+
+proc doprogupdate {} {
+ global lastprogupdate progupdatepending
+
+ if {$progupdatepending} {
+ set progupdatepending 0
+ set lastprogupdate [clock clicks -milliseconds]
+ update
+ }
+}
+
+proc savestuff {w} {
+ global canv canv2 canv3 mainfont textfont uifont tabstop
+ global stuffsaved findmergefiles maxgraphpct
+ global maxwidth showneartags showlocalchanges
+ global viewname viewfiles viewargs viewperm nextviewnum
+ global cmitmode wrapcomment datetimeformat limitdiffs
+ global colors bgcolor fgcolor diffcolors diffcontext selectbgcolor
+
+ if {$stuffsaved} return
+ if {![winfo viewable .]} return
+ catch {
+ set f [open "~/.gitk-new" w]
+ puts $f [list set mainfont $mainfont]
+ puts $f [list set textfont $textfont]
+ puts $f [list set uifont $uifont]
+ puts $f [list set tabstop $tabstop]
+ puts $f [list set findmergefiles $findmergefiles]
+ puts $f [list set maxgraphpct $maxgraphpct]
+ puts $f [list set maxwidth $maxwidth]
+ puts $f [list set cmitmode $cmitmode]
+ puts $f [list set wrapcomment $wrapcomment]
+ puts $f [list set showneartags $showneartags]
+ puts $f [list set showlocalchanges $showlocalchanges]
+ puts $f [list set datetimeformat $datetimeformat]
+ puts $f [list set limitdiffs $limitdiffs]
+ puts $f [list set bgcolor $bgcolor]
+ puts $f [list set fgcolor $fgcolor]
+ puts $f [list set colors $colors]
+ puts $f [list set diffcolors $diffcolors]
+ puts $f [list set diffcontext $diffcontext]
+ puts $f [list set selectbgcolor $selectbgcolor]
+
+ puts $f "set geometry(main) [wm geometry .]"
+ puts $f "set geometry(topwidth) [winfo width .tf]"
+ puts $f "set geometry(topheight) [winfo height .tf]"
+ puts $f "set geometry(pwsash0) \"[.tf.histframe.pwclist sash coord 0]\""
+ puts $f "set geometry(pwsash1) \"[.tf.histframe.pwclist sash coord 1]\""
+ puts $f "set geometry(botwidth) [winfo width .bleft]"
+ puts $f "set geometry(botheight) [winfo height .bleft]"
+
+ puts -nonewline $f "set permviews {"
+ for {set v 0} {$v < $nextviewnum} {incr v} {
+ if {$viewperm($v)} {
+ puts $f "{[list $viewname($v) $viewfiles($v) $viewargs($v)]}"
+ }
+ }
+ puts $f "}"
+ close $f
+ file rename -force "~/.gitk-new" "~/.gitk"
+ }
+ set stuffsaved 1
+}
+
+proc resizeclistpanes {win w} {
+ global oldwidth
+ if {[info exists oldwidth($win)]} {
+ set s0 [$win sash coord 0]
+ set s1 [$win sash coord 1]
+ if {$w < 60} {
+ set sash0 [expr {int($w/2 - 2)}]
+ set sash1 [expr {int($w*5/6 - 2)}]
+ } else {
+ set factor [expr {1.0 * $w / $oldwidth($win)}]
+ set sash0 [expr {int($factor * [lindex $s0 0])}]
+ set sash1 [expr {int($factor * [lindex $s1 0])}]
+ if {$sash0 < 30} {
+ set sash0 30
+ }
+ if {$sash1 < $sash0 + 20} {
+ set sash1 [expr {$sash0 + 20}]
+ }
+ if {$sash1 > $w - 10} {
+ set sash1 [expr {$w - 10}]
+ if {$sash0 > $sash1 - 20} {
+ set sash0 [expr {$sash1 - 20}]
+ }
+ }
+ }
+ $win sash place 0 $sash0 [lindex $s0 1]
+ $win sash place 1 $sash1 [lindex $s1 1]
+ }
+ set oldwidth($win) $w
+}
+
+proc resizecdetpanes {win w} {
+ global oldwidth
+ if {[info exists oldwidth($win)]} {
+ set s0 [$win sash coord 0]
+ if {$w < 60} {
+ set sash0 [expr {int($w*3/4 - 2)}]
+ } else {
+ set factor [expr {1.0 * $w / $oldwidth($win)}]
+ set sash0 [expr {int($factor * [lindex $s0 0])}]
+ if {$sash0 < 45} {
+ set sash0 45
+ }
+ if {$sash0 > $w - 15} {
+ set sash0 [expr {$w - 15}]
+ }
+ }
+ $win sash place 0 $sash0 [lindex $s0 1]
+ }
+ set oldwidth($win) $w
+}
+
+proc allcanvs args {
+ global canv canv2 canv3
+ eval $canv $args
+ eval $canv2 $args
+ eval $canv3 $args
+}
+
+proc bindall {event action} {
+ global canv canv2 canv3
+ bind $canv $event $action
+ bind $canv2 $event $action
+ bind $canv3 $event $action
+}
+
+proc about {} {
+ global uifont
+ set w .about
+ if {[winfo exists $w]} {
+ raise $w
+ return
+ }
+ toplevel $w
+ wm title $w "About gitk"
+ message $w.m -text {
+Gitk - a commit viewer for git
+
+Copyright © 2005-2006 Paul Mackerras
+
+Use and redistribute under the terms of the GNU General Public License} \
+ -justify center -aspect 400 -border 2 -bg white -relief groove
+ pack $w.m -side top -fill x -padx 2 -pady 2
+ $w.m configure -font uifont
+ button $w.ok -text Close -command "destroy $w" -default active
+ pack $w.ok -side bottom
+ $w.ok configure -font uifont
+ bind $w <Visibility> "focus $w.ok"
+ bind $w <Key-Escape> "destroy $w"
+ bind $w <Key-Return> "destroy $w"
+}
+
+proc keys {} {
+ global uifont
+ set w .keys
+ if {[winfo exists $w]} {
+ raise $w
+ return
+ }
+ if {[tk windowingsystem] eq {aqua}} {
+ set M1T Cmd
+ } else {
+ set M1T Ctrl
+ }
+ toplevel $w
+ wm title $w "Gitk key bindings"
+ message $w.m -text "
+Gitk key bindings:
+
+<$M1T-Q> Quit
+<Home> Move to first commit
+<End> Move to last commit
+<Up>, p, i Move up one commit
+<Down>, n, k Move down one commit
+<Left>, z, j Go back in history list
+<Right>, x, l Go forward in history list
+<PageUp> Move up one page in commit list
+<PageDown> Move down one page in commit list
+<$M1T-Home> Scroll to top of commit list
+<$M1T-End> Scroll to bottom of commit list
+<$M1T-Up> Scroll commit list up one line
+<$M1T-Down> Scroll commit list down one line
+<$M1T-PageUp> Scroll commit list up one page
+<$M1T-PageDown> Scroll commit list down one page
+<Shift-Up> Find backwards (upwards, later commits)
+<Shift-Down> Find forwards (downwards, earlier commits)
+<Delete>, b Scroll diff view up one page
+<Backspace> Scroll diff view up one page
+<Space> Scroll diff view down one page
+u Scroll diff view up 18 lines
+d Scroll diff view down 18 lines
+<$M1T-F> Find
+<$M1T-G> Move to next find hit
+<Return> Move to next find hit
+/ Move to next find hit, or redo find
+? Move to previous find hit
+f Scroll diff view to next file
+<$M1T-S> Search for next hit in diff view
+<$M1T-R> Search for previous hit in diff view
+<$M1T-KP+> Increase font size
+<$M1T-plus> Increase font size
+<$M1T-KP-> Decrease font size
+<$M1T-minus> Decrease font size
+<F5> Update
+" \
+ -justify left -bg white -border 2 -relief groove
+ pack $w.m -side top -fill both -padx 2 -pady 2
+ $w.m configure -font uifont
+ button $w.ok -text Close -command "destroy $w" -default active
+ pack $w.ok -side bottom
+ $w.ok configure -font uifont
+ bind $w <Visibility> "focus $w.ok"
+ bind $w <Key-Escape> "destroy $w"
+ bind $w <Key-Return> "destroy $w"
+}
+
+# Procedures for manipulating the file list window at the
+# bottom right of the overall window.
+
+proc treeview {w l openlevs} {
+ global treecontents treediropen treeheight treeparent treeindex
+
+ set ix 0
+ set treeindex() 0
+ set lev 0
+ set prefix {}
+ set prefixend -1
+ set prefendstack {}
+ set htstack {}
+ set ht 0
+ set treecontents() {}
+ $w conf -state normal
+ foreach f $l {
+ while {[string range $f 0 $prefixend] ne $prefix} {
+ if {$lev <= $openlevs} {
+ $w mark set e:$treeindex($prefix) "end -1c"
+ $w mark gravity e:$treeindex($prefix) left
+ }
+ set treeheight($prefix) $ht
+ incr ht [lindex $htstack end]
+ set htstack [lreplace $htstack end end]
+ set prefixend [lindex $prefendstack end]
+ set prefendstack [lreplace $prefendstack end end]
+ set prefix [string range $prefix 0 $prefixend]
+ incr lev -1
+ }
+ set tail [string range $f [expr {$prefixend+1}] end]
+ while {[set slash [string first "/" $tail]] >= 0} {
+ lappend htstack $ht
+ set ht 0
+ lappend prefendstack $prefixend
+ incr prefixend [expr {$slash + 1}]
+ set d [string range $tail 0 $slash]
+ lappend treecontents($prefix) $d
+ set oldprefix $prefix
+ append prefix $d
+ set treecontents($prefix) {}
+ set treeindex($prefix) [incr ix]
+ set treeparent($prefix) $oldprefix
+ set tail [string range $tail [expr {$slash+1}] end]
+ if {$lev <= $openlevs} {
+ set ht 1
+ set treediropen($prefix) [expr {$lev < $openlevs}]
+ set bm [expr {$lev == $openlevs? "tri-rt": "tri-dn"}]
+ $w mark set d:$ix "end -1c"
+ $w mark gravity d:$ix left
+ set str "\n"
+ for {set i 0} {$i < $lev} {incr i} {append str "\t"}
+ $w insert end $str
+ $w image create end -align center -image $bm -padx 1 \
+ -name a:$ix
+ $w insert end $d [highlight_tag $prefix]
+ $w mark set s:$ix "end -1c"
+ $w mark gravity s:$ix left
+ }
+ incr lev
+ }
+ if {$tail ne {}} {
+ if {$lev <= $openlevs} {
+ incr ht
+ set str "\n"
+ for {set i 0} {$i < $lev} {incr i} {append str "\t"}
+ $w insert end $str
+ $w insert end $tail [highlight_tag $f]
+ }
+ lappend treecontents($prefix) $tail
+ }
+ }
+ while {$htstack ne {}} {
+ set treeheight($prefix) $ht
+ incr ht [lindex $htstack end]
+ set htstack [lreplace $htstack end end]
+ set prefixend [lindex $prefendstack end]
+ set prefendstack [lreplace $prefendstack end end]
+ set prefix [string range $prefix 0 $prefixend]
+ }
+ $w conf -state disabled
+}
+
+proc linetoelt {l} {
+ global treeheight treecontents
+
+ set y 2
+ set prefix {}
+ while {1} {
+ foreach e $treecontents($prefix) {
+ if {$y == $l} {
+ return "$prefix$e"
+ }
+ set n 1
+ if {[string index $e end] eq "/"} {
+ set n $treeheight($prefix$e)
+ if {$y + $n > $l} {
+ append prefix $e
+ incr y
+ break
+ }
+ }
+ incr y $n
+ }
+ }
+}
+
+proc highlight_tree {y prefix} {
+ global treeheight treecontents cflist
+
+ foreach e $treecontents($prefix) {
+ set path $prefix$e
+ if {[highlight_tag $path] ne {}} {
+ $cflist tag add bold $y.0 "$y.0 lineend"
+ }
+ incr y
+ if {[string index $e end] eq "/" && $treeheight($path) > 1} {
+ set y [highlight_tree $y $path]
+ }
+ }
+ return $y
+}
+
+proc treeclosedir {w dir} {
+ global treediropen treeheight treeparent treeindex
+
+ set ix $treeindex($dir)
+ $w conf -state normal
+ $w delete s:$ix e:$ix
+ set treediropen($dir) 0
+ $w image configure a:$ix -image tri-rt
+ $w conf -state disabled
+ set n [expr {1 - $treeheight($dir)}]
+ while {$dir ne {}} {
+ incr treeheight($dir) $n
+ set dir $treeparent($dir)
+ }
+}
+
+proc treeopendir {w dir} {
+ global treediropen treeheight treeparent treecontents treeindex
+
+ set ix $treeindex($dir)
+ $w conf -state normal
+ $w image configure a:$ix -image tri-dn
+ $w mark set e:$ix s:$ix
+ $w mark gravity e:$ix right
+ set lev 0
+ set str "\n"
+ set n [llength $treecontents($dir)]
+ for {set x $dir} {$x ne {}} {set x $treeparent($x)} {
+ incr lev
+ append str "\t"
+ incr treeheight($x) $n
+ }
+ foreach e $treecontents($dir) {
+ set de $dir$e
+ if {[string index $e end] eq "/"} {
+ set iy $treeindex($de)
+ $w mark set d:$iy e:$ix
+ $w mark gravity d:$iy left
+ $w insert e:$ix $str
+ set treediropen($de) 0
+ $w image create e:$ix -align center -image tri-rt -padx 1 \
+ -name a:$iy
+ $w insert e:$ix $e [highlight_tag $de]
+ $w mark set s:$iy e:$ix
+ $w mark gravity s:$iy left
+ set treeheight($de) 1
+ } else {
+ $w insert e:$ix $str
+ $w insert e:$ix $e [highlight_tag $de]
+ }
+ }
+ $w mark gravity e:$ix left
+ $w conf -state disabled
+ set treediropen($dir) 1
+ set top [lindex [split [$w index @0,0] .] 0]
+ set ht [$w cget -height]
+ set l [lindex [split [$w index s:$ix] .] 0]
+ if {$l < $top} {
+ $w yview $l.0
+ } elseif {$l + $n + 1 > $top + $ht} {
+ set top [expr {$l + $n + 2 - $ht}]
+ if {$l < $top} {
+ set top $l
+ }
+ $w yview $top.0
+ }
+}
+
+proc treeclick {w x y} {
+ global treediropen cmitmode ctext cflist cflist_top
+
+ if {$cmitmode ne "tree"} return
+ if {![info exists cflist_top]} return
+ set l [lindex [split [$w index "@$x,$y"] "."] 0]
+ $cflist tag remove highlight $cflist_top.0 "$cflist_top.0 lineend"
+ $cflist tag add highlight $l.0 "$l.0 lineend"
+ set cflist_top $l
+ if {$l == 1} {
+ $ctext yview 1.0
+ return
+ }
+ set e [linetoelt $l]
+ if {[string index $e end] ne "/"} {
+ showfile $e
+ } elseif {$treediropen($e)} {
+ treeclosedir $w $e
+ } else {
+ treeopendir $w $e
+ }
+}
+
+proc setfilelist {id} {
+ global treefilelist cflist
+
+ treeview $cflist $treefilelist($id) 0
+}
+
+image create bitmap tri-rt -background black -foreground blue -data {
+ #define tri-rt_width 13
+ #define tri-rt_height 13
+ static unsigned char tri-rt_bits[] = {
+ 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x30, 0x00, 0x70, 0x00, 0xf0, 0x00,
+ 0xf0, 0x01, 0xf0, 0x00, 0x70, 0x00, 0x30, 0x00, 0x10, 0x00, 0x00, 0x00,
+ 0x00, 0x00};
+} -maskdata {
+ #define tri-rt-mask_width 13
+ #define tri-rt-mask_height 13
+ static unsigned char tri-rt-mask_bits[] = {
+ 0x08, 0x00, 0x18, 0x00, 0x38, 0x00, 0x78, 0x00, 0xf8, 0x00, 0xf8, 0x01,
+ 0xf8, 0x03, 0xf8, 0x01, 0xf8, 0x00, 0x78, 0x00, 0x38, 0x00, 0x18, 0x00,
+ 0x08, 0x00};
+}
+image create bitmap tri-dn -background black -foreground blue -data {
+ #define tri-dn_width 13
+ #define tri-dn_height 13
+ static unsigned char tri-dn_bits[] = {
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0x07, 0xf8, 0x03,
+ 0xf0, 0x01, 0xe0, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00};
+} -maskdata {
+ #define tri-dn-mask_width 13
+ #define tri-dn-mask_height 13
+ static unsigned char tri-dn-mask_bits[] = {
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x1f, 0xfe, 0x0f, 0xfc, 0x07,
+ 0xf8, 0x03, 0xf0, 0x01, 0xe0, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00};
+}
+
+image create bitmap reficon-T -background black -foreground yellow -data {
+ #define tagicon_width 13
+ #define tagicon_height 9
+ static unsigned char tagicon_bits[] = {
+ 0x00, 0x00, 0x00, 0x00, 0xf0, 0x07, 0xf8, 0x07,
+ 0xfc, 0x07, 0xf8, 0x07, 0xf0, 0x07, 0x00, 0x00, 0x00, 0x00};
+} -maskdata {
+ #define tagicon-mask_width 13
+ #define tagicon-mask_height 9
+ static unsigned char tagicon-mask_bits[] = {
+ 0x00, 0x00, 0xf0, 0x0f, 0xf8, 0x0f, 0xfc, 0x0f,
+ 0xfe, 0x0f, 0xfc, 0x0f, 0xf8, 0x0f, 0xf0, 0x0f, 0x00, 0x00};
+}
+set rectdata {
+ #define headicon_width 13
+ #define headicon_height 9
+ static unsigned char headicon_bits[] = {
+ 0x00, 0x00, 0x00, 0x00, 0xf8, 0x07, 0xf8, 0x07,
+ 0xf8, 0x07, 0xf8, 0x07, 0xf8, 0x07, 0x00, 0x00, 0x00, 0x00};
+}
+set rectmask {
+ #define headicon-mask_width 13
+ #define headicon-mask_height 9
+ static unsigned char headicon-mask_bits[] = {
+ 0x00, 0x00, 0xfc, 0x0f, 0xfc, 0x0f, 0xfc, 0x0f,
+ 0xfc, 0x0f, 0xfc, 0x0f, 0xfc, 0x0f, 0xfc, 0x0f, 0x00, 0x00};
+}
+image create bitmap reficon-H -background black -foreground green \
+ -data $rectdata -maskdata $rectmask
+image create bitmap reficon-o -background black -foreground "#ddddff" \
+ -data $rectdata -maskdata $rectmask
+
+proc init_flist {first} {
+ global cflist cflist_top selectedline difffilestart
+
+ $cflist conf -state normal
+ $cflist delete 0.0 end
+ if {$first ne {}} {
+ $cflist insert end $first
+ set cflist_top 1
+ $cflist tag add highlight 1.0 "1.0 lineend"
+ } else {
+ catch {unset cflist_top}
+ }
+ $cflist conf -state disabled
+ set difffilestart {}
+}
+
+proc highlight_tag {f} {
+ global highlight_paths
+
+ foreach p $highlight_paths {
+ if {[string match $p $f]} {
+ return "bold"
+ }
+ }
+ return {}
+}
+
+proc highlight_filelist {} {
+ global cmitmode cflist
+
+ $cflist conf -state normal
+ if {$cmitmode ne "tree"} {
+ set end [lindex [split [$cflist index end] .] 0]
+ for {set l 2} {$l < $end} {incr l} {
+ set line [$cflist get $l.0 "$l.0 lineend"]
+ if {[highlight_tag $line] ne {}} {
+ $cflist tag add bold $l.0 "$l.0 lineend"
+ }
+ }
+ } else {
+ highlight_tree 2 {}
+ }
+ $cflist conf -state disabled
+}
+
+proc unhighlight_filelist {} {
+ global cflist
+
+ $cflist conf -state normal
+ $cflist tag remove bold 1.0 end
+ $cflist conf -state disabled
+}
+
+proc add_flist {fl} {
+ global cflist
+
+ $cflist conf -state normal
+ foreach f $fl {
+ $cflist insert end "\n"
+ $cflist insert end $f [highlight_tag $f]
+ }
+ $cflist conf -state disabled
+}
+
+proc sel_flist {w x y} {
+ global ctext difffilestart cflist cflist_top cmitmode
+
+ if {$cmitmode eq "tree"} return
+ if {![info exists cflist_top]} return
+ set l [lindex [split [$w index "@$x,$y"] "."] 0]
+ $cflist tag remove highlight $cflist_top.0 "$cflist_top.0 lineend"
+ $cflist tag add highlight $l.0 "$l.0 lineend"
+ set cflist_top $l
+ if {$l == 1} {
+ $ctext yview 1.0
+ } else {
+ catch {$ctext yview [lindex $difffilestart [expr {$l - 2}]]}
+ }
+}
+
+proc pop_flist_menu {w X Y x y} {
+ global ctext cflist cmitmode flist_menu flist_menu_file
+ global treediffs diffids
+
+ stopfinding
+ set l [lindex [split [$w index "@$x,$y"] "."] 0]
+ if {$l <= 1} return
+ if {$cmitmode eq "tree"} {
+ set e [linetoelt $l]
+ if {[string index $e end] eq "/"} return
+ } else {
+ set e [lindex $treediffs($diffids) [expr {$l-2}]]
+ }
+ set flist_menu_file $e
+ tk_popup $flist_menu $X $Y
+}
+
+proc flist_hl {only} {
+ global flist_menu_file findstring gdttype
+
+ set x [shellquote $flist_menu_file]
+ if {$only || $findstring eq {} || $gdttype ne "touching paths:"} {
+ set findstring $x
+ } else {
+ append findstring " " $x
+ }
+ set gdttype "touching paths:"
+}
+
+# Functions for adding and removing shell-type quoting
+
+proc shellquote {str} {
+ if {![string match "*\['\"\\ \t]*" $str]} {
+ return $str
+ }
+ if {![string match "*\['\"\\]*" $str]} {
+ return "\"$str\""
+ }
+ if {![string match "*'*" $str]} {
+ return "'$str'"
+ }
+ return "\"[string map {\" \\\" \\ \\\\} $str]\""
+}
+
+proc shellarglist {l} {
+ set str {}
+ foreach a $l {
+ if {$str ne {}} {
+ append str " "
+ }
+ append str [shellquote $a]
+ }
+ return $str
+}
+
+proc shelldequote {str} {
+ set ret {}
+ set used -1
+ while {1} {
+ incr used
+ if {![regexp -start $used -indices "\['\"\\\\ \t]" $str first]} {
+ append ret [string range $str $used end]
+ set used [string length $str]
+ break
+ }
+ set first [lindex $first 0]
+ set ch [string index $str $first]
+ if {$first > $used} {
+ append ret [string range $str $used [expr {$first - 1}]]
+ set used $first
+ }
+ if {$ch eq " " || $ch eq "\t"} break
+ incr used
+ if {$ch eq "'"} {
+ set first [string first "'" $str $used]
+ if {$first < 0} {
+ error "unmatched single-quote"
+ }
+ append ret [string range $str $used [expr {$first - 1}]]
+ set used $first
+ continue
+ }
+ if {$ch eq "\\"} {
+ if {$used >= [string length $str]} {
+ error "trailing backslash"
+ }
+ append ret [string index $str $used]
+ continue
+ }
+ # here ch == "\""
+ while {1} {
+ if {![regexp -start $used -indices "\[\"\\\\]" $str first]} {
+ error "unmatched double-quote"
+ }
+ set first [lindex $first 0]
+ set ch [string index $str $first]
+ if {$first > $used} {
+ append ret [string range $str $used [expr {$first - 1}]]
+ set used $first
+ }
+ if {$ch eq "\""} break
+ incr used
+ append ret [string index $str $used]
+ incr used
+ }
+ }
+ return [list $used $ret]
+}
+
+proc shellsplit {str} {
+ set l {}
+ while {1} {
+ set str [string trimleft $str]
+ if {$str eq {}} break
+ set dq [shelldequote $str]
+ set n [lindex $dq 0]
+ set word [lindex $dq 1]
+ set str [string range $str $n end]
+ lappend l $word
+ }
+ return $l
+}
+
+# Code to implement multiple views
+
+proc newview {ishighlight} {
+ global nextviewnum newviewname newviewperm uifont newishighlight
+ global newviewargs revtreeargs
+
+ set newishighlight $ishighlight
+ set top .gitkview
+ if {[winfo exists $top]} {
+ raise $top
+ return
+ }
+ set newviewname($nextviewnum) "View $nextviewnum"
+ set newviewperm($nextviewnum) 0
+ set newviewargs($nextviewnum) [shellarglist $revtreeargs]
+ vieweditor $top $nextviewnum "Gitk view definition"
+}
+
+proc editview {} {
+ global curview
+ global viewname viewperm newviewname newviewperm
+ global viewargs newviewargs
+
+ set top .gitkvedit-$curview
+ if {[winfo exists $top]} {
+ raise $top
+ return
+ }
+ set newviewname($curview) $viewname($curview)
+ set newviewperm($curview) $viewperm($curview)
+ set newviewargs($curview) [shellarglist $viewargs($curview)]
+ vieweditor $top $curview "Gitk: edit view $viewname($curview)"
+}
+
+proc vieweditor {top n title} {
+ global newviewname newviewperm viewfiles
+ global uifont
+
+ toplevel $top
+ wm title $top $title
+ label $top.nl -text "Name" -font uifont
+ entry $top.name -width 20 -textvariable newviewname($n) -font uifont
+ grid $top.nl $top.name -sticky w -pady 5
+ checkbutton $top.perm -text "Remember this view" -variable newviewperm($n) \
+ -font uifont
+ grid $top.perm - -pady 5 -sticky w
+ message $top.al -aspect 1000 -font uifont \
+ -text "Commits to include (arguments to git rev-list):"
+ grid $top.al - -sticky w -pady 5
+ entry $top.args -width 50 -textvariable newviewargs($n) \
+ -background white -font uifont
+ grid $top.args - -sticky ew -padx 5
+ message $top.l -aspect 1000 -font uifont \
+ -text "Enter files and directories to include, one per line:"
+ grid $top.l - -sticky w
+ text $top.t -width 40 -height 10 -background white -font uifont
+ if {[info exists viewfiles($n)]} {
+ foreach f $viewfiles($n) {
+ $top.t insert end $f
+ $top.t insert end "\n"
+ }
+ $top.t delete {end - 1c} end
+ $top.t mark set insert 0.0
+ }
+ grid $top.t - -sticky ew -padx 5
+ frame $top.buts
+ button $top.buts.ok -text "OK" -command [list newviewok $top $n] \
+ -font uifont
+ button $top.buts.can -text "Cancel" -command [list destroy $top] \
+ -font uifont
+ grid $top.buts.ok $top.buts.can
+ grid columnconfigure $top.buts 0 -weight 1 -uniform a
+ grid columnconfigure $top.buts 1 -weight 1 -uniform a
+ grid $top.buts - -pady 10 -sticky ew
+ focus $top.t
+}
+
+proc doviewmenu {m first cmd op argv} {
+ set nmenu [$m index end]
+ for {set i $first} {$i <= $nmenu} {incr i} {
+ if {[$m entrycget $i -command] eq $cmd} {
+ eval $m $op $i $argv
+ break
+ }
+ }
+}
+
+proc allviewmenus {n op args} {
+ # global viewhlmenu
+
+ doviewmenu .bar.view 5 [list showview $n] $op $args
+ # doviewmenu $viewhlmenu 1 [list addvhighlight $n] $op $args
+}
+
+proc newviewok {top n} {
+ global nextviewnum newviewperm newviewname newishighlight
+ global viewname viewfiles viewperm selectedview curview
+ global viewargs newviewargs viewhlmenu
+
+ if {[catch {
+ set newargs [shellsplit $newviewargs($n)]
+ } err]} {
+ error_popup "Error in commit selection arguments: $err"
+ wm raise $top
+ focus $top
+ return
+ }
+ set files {}
+ foreach f [split [$top.t get 0.0 end] "\n"] {
+ set ft [string trim $f]
+ if {$ft ne {}} {
+ lappend files $ft
+ }
+ }
+ if {![info exists viewfiles($n)]} {
+ # creating a new view
+ incr nextviewnum
+ set viewname($n) $newviewname($n)
+ set viewperm($n) $newviewperm($n)
+ set viewfiles($n) $files
+ set viewargs($n) $newargs
+ addviewmenu $n
+ if {!$newishighlight} {
+ run showview $n
+ } else {
+ run addvhighlight $n
+ }
+ } else {
+ # editing an existing view
+ set viewperm($n) $newviewperm($n)
+ if {$newviewname($n) ne $viewname($n)} {
+ set viewname($n) $newviewname($n)
+ doviewmenu .bar.view 5 [list showview $n] \
+ entryconf [list -label $viewname($n)]
+ # doviewmenu $viewhlmenu 1 [list addvhighlight $n] \
+ # entryconf [list -label $viewname($n) -value $viewname($n)]
+ }
+ if {$files ne $viewfiles($n) || $newargs ne $viewargs($n)} {
+ set viewfiles($n) $files
+ set viewargs($n) $newargs
+ if {$curview == $n} {
+ run updatecommits
+ }
+ }
+ }
+ catch {destroy $top}
+}
+
+proc delview {} {
+ global curview viewdata viewperm hlview selectedhlview
+
+ if {$curview == 0} return
+ if {[info exists hlview] && $hlview == $curview} {
+ set selectedhlview None
+ unset hlview
+ }
+ allviewmenus $curview delete
+ set viewdata($curview) {}
+ set viewperm($curview) 0
+ showview 0
+}
+
+proc addviewmenu {n} {
+ global viewname viewhlmenu
+
+ .bar.view add radiobutton -label $viewname($n) \
+ -command [list showview $n] -variable selectedview -value $n
+ #$viewhlmenu add radiobutton -label $viewname($n) \
+ # -command [list addvhighlight $n] -variable selectedhlview
+}
+
+proc flatten {var} {
+ global $var
+
+ set ret {}
+ foreach i [array names $var] {
+ lappend ret $i [set $var\($i\)]
+ }
+ return $ret
+}
+
+proc unflatten {var l} {
+ global $var
+
+ catch {unset $var}
+ foreach {i v} $l {
+ set $var\($i\) $v
+ }
+}
+
+proc showview {n} {
+ global curview viewdata viewfiles
+ global displayorder parentlist rowidlist rowisopt rowfinal
+ global colormap rowtextx commitrow nextcolor canvxmax
+ global numcommits commitlisted
+ global selectedline currentid canv canvy0
+ global treediffs
+ global pending_select phase
+ global commitidx
+ global commfd
+ global selectedview selectfirst
+ global vparentlist vdisporder vcmitlisted
+ global hlview selectedhlview commitinterest
+
+ if {$n == $curview} return
+ set selid {}
+ if {[info exists selectedline]} {
+ set selid $currentid
+ set y [yc $selectedline]
+ set ymax [lindex [$canv cget -scrollregion] 3]
+ set span [$canv yview]
+ set ytop [expr {[lindex $span 0] * $ymax}]
+ set ybot [expr {[lindex $span 1] * $ymax}]
+ if {$ytop < $y && $y < $ybot} {
+ set yscreen [expr {$y - $ytop}]
+ } else {
+ set yscreen [expr {($ybot - $ytop) / 2}]
+ }
+ } elseif {[info exists pending_select]} {
+ set selid $pending_select
+ unset pending_select
+ }
+ unselectline
+ normalline
+ if {$curview >= 0} {
+ set vparentlist($curview) $parentlist
+ set vdisporder($curview) $displayorder
+ set vcmitlisted($curview) $commitlisted
+ if {$phase ne {} ||
+ ![info exists viewdata($curview)] ||
+ [lindex $viewdata($curview) 0] ne {}} {
+ set viewdata($curview) \
+ [list $phase $rowidlist $rowisopt $rowfinal]
+ }
+ }
+ catch {unset treediffs}
+ clear_display
+ if {[info exists hlview] && $hlview == $n} {
+ unset hlview
+ set selectedhlview None
+ }
+ catch {unset commitinterest}
+
+ set curview $n
+ set selectedview $n
+ .bar.view entryconf Edit* -state [expr {$n == 0? "disabled": "normal"}]
+ .bar.view entryconf Delete* -state [expr {$n == 0? "disabled": "normal"}]
+
+ run refill_reflist
+ if {![info exists viewdata($n)]} {
+ if {$selid ne {}} {
+ set pending_select $selid
+ }
+ getcommits
+ return
+ }
+
+ set v $viewdata($n)
+ set phase [lindex $v 0]
+ set displayorder $vdisporder($n)
+ set parentlist $vparentlist($n)
+ set commitlisted $vcmitlisted($n)
+ set rowidlist [lindex $v 1]
+ set rowisopt [lindex $v 2]
+ set rowfinal [lindex $v 3]
+ set numcommits $commitidx($n)
+
+ catch {unset colormap}
+ catch {unset rowtextx}
+ set nextcolor 0
+ set canvxmax [$canv cget -width]
+ set curview $n
+ set row 0
+ setcanvscroll
+ set yf 0
+ set row {}
+ set selectfirst 0
+ if {$selid ne {} && [info exists commitrow($n,$selid)]} {
+ set row $commitrow($n,$selid)
+ # try to get the selected row in the same position on the screen
+ set ymax [lindex [$canv cget -scrollregion] 3]
+ set ytop [expr {[yc $row] - $yscreen}]
+ if {$ytop < 0} {
+ set ytop 0
+ }
+ set yf [expr {$ytop * 1.0 / $ymax}]
+ }
+ allcanvs yview moveto $yf
+ drawvisible
+ if {$row ne {}} {
+ selectline $row 0
+ } elseif {$selid ne {}} {
+ set pending_select $selid
+ } else {
+ set row [first_real_row]
+ if {$row < $numcommits} {
+ selectline $row 0
+ } else {
+ set selectfirst 1
+ }
+ }
+ if {$phase ne {}} {
+ if {$phase eq "getcommits"} {
+ show_status "Reading commits..."
+ }
+ run chewcommits $n
+ } elseif {$numcommits == 0} {
+ show_status "No commits selected"
+ }
+}
+
+# Stuff relating to the highlighting facility
+
+proc ishighlighted {row} {
+ global vhighlights fhighlights nhighlights rhighlights
+
+ if {[info exists nhighlights($row)] && $nhighlights($row) > 0} {
+ return $nhighlights($row)
+ }
+ if {[info exists vhighlights($row)] && $vhighlights($row) > 0} {
+ return $vhighlights($row)
+ }
+ if {[info exists fhighlights($row)] && $fhighlights($row) > 0} {
+ return $fhighlights($row)
+ }
+ if {[info exists rhighlights($row)] && $rhighlights($row) > 0} {
+ return $rhighlights($row)
+ }
+ return 0
+}
+
+proc bolden {row font} {
+ global canv linehtag selectedline boldrows
+
+ lappend boldrows $row
+ $canv itemconf $linehtag($row) -font $font
+ if {[info exists selectedline] && $row == $selectedline} {
+ $canv delete secsel
+ set t [eval $canv create rect [$canv bbox $linehtag($row)] \
+ -outline {{}} -tags secsel \
+ -fill [$canv cget -selectbackground]]
+ $canv lower $t
+ }
+}
+
+proc bolden_name {row font} {
+ global canv2 linentag selectedline boldnamerows
+
+ lappend boldnamerows $row
+ $canv2 itemconf $linentag($row) -font $font
+ if {[info exists selectedline] && $row == $selectedline} {
+ $canv2 delete secsel
+ set t [eval $canv2 create rect [$canv2 bbox $linentag($row)] \
+ -outline {{}} -tags secsel \
+ -fill [$canv2 cget -selectbackground]]
+ $canv2 lower $t
+ }
+}
+
+proc unbolden {} {
+ global boldrows
+
+ set stillbold {}
+ foreach row $boldrows {
+ if {![ishighlighted $row]} {
+ bolden $row mainfont
+ } else {
+ lappend stillbold $row
+ }
+ }
+ set boldrows $stillbold
+}
+
+proc addvhighlight {n} {
+ global hlview curview viewdata vhl_done vhighlights commitidx
+
+ if {[info exists hlview]} {
+ delvhighlight
+ }
+ set hlview $n
+ if {$n != $curview && ![info exists viewdata($n)]} {
+ set viewdata($n) [list getcommits {{}} 0 0 0]
+ set vparentlist($n) {}
+ set vdisporder($n) {}
+ set vcmitlisted($n) {}
+ start_rev_list $n
+ }
+ set vhl_done $commitidx($hlview)
+ if {$vhl_done > 0} {
+ drawvisible
+ }
+}
+
+proc delvhighlight {} {
+ global hlview vhighlights
+
+ if {![info exists hlview]} return
+ unset hlview
+ catch {unset vhighlights}
+ unbolden
+}
+
+proc vhighlightmore {} {
+ global hlview vhl_done commitidx vhighlights
+ global displayorder vdisporder curview
+
+ set max $commitidx($hlview)
+ if {$hlview == $curview} {
+ set disp $displayorder
+ } else {
+ set disp $vdisporder($hlview)
+ }
+ set vr [visiblerows]
+ set r0 [lindex $vr 0]
+ set r1 [lindex $vr 1]
+ for {set i $vhl_done} {$i < $max} {incr i} {
+ set id [lindex $disp $i]
+ if {[info exists commitrow($curview,$id)]} {
+ set row $commitrow($curview,$id)
+ if {$r0 <= $row && $row <= $r1} {
+ if {![highlighted $row]} {
+ bolden $row mainfontbold
+ }
+ set vhighlights($row) 1
+ }
+ }
+ }
+ set vhl_done $max
+}
+
+proc askvhighlight {row id} {
+ global hlview vhighlights commitrow iddrawn
+
+ if {[info exists commitrow($hlview,$id)]} {
+ if {[info exists iddrawn($id)] && ![ishighlighted $row]} {
+ bolden $row mainfontbold
+ }
+ set vhighlights($row) 1
+ } else {
+ set vhighlights($row) 0
+ }
+}
+
+proc hfiles_change {} {
+ global highlight_files filehighlight fhighlights fh_serial
+ global highlight_paths gdttype
+
+ if {[info exists filehighlight]} {
+ # delete previous highlights
+ catch {close $filehighlight}
+ unset filehighlight
+ catch {unset fhighlights}
+ unbolden
+ unhighlight_filelist
+ }
+ set highlight_paths {}
+ after cancel do_file_hl $fh_serial
+ incr fh_serial
+ if {$highlight_files ne {}} {
+ after 300 do_file_hl $fh_serial
+ }
+}
+
+proc gdttype_change {name ix op} {
+ global gdttype highlight_files findstring findpattern
+
+ stopfinding
+ if {$findstring ne {}} {
+ if {$gdttype eq "containing:"} {
+ if {$highlight_files ne {}} {
+ set highlight_files {}
+ hfiles_change
+ }
+ findcom_change
+ } else {
+ if {$findpattern ne {}} {
+ set findpattern {}
+ findcom_change
+ }
+ set highlight_files $findstring
+ hfiles_change
+ }
+ drawvisible
+ }
+ # enable/disable findtype/findloc menus too
+}
+
+proc find_change {name ix op} {
+ global gdttype findstring highlight_files
+
+ stopfinding
+ if {$gdttype eq "containing:"} {
+ findcom_change
+ } else {
+ if {$highlight_files ne $findstring} {
+ set highlight_files $findstring
+ hfiles_change
+ }
+ }
+ drawvisible
+}
+
+proc findcom_change args {
+ global nhighlights boldnamerows
+ global findpattern findtype findstring gdttype
+
+ stopfinding
+ # delete previous highlights, if any
+ foreach row $boldnamerows {
+ bolden_name $row mainfont
+ }
+ set boldnamerows {}
+ catch {unset nhighlights}
+ unbolden
+ unmarkmatches
+ if {$gdttype ne "containing:" || $findstring eq {}} {
+ set findpattern {}
+ } elseif {$findtype eq "Regexp"} {
+ set findpattern $findstring
+ } else {
+ set e [string map {"*" "\\*" "?" "\\?" "\[" "\\\[" "\\" "\\\\"} \
+ $findstring]
+ set findpattern "*$e*"
+ }
+}
+
+proc makepatterns {l} {
+ set ret {}
+ foreach e $l {
+ set ee [string map {"*" "\\*" "?" "\\?" "\[" "\\\[" "\\" "\\\\"} $e]
+ if {[string index $ee end] eq "/"} {
+ lappend ret "$ee*"
+ } else {
+ lappend ret $ee
+ lappend ret "$ee/*"
+ }
+ }
+ return $ret
+}
+
+proc do_file_hl {serial} {
+ global highlight_files filehighlight highlight_paths gdttype fhl_list
+
+ if {$gdttype eq "touching paths:"} {
+ if {[catch {set paths [shellsplit $highlight_files]}]} return
+ set highlight_paths [makepatterns $paths]
+ highlight_filelist
+ set gdtargs [concat -- $paths]
+ } elseif {$gdttype eq "adding/removing string:"} {
+ set gdtargs [list "-S$highlight_files"]
+ } else {
+ # must be "containing:", i.e. we're searching commit info
+ return
+ }
+ set cmd [concat | git diff-tree -r -s --stdin $gdtargs]
+ set filehighlight [open $cmd r+]
+ fconfigure $filehighlight -blocking 0
+ filerun $filehighlight readfhighlight
+ set fhl_list {}
+ drawvisible
+ flushhighlights
+}
+
+proc flushhighlights {} {
+ global filehighlight fhl_list
+
+ if {[info exists filehighlight]} {
+ lappend fhl_list {}
+ puts $filehighlight ""
+ flush $filehighlight
+ }
+}
+
+proc askfilehighlight {row id} {
+ global filehighlight fhighlights fhl_list
+
+ lappend fhl_list $id
+ set fhighlights($row) -1
+ puts $filehighlight $id
+}
+
+proc readfhighlight {} {
+ global filehighlight fhighlights commitrow curview iddrawn
+ global fhl_list find_dirn
+
+ if {![info exists filehighlight]} {
+ return 0
+ }
+ set nr 0
+ while {[incr nr] <= 100 && [gets $filehighlight line] >= 0} {
+ set line [string trim $line]
+ set i [lsearch -exact $fhl_list $line]
+ if {$i < 0} continue
+ for {set j 0} {$j < $i} {incr j} {
+ set id [lindex $fhl_list $j]
+ if {[info exists commitrow($curview,$id)]} {
+ set fhighlights($commitrow($curview,$id)) 0
+ }
+ }
+ set fhl_list [lrange $fhl_list [expr {$i+1}] end]
+ if {$line eq {}} continue
+ if {![info exists commitrow($curview,$line)]} continue
+ set row $commitrow($curview,$line)
+ if {[info exists iddrawn($line)] && ![ishighlighted $row]} {
+ bolden $row mainfontbold
+ }
+ set fhighlights($row) 1
+ }
+ if {[eof $filehighlight]} {
+ # strange...
+ puts "oops, git diff-tree died"
+ catch {close $filehighlight}
+ unset filehighlight
+ return 0
+ }
+ if {[info exists find_dirn]} {
+ run findmore
+ }
+ return 1
+}
+
+proc doesmatch {f} {
+ global findtype findpattern
+
+ if {$findtype eq "Regexp"} {
+ return [regexp $findpattern $f]
+ } elseif {$findtype eq "IgnCase"} {
+ return [string match -nocase $findpattern $f]
+ } else {
+ return [string match $findpattern $f]
+ }
+}
+
+proc askfindhighlight {row id} {
+ global nhighlights commitinfo iddrawn
+ global findloc
+ global markingmatches
+
+ if {![info exists commitinfo($id)]} {
+ getcommit $id
+ }
+ set info $commitinfo($id)
+ set isbold 0
+ set fldtypes {Headline Author Date Committer CDate Comments}
+ foreach f $info ty $fldtypes {
+ if {($findloc eq "All fields" || $findloc eq $ty) &&
+ [doesmatch $f]} {
+ if {$ty eq "Author"} {
+ set isbold 2
+ break
+ }
+ set isbold 1
+ }
+ }
+ if {$isbold && [info exists iddrawn($id)]} {
+ if {![ishighlighted $row]} {
+ bolden $row mainfontbold
+ if {$isbold > 1} {
+ bolden_name $row mainfontbold
+ }
+ }
+ if {$markingmatches} {
+ markrowmatches $row $id
+ }
+ }
+ set nhighlights($row) $isbold
+}
+
+proc markrowmatches {row id} {
+ global canv canv2 linehtag linentag commitinfo findloc
+
+ set headline [lindex $commitinfo($id) 0]
+ set author [lindex $commitinfo($id) 1]
+ $canv delete match$row
+ $canv2 delete match$row
+ if {$findloc eq "All fields" || $findloc eq "Headline"} {
+ set m [findmatches $headline]
+ if {$m ne {}} {
+ markmatches $canv $row $headline $linehtag($row) $m \
+ [$canv itemcget $linehtag($row) -font] $row
+ }
+ }
+ if {$findloc eq "All fields" || $findloc eq "Author"} {
+ set m [findmatches $author]
+ if {$m ne {}} {
+ markmatches $canv2 $row $author $linentag($row) $m \
+ [$canv2 itemcget $linentag($row) -font] $row
+ }
+ }
+}
+
+proc vrel_change {name ix op} {
+ global highlight_related
+
+ rhighlight_none
+ if {$highlight_related ne "None"} {
+ run drawvisible
+ }
+}
+
+# prepare for testing whether commits are descendents or ancestors of a
+proc rhighlight_sel {a} {
+ global descendent desc_todo ancestor anc_todo
+ global highlight_related rhighlights
+
+ catch {unset descendent}
+ set desc_todo [list $a]
+ catch {unset ancestor}
+ set anc_todo [list $a]
+ if {$highlight_related ne "None"} {
+ rhighlight_none
+ run drawvisible
+ }
+}
+
+proc rhighlight_none {} {
+ global rhighlights
+
+ catch {unset rhighlights}
+ unbolden
+}
+
+proc is_descendent {a} {
+ global curview children commitrow descendent desc_todo
+
+ set v $curview
+ set la $commitrow($v,$a)
+ set todo $desc_todo
+ set leftover {}
+ set done 0
+ for {set i 0} {$i < [llength $todo]} {incr i} {
+ set do [lindex $todo $i]
+ if {$commitrow($v,$do) < $la} {
+ lappend leftover $do
+ continue
+ }
+ foreach nk $children($v,$do) {
+ if {![info exists descendent($nk)]} {
+ set descendent($nk) 1
+ lappend todo $nk
+ if {$nk eq $a} {
+ set done 1
+ }
+ }
+ }
+ if {$done} {
+ set desc_todo [concat $leftover [lrange $todo [expr {$i+1}] end]]
+ return
+ }
+ }
+ set descendent($a) 0
+ set desc_todo $leftover
+}
+
+proc is_ancestor {a} {
+ global curview parentlist commitrow ancestor anc_todo
+
+ set v $curview
+ set la $commitrow($v,$a)
+ set todo $anc_todo
+ set leftover {}
+ set done 0
+ for {set i 0} {$i < [llength $todo]} {incr i} {
+ set do [lindex $todo $i]
+ if {![info exists commitrow($v,$do)] || $commitrow($v,$do) > $la} {
+ lappend leftover $do
+ continue
+ }
+ foreach np [lindex $parentlist $commitrow($v,$do)] {
+ if {![info exists ancestor($np)]} {
+ set ancestor($np) 1
+ lappend todo $np
+ if {$np eq $a} {
+ set done 1
+ }
+ }
+ }
+ if {$done} {
+ set anc_todo [concat $leftover [lrange $todo [expr {$i+1}] end]]
+ return
+ }
+ }
+ set ancestor($a) 0
+ set anc_todo $leftover
+}
+
+proc askrelhighlight {row id} {
+ global descendent highlight_related iddrawn rhighlights
+ global selectedline ancestor
+
+ if {![info exists selectedline]} return
+ set isbold 0
+ if {$highlight_related eq "Descendent" ||
+ $highlight_related eq "Not descendent"} {
+ if {![info exists descendent($id)]} {
+ is_descendent $id
+ }
+ if {$descendent($id) == ($highlight_related eq "Descendent")} {
+ set isbold 1
+ }
+ } elseif {$highlight_related eq "Ancestor" ||
+ $highlight_related eq "Not ancestor"} {
+ if {![info exists ancestor($id)]} {
+ is_ancestor $id
+ }
+ if {$ancestor($id) == ($highlight_related eq "Ancestor")} {
+ set isbold 1
+ }
+ }
+ if {[info exists iddrawn($id)]} {
+ if {$isbold && ![ishighlighted $row]} {
+ bolden $row mainfontbold
+ }
+ }
+ set rhighlights($row) $isbold
+}
+
+# Graph layout functions
+
+proc shortids {ids} {
+ set res {}
+ foreach id $ids {
+ if {[llength $id] > 1} {
+ lappend res [shortids $id]
+ } elseif {[regexp {^[0-9a-f]{40}$} $id]} {
+ lappend res [string range $id 0 7]
+ } else {
+ lappend res $id
+ }
+ }
+ return $res
+}
+
+proc ntimes {n o} {
+ set ret {}
+ set o [list $o]
+ for {set mask 1} {$mask <= $n} {incr mask $mask} {
+ if {($n & $mask) != 0} {
+ set ret [concat $ret $o]
+ }
+ set o [concat $o $o]
+ }
+ return $ret
+}
+
+# Work out where id should go in idlist so that order-token
+# values increase from left to right
+proc idcol {idlist id {i 0}} {
+ global ordertok curview
+
+ set t $ordertok($curview,$id)
+ if {$i >= [llength $idlist] ||
+ $t < $ordertok($curview,[lindex $idlist $i])} {
+ if {$i > [llength $idlist]} {
+ set i [llength $idlist]
+ }
+ while {[incr i -1] >= 0 &&
+ $t < $ordertok($curview,[lindex $idlist $i])} {}
+ incr i
+ } else {
+ if {$t > $ordertok($curview,[lindex $idlist $i])} {
+ while {[incr i] < [llength $idlist] &&
+ $t >= $ordertok($curview,[lindex $idlist $i])} {}
+ }
+ }
+ return $i
+}
+
+proc initlayout {} {
+ global rowidlist rowisopt rowfinal displayorder commitlisted
+ global numcommits canvxmax canv
+ global nextcolor
+ global parentlist
+ global colormap rowtextx
+ global selectfirst
+
+ set numcommits 0
+ set displayorder {}
+ set commitlisted {}
+ set parentlist {}
+ set nextcolor 0
+ set rowidlist {}
+ set rowisopt {}
+ set rowfinal {}
+ set canvxmax [$canv cget -width]
+ catch {unset colormap}
+ catch {unset rowtextx}
+ set selectfirst 1
+}
+
+proc setcanvscroll {} {
+ global canv canv2 canv3 numcommits linespc canvxmax canvy0
+
+ set ymax [expr {$canvy0 + ($numcommits - 0.5) * $linespc + 2}]
+ $canv conf -scrollregion [list 0 0 $canvxmax $ymax]
+ $canv2 conf -scrollregion [list 0 0 0 $ymax]
+ $canv3 conf -scrollregion [list 0 0 0 $ymax]
+}
+
+proc visiblerows {} {
+ global canv numcommits linespc
+
+ set ymax [lindex [$canv cget -scrollregion] 3]
+ if {$ymax eq {} || $ymax == 0} return
+ set f [$canv yview]
+ set y0 [expr {int([lindex $f 0] * $ymax)}]
+ set r0 [expr {int(($y0 - 3) / $linespc) - 1}]
+ if {$r0 < 0} {
+ set r0 0
+ }
+ set y1 [expr {int([lindex $f 1] * $ymax)}]
+ set r1 [expr {int(($y1 - 3) / $linespc) + 1}]
+ if {$r1 >= $numcommits} {
+ set r1 [expr {$numcommits - 1}]
+ }
+ return [list $r0 $r1]
+}
+
+proc layoutmore {} {
+ global commitidx viewcomplete numcommits
+ global uparrowlen downarrowlen mingaplen curview
+
+ set show $commitidx($curview)
+ if {$show > $numcommits || $viewcomplete($curview)} {
+ showstuff $show $viewcomplete($curview)
+ }
+}
+
+proc showstuff {canshow last} {
+ global numcommits commitrow pending_select selectedline curview
+ global mainheadid displayorder selectfirst
+ global lastscrollset commitinterest
+
+ if {$numcommits == 0} {
+ global phase
+ set phase "incrdraw"
+ allcanvs delete all
+ }
+ set r0 $numcommits
+ set prev $numcommits
+ set numcommits $canshow
+ set t [clock clicks -milliseconds]
+ if {$prev < 100 || $last || $t - $lastscrollset > 500} {
+ set lastscrollset $t
+ setcanvscroll
+ }
+ set rows [visiblerows]
+ set r1 [lindex $rows 1]
+ if {$r1 >= $canshow} {
+ set r1 [expr {$canshow - 1}]
+ }
+ if {$r0 <= $r1} {
+ drawcommits $r0 $r1
+ }
+ if {[info exists pending_select] &&
+ [info exists commitrow($curview,$pending_select)] &&
+ $commitrow($curview,$pending_select) < $numcommits} {
+ selectline $commitrow($curview,$pending_select) 1
+ }
+ if {$selectfirst} {
+ if {[info exists selectedline] || [info exists pending_select]} {
+ set selectfirst 0
+ } else {
+ set l [first_real_row]
+ selectline $l 1
+ set selectfirst 0
+ }
+ }
+}
+
+proc doshowlocalchanges {} {
+ global curview mainheadid phase commitrow
+
+ if {[info exists commitrow($curview,$mainheadid)] &&
+ ($phase eq {} || $commitrow($curview,$mainheadid) < $numcommits - 1)} {
+ dodiffindex
+ } elseif {$phase ne {}} {
+ lappend commitinterest($mainheadid) {}
+ }
+}
+
+proc dohidelocalchanges {} {
+ global localfrow localirow lserial
+
+ if {$localfrow >= 0} {
+ removerow $localfrow
+ set localfrow -1
+ if {$localirow > 0} {
+ incr localirow -1
+ }
+ }
+ if {$localirow >= 0} {
+ removerow $localirow
+ set localirow -1
+ }
+ incr lserial
+}
+
+# spawn off a process to do git diff-index --cached HEAD
+proc dodiffindex {} {
+ global localirow localfrow lserial showlocalchanges
+
+ if {!$showlocalchanges} return
+ incr lserial
+ set localfrow -1
+ set localirow -1
+ set fd [open "|git diff-index --cached HEAD" r]
+ fconfigure $fd -blocking 0
+ filerun $fd [list readdiffindex $fd $lserial]
+}
+
+proc readdiffindex {fd serial} {
+ global localirow commitrow mainheadid nullid2 curview
+ global commitinfo commitdata lserial
+
+ set isdiff 1
+ if {[gets $fd line] < 0} {
+ if {![eof $fd]} {
+ return 1
+ }
+ set isdiff 0
+ }
+ # we only need to see one line and we don't really care what it says...
+ close $fd
+
+ # now see if there are any local changes not checked in to the index
+ if {$serial == $lserial} {
+ set fd [open "|git diff-files" r]
+ fconfigure $fd -blocking 0
+ filerun $fd [list readdifffiles $fd $serial]
+ }
+
+ if {$isdiff && $serial == $lserial && $localirow == -1} {
+ # add the line for the changes in the index to the graph
+ set localirow $commitrow($curview,$mainheadid)
+ set hl "Local changes checked in to index but not committed"
+ set commitinfo($nullid2) [list $hl {} {} {} {} " $hl\n"]
+ set commitdata($nullid2) "\n $hl\n"
+ insertrow $localirow $nullid2
+ }
+ return 0
+}
+
+proc readdifffiles {fd serial} {
+ global localirow localfrow commitrow mainheadid nullid curview
+ global commitinfo commitdata lserial
+
+ set isdiff 1
+ if {[gets $fd line] < 0} {
+ if {![eof $fd]} {
+ return 1
+ }
+ set isdiff 0
+ }
+ # we only need to see one line and we don't really care what it says...
+ close $fd
+
+ if {$isdiff && $serial == $lserial && $localfrow == -1} {
+ # add the line for the local diff to the graph
+ if {$localirow >= 0} {
+ set localfrow $localirow
+ incr localirow
+ } else {
+ set localfrow $commitrow($curview,$mainheadid)
+ }
+ set hl "Local uncommitted changes, not checked in to index"
+ set commitinfo($nullid) [list $hl {} {} {} {} " $hl\n"]
+ set commitdata($nullid) "\n $hl\n"
+ insertrow $localfrow $nullid
+ }
+ return 0
+}
+
+proc nextuse {id row} {
+ global commitrow curview children
+
+ if {[info exists children($curview,$id)]} {
+ foreach kid $children($curview,$id) {
+ if {![info exists commitrow($curview,$kid)]} {
+ return -1
+ }
+ if {$commitrow($curview,$kid) > $row} {
+ return $commitrow($curview,$kid)
+ }
+ }
+ }
+ if {[info exists commitrow($curview,$id)]} {
+ return $commitrow($curview,$id)
+ }
+ return -1
+}
+
+proc prevuse {id row} {
+ global commitrow curview children
+
+ set ret -1
+ if {[info exists children($curview,$id)]} {
+ foreach kid $children($curview,$id) {
+ if {![info exists commitrow($curview,$kid)]} break
+ if {$commitrow($curview,$kid) < $row} {
+ set ret $commitrow($curview,$kid)
+ }
+ }
+ }
+ return $ret
+}
+
+proc make_idlist {row} {
+ global displayorder parentlist uparrowlen downarrowlen mingaplen
+ global commitidx curview ordertok children commitrow
+
+ set r [expr {$row - $mingaplen - $downarrowlen - 1}]
+ if {$r < 0} {
+ set r 0
+ }
+ set ra [expr {$row - $downarrowlen}]
+ if {$ra < 0} {
+ set ra 0
+ }
+ set rb [expr {$row + $uparrowlen}]
+ if {$rb > $commitidx($curview)} {
+ set rb $commitidx($curview)
+ }
+ set ids {}
+ for {} {$r < $ra} {incr r} {
+ set nextid [lindex $displayorder [expr {$r + 1}]]
+ foreach p [lindex $parentlist $r] {
+ if {$p eq $nextid} continue
+ set rn [nextuse $p $r]
+ if {$rn >= $row &&
+ $rn <= $r + $downarrowlen + $mingaplen + $uparrowlen} {
+ lappend ids [list $ordertok($curview,$p) $p]
+ }
+ }
+ }
+ for {} {$r < $row} {incr r} {
+ set nextid [lindex $displayorder [expr {$r + 1}]]
+ foreach p [lindex $parentlist $r] {
+ if {$p eq $nextid} continue
+ set rn [nextuse $p $r]
+ if {$rn < 0 || $rn >= $row} {
+ lappend ids [list $ordertok($curview,$p) $p]
+ }
+ }
+ }
+ set id [lindex $displayorder $row]
+ lappend ids [list $ordertok($curview,$id) $id]
+ while {$r < $rb} {
+ foreach p [lindex $parentlist $r] {
+ set firstkid [lindex $children($curview,$p) 0]
+ if {$commitrow($curview,$firstkid) < $row} {
+ lappend ids [list $ordertok($curview,$p) $p]
+ }
+ }
+ incr r
+ set id [lindex $displayorder $r]
+ if {$id ne {}} {
+ set firstkid [lindex $children($curview,$id) 0]
+ if {$firstkid ne {} && $commitrow($curview,$firstkid) < $row} {
+ lappend ids [list $ordertok($curview,$id) $id]
+ }
+ }
+ }
+ set idlist {}
+ foreach idx [lsort -unique $ids] {
+ lappend idlist [lindex $idx 1]
+ }
+ return $idlist
+}
+
+proc rowsequal {a b} {
+ while {[set i [lsearch -exact $a {}]] >= 0} {
+ set a [lreplace $a $i $i]
+ }
+ while {[set i [lsearch -exact $b {}]] >= 0} {
+ set b [lreplace $b $i $i]
+ }
+ return [expr {$a eq $b}]
+}
+
+proc makeupline {id row rend col} {
+ global rowidlist uparrowlen downarrowlen mingaplen
+
+ for {set r $rend} {1} {set r $rstart} {
+ set rstart [prevuse $id $r]
+ if {$rstart < 0} return
+ if {$rstart < $row} break
+ }
+ if {$rstart + $uparrowlen + $mingaplen + $downarrowlen < $rend} {
+ set rstart [expr {$rend - $uparrowlen - 1}]
+ }
+ for {set r $rstart} {[incr r] <= $row} {} {
+ set idlist [lindex $rowidlist $r]
+ if {$idlist ne {} && [lsearch -exact $idlist $id] < 0} {
+ set col [idcol $idlist $id $col]
+ lset rowidlist $r [linsert $idlist $col $id]
+ changedrow $r
+ }
+ }
+}
+
+proc layoutrows {row endrow} {
+ global rowidlist rowisopt rowfinal displayorder
+ global uparrowlen downarrowlen maxwidth mingaplen
+ global children parentlist
+ global commitidx viewcomplete curview commitrow
+
+ set idlist {}
+ if {$row > 0} {
+ set rm1 [expr {$row - 1}]
+ foreach id [lindex $rowidlist $rm1] {
+ if {$id ne {}} {
+ lappend idlist $id
+ }
+ }
+ set final [lindex $rowfinal $rm1]
+ }
+ for {} {$row < $endrow} {incr row} {
+ set rm1 [expr {$row - 1}]
+ if {$rm1 < 0 || $idlist eq {}} {
+ set idlist [make_idlist $row]
+ set final 1
+ } else {
+ set id [lindex $displayorder $rm1]
+ set col [lsearch -exact $idlist $id]
+ set idlist [lreplace $idlist $col $col]
+ foreach p [lindex $parentlist $rm1] {
+ if {[lsearch -exact $idlist $p] < 0} {
+ set col [idcol $idlist $p $col]
+ set idlist [linsert $idlist $col $p]
+ # if not the first child, we have to insert a line going up
+ if {$id ne [lindex $children($curview,$p) 0]} {
+ makeupline $p $rm1 $row $col
+ }
+ }
+ }
+ set id [lindex $displayorder $row]
+ if {$row > $downarrowlen} {
+ set termrow [expr {$row - $downarrowlen - 1}]
+ foreach p [lindex $parentlist $termrow] {
+ set i [lsearch -exact $idlist $p]
+ if {$i < 0} continue
+ set nr [nextuse $p $termrow]
+ if {$nr < 0 || $nr >= $row + $mingaplen + $uparrowlen} {
+ set idlist [lreplace $idlist $i $i]
+ }
+ }
+ }
+ set col [lsearch -exact $idlist $id]
+ if {$col < 0} {
+ set col [idcol $idlist $id]
+ set idlist [linsert $idlist $col $id]
+ if {$children($curview,$id) ne {}} {
+ makeupline $id $rm1 $row $col
+ }
+ }
+ set r [expr {$row + $uparrowlen - 1}]
+ if {$r < $commitidx($curview)} {
+ set x $col
+ foreach p [lindex $parentlist $r] {
+ if {[lsearch -exact $idlist $p] >= 0} continue
+ set fk [lindex $children($curview,$p) 0]
+ if {$commitrow($curview,$fk) < $row} {
+ set x [idcol $idlist $p $x]
+ set idlist [linsert $idlist $x $p]
+ }
+ }
+ if {[incr r] < $commitidx($curview)} {
+ set p [lindex $displayorder $r]
+ if {[lsearch -exact $idlist $p] < 0} {
+ set fk [lindex $children($curview,$p) 0]
+ if {$fk ne {} && $commitrow($curview,$fk) < $row} {
+ set x [idcol $idlist $p $x]
+ set idlist [linsert $idlist $x $p]
+ }
+ }
+ }
+ }
+ }
+ if {$final && !$viewcomplete($curview) &&
+ $row + $uparrowlen + $mingaplen + $downarrowlen
+ >= $commitidx($curview)} {
+ set final 0
+ }
+ set l [llength $rowidlist]
+ if {$row == $l} {
+ lappend rowidlist $idlist
+ lappend rowisopt 0
+ lappend rowfinal $final
+ } elseif {$row < $l} {
+ if {![rowsequal $idlist [lindex $rowidlist $row]]} {
+ lset rowidlist $row $idlist
+ changedrow $row
+ }
+ lset rowfinal $row $final
+ } else {
+ set pad [ntimes [expr {$row - $l}] {}]
+ set rowidlist [concat $rowidlist $pad]
+ lappend rowidlist $idlist
+ set rowfinal [concat $rowfinal $pad]
+ lappend rowfinal $final
+ set rowisopt [concat $rowisopt [ntimes [expr {$row - $l + 1}] 0]]
+ }
+ }
+ return $row
+}
+
+proc changedrow {row} {
+ global displayorder iddrawn rowisopt need_redisplay
+
+ set l [llength $rowisopt]
+ if {$row < $l} {
+ lset rowisopt $row 0
+ if {$row + 1 < $l} {
+ lset rowisopt [expr {$row + 1}] 0
+ if {$row + 2 < $l} {
+ lset rowisopt [expr {$row + 2}] 0
+ }
+ }
+ }
+ set id [lindex $displayorder $row]
+ if {[info exists iddrawn($id)]} {
+ set need_redisplay 1
+ }
+}
+
+proc insert_pad {row col npad} {
+ global rowidlist
+
+ set pad [ntimes $npad {}]
+ set idlist [lindex $rowidlist $row]
+ set bef [lrange $idlist 0 [expr {$col - 1}]]
+ set aft [lrange $idlist $col end]
+ set i [lsearch -exact $aft {}]
+ if {$i > 0} {
+ set aft [lreplace $aft $i $i]
+ }
+ lset rowidlist $row [concat $bef $pad $aft]
+ changedrow $row
+}
+
+proc optimize_rows {row col endrow} {
+ global rowidlist rowisopt displayorder curview children
+
+ if {$row < 1} {
+ set row 1
+ }
+ for {} {$row < $endrow} {incr row; set col 0} {
+ if {[lindex $rowisopt $row]} continue
+ set haspad 0
+ set y0 [expr {$row - 1}]
+ set ym [expr {$row - 2}]
+ set idlist [lindex $rowidlist $row]
+ set previdlist [lindex $rowidlist $y0]
+ if {$idlist eq {} || $previdlist eq {}} continue
+ if {$ym >= 0} {
+ set pprevidlist [lindex $rowidlist $ym]
+ if {$pprevidlist eq {}} continue
+ } else {
+ set pprevidlist {}
+ }
+ set x0 -1
+ set xm -1
+ for {} {$col < [llength $idlist]} {incr col} {
+ set id [lindex $idlist $col]
+ if {[lindex $previdlist $col] eq $id} continue
+ if {$id eq {}} {
+ set haspad 1
+ continue
+ }
+ set x0 [lsearch -exact $previdlist $id]
+ if {$x0 < 0} continue
+ set z [expr {$x0 - $col}]
+ set isarrow 0
+ set z0 {}
+ if {$ym >= 0} {
+ set xm [lsearch -exact $pprevidlist $id]
+ if {$xm >= 0} {
+ set z0 [expr {$xm - $x0}]
+ }
+ }
+ if {$z0 eq {}} {
+ # if row y0 is the first child of $id then it's not an arrow
+ if {[lindex $children($curview,$id) 0] ne
+ [lindex $displayorder $y0]} {
+ set isarrow 1
+ }
+ }
+ if {!$isarrow && $id ne [lindex $displayorder $row] &&
+ [lsearch -exact [lindex $rowidlist [expr {$row+1}]] $id] < 0} {
+ set isarrow 1
+ }
+ # Looking at lines from this row to the previous row,
+ # make them go straight up if they end in an arrow on
+ # the previous row; otherwise make them go straight up
+ # or at 45 degrees.
+ if {$z < -1 || ($z < 0 && $isarrow)} {
+ # Line currently goes left too much;
+ # insert pads in the previous row, then optimize it
+ set npad [expr {-1 - $z + $isarrow}]
+ insert_pad $y0 $x0 $npad
+ if {$y0 > 0} {
+ optimize_rows $y0 $x0 $row
+ }
+ set previdlist [lindex $rowidlist $y0]
+ set x0 [lsearch -exact $previdlist $id]
+ set z [expr {$x0 - $col}]
+ if {$z0 ne {}} {
+ set pprevidlist [lindex $rowidlist $ym]
+ set xm [lsearch -exact $pprevidlist $id]
+ set z0 [expr {$xm - $x0}]
+ }
+ } elseif {$z > 1 || ($z > 0 && $isarrow)} {
+ # Line currently goes right too much;
+ # insert pads in this line
+ set npad [expr {$z - 1 + $isarrow}]
+ insert_pad $row $col $npad
+ set idlist [lindex $rowidlist $row]
+ incr col $npad
+ set z [expr {$x0 - $col}]
+ set haspad 1
+ }
+ if {$z0 eq {} && !$isarrow && $ym >= 0} {
+ # this line links to its first child on row $row-2
+ set id [lindex $displayorder $ym]
+ set xc [lsearch -exact $pprevidlist $id]
+ if {$xc >= 0} {
+ set z0 [expr {$xc - $x0}]
+ }
+ }
+ # avoid lines jigging left then immediately right
+ if {$z0 ne {} && $z < 0 && $z0 > 0} {
+ insert_pad $y0 $x0 1
+ incr x0
+ optimize_rows $y0 $x0 $row
+ set previdlist [lindex $rowidlist $y0]
+ }
+ }
+ if {!$haspad} {
+ # Find the first column that doesn't have a line going right
+ for {set col [llength $idlist]} {[incr col -1] >= 0} {} {
+ set id [lindex $idlist $col]
+ if {$id eq {}} break
+ set x0 [lsearch -exact $previdlist $id]
+ if {$x0 < 0} {
+ # check if this is the link to the first child
+ set kid [lindex $displayorder $y0]
+ if {[lindex $children($curview,$id) 0] eq $kid} {
+ # it is, work out offset to child
+ set x0 [lsearch -exact $previdlist $kid]
+ }
+ }
+ if {$x0 <= $col} break
+ }
+ # Insert a pad at that column as long as it has a line and
+ # isn't the last column
+ if {$x0 >= 0 && [incr col] < [llength $idlist]} {
+ set idlist [linsert $idlist $col {}]
+ lset rowidlist $row $idlist
+ changedrow $row
+ }
+ }
+ }
+}
+
+proc xc {row col} {
+ global canvx0 linespc
+ return [expr {$canvx0 + $col * $linespc}]
+}
+
+proc yc {row} {
+ global canvy0 linespc
+ return [expr {$canvy0 + $row * $linespc}]
+}
+
+proc linewidth {id} {
+ global thickerline lthickness
+
+ set wid $lthickness
+ if {[info exists thickerline] && $id eq $thickerline} {
+ set wid [expr {2 * $lthickness}]
+ }
+ return $wid
+}
+
+proc rowranges {id} {
+ global commitrow curview children uparrowlen downarrowlen
+ global rowidlist
+
+ set kids $children($curview,$id)
+ if {$kids eq {}} {
+ return {}
+ }
+ set ret {}
+ lappend kids $id
+ foreach child $kids {
+ if {![info exists commitrow($curview,$child)]} break
+ set row $commitrow($curview,$child)
+ if {![info exists prev]} {
+ lappend ret [expr {$row + 1}]
+ } else {
+ if {$row <= $prevrow} {
+ puts "oops children out of order [shortids $id] $row < [shortids $prev] $prevrow"
+ }
+ # see if the line extends the whole way from prevrow to row
+ if {$row > $prevrow + $uparrowlen + $downarrowlen &&
+ [lsearch -exact [lindex $rowidlist \
+ [expr {int(($row + $prevrow) / 2)}]] $id] < 0} {
+ # it doesn't, see where it ends
+ set r [expr {$prevrow + $downarrowlen}]
+ if {[lsearch -exact [lindex $rowidlist $r] $id] < 0} {
+ while {[incr r -1] > $prevrow &&
+ [lsearch -exact [lindex $rowidlist $r] $id] < 0} {}
+ } else {
+ while {[incr r] <= $row &&
+ [lsearch -exact [lindex $rowidlist $r] $id] >= 0} {}
+ incr r -1
+ }
+ lappend ret $r
+ # see where it starts up again
+ set r [expr {$row - $uparrowlen}]
+ if {[lsearch -exact [lindex $rowidlist $r] $id] < 0} {
+ while {[incr r] < $row &&
+ [lsearch -exact [lindex $rowidlist $r] $id] < 0} {}
+ } else {
+ while {[incr r -1] >= $prevrow &&
+ [lsearch -exact [lindex $rowidlist $r] $id] >= 0} {}
+ incr r
+ }
+ lappend ret $r
+ }
+ }
+ if {$child eq $id} {
+ lappend ret $row
+ }
+ set prev $id
+ set prevrow $row
+ }
+ return $ret
+}
+
+proc drawlineseg {id row endrow arrowlow} {
+ global rowidlist displayorder iddrawn linesegs
+ global canv colormap linespc curview maxlinelen parentlist
+
+ set cols [list [lsearch -exact [lindex $rowidlist $row] $id]]
+ set le [expr {$row + 1}]
+ set arrowhigh 1
+ while {1} {
+ set c [lsearch -exact [lindex $rowidlist $le] $id]
+ if {$c < 0} {
+ incr le -1
+ break
+ }
+ lappend cols $c
+ set x [lindex $displayorder $le]
+ if {$x eq $id} {
+ set arrowhigh 0
+ break
+ }
+ if {[info exists iddrawn($x)] || $le == $endrow} {
+ set c [lsearch -exact [lindex $rowidlist [expr {$le+1}]] $id]
+ if {$c >= 0} {
+ lappend cols $c
+ set arrowhigh 0
+ }
+ break
+ }
+ incr le
+ }
+ if {$le <= $row} {
+ return $row
+ }
+
+ set lines {}
+ set i 0
+ set joinhigh 0
+ if {[info exists linesegs($id)]} {
+ set lines $linesegs($id)
+ foreach li $lines {
+ set r0 [lindex $li 0]
+ if {$r0 > $row} {
+ if {$r0 == $le && [lindex $li 1] - $row <= $maxlinelen} {
+ set joinhigh 1
+ }
+ break
+ }
+ incr i
+ }
+ }
+ set joinlow 0
+ if {$i > 0} {
+ set li [lindex $lines [expr {$i-1}]]
+ set r1 [lindex $li 1]
+ if {$r1 == $row && $le - [lindex $li 0] <= $maxlinelen} {
+ set joinlow 1
+ }
+ }
+
+ set x [lindex $cols [expr {$le - $row}]]
+ set xp [lindex $cols [expr {$le - 1 - $row}]]
+ set dir [expr {$xp - $x}]
+ if {$joinhigh} {
+ set ith [lindex $lines $i 2]
+ set coords [$canv coords $ith]
+ set ah [$canv itemcget $ith -arrow]
+ set arrowhigh [expr {$ah eq "first" || $ah eq "both"}]
+ set x2 [lindex $cols [expr {$le + 1 - $row}]]
+ if {$x2 ne {} && $x - $x2 == $dir} {
+ set coords [lrange $coords 0 end-2]
+ }
+ } else {
+ set coords [list [xc $le $x] [yc $le]]
+ }
+ if {$joinlow} {
+ set itl [lindex $lines [expr {$i-1}] 2]
+ set al [$canv itemcget $itl -arrow]
+ set arrowlow [expr {$al eq "last" || $al eq "both"}]
+ } elseif {$arrowlow} {
+ if {[lsearch -exact [lindex $rowidlist [expr {$row-1}]] $id] >= 0 ||
+ [lsearch -exact [lindex $parentlist [expr {$row-1}]] $id] >= 0} {
+ set arrowlow 0
+ }
+ }
+ set arrow [lindex {none first last both} [expr {$arrowhigh + 2*$arrowlow}]]
+ for {set y $le} {[incr y -1] > $row} {} {
+ set x $xp
+ set xp [lindex $cols [expr {$y - 1 - $row}]]
+ set ndir [expr {$xp - $x}]
+ if {$dir != $ndir || $xp < 0} {
+ lappend coords [xc $y $x] [yc $y]
+ }
+ set dir $ndir
+ }
+ if {!$joinlow} {
+ if {$xp < 0} {
+ # join parent line to first child
+ set ch [lindex $displayorder $row]
+ set xc [lsearch -exact [lindex $rowidlist $row] $ch]
+ if {$xc < 0} {
+ puts "oops: drawlineseg: child $ch not on row $row"
+ } elseif {$xc != $x} {
+ if {($arrowhigh && $le == $row + 1) || $dir == 0} {
+ set d [expr {int(0.5 * $linespc)}]
+ set x1 [xc $row $x]
+ if {$xc < $x} {
+ set x2 [expr {$x1 - $d}]
+ } else {
+ set x2 [expr {$x1 + $d}]
+ }
+ set y2 [yc $row]
+ set y1 [expr {$y2 + $d}]
+ lappend coords $x1 $y1 $x2 $y2
+ } elseif {$xc < $x - 1} {
+ lappend coords [xc $row [expr {$x-1}]] [yc $row]
+ } elseif {$xc > $x + 1} {
+ lappend coords [xc $row [expr {$x+1}]] [yc $row]
+ }
+ set x $xc
+ }
+ lappend coords [xc $row $x] [yc $row]
+ } else {
+ set xn [xc $row $xp]
+ set yn [yc $row]
+ lappend coords $xn $yn
+ }
+ if {!$joinhigh} {
+ assigncolor $id
+ set t [$canv create line $coords -width [linewidth $id] \
+ -fill $colormap($id) -tags lines.$id -arrow $arrow]
+ $canv lower $t
+ bindline $t $id
+ set lines [linsert $lines $i [list $row $le $t]]
+ } else {
+ $canv coords $ith $coords
+ if {$arrow ne $ah} {
+ $canv itemconf $ith -arrow $arrow
+ }
+ lset lines $i 0 $row
+ }
+ } else {
+ set xo [lsearch -exact [lindex $rowidlist [expr {$row - 1}]] $id]
+ set ndir [expr {$xo - $xp}]
+ set clow [$canv coords $itl]
+ if {$dir == $ndir} {
+ set clow [lrange $clow 2 end]
+ }
+ set coords [concat $coords $clow]
+ if {!$joinhigh} {
+ lset lines [expr {$i-1}] 1 $le
+ } else {
+ # coalesce two pieces
+ $canv delete $ith
+ set b [lindex $lines [expr {$i-1}] 0]
+ set e [lindex $lines $i 1]
+ set lines [lreplace $lines [expr {$i-1}] $i [list $b $e $itl]]
+ }
+ $canv coords $itl $coords
+ if {$arrow ne $al} {
+ $canv itemconf $itl -arrow $arrow
+ }
+ }
+
+ set linesegs($id) $lines
+ return $le
+}
+
+proc drawparentlinks {id row} {
+ global rowidlist canv colormap curview parentlist
+ global idpos linespc
+
+ set rowids [lindex $rowidlist $row]
+ set col [lsearch -exact $rowids $id]
+ if {$col < 0} return
+ set olds [lindex $parentlist $row]
+ set row2 [expr {$row + 1}]
+ set x [xc $row $col]
+ set y [yc $row]
+ set y2 [yc $row2]
+ set d [expr {int(0.5 * $linespc)}]
+ set ymid [expr {$y + $d}]
+ set ids [lindex $rowidlist $row2]
+ # rmx = right-most X coord used
+ set rmx 0
+ foreach p $olds {
+ set i [lsearch -exact $ids $p]
+ if {$i < 0} {
+ puts "oops, parent $p of $id not in list"
+ continue
+ }
+ set x2 [xc $row2 $i]
+ if {$x2 > $rmx} {
+ set rmx $x2
+ }
+ set j [lsearch -exact $rowids $p]
+ if {$j < 0} {
+ # drawlineseg will do this one for us
+ continue
+ }
+ assigncolor $p
+ # should handle duplicated parents here...
+ set coords [list $x $y]
+ if {$i != $col} {
+ # if attaching to a vertical segment, draw a smaller
+ # slant for visual distinctness
+ if {$i == $j} {
+ if {$i < $col} {
+ lappend coords [expr {$x2 + $d}] $y $x2 $ymid
+ } else {
+ lappend coords [expr {$x2 - $d}] $y $x2 $ymid
+ }
+ } elseif {$i < $col && $i < $j} {
+ # segment slants towards us already
+ lappend coords [xc $row $j] $y
+ } else {
+ if {$i < $col - 1} {
+ lappend coords [expr {$x2 + $linespc}] $y
+ } elseif {$i > $col + 1} {
+ lappend coords [expr {$x2 - $linespc}] $y
+ }
+ lappend coords $x2 $y2
+ }
+ } else {
+ lappend coords $x2 $y2
+ }
+ set t [$canv create line $coords -width [linewidth $p] \
+ -fill $colormap($p) -tags lines.$p]
+ $canv lower $t
+ bindline $t $p
+ }
+ if {$rmx > [lindex $idpos($id) 1]} {
+ lset idpos($id) 1 $rmx
+ redrawtags $id
+ }
+}
+
+proc drawlines {id} {
+ global canv
+
+ $canv itemconf lines.$id -width [linewidth $id]
+}
+
+proc drawcmittext {id row col} {
+ global linespc canv canv2 canv3 canvy0 fgcolor curview
+ global commitlisted commitinfo rowidlist parentlist
+ global rowtextx idpos idtags idheads idotherrefs
+ global linehtag linentag linedtag selectedline
+ global canvxmax boldrows boldnamerows fgcolor nullid nullid2
+
+ # listed is 0 for boundary, 1 for normal, 2 for left, 3 for right
+ set listed [lindex $commitlisted $row]
+ if {$id eq $nullid} {
+ set ofill red
+ } elseif {$id eq $nullid2} {
+ set ofill green
+ } else {
+ set ofill [expr {$listed != 0? "blue": "white"}]
+ }
+ set x [xc $row $col]
+ set y [yc $row]
+ set orad [expr {$linespc / 3}]
+ if {$listed <= 1} {
+ set t [$canv create oval [expr {$x - $orad}] [expr {$y - $orad}] \
+ [expr {$x + $orad - 1}] [expr {$y + $orad - 1}] \
+ -fill $ofill -outline $fgcolor -width 1 -tags circle]
+ } elseif {$listed == 2} {
+ # triangle pointing left for left-side commits
+ set t [$canv create polygon \
+ [expr {$x - $orad}] $y \
+ [expr {$x + $orad - 1}] [expr {$y - $orad}] \
+ [expr {$x + $orad - 1}] [expr {$y + $orad - 1}] \
+ -fill $ofill -outline $fgcolor -width 1 -tags circle]
+ } else {
+ # triangle pointing right for right-side commits
+ set t [$canv create polygon \
+ [expr {$x + $orad - 1}] $y \
+ [expr {$x - $orad}] [expr {$y - $orad}] \
+ [expr {$x - $orad}] [expr {$y + $orad - 1}] \
+ -fill $ofill -outline $fgcolor -width 1 -tags circle]
+ }
+ $canv raise $t
+ $canv bind $t <1> {selcanvline {} %x %y}
+ set rmx [llength [lindex $rowidlist $row]]
+ set olds [lindex $parentlist $row]
+ if {$olds ne {}} {
+ set nextids [lindex $rowidlist [expr {$row + 1}]]
+ foreach p $olds {
+ set i [lsearch -exact $nextids $p]
+ if {$i > $rmx} {
+ set rmx $i
+ }
+ }
+ }
+ set xt [xc $row $rmx]
+ set rowtextx($row) $xt
+ set idpos($id) [list $x $xt $y]
+ if {[info exists idtags($id)] || [info exists idheads($id)]
+ || [info exists idotherrefs($id)]} {
+ set xt [drawtags $id $x $xt $y]
+ }
+ set headline [lindex $commitinfo($id) 0]
+ set name [lindex $commitinfo($id) 1]
+ set date [lindex $commitinfo($id) 2]
+ set date [formatdate $date]
+ set font mainfont
+ set nfont mainfont
+ set isbold [ishighlighted $row]
+ if {$isbold > 0} {
+ lappend boldrows $row
+ set font mainfontbold
+ if {$isbold > 1} {
+ lappend boldnamerows $row
+ set nfont mainfontbold
+ }
+ }
+ set linehtag($row) [$canv create text $xt $y -anchor w -fill $fgcolor \
+ -text $headline -font $font -tags text]
+ $canv bind $linehtag($row) <Button-3> "rowmenu %X %Y $id"
+ set linentag($row) [$canv2 create text 3 $y -anchor w -fill $fgcolor \
+ -text $name -font $nfont -tags text]
+ set linedtag($row) [$canv3 create text 3 $y -anchor w -fill $fgcolor \
+ -text $date -font mainfont -tags text]
+ if {[info exists selectedline] && $selectedline == $row} {
+ make_secsel $row
+ }
+ set xr [expr {$xt + [font measure $font $headline]}]
+ if {$xr > $canvxmax} {
+ set canvxmax $xr
+ setcanvscroll
+ }
+}
+
+proc drawcmitrow {row} {
+ global displayorder rowidlist nrows_drawn
+ global iddrawn markingmatches
+ global commitinfo parentlist numcommits
+ global filehighlight fhighlights findpattern nhighlights
+ global hlview vhighlights
+ global highlight_related rhighlights
+
+ if {$row >= $numcommits} return
+
+ set id [lindex $displayorder $row]
+ if {[info exists hlview] && ![info exists vhighlights($row)]} {
+ askvhighlight $row $id
+ }
+ if {[info exists filehighlight] && ![info exists fhighlights($row)]} {
+ askfilehighlight $row $id
+ }
+ if {$findpattern ne {} && ![info exists nhighlights($row)]} {
+ askfindhighlight $row $id
+ }
+ if {$highlight_related ne "None" && ![info exists rhighlights($row)]} {
+ askrelhighlight $row $id
+ }
+ if {![info exists iddrawn($id)]} {
+ set col [lsearch -exact [lindex $rowidlist $row] $id]
+ if {$col < 0} {
+ puts "oops, row $row id $id not in list"
+ return
+ }
+ if {![info exists commitinfo($id)]} {
+ getcommit $id
+ }
+ assigncolor $id
+ drawcmittext $id $row $col
+ set iddrawn($id) 1
+ incr nrows_drawn
+ }
+ if {$markingmatches} {
+ markrowmatches $row $id
+ }
+}
+
+proc drawcommits {row {endrow {}}} {
+ global numcommits iddrawn displayorder curview need_redisplay
+ global parentlist rowidlist rowfinal uparrowlen downarrowlen nrows_drawn
+
+ if {$row < 0} {
+ set row 0
+ }
+ if {$endrow eq {}} {
+ set endrow $row
+ }
+ if {$endrow >= $numcommits} {
+ set endrow [expr {$numcommits - 1}]
+ }
+
+ set rl1 [expr {$row - $downarrowlen - 3}]
+ if {$rl1 < 0} {
+ set rl1 0
+ }
+ set ro1 [expr {$row - 3}]
+ if {$ro1 < 0} {
+ set ro1 0
+ }
+ set r2 [expr {$endrow + $uparrowlen + 3}]
+ if {$r2 > $numcommits} {
+ set r2 $numcommits
+ }
+ for {set r $rl1} {$r < $r2} {incr r} {
+ if {[lindex $rowidlist $r] ne {} && [lindex $rowfinal $r]} {
+ if {$rl1 < $r} {
+ layoutrows $rl1 $r
+ }
+ set rl1 [expr {$r + 1}]
+ }
+ }
+ if {$rl1 < $r} {
+ layoutrows $rl1 $r
+ }
+ optimize_rows $ro1 0 $r2
+ if {$need_redisplay || $nrows_drawn > 2000} {
+ clear_display
+ drawvisible
+ }
+
+ # make the lines join to already-drawn rows either side
+ set r [expr {$row - 1}]
+ if {$r < 0 || ![info exists iddrawn([lindex $displayorder $r])]} {
+ set r $row
+ }
+ set er [expr {$endrow + 1}]
+ if {$er >= $numcommits ||
+ ![info exists iddrawn([lindex $displayorder $er])]} {
+ set er $endrow
+ }
+ for {} {$r <= $er} {incr r} {
+ set id [lindex $displayorder $r]
+ set wasdrawn [info exists iddrawn($id)]
+ drawcmitrow $r
+ if {$r == $er} break
+ set nextid [lindex $displayorder [expr {$r + 1}]]
+ if {$wasdrawn && [info exists iddrawn($nextid)]} continue
+ drawparentlinks $id $r
+
+ set rowids [lindex $rowidlist $r]
+ foreach lid $rowids {
+ if {$lid eq {}} continue
+ if {[info exists lineend($lid)] && $lineend($lid) > $r} continue
+ if {$lid eq $id} {
+ # see if this is the first child of any of its parents
+ foreach p [lindex $parentlist $r] {
+ if {[lsearch -exact $rowids $p] < 0} {
+ # make this line extend up to the child
+ set lineend($p) [drawlineseg $p $r $er 0]
+ }
+ }
+ } else {
+ set lineend($lid) [drawlineseg $lid $r $er 1]
+ }
+ }
+ }
+}
+
+proc drawfrac {f0 f1} {
+ global canv linespc
+
+ set ymax [lindex [$canv cget -scrollregion] 3]
+ if {$ymax eq {} || $ymax == 0} return
+ set y0 [expr {int($f0 * $ymax)}]
+ set row [expr {int(($y0 - 3) / $linespc) - 1}]
+ set y1 [expr {int($f1 * $ymax)}]
+ set endrow [expr {int(($y1 - 3) / $linespc) + 1}]
+ drawcommits $row $endrow
+}
+
+proc drawvisible {} {
+ global canv
+ eval drawfrac [$canv yview]
+}
+
+proc clear_display {} {
+ global iddrawn linesegs need_redisplay nrows_drawn
+ global vhighlights fhighlights nhighlights rhighlights
+
+ allcanvs delete all
+ catch {unset iddrawn}
+ catch {unset linesegs}
+ catch {unset vhighlights}
+ catch {unset fhighlights}
+ catch {unset nhighlights}
+ catch {unset rhighlights}
+ set need_redisplay 0
+ set nrows_drawn 0
+}
+
+proc findcrossings {id} {
+ global rowidlist parentlist numcommits displayorder
+
+ set cross {}
+ set ccross {}
+ foreach {s e} [rowranges $id] {
+ if {$e >= $numcommits} {
+ set e [expr {$numcommits - 1}]
+ }
+ if {$e <= $s} continue
+ for {set row $e} {[incr row -1] >= $s} {} {
+ set x [lsearch -exact [lindex $rowidlist $row] $id]
+ if {$x < 0} break
+ set olds [lindex $parentlist $row]
+ set kid [lindex $displayorder $row]
+ set kidx [lsearch -exact [lindex $rowidlist $row] $kid]
+ if {$kidx < 0} continue
+ set nextrow [lindex $rowidlist [expr {$row + 1}]]
+ foreach p $olds {
+ set px [lsearch -exact $nextrow $p]
+ if {$px < 0} continue
+ if {($kidx < $x && $x < $px) || ($px < $x && $x < $kidx)} {
+ if {[lsearch -exact $ccross $p] >= 0} continue
+ if {$x == $px + ($kidx < $px? -1: 1)} {
+ lappend ccross $p
+ } elseif {[lsearch -exact $cross $p] < 0} {
+ lappend cross $p
+ }
+ }
+ }
+ }
+ }
+ return [concat $ccross {{}} $cross]
+}
+
+proc assigncolor {id} {
+ global colormap colors nextcolor
+ global commitrow parentlist children children curview
+
+ if {[info exists colormap($id)]} return
+ set ncolors [llength $colors]
+ if {[info exists children($curview,$id)]} {
+ set kids $children($curview,$id)
+ } else {
+ set kids {}
+ }
+ if {[llength $kids] == 1} {
+ set child [lindex $kids 0]
+ if {[info exists colormap($child)]
+ && [llength [lindex $parentlist $commitrow($curview,$child)]] == 1} {
+ set colormap($id) $colormap($child)
+ return
+ }
+ }
+ set badcolors {}
+ set origbad {}
+ foreach x [findcrossings $id] {
+ if {$x eq {}} {
+ # delimiter between corner crossings and other crossings
+ if {[llength $badcolors] >= $ncolors - 1} break
+ set origbad $badcolors
+ }
+ if {[info exists colormap($x)]
+ && [lsearch -exact $badcolors $colormap($x)] < 0} {
+ lappend badcolors $colormap($x)
+ }
+ }
+ if {[llength $badcolors] >= $ncolors} {
+ set badcolors $origbad
+ }
+ set origbad $badcolors
+ if {[llength $badcolors] < $ncolors - 1} {
+ foreach child $kids {
+ if {[info exists colormap($child)]
+ && [lsearch -exact $badcolors $colormap($child)] < 0} {
+ lappend badcolors $colormap($child)
+ }
+ foreach p [lindex $parentlist $commitrow($curview,$child)] {
+ if {[info exists colormap($p)]
+ && [lsearch -exact $badcolors $colormap($p)] < 0} {
+ lappend badcolors $colormap($p)
+ }
+ }
+ }
+ if {[llength $badcolors] >= $ncolors} {
+ set badcolors $origbad
+ }
+ }
+ for {set i 0} {$i <= $ncolors} {incr i} {
+ set c [lindex $colors $nextcolor]
+ if {[incr nextcolor] >= $ncolors} {
+ set nextcolor 0
+ }
+ if {[lsearch -exact $badcolors $c]} break
+ }
+ set colormap($id) $c
+}
+
+proc bindline {t id} {
+ global canv
+
+ $canv bind $t <Enter> "lineenter %x %y $id"
+ $canv bind $t <Motion> "linemotion %x %y $id"
+ $canv bind $t <Leave> "lineleave $id"
+ $canv bind $t <Button-1> "lineclick %x %y $id 1"
+}
+
+proc drawtags {id x xt y1} {
+ global idtags idheads idotherrefs mainhead
+ global linespc lthickness
+ global canv commitrow rowtextx curview fgcolor bgcolor
+
+ set marks {}
+ set ntags 0
+ set nheads 0
+ if {[info exists idtags($id)]} {
+ set marks $idtags($id)
+ set ntags [llength $marks]
+ }
+ if {[info exists idheads($id)]} {
+ set marks [concat $marks $idheads($id)]
+ set nheads [llength $idheads($id)]
+ }
+ if {[info exists idotherrefs($id)]} {
+ set marks [concat $marks $idotherrefs($id)]
+ }
+ if {$marks eq {}} {
+ return $xt
+ }
+
+ set delta [expr {int(0.5 * ($linespc - $lthickness))}]
+ set yt [expr {$y1 - 0.5 * $linespc}]
+ set yb [expr {$yt + $linespc - 1}]
+ set xvals {}
+ set wvals {}
+ set i -1
+ foreach tag $marks {
+ incr i
+ if {$i >= $ntags && $i < $ntags + $nheads && $tag eq $mainhead} {
+ set wid [font measure mainfontbold $tag]
+ } else {
+ set wid [font measure mainfont $tag]
+ }
+ lappend xvals $xt
+ lappend wvals $wid
+ set xt [expr {$xt + $delta + $wid + $lthickness + $linespc}]
+ }
+ set t [$canv create line $x $y1 [lindex $xvals end] $y1 \
+ -width $lthickness -fill black -tags tag.$id]
+ $canv lower $t
+ foreach tag $marks x $xvals wid $wvals {
+ set xl [expr {$x + $delta}]
+ set xr [expr {$x + $delta + $wid + $lthickness}]
+ set font mainfont
+ if {[incr ntags -1] >= 0} {
+ # draw a tag
+ set t [$canv create polygon $x [expr {$yt + $delta}] $xl $yt \
+ $xr $yt $xr $yb $xl $yb $x [expr {$yb - $delta}] \
+ -width 1 -outline black -fill yellow -tags tag.$id]
+ $canv bind $t <1> [list showtag $tag 1]
+ set rowtextx($commitrow($curview,$id)) [expr {$xr + $linespc}]
+ } else {
+ # draw a head or other ref
+ if {[incr nheads -1] >= 0} {
+ set col green
+ if {$tag eq $mainhead} {
+ set font mainfontbold
+ }
+ } else {
+ set col "#ddddff"
+ }
+ set xl [expr {$xl - $delta/2}]
+ $canv create polygon $x $yt $xr $yt $xr $yb $x $yb \
+ -width 1 -outline black -fill $col -tags tag.$id
+ if {[regexp {^(remotes/.*/|remotes/)} $tag match remoteprefix]} {
+ set rwid [font measure mainfont $remoteprefix]
+ set xi [expr {$x + 1}]
+ set yti [expr {$yt + 1}]
+ set xri [expr {$x + $rwid}]
+ $canv create polygon $xi $yti $xri $yti $xri $yb $xi $yb \
+ -width 0 -fill "#ffddaa" -tags tag.$id
+ }
+ }
+ set t [$canv create text $xl $y1 -anchor w -text $tag -fill $fgcolor \
+ -font $font -tags [list tag.$id text]]
+ if {$ntags >= 0} {
+ $canv bind $t <1> [list showtag $tag 1]
+ } elseif {$nheads >= 0} {
+ $canv bind $t <Button-3> [list headmenu %X %Y $id $tag]
+ }
+ }
+ return $xt
+}
+
+proc xcoord {i level ln} {
+ global canvx0 xspc1 xspc2
+
+ set x [expr {$canvx0 + $i * $xspc1($ln)}]
+ if {$i > 0 && $i == $level} {
+ set x [expr {$x + 0.5 * ($xspc2 - $xspc1($ln))}]
+ } elseif {$i > $level} {
+ set x [expr {$x + $xspc2 - $xspc1($ln)}]
+ }
+ return $x
+}
+
+proc show_status {msg} {
+ global canv fgcolor
+
+ clear_display
+ $canv create text 3 3 -anchor nw -text $msg -font mainfont \
+ -tags text -fill $fgcolor
+}
+
+# Insert a new commit as the child of the commit on row $row.
+# The new commit will be displayed on row $row and the commits
+# on that row and below will move down one row.
+proc insertrow {row newcmit} {
+ global displayorder parentlist commitlisted children
+ global commitrow curview rowidlist rowisopt rowfinal numcommits
+ global numcommits
+ global selectedline commitidx ordertok
+
+ if {$row >= $numcommits} {
+ puts "oops, inserting new row $row but only have $numcommits rows"
+ return
+ }
+ set p [lindex $displayorder $row]
+ set displayorder [linsert $displayorder $row $newcmit]
+ set parentlist [linsert $parentlist $row $p]
+ set kids $children($curview,$p)
+ lappend kids $newcmit
+ set children($curview,$p) $kids
+ set children($curview,$newcmit) {}
+ set commitlisted [linsert $commitlisted $row 1]
+ set l [llength $displayorder]
+ for {set r $row} {$r < $l} {incr r} {
+ set id [lindex $displayorder $r]
+ set commitrow($curview,$id) $r
+ }
+ incr commitidx($curview)
+ set ordertok($curview,$newcmit) $ordertok($curview,$p)
+
+ if {$row < [llength $rowidlist]} {
+ set idlist [lindex $rowidlist $row]
+ if {$idlist ne {}} {
+ if {[llength $kids] == 1} {
+ set col [lsearch -exact $idlist $p]
+ lset idlist $col $newcmit
+ } else {
+ set col [llength $idlist]
+ lappend idlist $newcmit
+ }
+ }
+ set rowidlist [linsert $rowidlist $row $idlist]
+ set rowisopt [linsert $rowisopt $row 0]
+ set rowfinal [linsert $rowfinal $row [lindex $rowfinal $row]]
+ }
+
+ incr numcommits
+
+ if {[info exists selectedline] && $selectedline >= $row} {
+ incr selectedline
+ }
+ redisplay
+}
+
+# Remove a commit that was inserted with insertrow on row $row.
+proc removerow {row} {
+ global displayorder parentlist commitlisted children
+ global commitrow curview rowidlist rowisopt rowfinal numcommits
+ global numcommits
+ global linesegends selectedline commitidx
+
+ if {$row >= $numcommits} {
+ puts "oops, removing row $row but only have $numcommits rows"
+ return
+ }
+ set rp1 [expr {$row + 1}]
+ set id [lindex $displayorder $row]
+ set p [lindex $parentlist $row]
+ set displayorder [lreplace $displayorder $row $row]
+ set parentlist [lreplace $parentlist $row $row]
+ set commitlisted [lreplace $commitlisted $row $row]
+ set kids $children($curview,$p)
+ set i [lsearch -exact $kids $id]
+ if {$i >= 0} {
+ set kids [lreplace $kids $i $i]
+ set children($curview,$p) $kids
+ }
+ set l [llength $displayorder]
+ for {set r $row} {$r < $l} {incr r} {
+ set id [lindex $displayorder $r]
+ set commitrow($curview,$id) $r
+ }
+ incr commitidx($curview) -1
+
+ if {$row < [llength $rowidlist]} {
+ set rowidlist [lreplace $rowidlist $row $row]
+ set rowisopt [lreplace $rowisopt $row $row]
+ set rowfinal [lreplace $rowfinal $row $row]
+ }
+
+ incr numcommits -1
+
+ if {[info exists selectedline] && $selectedline > $row} {
+ incr selectedline -1
+ }
+ redisplay
+}
+
+# Don't change the text pane cursor if it is currently the hand cursor,
+# showing that we are over a sha1 ID link.
+proc settextcursor {c} {
+ global ctext curtextcursor
+
+ if {[$ctext cget -cursor] == $curtextcursor} {
+ $ctext config -cursor $c
+ }
+ set curtextcursor $c
+}
+
+proc nowbusy {what {name {}}} {
+ global isbusy busyname statusw
+
+ if {[array names isbusy] eq {}} {
+ . config -cursor watch
+ settextcursor watch
+ }
+ set isbusy($what) 1
+ set busyname($what) $name
+ if {$name ne {}} {
+ $statusw conf -text $name
+ }
+}
+
+proc notbusy {what} {
+ global isbusy maincursor textcursor busyname statusw
+
+ catch {
+ unset isbusy($what)
+ if {$busyname($what) ne {} &&
+ [$statusw cget -text] eq $busyname($what)} {
+ $statusw conf -text {}
+ }
+ }
+ if {[array names isbusy] eq {}} {
+ . config -cursor $maincursor
+ settextcursor $textcursor
+ }
+}
+
+proc findmatches {f} {
+ global findtype findstring
+ if {$findtype == "Regexp"} {
+ set matches [regexp -indices -all -inline $findstring $f]
+ } else {
+ set fs $findstring
+ if {$findtype == "IgnCase"} {
+ set f [string tolower $f]
+ set fs [string tolower $fs]
+ }
+ set matches {}
+ set i 0
+ set l [string length $fs]
+ while {[set j [string first $fs $f $i]] >= 0} {
+ lappend matches [list $j [expr {$j+$l-1}]]
+ set i [expr {$j + $l}]
+ }
+ }
+ return $matches
+}
+
+proc dofind {{dirn 1} {wrap 1}} {
+ global findstring findstartline findcurline selectedline numcommits
+ global gdttype filehighlight fh_serial find_dirn findallowwrap
+
+ if {[info exists find_dirn]} {
+ if {$find_dirn == $dirn} return
+ stopfinding
+ }
+ focus .
+ if {$findstring eq {} || $numcommits == 0} return
+ if {![info exists selectedline]} {
+ set findstartline [lindex [visiblerows] [expr {$dirn < 0}]]
+ } else {
+ set findstartline $selectedline
+ }
+ set findcurline $findstartline
+ nowbusy finding "Searching"
+ if {$gdttype ne "containing:" && ![info exists filehighlight]} {
+ after cancel do_file_hl $fh_serial
+ do_file_hl $fh_serial
+ }
+ set find_dirn $dirn
+ set findallowwrap $wrap
+ run findmore
+}
+
+proc stopfinding {} {
+ global find_dirn findcurline fprogcoord
+
+ if {[info exists find_dirn]} {
+ unset find_dirn
+ unset findcurline
+ notbusy finding
+ set fprogcoord 0
+ adjustprogress
+ }
+}
+
+proc findmore {} {
+ global commitdata commitinfo numcommits findpattern findloc
+ global findstartline findcurline displayorder
+ global find_dirn gdttype fhighlights fprogcoord
+ global findallowwrap
+
+ if {![info exists find_dirn]} {
+ return 0
+ }
+ set fldtypes {Headline Author Date Committer CDate Comments}
+ set l $findcurline
+ set moretodo 0
+ if {$find_dirn > 0} {
+ incr l
+ if {$l >= $numcommits} {
+ set l 0
+ }
+ if {$l <= $findstartline} {
+ set lim [expr {$findstartline + 1}]
+ } else {
+ set lim $numcommits
+ set moretodo $findallowwrap
+ }
+ } else {
+ if {$l == 0} {
+ set l $numcommits
+ }
+ incr l -1
+ if {$l >= $findstartline} {
+ set lim [expr {$findstartline - 1}]
+ } else {
+ set lim -1
+ set moretodo $findallowwrap
+ }
+ }
+ set n [expr {($lim - $l) * $find_dirn}]
+ if {$n > 500} {
+ set n 500
+ set moretodo 1
+ }
+ set found 0
+ set domore 1
+ if {$gdttype eq "containing:"} {
+ for {} {$n > 0} {incr n -1; incr l $find_dirn} {
+ set id [lindex $displayorder $l]
+ # shouldn't happen unless git log doesn't give all the commits...
+ if {![info exists commitdata($id)]} continue
+ if {![doesmatch $commitdata($id)]} continue
+ if {![info exists commitinfo($id)]} {
+ getcommit $id
+ }
+ set info $commitinfo($id)
+ foreach f $info ty $fldtypes {
+ if {($findloc eq "All fields" || $findloc eq $ty) &&
+ [doesmatch $f]} {
+ set found 1
+ break
+ }
+ }
+ if {$found} break
+ }
+ } else {
+ for {} {$n > 0} {incr n -1; incr l $find_dirn} {
+ set id [lindex $displayorder $l]
+ if {![info exists fhighlights($l)]} {
+ askfilehighlight $l $id
+ if {$domore} {
+ set domore 0
+ set findcurline [expr {$l - $find_dirn}]
+ }
+ } elseif {$fhighlights($l)} {
+ set found $domore
+ break
+ }
+ }
+ }
+ if {$found || ($domore && !$moretodo)} {
+ unset findcurline
+ unset find_dirn
+ notbusy finding
+ set fprogcoord 0
+ adjustprogress
+ if {$found} {
+ findselectline $l
+ } else {
+ bell
+ }
+ return 0
+ }
+ if {!$domore} {
+ flushhighlights
+ } else {
+ set findcurline [expr {$l - $find_dirn}]
+ }
+ set n [expr {($findcurline - $findstartline) * $find_dirn - 1}]
+ if {$n < 0} {
+ incr n $numcommits
+ }
+ set fprogcoord [expr {$n * 1.0 / $numcommits}]
+ adjustprogress
+ return $domore
+}
+
+proc findselectline {l} {
+ global findloc commentend ctext findcurline markingmatches gdttype
+
+ set markingmatches 1
+ set findcurline $l
+ selectline $l 1
+ if {$findloc == "All fields" || $findloc == "Comments"} {
+ # highlight the matches in the comments
+ set f [$ctext get 1.0 $commentend]
+ set matches [findmatches $f]
+ foreach match $matches {
+ set start [lindex $match 0]
+ set end [expr {[lindex $match 1] + 1}]
+ $ctext tag add found "1.0 + $start c" "1.0 + $end c"
+ }
+ }
+ drawvisible
+}
+
+# mark the bits of a headline or author that match a find string
+proc markmatches {canv l str tag matches font row} {
+ global selectedline
+
+ set bbox [$canv bbox $tag]
+ set x0 [lindex $bbox 0]
+ set y0 [lindex $bbox 1]
+ set y1 [lindex $bbox 3]
+ foreach match $matches {
+ set start [lindex $match 0]
+ set end [lindex $match 1]
+ if {$start > $end} continue
+ set xoff [font measure $font [string range $str 0 [expr {$start-1}]]]
+ set xlen [font measure $font [string range $str 0 [expr {$end}]]]
+ set t [$canv create rect [expr {$x0+$xoff}] $y0 \
+ [expr {$x0+$xlen+2}] $y1 \
+ -outline {} -tags [list match$l matches] -fill yellow]
+ $canv lower $t
+ if {[info exists selectedline] && $row == $selectedline} {
+ $canv raise $t secsel
+ }
+ }
+}
+
+proc unmarkmatches {} {
+ global markingmatches
+
+ allcanvs delete matches
+ set markingmatches 0
+ stopfinding
+}
+
+proc selcanvline {w x y} {
+ global canv canvy0 ctext linespc
+ global rowtextx
+ set ymax [lindex [$canv cget -scrollregion] 3]
+ if {$ymax == {}} return
+ set yfrac [lindex [$canv yview] 0]
+ set y [expr {$y + $yfrac * $ymax}]
+ set l [expr {int(($y - $canvy0) / $linespc + 0.5)}]
+ if {$l < 0} {
+ set l 0
+ }
+ if {$w eq $canv} {
+ if {![info exists rowtextx($l)] || $x < $rowtextx($l)} return
+ }
+ unmarkmatches
+ selectline $l 1
+}
+
+proc commit_descriptor {p} {
+ global commitinfo
+ if {![info exists commitinfo($p)]} {
+ getcommit $p
+ }
+ set l "..."
+ if {[llength $commitinfo($p)] > 1} {
+ set l [lindex $commitinfo($p) 0]
+ }
+ return "$p ($l)\n"
+}
+
+# append some text to the ctext widget, and make any SHA1 ID
+# that we know about be a clickable link.
+proc appendwithlinks {text tags} {
+ global ctext commitrow linknum curview pendinglinks
+
+ set start [$ctext index "end - 1c"]
+ $ctext insert end $text $tags
+ set links [regexp -indices -all -inline {[0-9a-f]{40}} $text]
+ foreach l $links {
+ set s [lindex $l 0]
+ set e [lindex $l 1]
+ set linkid [string range $text $s $e]
+ incr e
+ $ctext tag delete link$linknum
+ $ctext tag add link$linknum "$start + $s c" "$start + $e c"
+ setlink $linkid link$linknum
+ incr linknum
+ }
+}
+
+proc setlink {id lk} {
+ global curview commitrow ctext pendinglinks commitinterest
+
+ if {[info exists commitrow($curview,$id)]} {
+ $ctext tag conf $lk -foreground blue -underline 1
+ $ctext tag bind $lk <1> [list selectline $commitrow($curview,$id) 1]
+ $ctext tag bind $lk <Enter> {linkcursor %W 1}
+ $ctext tag bind $lk <Leave> {linkcursor %W -1}
+ } else {
+ lappend pendinglinks($id) $lk
+ lappend commitinterest($id) {makelink %I}
+ }
+}
+
+proc makelink {id} {
+ global pendinglinks
+
+ if {![info exists pendinglinks($id)]} return
+ foreach lk $pendinglinks($id) {
+ setlink $id $lk
+ }
+ unset pendinglinks($id)
+}
+
+proc linkcursor {w inc} {
+ global linkentercount curtextcursor
+
+ if {[incr linkentercount $inc] > 0} {
+ $w configure -cursor hand2
+ } else {
+ $w configure -cursor $curtextcursor
+ if {$linkentercount < 0} {
+ set linkentercount 0
+ }
+ }
+}
+
+proc viewnextline {dir} {
+ global canv linespc
+
+ $canv delete hover
+ set ymax [lindex [$canv cget -scrollregion] 3]
+ set wnow [$canv yview]
+ set wtop [expr {[lindex $wnow 0] * $ymax}]
+ set newtop [expr {$wtop + $dir * $linespc}]
+ if {$newtop < 0} {
+ set newtop 0
+ } elseif {$newtop > $ymax} {
+ set newtop $ymax
+ }
+ allcanvs yview moveto [expr {$newtop * 1.0 / $ymax}]
+}
+
+# add a list of tag or branch names at position pos
+# returns the number of names inserted
+proc appendrefs {pos ids var} {
+ global ctext commitrow linknum curview $var maxrefs
+
+ if {[catch {$ctext index $pos}]} {
+ return 0
+ }
+ $ctext conf -state normal
+ $ctext delete $pos "$pos lineend"
+ set tags {}
+ foreach id $ids {
+ foreach tag [set $var\($id\)] {
+ lappend tags [list $tag $id]
+ }
+ }
+ if {[llength $tags] > $maxrefs} {
+ $ctext insert $pos "many ([llength $tags])"
+ } else {
+ set tags [lsort -index 0 -decreasing $tags]
+ set sep {}
+ foreach ti $tags {
+ set id [lindex $ti 1]
+ set lk link$linknum
+ incr linknum
+ $ctext tag delete $lk
+ $ctext insert $pos $sep
+ $ctext insert $pos [lindex $ti 0] $lk
+ setlink $id $lk
+ set sep ", "
+ }
+ }
+ $ctext conf -state disabled
+ return [llength $tags]
+}
+
+# called when we have finished computing the nearby tags
+proc dispneartags {delay} {
+ global selectedline currentid showneartags tagphase
+
+ if {![info exists selectedline] || !$showneartags} return
+ after cancel dispnexttag
+ if {$delay} {
+ after 200 dispnexttag
+ set tagphase -1
+ } else {
+ after idle dispnexttag
+ set tagphase 0
+ }
+}
+
+proc dispnexttag {} {
+ global selectedline currentid showneartags tagphase ctext
+
+ if {![info exists selectedline] || !$showneartags} return
+ switch -- $tagphase {
+ 0 {
+ set dtags [desctags $currentid]
+ if {$dtags ne {}} {
+ appendrefs precedes $dtags idtags
+ }
+ }
+ 1 {
+ set atags [anctags $currentid]
+ if {$atags ne {}} {
+ appendrefs follows $atags idtags
+ }
+ }
+ 2 {
+ set dheads [descheads $currentid]
+ if {$dheads ne {}} {
+ if {[appendrefs branch $dheads idheads] > 1
+ && [$ctext get "branch -3c"] eq "h"} {
+ # turn "Branch" into "Branches"
+ $ctext conf -state normal
+ $ctext insert "branch -2c" "es"
+ $ctext conf -state disabled
+ }
+ }
+ }
+ }
+ if {[incr tagphase] <= 2} {
+ after idle dispnexttag
+ }
+}
+
+proc make_secsel {l} {
+ global linehtag linentag linedtag canv canv2 canv3
+
+ if {![info exists linehtag($l)]} return
+ $canv delete secsel
+ set t [eval $canv create rect [$canv bbox $linehtag($l)] -outline {{}} \
+ -tags secsel -fill [$canv cget -selectbackground]]
+ $canv lower $t
+ $canv2 delete secsel
+ set t [eval $canv2 create rect [$canv2 bbox $linentag($l)] -outline {{}} \
+ -tags secsel -fill [$canv2 cget -selectbackground]]
+ $canv2 lower $t
+ $canv3 delete secsel
+ set t [eval $canv3 create rect [$canv3 bbox $linedtag($l)] -outline {{}} \
+ -tags secsel -fill [$canv3 cget -selectbackground]]
+ $canv3 lower $t
+}
+
+proc selectline {l isnew} {
+ global canv ctext commitinfo selectedline
+ global displayorder
+ global canvy0 linespc parentlist children curview
+ global currentid sha1entry
+ global commentend idtags linknum
+ global mergemax numcommits pending_select
+ global cmitmode showneartags allcommits
+
+ catch {unset pending_select}
+ $canv delete hover
+ normalline
+ unsel_reflist
+ stopfinding
+ if {$l < 0 || $l >= $numcommits} return
+ set y [expr {$canvy0 + $l * $linespc}]
+ set ymax [lindex [$canv cget -scrollregion] 3]
+ set ytop [expr {$y - $linespc - 1}]
+ set ybot [expr {$y + $linespc + 1}]
+ set wnow [$canv yview]
+ set wtop [expr {[lindex $wnow 0] * $ymax}]
+ set wbot [expr {[lindex $wnow 1] * $ymax}]
+ set wh [expr {$wbot - $wtop}]
+ set newtop $wtop
+ if {$ytop < $wtop} {
+ if {$ybot < $wtop} {
+ set newtop [expr {$y - $wh / 2.0}]
+ } else {
+ set newtop $ytop
+ if {$newtop > $wtop - $linespc} {
+ set newtop [expr {$wtop - $linespc}]
+ }
+ }
+ } elseif {$ybot > $wbot} {
+ if {$ytop > $wbot} {
+ set newtop [expr {$y - $wh / 2.0}]
+ } else {
+ set newtop [expr {$ybot - $wh}]
+ if {$newtop < $wtop + $linespc} {
+ set newtop [expr {$wtop + $linespc}]
+ }
+ }
+ }
+ if {$newtop != $wtop} {
+ if {$newtop < 0} {
+ set newtop 0
+ }
+ allcanvs yview moveto [expr {$newtop * 1.0 / $ymax}]
+ drawvisible
+ }
+
+ make_secsel $l
+
+ if {$isnew} {
+ addtohistory [list selectline $l 0]
+ }
+
+ set selectedline $l
+
+ set id [lindex $displayorder $l]
+ set currentid $id
+ $sha1entry delete 0 end
+ $sha1entry insert 0 $id
+ $sha1entry selection from 0
+ $sha1entry selection to end
+ rhighlight_sel $id
+
+ $ctext conf -state normal
+ clear_ctext
+ set linknum 0
+ set info $commitinfo($id)
+ set date [formatdate [lindex $info 2]]
+ $ctext insert end "Author: [lindex $info 1] $date\n"
+ set date [formatdate [lindex $info 4]]
+ $ctext insert end "Committer: [lindex $info 3] $date\n"
+ if {[info exists idtags($id)]} {
+ $ctext insert end "Tags:"
+ foreach tag $idtags($id) {
+ $ctext insert end " $tag"
+ }
+ $ctext insert end "\n"
+ }
+
+ set headers {}
+ set olds [lindex $parentlist $l]
+ if {[llength $olds] > 1} {
+ set np 0
+ foreach p $olds {
+ if {$np >= $mergemax} {
+ set tag mmax
+ } else {
+ set tag m$np
+ }
+ $ctext insert end "Parent: " $tag
+ appendwithlinks [commit_descriptor $p] {}
+ incr np
+ }
+ } else {
+ foreach p $olds {
+ append headers "Parent: [commit_descriptor $p]"
+ }
+ }
+
+ foreach c $children($curview,$id) {
+ append headers "Child: [commit_descriptor $c]"
+ }
+
+ # make anything that looks like a SHA1 ID be a clickable link
+ appendwithlinks $headers {}
+ if {$showneartags} {
+ if {![info exists allcommits]} {
+ getallcommits
+ }
+ $ctext insert end "Branch: "
+ $ctext mark set branch "end -1c"
+ $ctext mark gravity branch left
+ $ctext insert end "\nFollows: "
+ $ctext mark set follows "end -1c"
+ $ctext mark gravity follows left
+ $ctext insert end "\nPrecedes: "
+ $ctext mark set precedes "end -1c"
+ $ctext mark gravity precedes left
+ $ctext insert end "\n"
+ dispneartags 1
+ }
+ $ctext insert end "\n"
+ set comment [lindex $info 5]
+ if {[string first "\r" $comment] >= 0} {
+ set comment [string map {"\r" "\n "} $comment]
+ }
+ appendwithlinks $comment {comment}
+
+ $ctext tag remove found 1.0 end
+ $ctext conf -state disabled
+ set commentend [$ctext index "end - 1c"]
+
+ init_flist "Comments"
+ if {$cmitmode eq "tree"} {
+ gettree $id
+ } elseif {[llength $olds] <= 1} {
+ startdiff $id
+ } else {
+ mergediff $id $l
+ }
+}
+
+proc selfirstline {} {
+ unmarkmatches
+ selectline 0 1
+}
+
+proc sellastline {} {
+ global numcommits
+ unmarkmatches
+ set l [expr {$numcommits - 1}]
+ selectline $l 1
+}
+
+proc selnextline {dir} {
+ global selectedline
+ focus .
+ if {![info exists selectedline]} return
+ set l [expr {$selectedline + $dir}]
+ unmarkmatches
+ selectline $l 1
+}
+
+proc selnextpage {dir} {
+ global canv linespc selectedline numcommits
+
+ set lpp [expr {([winfo height $canv] - 2) / $linespc}]
+ if {$lpp < 1} {
+ set lpp 1
+ }
+ allcanvs yview scroll [expr {$dir * $lpp}] units
+ drawvisible
+ if {![info exists selectedline]} return
+ set l [expr {$selectedline + $dir * $lpp}]
+ if {$l < 0} {
+ set l 0
+ } elseif {$l >= $numcommits} {
+ set l [expr $numcommits - 1]
+ }
+ unmarkmatches
+ selectline $l 1
+}
+
+proc unselectline {} {
+ global selectedline currentid
+
+ catch {unset selectedline}
+ catch {unset currentid}
+ allcanvs delete secsel
+ rhighlight_none
+}
+
+proc reselectline {} {
+ global selectedline
+
+ if {[info exists selectedline]} {
+ selectline $selectedline 0
+ }
+}
+
+proc addtohistory {cmd} {
+ global history historyindex curview
+
+ set elt [list $curview $cmd]
+ if {$historyindex > 0
+ && [lindex $history [expr {$historyindex - 1}]] == $elt} {
+ return
+ }
+
+ if {$historyindex < [llength $history]} {
+ set history [lreplace $history $historyindex end $elt]
+ } else {
+ lappend history $elt
+ }
+ incr historyindex
+ if {$historyindex > 1} {
+ .tf.bar.leftbut conf -state normal
+ } else {
+ .tf.bar.leftbut conf -state disabled
+ }
+ .tf.bar.rightbut conf -state disabled
+}
+
+proc godo {elt} {
+ global curview
+
+ set view [lindex $elt 0]
+ set cmd [lindex $elt 1]
+ if {$curview != $view} {
+ showview $view
+ }
+ eval $cmd
+}
+
+proc goback {} {
+ global history historyindex
+ focus .
+
+ if {$historyindex > 1} {
+ incr historyindex -1
+ godo [lindex $history [expr {$historyindex - 1}]]
+ .tf.bar.rightbut conf -state normal
+ }
+ if {$historyindex <= 1} {
+ .tf.bar.leftbut conf -state disabled
+ }
+}
+
+proc goforw {} {
+ global history historyindex
+ focus .
+
+ if {$historyindex < [llength $history]} {
+ set cmd [lindex $history $historyindex]
+ incr historyindex
+ godo $cmd
+ .tf.bar.leftbut conf -state normal
+ }
+ if {$historyindex >= [llength $history]} {
+ .tf.bar.rightbut conf -state disabled
+ }
+}
+
+proc gettree {id} {
+ global treefilelist treeidlist diffids diffmergeid treepending
+ global nullid nullid2
+
+ set diffids $id
+ catch {unset diffmergeid}
+ if {![info exists treefilelist($id)]} {
+ if {![info exists treepending]} {
+ if {$id eq $nullid} {
+ set cmd [list | git ls-files]
+ } elseif {$id eq $nullid2} {
+ set cmd [list | git ls-files --stage -t]
+ } else {
+ set cmd [list | git ls-tree -r $id]
+ }
+ if {[catch {set gtf [open $cmd r]}]} {
+ return
+ }
+ set treepending $id
+ set treefilelist($id) {}
+ set treeidlist($id) {}
+ fconfigure $gtf -blocking 0
+ filerun $gtf [list gettreeline $gtf $id]
+ }
+ } else {
+ setfilelist $id
+ }
+}
+
+proc gettreeline {gtf id} {
+ global treefilelist treeidlist treepending cmitmode diffids nullid nullid2
+
+ set nl 0
+ while {[incr nl] <= 1000 && [gets $gtf line] >= 0} {
+ if {$diffids eq $nullid} {
+ set fname $line
+ } else {
+ if {$diffids ne $nullid2 && [lindex $line 1] ne "blob"} continue
+ set i [string first "\t" $line]
+ if {$i < 0} continue
+ set sha1 [lindex $line 2]
+ set fname [string range $line [expr {$i+1}] end]
+ if {[string index $fname 0] eq "\""} {
+ set fname [lindex $fname 0]
+ }
+ lappend treeidlist($id) $sha1
+ }
+ lappend treefilelist($id) $fname
+ }
+ if {![eof $gtf]} {
+ return [expr {$nl >= 1000? 2: 1}]
+ }
+ close $gtf
+ unset treepending
+ if {$cmitmode ne "tree"} {
+ if {![info exists diffmergeid]} {
+ gettreediffs $diffids
+ }
+ } elseif {$id ne $diffids} {
+ gettree $diffids
+ } else {
+ setfilelist $id
+ }
+ return 0
+}
+
+proc showfile {f} {
+ global treefilelist treeidlist diffids nullid nullid2
+ global ctext commentend
+
+ set i [lsearch -exact $treefilelist($diffids) $f]
+ if {$i < 0} {
+ puts "oops, $f not in list for id $diffids"
+ return
+ }
+ if {$diffids eq $nullid} {
+ if {[catch {set bf [open $f r]} err]} {
+ puts "oops, can't read $f: $err"
+ return
+ }
+ } else {
+ set blob [lindex $treeidlist($diffids) $i]
+ if {[catch {set bf [open [concat | git cat-file blob $blob] r]} err]} {
+ puts "oops, error reading blob $blob: $err"
+ return
+ }
+ }
+ fconfigure $bf -blocking 0
+ filerun $bf [list getblobline $bf $diffids]
+ $ctext config -state normal
+ clear_ctext $commentend
+ $ctext insert end "\n"
+ $ctext insert end "$f\n" filesep
+ $ctext config -state disabled
+ $ctext yview $commentend
+ settabs 0
+}
+
+proc getblobline {bf id} {
+ global diffids cmitmode ctext
+
+ if {$id ne $diffids || $cmitmode ne "tree"} {
+ catch {close $bf}
+ return 0
+ }
+ $ctext config -state normal
+ set nl 0
+ while {[incr nl] <= 1000 && [gets $bf line] >= 0} {
+ $ctext insert end "$line\n"
+ }
+ if {[eof $bf]} {
+ # delete last newline
+ $ctext delete "end - 2c" "end - 1c"
+ close $bf
+ return 0
+ }
+ $ctext config -state disabled
+ return [expr {$nl >= 1000? 2: 1}]
+}
+
+proc mergediff {id l} {
+ global diffmergeid mdifffd
+ global diffids
+ global parentlist
+ global limitdiffs viewfiles curview
+
+ set diffmergeid $id
+ set diffids $id
+ # this doesn't seem to actually affect anything...
+ set cmd [concat | git diff-tree --no-commit-id --cc $id]
+ if {$limitdiffs && $viewfiles($curview) ne {}} {
+ set cmd [concat $cmd -- $viewfiles($curview)]
+ }
+ if {[catch {set mdf [open $cmd r]} err]} {
+ error_popup "Error getting merge diffs: $err"
+ return
+ }
+ fconfigure $mdf -blocking 0
+ set mdifffd($id) $mdf
+ set np [llength [lindex $parentlist $l]]
+ settabs $np
+ filerun $mdf [list getmergediffline $mdf $id $np]
+}
+
+proc getmergediffline {mdf id np} {
+ global diffmergeid ctext cflist mergemax
+ global difffilestart mdifffd
+
+ $ctext conf -state normal
+ set nr 0
+ while {[incr nr] <= 1000 && [gets $mdf line] >= 0} {
+ if {![info exists diffmergeid] || $id != $diffmergeid
+ || $mdf != $mdifffd($id)} {
+ close $mdf
+ return 0
+ }
+ if {[regexp {^diff --cc (.*)} $line match fname]} {
+ # start of a new file
+ $ctext insert end "\n"
+ set here [$ctext index "end - 1c"]
+ lappend difffilestart $here
+ add_flist [list $fname]
+ set l [expr {(78 - [string length $fname]) / 2}]
+ set pad [string range "----------------------------------------" 1 $l]
+ $ctext insert end "$pad $fname $pad\n" filesep
+ } elseif {[regexp {^@@} $line]} {
+ $ctext insert end "$line\n" hunksep
+ } elseif {[regexp {^[0-9a-f]{40}$} $line] || [regexp {^index} $line]} {
+ # do nothing
+ } else {
+ # parse the prefix - one ' ', '-' or '+' for each parent
+ set spaces {}
+ set minuses {}
+ set pluses {}
+ set isbad 0
+ for {set j 0} {$j < $np} {incr j} {
+ set c [string range $line $j $j]
+ if {$c == " "} {
+ lappend spaces $j
+ } elseif {$c == "-"} {
+ lappend minuses $j
+ } elseif {$c == "+"} {
+ lappend pluses $j
+ } else {
+ set isbad 1
+ break
+ }
+ }
+ set tags {}
+ set num {}
+ if {!$isbad && $minuses ne {} && $pluses eq {}} {
+ # line doesn't appear in result, parents in $minuses have the line
+ set num [lindex $minuses 0]
+ } elseif {!$isbad && $pluses ne {} && $minuses eq {}} {
+ # line appears in result, parents in $pluses don't have the line
+ lappend tags mresult
+ set num [lindex $spaces 0]
+ }
+ if {$num ne {}} {
+ if {$num >= $mergemax} {
+ set num "max"
+ }
+ lappend tags m$num
+ }
+ $ctext insert end "$line\n" $tags
+ }
+ }
+ $ctext conf -state disabled
+ if {[eof $mdf]} {
+ close $mdf
+ return 0
+ }
+ return [expr {$nr >= 1000? 2: 1}]
+}
+
+proc startdiff {ids} {
+ global treediffs diffids treepending diffmergeid nullid nullid2
+
+ settabs 1
+ set diffids $ids
+ catch {unset diffmergeid}
+ if {![info exists treediffs($ids)] ||
+ [lsearch -exact $ids $nullid] >= 0 ||
+ [lsearch -exact $ids $nullid2] >= 0} {
+ if {![info exists treepending]} {
+ gettreediffs $ids
+ }
+ } else {
+ addtocflist $ids
+ }
+}
+
+proc path_filter {filter name} {
+ foreach p $filter {
+ set l [string length $p]
+ if {[string index $p end] eq "/"} {
+ if {[string compare -length $l $p $name] == 0} {
+ return 1
+ }
+ } else {
+ if {[string compare -length $l $p $name] == 0 &&
+ ([string length $name] == $l ||
+ [string index $name $l] eq "/")} {
+ return 1
+ }
+ }
+ }
+ return 0
+}
+
+proc addtocflist {ids} {
+ global treediffs
+
+ add_flist $treediffs($ids)
+ getblobdiffs $ids
+}
+
+proc diffcmd {ids flags} {
+ global nullid nullid2
+
+ set i [lsearch -exact $ids $nullid]
+ set j [lsearch -exact $ids $nullid2]
+ if {$i >= 0} {
+ if {[llength $ids] > 1 && $j < 0} {
+ # comparing working directory with some specific revision
+ set cmd [concat | git diff-index $flags]
+ if {$i == 0} {
+ lappend cmd -R [lindex $ids 1]
+ } else {
+ lappend cmd [lindex $ids 0]
+ }
+ } else {
+ # comparing working directory with index
+ set cmd [concat | git diff-files $flags]
+ if {$j == 1} {
+ lappend cmd -R
+ }
+ }
+ } elseif {$j >= 0} {
+ set cmd [concat | git diff-index --cached $flags]
+ if {[llength $ids] > 1} {
+ # comparing index with specific revision
+ if {$i == 0} {
+ lappend cmd -R [lindex $ids 1]
+ } else {
+ lappend cmd [lindex $ids 0]
+ }
+ } else {
+ # comparing index with HEAD
+ lappend cmd HEAD
+ }
+ } else {
+ set cmd [concat | git diff-tree -r $flags $ids]
+ }
+ return $cmd
+}
+
+proc gettreediffs {ids} {
+ global treediff treepending
+
+ set treepending $ids
+ set treediff {}
+ if {[catch {set gdtf [open [diffcmd $ids {--no-commit-id}] r]}]} return
+ fconfigure $gdtf -blocking 0
+ filerun $gdtf [list gettreediffline $gdtf $ids]
+}
+
+proc gettreediffline {gdtf ids} {
+ global treediff treediffs treepending diffids diffmergeid
+ global cmitmode viewfiles curview limitdiffs
+
+ set nr 0
+ while {[incr nr] <= 1000 && [gets $gdtf line] >= 0} {
+ set i [string first "\t" $line]
+ if {$i >= 0} {
+ set file [string range $line [expr {$i+1}] end]
+ if {[string index $file 0] eq "\""} {
+ set file [lindex $file 0]
+ }
+ lappend treediff $file
+ }
+ }
+ if {![eof $gdtf]} {
+ return [expr {$nr >= 1000? 2: 1}]
+ }
+ close $gdtf
+ if {$limitdiffs && $viewfiles($curview) ne {}} {
+ set flist {}
+ foreach f $treediff {
+ if {[path_filter $viewfiles($curview) $f]} {
+ lappend flist $f
+ }
+ }
+ set treediffs($ids) $flist
+ } else {
+ set treediffs($ids) $treediff
+ }
+ unset treepending
+ if {$cmitmode eq "tree"} {
+ gettree $diffids
+ } elseif {$ids != $diffids} {
+ if {![info exists diffmergeid]} {
+ gettreediffs $diffids
+ }
+ } else {
+ addtocflist $ids
+ }
+ return 0
+}
+
+# empty string or positive integer
+proc diffcontextvalidate {v} {
+ return [regexp {^(|[1-9][0-9]*)$} $v]
+}
+
+proc diffcontextchange {n1 n2 op} {
+ global diffcontextstring diffcontext
+
+ if {[string is integer -strict $diffcontextstring]} {
+ if {$diffcontextstring > 0} {
+ set diffcontext $diffcontextstring
+ reselectline
+ }
+ }
+}
+
+proc getblobdiffs {ids} {
+ global blobdifffd diffids env
+ global diffinhdr treediffs
+ global diffcontext
+ global limitdiffs viewfiles curview
+
+ set cmd [diffcmd $ids "-p -C --no-commit-id -U$diffcontext"]
+ if {$limitdiffs && $viewfiles($curview) ne {}} {
+ set cmd [concat $cmd -- $viewfiles($curview)]
+ }
+ if {[catch {set bdf [open $cmd r]} err]} {
+ puts "error getting diffs: $err"
+ return
+ }
+ set diffinhdr 0
+ fconfigure $bdf -blocking 0
+ set blobdifffd($ids) $bdf
+ filerun $bdf [list getblobdiffline $bdf $diffids]
+}
+
+proc setinlist {var i val} {
+ global $var
+
+ while {[llength [set $var]] < $i} {
+ lappend $var {}
+ }
+ if {[llength [set $var]] == $i} {
+ lappend $var $val
+ } else {
+ lset $var $i $val
+ }
+}
+
+proc makediffhdr {fname ids} {
+ global ctext curdiffstart treediffs
+
+ set i [lsearch -exact $treediffs($ids) $fname]
+ if {$i >= 0} {
+ setinlist difffilestart $i $curdiffstart
+ }
+ set l [expr {(78 - [string length $fname]) / 2}]
+ set pad [string range "----------------------------------------" 1 $l]
+ $ctext insert $curdiffstart "$pad $fname $pad" filesep
+}
+
+proc getblobdiffline {bdf ids} {
+ global diffids blobdifffd ctext curdiffstart
+ global diffnexthead diffnextnote difffilestart
+ global diffinhdr treediffs
+
+ set nr 0
+ $ctext conf -state normal
+ while {[incr nr] <= 1000 && [gets $bdf line] >= 0} {
+ if {$ids != $diffids || $bdf != $blobdifffd($ids)} {
+ close $bdf
+ return 0
+ }
+ if {![string compare -length 11 "diff --git " $line]} {
+ # trim off "diff --git "
+ set line [string range $line 11 end]
+ set diffinhdr 1
+ # start of a new file
+ $ctext insert end "\n"
+ set curdiffstart [$ctext index "end - 1c"]
+ $ctext insert end "\n" filesep
+ # If the name hasn't changed the length will be odd,
+ # the middle char will be a space, and the two bits either
+ # side will be a/name and b/name, or "a/name" and "b/name".
+ # If the name has changed we'll get "rename from" and
+ # "rename to" or "copy from" and "copy to" lines following this,
+ # and we'll use them to get the filenames.
+ # This complexity is necessary because spaces in the filename(s)
+ # don't get escaped.
+ set l [string length $line]
+ set i [expr {$l / 2}]
+ if {!(($l & 1) && [string index $line $i] eq " " &&
+ [string range $line 2 [expr {$i - 1}]] eq \
+ [string range $line [expr {$i + 3}] end])} {
+ continue
+ }
+ # unescape if quoted and chop off the a/ from the front
+ if {[string index $line 0] eq "\""} {
+ set fname [string range [lindex $line 0] 2 end]
+ } else {
+ set fname [string range $line 2 [expr {$i - 1}]]
+ }
+ makediffhdr $fname $ids
+
+ } elseif {[regexp {^@@ -([0-9]+)(,[0-9]+)? \+([0-9]+)(,[0-9]+)? @@(.*)} \
+ $line match f1l f1c f2l f2c rest]} {
+ $ctext insert end "$line\n" hunksep
+ set diffinhdr 0
+
+ } elseif {$diffinhdr} {
+ if {![string compare -length 12 "rename from " $line]} {
+ set fname [string range $line [expr 6 + [string first " from " $line] ] end]
+ if {[string index $fname 0] eq "\""} {
+ set fname [lindex $fname 0]
+ }
+ set i [lsearch -exact $treediffs($ids) $fname]
+ if {$i >= 0} {
+ setinlist difffilestart $i $curdiffstart
+ }
+ } elseif {![string compare -length 10 $line "rename to "] ||
+ ![string compare -length 8 $line "copy to "]} {
+ set fname [string range $line [expr 4 + [string first " to " $line] ] end]
+ if {[string index $fname 0] eq "\""} {
+ set fname [lindex $fname 0]
+ }
+ makediffhdr $fname $ids
+ } elseif {[string compare -length 3 $line "---"] == 0} {
+ # do nothing
+ continue
+ } elseif {[string compare -length 3 $line "+++"] == 0} {
+ set diffinhdr 0
+ continue
+ }
+ $ctext insert end "$line\n" filesep
+
+ } else {
+ set x [string range $line 0 0]
+ if {$x == "-" || $x == "+"} {
+ set tag [expr {$x == "+"}]
+ $ctext insert end "$line\n" d$tag
+ } elseif {$x == " "} {
+ $ctext insert end "$line\n"
+ } else {
+ # "\ No newline at end of file",
+ # or something else we don't recognize
+ $ctext insert end "$line\n" hunksep
+ }
+ }
+ }
+ $ctext conf -state disabled
+ if {[eof $bdf]} {
+ close $bdf
+ return 0
+ }
+ return [expr {$nr >= 1000? 2: 1}]
+}
+
+proc changediffdisp {} {
+ global ctext diffelide
+
+ $ctext tag conf d0 -elide [lindex $diffelide 0]
+ $ctext tag conf d1 -elide [lindex $diffelide 1]
+}
+
+proc prevfile {} {
+ global difffilestart ctext
+ set prev [lindex $difffilestart 0]
+ set here [$ctext index @0,0]
+ foreach loc $difffilestart {
+ if {[$ctext compare $loc >= $here]} {
+ $ctext yview $prev
+ return
+ }
+ set prev $loc
+ }
+ $ctext yview $prev
+}
+
+proc nextfile {} {
+ global difffilestart ctext
+ set here [$ctext index @0,0]
+ foreach loc $difffilestart {
+ if {[$ctext compare $loc > $here]} {
+ $ctext yview $loc
+ return
+ }
+ }
+}
+
+proc clear_ctext {{first 1.0}} {
+ global ctext smarktop smarkbot
+ global pendinglinks
+
+ set l [lindex [split $first .] 0]
+ if {![info exists smarktop] || [$ctext compare $first < $smarktop.0]} {
+ set smarktop $l
+ }
+ if {![info exists smarkbot] || [$ctext compare $first < $smarkbot.0]} {
+ set smarkbot $l
+ }
+ $ctext delete $first end
+ if {$first eq "1.0"} {
+ catch {unset pendinglinks}
+ }
+}
+
+proc settabs {{firstab {}}} {
+ global firsttabstop tabstop ctext have_tk85
+
+ if {$firstab ne {} && $have_tk85} {
+ set firsttabstop $firstab
+ }
+ set w [font measure textfont "0"]
+ if {$firsttabstop != 0} {
+ $ctext conf -tabs [list [expr {($firsttabstop + $tabstop) * $w}] \
+ [expr {($firsttabstop + 2 * $tabstop) * $w}]]
+ } elseif {$have_tk85 || $tabstop != 8} {
+ $ctext conf -tabs [expr {$tabstop * $w}]
+ } else {
+ $ctext conf -tabs {}
+ }
+}
+
+proc incrsearch {name ix op} {
+ global ctext searchstring searchdirn
+
+ $ctext tag remove found 1.0 end
+ if {[catch {$ctext index anchor}]} {
+ # no anchor set, use start of selection, or of visible area
+ set sel [$ctext tag ranges sel]
+ if {$sel ne {}} {
+ $ctext mark set anchor [lindex $sel 0]
+ } elseif {$searchdirn eq "-forwards"} {
+ $ctext mark set anchor @0,0
+ } else {
+ $ctext mark set anchor @0,[winfo height $ctext]
+ }
+ }
+ if {$searchstring ne {}} {
+ set here [$ctext search $searchdirn -- $searchstring anchor]
+ if {$here ne {}} {
+ $ctext see $here
+ }
+ searchmarkvisible 1
+ }
+}
+
+proc dosearch {} {
+ global sstring ctext searchstring searchdirn
+
+ focus $sstring
+ $sstring icursor end
+ set searchdirn -forwards
+ if {$searchstring ne {}} {
+ set sel [$ctext tag ranges sel]
+ if {$sel ne {}} {
+ set start "[lindex $sel 0] + 1c"
+ } elseif {[catch {set start [$ctext index anchor]}]} {
+ set start "@0,0"
+ }
+ set match [$ctext search -count mlen -- $searchstring $start]
+ $ctext tag remove sel 1.0 end
+ if {$match eq {}} {
+ bell
+ return
+ }
+ $ctext see $match
+ set mend "$match + $mlen c"
+ $ctext tag add sel $match $mend
+ $ctext mark unset anchor
+ }
+}
+
+proc dosearchback {} {
+ global sstring ctext searchstring searchdirn
+
+ focus $sstring
+ $sstring icursor end
+ set searchdirn -backwards
+ if {$searchstring ne {}} {
+ set sel [$ctext tag ranges sel]
+ if {$sel ne {}} {
+ set start [lindex $sel 0]
+ } elseif {[catch {set start [$ctext index anchor]}]} {
+ set start @0,[winfo height $ctext]
+ }
+ set match [$ctext search -backwards -count ml -- $searchstring $start]
+ $ctext tag remove sel 1.0 end
+ if {$match eq {}} {
+ bell
+ return
+ }
+ $ctext see $match
+ set mend "$match + $ml c"
+ $ctext tag add sel $match $mend
+ $ctext mark unset anchor
+ }
+}
+
+proc searchmark {first last} {
+ global ctext searchstring
+
+ set mend $first.0
+ while {1} {
+ set match [$ctext search -count mlen -- $searchstring $mend $last.end]
+ if {$match eq {}} break
+ set mend "$match + $mlen c"
+ $ctext tag add found $match $mend
+ }
+}
+
+proc searchmarkvisible {doall} {
+ global ctext smarktop smarkbot
+
+ set topline [lindex [split [$ctext index @0,0] .] 0]
+ set botline [lindex [split [$ctext index @0,[winfo height $ctext]] .] 0]
+ if {$doall || $botline < $smarktop || $topline > $smarkbot} {
+ # no overlap with previous
+ searchmark $topline $botline
+ set smarktop $topline
+ set smarkbot $botline
+ } else {
+ if {$topline < $smarktop} {
+ searchmark $topline [expr {$smarktop-1}]
+ set smarktop $topline
+ }
+ if {$botline > $smarkbot} {
+ searchmark [expr {$smarkbot+1}] $botline
+ set smarkbot $botline
+ }
+ }
+}
+
+proc scrolltext {f0 f1} {
+ global searchstring
+
+ .bleft.sb set $f0 $f1
+ if {$searchstring ne {}} {
+ searchmarkvisible 0
+ }
+}
+
+proc setcoords {} {
+ global linespc charspc canvx0 canvy0
+ global xspc1 xspc2 lthickness
+
+ set linespc [font metrics mainfont -linespace]
+ set charspc [font measure mainfont "m"]
+ set canvy0 [expr {int(3 + 0.5 * $linespc)}]
+ set canvx0 [expr {int(3 + 0.5 * $linespc)}]
+ set lthickness [expr {int($linespc / 9) + 1}]
+ set xspc1(0) $linespc
+ set xspc2 $linespc
+}
+
+proc redisplay {} {
+ global canv
+ global selectedline
+
+ set ymax [lindex [$canv cget -scrollregion] 3]
+ if {$ymax eq {} || $ymax == 0} return
+ set span [$canv yview]
+ clear_display
+ setcanvscroll
+ allcanvs yview moveto [lindex $span 0]
+ drawvisible
+ if {[info exists selectedline]} {
+ selectline $selectedline 0
+ allcanvs yview moveto [lindex $span 0]
+ }
+}
+
+proc parsefont {f n} {
+ global fontattr
+
+ set fontattr($f,family) [lindex $n 0]
+ set s [lindex $n 1]
+ if {$s eq {} || $s == 0} {
+ set s 10
+ } elseif {$s < 0} {
+ set s [expr {int(-$s / [winfo fpixels . 1p] + 0.5)}]
+ }
+ set fontattr($f,size) $s
+ set fontattr($f,weight) normal
+ set fontattr($f,slant) roman
+ foreach style [lrange $n 2 end] {
+ switch -- $style {
+ "normal" -
+ "bold" {set fontattr($f,weight) $style}
+ "roman" -
+ "italic" {set fontattr($f,slant) $style}
+ }
+ }
+}
+
+proc fontflags {f {isbold 0}} {
+ global fontattr
+
+ return [list -family $fontattr($f,family) -size $fontattr($f,size) \
+ -weight [expr {$isbold? "bold": $fontattr($f,weight)}] \
+ -slant $fontattr($f,slant)]
+}
+
+proc fontname {f} {
+ global fontattr
+
+ set n [list $fontattr($f,family) $fontattr($f,size)]
+ if {$fontattr($f,weight) eq "bold"} {
+ lappend n "bold"
+ }
+ if {$fontattr($f,slant) eq "italic"} {
+ lappend n "italic"
+ }
+ return $n
+}
+
+proc incrfont {inc} {
+ global mainfont textfont ctext canv phase cflist showrefstop
+ global stopped entries fontattr
+
+ unmarkmatches
+ set s $fontattr(mainfont,size)
+ incr s $inc
+ if {$s < 1} {
+ set s 1
+ }
+ set fontattr(mainfont,size) $s
+ font config mainfont -size $s
+ font config mainfontbold -size $s
+ set mainfont [fontname mainfont]
+ set s $fontattr(textfont,size)
+ incr s $inc
+ if {$s < 1} {
+ set s 1
+ }
+ set fontattr(textfont,size) $s
+ font config textfont -size $s
+ font config textfontbold -size $s
+ set textfont [fontname textfont]
+ setcoords
+ settabs
+ redisplay
+}
+
+proc clearsha1 {} {
+ global sha1entry sha1string
+ if {[string length $sha1string] == 40} {
+ $sha1entry delete 0 end
+ }
+}
+
+proc sha1change {n1 n2 op} {
+ global sha1string currentid sha1but
+ if {$sha1string == {}
+ || ([info exists currentid] && $sha1string == $currentid)} {
+ set state disabled
+ } else {
+ set state normal
+ }
+ if {[$sha1but cget -state] == $state} return
+ if {$state == "normal"} {
+ $sha1but conf -state normal -relief raised -text "Goto: "
+ } else {
+ $sha1but conf -state disabled -relief flat -text "SHA1 ID: "
+ }
+}
+
+proc gotocommit {} {
+ global sha1string currentid commitrow tagids headids
+ global displayorder numcommits curview
+
+ if {$sha1string == {}
+ || ([info exists currentid] && $sha1string == $currentid)} return
+ if {[info exists tagids($sha1string)]} {
+ set id $tagids($sha1string)
+ } elseif {[info exists headids($sha1string)]} {
+ set id $headids($sha1string)
+ } else {
+ set id [string tolower $sha1string]
+ if {[regexp {^[0-9a-f]{4,39}$} $id]} {
+ set matches {}
+ foreach i $displayorder {
+ if {[string match $id* $i]} {
+ lappend matches $i
+ }
+ }
+ if {$matches ne {}} {
+ if {[llength $matches] > 1} {
+ error_popup "Short SHA1 id $id is ambiguous"
+ return
+ }
+ set id [lindex $matches 0]
+ }
+ }
+ }
+ if {[info exists commitrow($curview,$id)]} {
+ selectline $commitrow($curview,$id) 1
+ return
+ }
+ if {[regexp {^[0-9a-fA-F]{4,}$} $sha1string]} {
+ set type "SHA1 id"
+ } else {
+ set type "Tag/Head"
+ }
+ error_popup "$type $sha1string is not known"
+}
+
+proc lineenter {x y id} {
+ global hoverx hovery hoverid hovertimer
+ global commitinfo canv
+
+ if {![info exists commitinfo($id)] && ![getcommit $id]} return
+ set hoverx $x
+ set hovery $y
+ set hoverid $id
+ if {[info exists hovertimer]} {
+ after cancel $hovertimer
+ }
+ set hovertimer [after 500 linehover]
+ $canv delete hover
+}
+
+proc linemotion {x y id} {
+ global hoverx hovery hoverid hovertimer
+
+ if {[info exists hoverid] && $id == $hoverid} {
+ set hoverx $x
+ set hovery $y
+ if {[info exists hovertimer]} {
+ after cancel $hovertimer
+ }
+ set hovertimer [after 500 linehover]
+ }
+}
+
+proc lineleave {id} {
+ global hoverid hovertimer canv
+
+ if {[info exists hoverid] && $id == $hoverid} {
+ $canv delete hover
+ if {[info exists hovertimer]} {
+ after cancel $hovertimer
+ unset hovertimer
+ }
+ unset hoverid
+ }
+}
+
+proc linehover {} {
+ global hoverx hovery hoverid hovertimer
+ global canv linespc lthickness
+ global commitinfo
+
+ set text [lindex $commitinfo($hoverid) 0]
+ set ymax [lindex [$canv cget -scrollregion] 3]
+ if {$ymax == {}} return
+ set yfrac [lindex [$canv yview] 0]
+ set x [expr {$hoverx + 2 * $linespc}]
+ set y [expr {$hovery + $yfrac * $ymax - $linespc / 2}]
+ set x0 [expr {$x - 2 * $lthickness}]
+ set y0 [expr {$y - 2 * $lthickness}]
+ set x1 [expr {$x + [font measure mainfont $text] + 2 * $lthickness}]
+ set y1 [expr {$y + $linespc + 2 * $lthickness}]
+ set t [$canv create rectangle $x0 $y0 $x1 $y1 \
+ -fill \#ffff80 -outline black -width 1 -tags hover]
+ $canv raise $t
+ set t [$canv create text $x $y -anchor nw -text $text -tags hover \
+ -font mainfont]
+ $canv raise $t
+}
+
+proc clickisonarrow {id y} {
+ global lthickness
+
+ set ranges [rowranges $id]
+ set thresh [expr {2 * $lthickness + 6}]
+ set n [expr {[llength $ranges] - 1}]
+ for {set i 1} {$i < $n} {incr i} {
+ set row [lindex $ranges $i]
+ if {abs([yc $row] - $y) < $thresh} {
+ return $i
+ }
+ }
+ return {}
+}
+
+proc arrowjump {id n y} {
+ global canv
+
+ # 1 <-> 2, 3 <-> 4, etc...
+ set n [expr {(($n - 1) ^ 1) + 1}]
+ set row [lindex [rowranges $id] $n]
+ set yt [yc $row]
+ set ymax [lindex [$canv cget -scrollregion] 3]
+ if {$ymax eq {} || $ymax <= 0} return
+ set view [$canv yview]
+ set yspan [expr {[lindex $view 1] - [lindex $view 0]}]
+ set yfrac [expr {$yt / $ymax - $yspan / 2}]
+ if {$yfrac < 0} {
+ set yfrac 0
+ }
+ allcanvs yview moveto $yfrac
+}
+
+proc lineclick {x y id isnew} {
+ global ctext commitinfo children canv thickerline curview commitrow
+
+ if {![info exists commitinfo($id)] && ![getcommit $id]} return
+ unmarkmatches
+ unselectline
+ normalline
+ $canv delete hover
+ # draw this line thicker than normal
+ set thickerline $id
+ drawlines $id
+ if {$isnew} {
+ set ymax [lindex [$canv cget -scrollregion] 3]
+ if {$ymax eq {}} return
+ set yfrac [lindex [$canv yview] 0]
+ set y [expr {$y + $yfrac * $ymax}]
+ }
+ set dirn [clickisonarrow $id $y]
+ if {$dirn ne {}} {
+ arrowjump $id $dirn $y
+ return
+ }
+
+ if {$isnew} {
+ addtohistory [list lineclick $x $y $id 0]
+ }
+ # fill the details pane with info about this line
+ $ctext conf -state normal
+ clear_ctext
+ settabs 0
+ $ctext insert end "Parent:\t"
+ $ctext insert end $id link0
+ setlink $id link0
+ set info $commitinfo($id)
+ $ctext insert end "\n\t[lindex $info 0]\n"
+ $ctext insert end "\tAuthor:\t[lindex $info 1]\n"
+ set date [formatdate [lindex $info 2]]
+ $ctext insert end "\tDate:\t$date\n"
+ set kids $children($curview,$id)
+ if {$kids ne {}} {
+ $ctext insert end "\nChildren:"
+ set i 0
+ foreach child $kids {
+ incr i
+ if {![info exists commitinfo($child)] && ![getcommit $child]} continue
+ set info $commitinfo($child)
+ $ctext insert end "\n\t"
+ $ctext insert end $child link$i
+ setlink $child link$i
+ $ctext insert end "\n\t[lindex $info 0]"
+ $ctext insert end "\n\tAuthor:\t[lindex $info 1]"
+ set date [formatdate [lindex $info 2]]
+ $ctext insert end "\n\tDate:\t$date\n"
+ }
+ }
+ $ctext conf -state disabled
+ init_flist {}
+}
+
+proc normalline {} {
+ global thickerline
+ if {[info exists thickerline]} {
+ set id $thickerline
+ unset thickerline
+ drawlines $id
+ }
+}
+
+proc selbyid {id} {
+ global commitrow curview
+ if {[info exists commitrow($curview,$id)]} {
+ selectline $commitrow($curview,$id) 1
+ }
+}
+
+proc mstime {} {
+ global startmstime
+ if {![info exists startmstime]} {
+ set startmstime [clock clicks -milliseconds]
+ }
+ return [format "%.3f" [expr {([clock click -milliseconds] - $startmstime) / 1000.0}]]
+}
+
+proc rowmenu {x y id} {
+ global rowctxmenu commitrow selectedline rowmenuid curview
+ global nullid nullid2 fakerowmenu mainhead
+
+ stopfinding
+ set rowmenuid $id
+ if {![info exists selectedline]
+ || $commitrow($curview,$id) eq $selectedline} {
+ set state disabled
+ } else {
+ set state normal
+ }
+ if {$id ne $nullid && $id ne $nullid2} {
+ set menu $rowctxmenu
+ $menu entryconfigure 7 -label "Reset $mainhead branch to here"
+ } else {
+ set menu $fakerowmenu
+ }
+ $menu entryconfigure "Diff this*" -state $state
+ $menu entryconfigure "Diff selected*" -state $state
+ $menu entryconfigure "Make patch" -state $state
+ tk_popup $menu $x $y
+}
+
+proc diffvssel {dirn} {
+ global rowmenuid selectedline displayorder
+
+ if {![info exists selectedline]} return
+ if {$dirn} {
+ set oldid [lindex $displayorder $selectedline]
+ set newid $rowmenuid
+ } else {
+ set oldid $rowmenuid
+ set newid [lindex $displayorder $selectedline]
+ }
+ addtohistory [list doseldiff $oldid $newid]
+ doseldiff $oldid $newid
+}
+
+proc doseldiff {oldid newid} {
+ global ctext
+ global commitinfo
+
+ $ctext conf -state normal
+ clear_ctext
+ init_flist "Top"
+ $ctext insert end "From "
+ $ctext insert end $oldid link0
+ setlink $oldid link0
+ $ctext insert end "\n "
+ $ctext insert end [lindex $commitinfo($oldid) 0]
+ $ctext insert end "\n\nTo "
+ $ctext insert end $newid link1
+ setlink $newid link1
+ $ctext insert end "\n "
+ $ctext insert end [lindex $commitinfo($newid) 0]
+ $ctext insert end "\n"
+ $ctext conf -state disabled
+ $ctext tag remove found 1.0 end
+ startdiff [list $oldid $newid]
+}
+
+proc mkpatch {} {
+ global rowmenuid currentid commitinfo patchtop patchnum
+
+ if {![info exists currentid]} return
+ set oldid $currentid
+ set oldhead [lindex $commitinfo($oldid) 0]
+ set newid $rowmenuid
+ set newhead [lindex $commitinfo($newid) 0]
+ set top .patch
+ set patchtop $top
+ catch {destroy $top}
+ toplevel $top
+ label $top.title -text "Generate patch"
+ grid $top.title - -pady 10
+ label $top.from -text "From:"
+ entry $top.fromsha1 -width 40 -relief flat
+ $top.fromsha1 insert 0 $oldid
+ $top.fromsha1 conf -state readonly
+ grid $top.from $top.fromsha1 -sticky w
+ entry $top.fromhead -width 60 -relief flat
+ $top.fromhead insert 0 $oldhead
+ $top.fromhead conf -state readonly
+ grid x $top.fromhead -sticky w
+ label $top.to -text "To:"
+ entry $top.tosha1 -width 40 -relief flat
+ $top.tosha1 insert 0 $newid
+ $top.tosha1 conf -state readonly
+ grid $top.to $top.tosha1 -sticky w
+ entry $top.tohead -width 60 -relief flat
+ $top.tohead insert 0 $newhead
+ $top.tohead conf -state readonly
+ grid x $top.tohead -sticky w
+ button $top.rev -text "Reverse" -command mkpatchrev -padx 5
+ grid $top.rev x -pady 10
+ label $top.flab -text "Output file:"
+ entry $top.fname -width 60
+ $top.fname insert 0 [file normalize "patch$patchnum.patch"]
+ incr patchnum
+ grid $top.flab $top.fname -sticky w
+ frame $top.buts
+ button $top.buts.gen -text "Generate" -command mkpatchgo
+ button $top.buts.can -text "Cancel" -command mkpatchcan
+ grid $top.buts.gen $top.buts.can
+ grid columnconfigure $top.buts 0 -weight 1 -uniform a
+ grid columnconfigure $top.buts 1 -weight 1 -uniform a
+ grid $top.buts - -pady 10 -sticky ew
+ focus $top.fname
+}
+
+proc mkpatchrev {} {
+ global patchtop
+
+ set oldid [$patchtop.fromsha1 get]
+ set oldhead [$patchtop.fromhead get]
+ set newid [$patchtop.tosha1 get]
+ set newhead [$patchtop.tohead get]
+ foreach e [list fromsha1 fromhead tosha1 tohead] \
+ v [list $newid $newhead $oldid $oldhead] {
+ $patchtop.$e conf -state normal
+ $patchtop.$e delete 0 end
+ $patchtop.$e insert 0 $v
+ $patchtop.$e conf -state readonly
+ }
+}
+
+proc mkpatchgo {} {
+ global patchtop nullid nullid2
+
+ set oldid [$patchtop.fromsha1 get]
+ set newid [$patchtop.tosha1 get]
+ set fname [$patchtop.fname get]
+ set cmd [diffcmd [list $oldid $newid] -p]
+ # trim off the initial "|"
+ set cmd [lrange $cmd 1 end]
+ lappend cmd >$fname &
+ if {[catch {eval exec $cmd} err]} {
+ error_popup "Error creating patch: $err"
+ }
+ catch {destroy $patchtop}
+ unset patchtop
+}
+
+proc mkpatchcan {} {
+ global patchtop
+
+ catch {destroy $patchtop}
+ unset patchtop
+}
+
+proc mktag {} {
+ global rowmenuid mktagtop commitinfo
+
+ set top .maketag
+ set mktagtop $top
+ catch {destroy $top}
+ toplevel $top
+ label $top.title -text "Create tag"
+ grid $top.title - -pady 10
+ label $top.id -text "ID:"
+ entry $top.sha1 -width 40 -relief flat
+ $top.sha1 insert 0 $rowmenuid
+ $top.sha1 conf -state readonly
+ grid $top.id $top.sha1 -sticky w
+ entry $top.head -width 60 -relief flat
+ $top.head insert 0 [lindex $commitinfo($rowmenuid) 0]
+ $top.head conf -state readonly
+ grid x $top.head -sticky w
+ label $top.tlab -text "Tag name:"
+ entry $top.tag -width 60
+ grid $top.tlab $top.tag -sticky w
+ frame $top.buts
+ button $top.buts.gen -text "Create" -command mktaggo
+ button $top.buts.can -text "Cancel" -command mktagcan
+ grid $top.buts.gen $top.buts.can
+ grid columnconfigure $top.buts 0 -weight 1 -uniform a
+ grid columnconfigure $top.buts 1 -weight 1 -uniform a
+ grid $top.buts - -pady 10 -sticky ew
+ focus $top.tag
+}
+
+proc domktag {} {
+ global mktagtop env tagids idtags
+
+ set id [$mktagtop.sha1 get]
+ set tag [$mktagtop.tag get]
+ if {$tag == {}} {
+ error_popup "No tag name specified"
+ return
+ }
+ if {[info exists tagids($tag)]} {
+ error_popup "Tag \"$tag\" already exists"
+ return
+ }
+ if {[catch {
+ set dir [gitdir]
+ set fname [file join $dir "refs/tags" $tag]
+ set f [open $fname w]
+ puts $f $id
+ close $f
+ } err]} {
+ error_popup "Error creating tag: $err"
+ return
+ }
+
+ set tagids($tag) $id
+ lappend idtags($id) $tag
+ redrawtags $id
+ addedtag $id
+ dispneartags 0
+ run refill_reflist
+}
+
+proc redrawtags {id} {
+ global canv linehtag commitrow idpos selectedline curview
+ global canvxmax iddrawn
+
+ if {![info exists commitrow($curview,$id)]} return
+ if {![info exists iddrawn($id)]} return
+ drawcommits $commitrow($curview,$id)
+ $canv delete tag.$id
+ set xt [eval drawtags $id $idpos($id)]
+ $canv coords $linehtag($commitrow($curview,$id)) $xt [lindex $idpos($id) 2]
+ set text [$canv itemcget $linehtag($commitrow($curview,$id)) -text]
+ set xr [expr {$xt + [font measure mainfont $text]}]
+ if {$xr > $canvxmax} {
+ set canvxmax $xr
+ setcanvscroll
+ }
+ if {[info exists selectedline]
+ && $selectedline == $commitrow($curview,$id)} {
+ selectline $selectedline 0
+ }
+}
+
+proc mktagcan {} {
+ global mktagtop
+
+ catch {destroy $mktagtop}
+ unset mktagtop
+}
+
+proc mktaggo {} {
+ domktag
+ mktagcan
+}
+
+proc writecommit {} {
+ global rowmenuid wrcomtop commitinfo wrcomcmd
+
+ set top .writecommit
+ set wrcomtop $top
+ catch {destroy $top}
+ toplevel $top
+ label $top.title -text "Write commit to file"
+ grid $top.title - -pady 10
+ label $top.id -text "ID:"
+ entry $top.sha1 -width 40 -relief flat
+ $top.sha1 insert 0 $rowmenuid
+ $top.sha1 conf -state readonly
+ grid $top.id $top.sha1 -sticky w
+ entry $top.head -width 60 -relief flat
+ $top.head insert 0 [lindex $commitinfo($rowmenuid) 0]
+ $top.head conf -state readonly
+ grid x $top.head -sticky w
+ label $top.clab -text "Command:"
+ entry $top.cmd -width 60 -textvariable wrcomcmd
+ grid $top.clab $top.cmd -sticky w -pady 10
+ label $top.flab -text "Output file:"
+ entry $top.fname -width 60
+ $top.fname insert 0 [file normalize "commit-[string range $rowmenuid 0 6]"]
+ grid $top.flab $top.fname -sticky w
+ frame $top.buts
+ button $top.buts.gen -text "Write" -command wrcomgo
+ button $top.buts.can -text "Cancel" -command wrcomcan
+ grid $top.buts.gen $top.buts.can
+ grid columnconfigure $top.buts 0 -weight 1 -uniform a
+ grid columnconfigure $top.buts 1 -weight 1 -uniform a
+ grid $top.buts - -pady 10 -sticky ew
+ focus $top.fname
+}
+
+proc wrcomgo {} {
+ global wrcomtop
+
+ set id [$wrcomtop.sha1 get]
+ set cmd "echo $id | [$wrcomtop.cmd get]"
+ set fname [$wrcomtop.fname get]
+ if {[catch {exec sh -c $cmd >$fname &} err]} {
+ error_popup "Error writing commit: $err"
+ }
+ catch {destroy $wrcomtop}
+ unset wrcomtop
+}
+
+proc wrcomcan {} {
+ global wrcomtop
+
+ catch {destroy $wrcomtop}
+ unset wrcomtop
+}
+
+proc mkbranch {} {
+ global rowmenuid mkbrtop
+
+ set top .makebranch
+ catch {destroy $top}
+ toplevel $top
+ label $top.title -text "Create new branch"
+ grid $top.title - -pady 10
+ label $top.id -text "ID:"
+ entry $top.sha1 -width 40 -relief flat
+ $top.sha1 insert 0 $rowmenuid
+ $top.sha1 conf -state readonly
+ grid $top.id $top.sha1 -sticky w
+ label $top.nlab -text "Name:"
+ entry $top.name -width 40
+ grid $top.nlab $top.name -sticky w
+ frame $top.buts
+ button $top.buts.go -text "Create" -command [list mkbrgo $top]
+ button $top.buts.can -text "Cancel" -command "catch {destroy $top}"
+ grid $top.buts.go $top.buts.can
+ grid columnconfigure $top.buts 0 -weight 1 -uniform a
+ grid columnconfigure $top.buts 1 -weight 1 -uniform a
+ grid $top.buts - -pady 10 -sticky ew
+ focus $top.name
+}
+
+proc mkbrgo {top} {
+ global headids idheads
+
+ set name [$top.name get]
+ set id [$top.sha1 get]
+ if {$name eq {}} {
+ error_popup "Please specify a name for the new branch"
+ return
+ }
+ catch {destroy $top}
+ nowbusy newbranch
+ update
+ if {[catch {
+ exec git branch $name $id
+ } err]} {
+ notbusy newbranch
+ error_popup $err
+ } else {
+ set headids($name) $id
+ lappend idheads($id) $name
+ addedhead $id $name
+ notbusy newbranch
+ redrawtags $id
+ dispneartags 0
+ run refill_reflist
+ }
+}
+
+proc cherrypick {} {
+ global rowmenuid curview commitrow
+ global mainhead
+
+ set oldhead [exec git rev-parse HEAD]
+ set dheads [descheads $rowmenuid]
+ if {$dheads ne {} && [lsearch -exact $dheads $oldhead] >= 0} {
+ set ok [confirm_popup "Commit [string range $rowmenuid 0 7] is already\
+ included in branch $mainhead -- really re-apply it?"]
+ if {!$ok} return
+ }
+ nowbusy cherrypick "Cherry-picking"
+ update
+ # Unfortunately git-cherry-pick writes stuff to stderr even when
+ # no error occurs, and exec takes that as an indication of error...
+ if {[catch {exec sh -c "git cherry-pick -r $rowmenuid 2>&1"} err]} {
+ notbusy cherrypick
+ error_popup $err
+ return
+ }
+ set newhead [exec git rev-parse HEAD]
+ if {$newhead eq $oldhead} {
+ notbusy cherrypick
+ error_popup "No changes committed"
+ return
+ }
+ addnewchild $newhead $oldhead
+ if {[info exists commitrow($curview,$oldhead)]} {
+ insertrow $commitrow($curview,$oldhead) $newhead
+ if {$mainhead ne {}} {
+ movehead $newhead $mainhead
+ movedhead $newhead $mainhead
+ }
+ redrawtags $oldhead
+ redrawtags $newhead
+ }
+ notbusy cherrypick
+}
+
+proc resethead {} {
+ global mainheadid mainhead rowmenuid confirm_ok resettype
+
+ set confirm_ok 0
+ set w ".confirmreset"
+ toplevel $w
+ wm transient $w .
+ wm title $w "Confirm reset"
+ message $w.m -text \
+ "Reset branch $mainhead to [string range $rowmenuid 0 7]?" \
+ -justify center -aspect 1000
+ pack $w.m -side top -fill x -padx 20 -pady 20
+ frame $w.f -relief sunken -border 2
+ message $w.f.rt -text "Reset type:" -aspect 1000
+ grid $w.f.rt -sticky w
+ set resettype mixed
+ radiobutton $w.f.soft -value soft -variable resettype -justify left \
+ -text "Soft: Leave working tree and index untouched"
+ grid $w.f.soft -sticky w
+ radiobutton $w.f.mixed -value mixed -variable resettype -justify left \
+ -text "Mixed: Leave working tree untouched, reset index"
+ grid $w.f.mixed -sticky w
+ radiobutton $w.f.hard -value hard -variable resettype -justify left \
+ -text "Hard: Reset working tree and index\n(discard ALL local changes)"
+ grid $w.f.hard -sticky w
+ pack $w.f -side top -fill x
+ button $w.ok -text OK -command "set confirm_ok 1; destroy $w"
+ pack $w.ok -side left -fill x -padx 20 -pady 20
+ button $w.cancel -text Cancel -command "destroy $w"
+ pack $w.cancel -side right -fill x -padx 20 -pady 20
+ bind $w <Visibility> "grab $w; focus $w"
+ tkwait window $w
+ if {!$confirm_ok} return
+ if {[catch {set fd [open \
+ [list | sh -c "git reset --$resettype $rowmenuid 2>&1"] r]} err]} {
+ error_popup $err
+ } else {
+ dohidelocalchanges
+ filerun $fd [list readresetstat $fd]
+ nowbusy reset "Resetting"
+ }
+}
+
+proc readresetstat {fd} {
+ global mainhead mainheadid showlocalchanges rprogcoord
+
+ if {[gets $fd line] >= 0} {
+ if {[regexp {([0-9]+)% \(([0-9]+)/([0-9]+)\)} $line match p m n]} {
+ set rprogcoord [expr {1.0 * $m / $n}]
+ adjustprogress
+ }
+ return 1
+ }
+ set rprogcoord 0
+ adjustprogress
+ notbusy reset
+ if {[catch {close $fd} err]} {
+ error_popup $err
+ }
+ set oldhead $mainheadid
+ set newhead [exec git rev-parse HEAD]
+ if {$newhead ne $oldhead} {
+ movehead $newhead $mainhead
+ movedhead $newhead $mainhead
+ set mainheadid $newhead
+ redrawtags $oldhead
+ redrawtags $newhead
+ }
+ if {$showlocalchanges} {
+ doshowlocalchanges
+ }
+ return 0
+}
+
+# context menu for a head
+proc headmenu {x y id head} {
+ global headmenuid headmenuhead headctxmenu mainhead
+
+ stopfinding
+ set headmenuid $id
+ set headmenuhead $head
+ set state normal
+ if {$head eq $mainhead} {
+ set state disabled
+ }
+ $headctxmenu entryconfigure 0 -state $state
+ $headctxmenu entryconfigure 1 -state $state
+ tk_popup $headctxmenu $x $y
+}
+
+proc cobranch {} {
+ global headmenuid headmenuhead mainhead headids
+ global showlocalchanges mainheadid
+
+ # check the tree is clean first??
+ set oldmainhead $mainhead
+ nowbusy checkout "Checking out"
+ update
+ dohidelocalchanges
+ if {[catch {
+ exec git checkout -q $headmenuhead
+ } err]} {
+ notbusy checkout
+ error_popup $err
+ } else {
+ notbusy checkout
+ set mainhead $headmenuhead
+ set mainheadid $headmenuid
+ if {[info exists headids($oldmainhead)]} {
+ redrawtags $headids($oldmainhead)
+ }
+ redrawtags $headmenuid
+ }
+ if {$showlocalchanges} {
+ dodiffindex
+ }
+}
+
+proc rmbranch {} {
+ global headmenuid headmenuhead mainhead
+ global idheads
+
+ set head $headmenuhead
+ set id $headmenuid
+ # this check shouldn't be needed any more...
+ if {$head eq $mainhead} {
+ error_popup "Cannot delete the currently checked-out branch"
+ return
+ }
+ set dheads [descheads $id]
+ if {[llength $dheads] == 1 && $idheads($dheads) eq $head} {
+ # the stuff on this branch isn't on any other branch
+ if {![confirm_popup "The commits on branch $head aren't on any other\
+ branch.\nReally delete branch $head?"]} return
+ }
+ nowbusy rmbranch
+ update
+ if {[catch {exec git branch -D $head} err]} {
+ notbusy rmbranch
+ error_popup $err
+ return
+ }
+ removehead $id $head
+ removedhead $id $head
+ redrawtags $id
+ notbusy rmbranch
+ dispneartags 0
+ run refill_reflist
+}
+
+# Display a list of tags and heads
+proc showrefs {} {
+ global showrefstop bgcolor fgcolor selectbgcolor
+ global bglist fglist reflistfilter reflist maincursor
+
+ set top .showrefs
+ set showrefstop $top
+ if {[winfo exists $top]} {
+ raise $top
+ refill_reflist
+ return
+ }
+ toplevel $top
+ wm title $top "Tags and heads: [file tail [pwd]]"
+ text $top.list -background $bgcolor -foreground $fgcolor \
+ -selectbackground $selectbgcolor -font mainfont \
+ -xscrollcommand "$top.xsb set" -yscrollcommand "$top.ysb set" \
+ -width 30 -height 20 -cursor $maincursor \
+ -spacing1 1 -spacing3 1 -state disabled
+ $top.list tag configure highlight -background $selectbgcolor
+ lappend bglist $top.list
+ lappend fglist $top.list
+ scrollbar $top.ysb -command "$top.list yview" -orient vertical
+ scrollbar $top.xsb -command "$top.list xview" -orient horizontal
+ grid $top.list $top.ysb -sticky nsew
+ grid $top.xsb x -sticky ew
+ frame $top.f
+ label $top.f.l -text "Filter: " -font uifont
+ entry $top.f.e -width 20 -textvariable reflistfilter -font uifont
+ set reflistfilter "*"
+ trace add variable reflistfilter write reflistfilter_change
+ pack $top.f.e -side right -fill x -expand 1
+ pack $top.f.l -side left
+ grid $top.f - -sticky ew -pady 2
+ button $top.close -command [list destroy $top] -text "Close" \
+ -font uifont
+ grid $top.close -
+ grid columnconfigure $top 0 -weight 1
+ grid rowconfigure $top 0 -weight 1
+ bind $top.list <1> {break}
+ bind $top.list <B1-Motion> {break}
+ bind $top.list <ButtonRelease-1> {sel_reflist %W %x %y; break}
+ set reflist {}
+ refill_reflist
+}
+
+proc sel_reflist {w x y} {
+ global showrefstop reflist headids tagids otherrefids
+
+ if {![winfo exists $showrefstop]} return
+ set l [lindex [split [$w index "@$x,$y"] "."] 0]
+ set ref [lindex $reflist [expr {$l-1}]]
+ set n [lindex $ref 0]
+ switch -- [lindex $ref 1] {
+ "H" {selbyid $headids($n)}
+ "T" {selbyid $tagids($n)}
+ "o" {selbyid $otherrefids($n)}
+ }
+ $showrefstop.list tag add highlight $l.0 "$l.0 lineend"
+}
+
+proc unsel_reflist {} {
+ global showrefstop
+
+ if {![info exists showrefstop] || ![winfo exists $showrefstop]} return
+ $showrefstop.list tag remove highlight 0.0 end
+}
+
+proc reflistfilter_change {n1 n2 op} {
+ global reflistfilter
+
+ after cancel refill_reflist
+ after 200 refill_reflist
+}
+
+proc refill_reflist {} {
+ global reflist reflistfilter showrefstop headids tagids otherrefids
+ global commitrow curview commitinterest
+
+ if {![info exists showrefstop] || ![winfo exists $showrefstop]} return
+ set refs {}
+ foreach n [array names headids] {
+ if {[string match $reflistfilter $n]} {
+ if {[info exists commitrow($curview,$headids($n))]} {
+ lappend refs [list $n H]
+ } else {
+ set commitinterest($headids($n)) {run refill_reflist}
+ }
+ }
+ }
+ foreach n [array names tagids] {
+ if {[string match $reflistfilter $n]} {
+ if {[info exists commitrow($curview,$tagids($n))]} {
+ lappend refs [list $n T]
+ } else {
+ set commitinterest($tagids($n)) {run refill_reflist}
+ }
+ }
+ }
+ foreach n [array names otherrefids] {
+ if {[string match $reflistfilter $n]} {
+ if {[info exists commitrow($curview,$otherrefids($n))]} {
+ lappend refs [list $n o]
+ } else {
+ set commitinterest($otherrefids($n)) {run refill_reflist}
+ }
+ }
+ }
+ set refs [lsort -index 0 $refs]
+ if {$refs eq $reflist} return
+
+ # Update the contents of $showrefstop.list according to the
+ # differences between $reflist (old) and $refs (new)
+ $showrefstop.list conf -state normal
+ $showrefstop.list insert end "\n"
+ set i 0
+ set j 0
+ while {$i < [llength $reflist] || $j < [llength $refs]} {
+ if {$i < [llength $reflist]} {
+ if {$j < [llength $refs]} {
+ set cmp [string compare [lindex $reflist $i 0] \
+ [lindex $refs $j 0]]
+ if {$cmp == 0} {
+ set cmp [string compare [lindex $reflist $i 1] \
+ [lindex $refs $j 1]]
+ }
+ } else {
+ set cmp -1
+ }
+ } else {
+ set cmp 1
+ }
+ switch -- $cmp {
+ -1 {
+ $showrefstop.list delete "[expr {$j+1}].0" "[expr {$j+2}].0"
+ incr i
+ }
+ 0 {
+ incr i
+ incr j
+ }
+ 1 {
+ set l [expr {$j + 1}]
+ $showrefstop.list image create $l.0 -align baseline \
+ -image reficon-[lindex $refs $j 1] -padx 2
+ $showrefstop.list insert $l.1 "[lindex $refs $j 0]\n"
+ incr j
+ }
+ }
+ }
+ set reflist $refs
+ # delete last newline
+ $showrefstop.list delete end-2c end-1c
+ $showrefstop.list conf -state disabled
+}
+
+# Stuff for finding nearby tags
+proc getallcommits {} {
+ global allcommits nextarc seeds allccache allcwait cachedarcs allcupdate
+ global idheads idtags idotherrefs allparents tagobjid
+
+ if {![info exists allcommits]} {
+ set nextarc 0
+ set allcommits 0
+ set seeds {}
+ set allcwait 0
+ set cachedarcs 0
+ set allccache [file join [gitdir] "gitk.cache"]
+ if {![catch {
+ set f [open $allccache r]
+ set allcwait 1
+ getcache $f
+ }]} return
+ }
+
+ if {$allcwait} {
+ return
+ }
+ set cmd [list | git rev-list --parents]
+ set allcupdate [expr {$seeds ne {}}]
+ if {!$allcupdate} {
+ set ids "--all"
+ } else {
+ set refs [concat [array names idheads] [array names idtags] \
+ [array names idotherrefs]]
+ set ids {}
+ set tagobjs {}
+ foreach name [array names tagobjid] {
+ lappend tagobjs $tagobjid($name)
+ }
+ foreach id [lsort -unique $refs] {
+ if {![info exists allparents($id)] &&
+ [lsearch -exact $tagobjs $id] < 0} {
+ lappend ids $id
+ }
+ }
+ if {$ids ne {}} {
+ foreach id $seeds {
+ lappend ids "^$id"
+ }
+ }
+ }
+ if {$ids ne {}} {
+ set fd [open [concat $cmd $ids] r]
+ fconfigure $fd -blocking 0
+ incr allcommits
+ nowbusy allcommits
+ filerun $fd [list getallclines $fd]
+ } else {
+ dispneartags 0
+ }
+}
+
+# Since most commits have 1 parent and 1 child, we group strings of
+# such commits into "arcs" joining branch/merge points (BMPs), which
+# are commits that either don't have 1 parent or don't have 1 child.
+#
+# arcnos(id) - incoming arcs for BMP, arc we're on for other nodes
+# arcout(id) - outgoing arcs for BMP
+# arcids(a) - list of IDs on arc including end but not start
+# arcstart(a) - BMP ID at start of arc
+# arcend(a) - BMP ID at end of arc
+# growing(a) - arc a is still growing
+# arctags(a) - IDs out of arcids (excluding end) that have tags
+# archeads(a) - IDs out of arcids (excluding end) that have heads
+# The start of an arc is at the descendent end, so "incoming" means
+# coming from descendents, and "outgoing" means going towards ancestors.
+
+proc getallclines {fd} {
+ global allparents allchildren idtags idheads nextarc
+ global arcnos arcids arctags arcout arcend arcstart archeads growing
+ global seeds allcommits cachedarcs allcupdate
+
+ set nid 0
+ while {[incr nid] <= 1000 && [gets $fd line] >= 0} {
+ set id [lindex $line 0]
+ if {[info exists allparents($id)]} {
+ # seen it already
+ continue
+ }
+ set cachedarcs 0
+ set olds [lrange $line 1 end]
+ set allparents($id) $olds
+ if {![info exists allchildren($id)]} {
+ set allchildren($id) {}
+ set arcnos($id) {}
+ lappend seeds $id
+ } else {
+ set a $arcnos($id)
+ if {[llength $olds] == 1 && [llength $a] == 1} {
+ lappend arcids($a) $id
+ if {[info exists idtags($id)]} {
+ lappend arctags($a) $id
+ }
+ if {[info exists idheads($id)]} {
+ lappend archeads($a) $id
+ }
+ if {[info exists allparents($olds)]} {
+ # seen parent already
+ if {![info exists arcout($olds)]} {
+ splitarc $olds
+ }
+ lappend arcids($a) $olds
+ set arcend($a) $olds
+ unset growing($a)
+ }
+ lappend allchildren($olds) $id
+ lappend arcnos($olds) $a
+ continue
+ }
+ }
+ foreach a $arcnos($id) {
+ lappend arcids($a) $id
+ set arcend($a) $id
+ unset growing($a)
+ }
+
+ set ao {}
+ foreach p $olds {
+ lappend allchildren($p) $id
+ set a [incr nextarc]
+ set arcstart($a) $id
+ set archeads($a) {}
+ set arctags($a) {}
+ set archeads($a) {}
+ set arcids($a) {}
+ lappend ao $a
+ set growing($a) 1
+ if {[info exists allparents($p)]} {
+ # seen it already, may need to make a new branch
+ if {![info exists arcout($p)]} {
+ splitarc $p
+ }
+ lappend arcids($a) $p
+ set arcend($a) $p
+ unset growing($a)
+ }
+ lappend arcnos($p) $a
+ }
+ set arcout($id) $ao
+ }
+ if {$nid > 0} {
+ global cached_dheads cached_dtags cached_atags
+ catch {unset cached_dheads}
+ catch {unset cached_dtags}
+ catch {unset cached_atags}
+ }
+ if {![eof $fd]} {
+ return [expr {$nid >= 1000? 2: 1}]
+ }
+ set cacheok 1
+ if {[catch {
+ fconfigure $fd -blocking 1
+ close $fd
+ } err]} {
+ # got an error reading the list of commits
+ # if we were updating, try rereading the whole thing again
+ if {$allcupdate} {
+ incr allcommits -1
+ dropcache $err
+ return
+ }
+ error_popup "Error reading commit topology information;\
+ branch and preceding/following tag information\
+ will be incomplete.\n($err)"
+ set cacheok 0
+ }
+ if {[incr allcommits -1] == 0} {
+ notbusy allcommits
+ if {$cacheok} {
+ run savecache
+ }
+ }
+ dispneartags 0
+ return 0
+}
+
+proc recalcarc {a} {
+ global arctags archeads arcids idtags idheads
+
+ set at {}
+ set ah {}
+ foreach id [lrange $arcids($a) 0 end-1] {
+ if {[info exists idtags($id)]} {
+ lappend at $id
+ }
+ if {[info exists idheads($id)]} {
+ lappend ah $id
+ }
+ }
+ set arctags($a) $at
+ set archeads($a) $ah
+}
+
+proc splitarc {p} {
+ global arcnos arcids nextarc arctags archeads idtags idheads
+ global arcstart arcend arcout allparents growing
+
+ set a $arcnos($p)
+ if {[llength $a] != 1} {
+ puts "oops splitarc called but [llength $a] arcs already"
+ return
+ }
+ set a [lindex $a 0]
+ set i [lsearch -exact $arcids($a) $p]
+ if {$i < 0} {
+ puts "oops splitarc $p not in arc $a"
+ return
+ }
+ set na [incr nextarc]
+ if {[info exists arcend($a)]} {
+ set arcend($na) $arcend($a)
+ } else {
+ set l [lindex $allparents([lindex $arcids($a) end]) 0]
+ set j [lsearch -exact $arcnos($l) $a]
+ set arcnos($l) [lreplace $arcnos($l) $j $j $na]
+ }
+ set tail [lrange $arcids($a) [expr {$i+1}] end]
+ set arcids($a) [lrange $arcids($a) 0 $i]
+ set arcend($a) $p
+ set arcstart($na) $p
+ set arcout($p) $na
+ set arcids($na) $tail
+ if {[info exists growing($a)]} {
+ set growing($na) 1
+ unset growing($a)
+ }
+
+ foreach id $tail {
+ if {[llength $arcnos($id)] == 1} {
+ set arcnos($id) $na
+ } else {
+ set j [lsearch -exact $arcnos($id) $a]
+ set arcnos($id) [lreplace $arcnos($id) $j $j $na]
+ }
+ }
+
+ # reconstruct tags and heads lists
+ if {$arctags($a) ne {} || $archeads($a) ne {}} {
+ recalcarc $a
+ recalcarc $na
+ } else {
+ set arctags($na) {}
+ set archeads($na) {}
+ }
+}
+
+# Update things for a new commit added that is a child of one
+# existing commit. Used when cherry-picking.
+proc addnewchild {id p} {
+ global allparents allchildren idtags nextarc
+ global arcnos arcids arctags arcout arcend arcstart archeads growing
+ global seeds allcommits
+
+ if {![info exists allcommits] || ![info exists arcnos($p)]} return
+ set allparents($id) [list $p]
+ set allchildren($id) {}
+ set arcnos($id) {}
+ lappend seeds $id
+ lappend allchildren($p) $id
+ set a [incr nextarc]
+ set arcstart($a) $id
+ set archeads($a) {}
+ set arctags($a) {}
+ set arcids($a) [list $p]
+ set arcend($a) $p
+ if {![info exists arcout($p)]} {
+ splitarc $p
+ }
+ lappend arcnos($p) $a
+ set arcout($id) [list $a]
+}
+
+# This implements a cache for the topology information.
+# The cache saves, for each arc, the start and end of the arc,
+# the ids on the arc, and the outgoing arcs from the end.
+proc readcache {f} {
+ global arcnos arcids arcout arcstart arcend arctags archeads nextarc
+ global idtags idheads allparents cachedarcs possible_seeds seeds growing
+ global allcwait
+
+ set a $nextarc
+ set lim $cachedarcs
+ if {$lim - $a > 500} {
+ set lim [expr {$a + 500}]
+ }
+ if {[catch {
+ if {$a == $lim} {
+ # finish reading the cache and setting up arctags, etc.
+ set line [gets $f]
+ if {$line ne "1"} {error "bad final version"}
+ close $f
+ foreach id [array names idtags] {
+ if {[info exists arcnos($id)] && [llength $arcnos($id)] == 1 &&
+ [llength $allparents($id)] == 1} {
+ set a [lindex $arcnos($id) 0]
+ if {$arctags($a) eq {}} {
+ recalcarc $a
+ }
+ }
+ }
+ foreach id [array names idheads] {
+ if {[info exists arcnos($id)] && [llength $arcnos($id)] == 1 &&
+ [llength $allparents($id)] == 1} {
+ set a [lindex $arcnos($id) 0]
+ if {$archeads($a) eq {}} {
+ recalcarc $a
+ }
+ }
+ }
+ foreach id [lsort -unique $possible_seeds] {
+ if {$arcnos($id) eq {}} {
+ lappend seeds $id
+ }
+ }
+ set allcwait 0
+ } else {
+ while {[incr a] <= $lim} {
+ set line [gets $f]
+ if {[llength $line] != 3} {error "bad line"}
+ set s [lindex $line 0]
+ set arcstart($a) $s
+ lappend arcout($s) $a
+ if {![info exists arcnos($s)]} {
+ lappend possible_seeds $s
+ set arcnos($s) {}
+ }
+ set e [lindex $line 1]
+ if {$e eq {}} {
+ set growing($a) 1
+ } else {
+ set arcend($a) $e
+ if {![info exists arcout($e)]} {
+ set arcout($e) {}
+ }
+ }
+ set arcids($a) [lindex $line 2]
+ foreach id $arcids($a) {
+ lappend allparents($s) $id
+ set s $id
+ lappend arcnos($id) $a
+ }
+ if {![info exists allparents($s)]} {
+ set allparents($s) {}
+ }
+ set arctags($a) {}
+ set archeads($a) {}
+ }
+ set nextarc [expr {$a - 1}]
+ }
+ } err]} {
+ dropcache $err
+ return 0
+ }
+ if {!$allcwait} {
+ getallcommits
+ }
+ return $allcwait
+}
+
+proc getcache {f} {
+ global nextarc cachedarcs possible_seeds
+
+ if {[catch {
+ set line [gets $f]
+ if {[llength $line] != 2 || [lindex $line 0] ne "1"} {error "bad version"}
+ # make sure it's an integer
+ set cachedarcs [expr {int([lindex $line 1])}]
+ if {$cachedarcs < 0} {error "bad number of arcs"}
+ set nextarc 0
+ set possible_seeds {}
+ run readcache $f
+ } err]} {
+ dropcache $err
+ }
+ return 0
+}
+
+proc dropcache {err} {
+ global allcwait nextarc cachedarcs seeds
+
+ #puts "dropping cache ($err)"
+ foreach v {arcnos arcout arcids arcstart arcend growing \
+ arctags archeads allparents allchildren} {
+ global $v
+ catch {unset $v}
+ }
+ set allcwait 0
+ set nextarc 0
+ set cachedarcs 0
+ set seeds {}
+ getallcommits
+}
+
+proc writecache {f} {
+ global cachearc cachedarcs allccache
+ global arcstart arcend arcnos arcids arcout
+
+ set a $cachearc
+ set lim $cachedarcs
+ if {$lim - $a > 1000} {
+ set lim [expr {$a + 1000}]
+ }
+ if {[catch {
+ while {[incr a] <= $lim} {
+ if {[info exists arcend($a)]} {
+ puts $f [list $arcstart($a) $arcend($a) $arcids($a)]
+ } else {
+ puts $f [list $arcstart($a) {} $arcids($a)]
+ }
+ }
+ } err]} {
+ catch {close $f}
+ catch {file delete $allccache}
+ #puts "writing cache failed ($err)"
+ return 0
+ }
+ set cachearc [expr {$a - 1}]
+ if {$a > $cachedarcs} {
+ puts $f "1"
+ close $f
+ return 0
+ }
+ return 1
+}
+
+proc savecache {} {
+ global nextarc cachedarcs cachearc allccache
+
+ if {$nextarc == $cachedarcs} return
+ set cachearc 0
+ set cachedarcs $nextarc
+ catch {
+ set f [open $allccache w]
+ puts $f [list 1 $cachedarcs]
+ run writecache $f
+ }
+}
+
+# Returns 1 if a is an ancestor of b, -1 if b is an ancestor of a,
+# or 0 if neither is true.
+proc anc_or_desc {a b} {
+ global arcout arcstart arcend arcnos cached_isanc
+
+ if {$arcnos($a) eq $arcnos($b)} {
+ # Both are on the same arc(s); either both are the same BMP,
+ # or if one is not a BMP, the other is also not a BMP or is
+ # the BMP at end of the arc (and it only has 1 incoming arc).
+ # Or both can be BMPs with no incoming arcs.
+ if {$a eq $b || $arcnos($a) eq {}} {
+ return 0
+ }
+ # assert {[llength $arcnos($a)] == 1}
+ set arc [lindex $arcnos($a) 0]
+ set i [lsearch -exact $arcids($arc) $a]
+ set j [lsearch -exact $arcids($arc) $b]
+ if {$i < 0 || $i > $j} {
+ return 1
+ } else {
+ return -1
+ }
+ }
+
+ if {![info exists arcout($a)]} {
+ set arc [lindex $arcnos($a) 0]
+ if {[info exists arcend($arc)]} {
+ set aend $arcend($arc)
+ } else {
+ set aend {}
+ }
+ set a $arcstart($arc)
+ } else {
+ set aend $a
+ }
+ if {![info exists arcout($b)]} {
+ set arc [lindex $arcnos($b) 0]
+ if {[info exists arcend($arc)]} {
+ set bend $arcend($arc)
+ } else {
+ set bend {}
+ }
+ set b $arcstart($arc)
+ } else {
+ set bend $b
+ }
+ if {$a eq $bend} {
+ return 1
+ }
+ if {$b eq $aend} {
+ return -1
+ }
+ if {[info exists cached_isanc($a,$bend)]} {
+ if {$cached_isanc($a,$bend)} {
+ return 1
+ }
+ }
+ if {[info exists cached_isanc($b,$aend)]} {
+ if {$cached_isanc($b,$aend)} {
+ return -1
+ }
+ if {[info exists cached_isanc($a,$bend)]} {
+ return 0
+ }
+ }
+
+ set todo [list $a $b]
+ set anc($a) a
+ set anc($b) b
+ for {set i 0} {$i < [llength $todo]} {incr i} {
+ set x [lindex $todo $i]
+ if {$anc($x) eq {}} {
+ continue
+ }
+ foreach arc $arcnos($x) {
+ set xd $arcstart($arc)
+ if {$xd eq $bend} {
+ set cached_isanc($a,$bend) 1
+ set cached_isanc($b,$aend) 0
+ return 1
+ } elseif {$xd eq $aend} {
+ set cached_isanc($b,$aend) 1
+ set cached_isanc($a,$bend) 0
+ return -1
+ }
+ if {![info exists anc($xd)]} {
+ set anc($xd) $anc($x)
+ lappend todo $xd
+ } elseif {$anc($xd) ne $anc($x)} {
+ set anc($xd) {}
+ }
+ }
+ }
+ set cached_isanc($a,$bend) 0
+ set cached_isanc($b,$aend) 0
+ return 0
+}
+
+# This identifies whether $desc has an ancestor that is
+# a growing tip of the graph and which is not an ancestor of $anc
+# and returns 0 if so and 1 if not.
+# If we subsequently discover a tag on such a growing tip, and that
+# turns out to be a descendent of $anc (which it could, since we
+# don't necessarily see children before parents), then $desc
+# isn't a good choice to display as a descendent tag of
+# $anc (since it is the descendent of another tag which is
+# a descendent of $anc). Similarly, $anc isn't a good choice to
+# display as a ancestor tag of $desc.
+#
+proc is_certain {desc anc} {
+ global arcnos arcout arcstart arcend growing problems
+
+ set certain {}
+ if {[llength $arcnos($anc)] == 1} {
+ # tags on the same arc are certain
+ if {$arcnos($desc) eq $arcnos($anc)} {
+ return 1
+ }
+ if {![info exists arcout($anc)]} {
+ # if $anc is partway along an arc, use the start of the arc instead
+ set a [lindex $arcnos($anc) 0]
+ set anc $arcstart($a)
+ }
+ }
+ if {[llength $arcnos($desc)] > 1 || [info exists arcout($desc)]} {
+ set x $desc
+ } else {
+ set a [lindex $arcnos($desc) 0]
+ set x $arcend($a)
+ }
+ if {$x == $anc} {
+ return 1
+ }
+ set anclist [list $x]
+ set dl($x) 1
+ set nnh 1
+ set ngrowanc 0
+ for {set i 0} {$i < [llength $anclist] && ($nnh > 0 || $ngrowanc > 0)} {incr i} {
+ set x [lindex $anclist $i]
+ if {$dl($x)} {
+ incr nnh -1
+ }
+ set done($x) 1
+ foreach a $arcout($x) {
+ if {[info exists growing($a)]} {
+ if {![info exists growanc($x)] && $dl($x)} {
+ set growanc($x) 1
+ incr ngrowanc
+ }
+ } else {
+ set y $arcend($a)
+ if {[info exists dl($y)]} {
+ if {$dl($y)} {
+ if {!$dl($x)} {
+ set dl($y) 0
+ if {![info exists done($y)]} {
+ incr nnh -1
+ }
+ if {[info exists growanc($x)]} {
+ incr ngrowanc -1
+ }
+ set xl [list $y]
+ for {set k 0} {$k < [llength $xl]} {incr k} {
+ set z [lindex $xl $k]
+ foreach c $arcout($z) {
+ if {[info exists arcend($c)]} {
+ set v $arcend($c)
+ if {[info exists dl($v)] && $dl($v)} {
+ set dl($v) 0
+ if {![info exists done($v)]} {
+ incr nnh -1
+ }
+ if {[info exists growanc($v)]} {
+ incr ngrowanc -1
+ }
+ lappend xl $v
+ }
+ }
+ }
+ }
+ }
+ }
+ } elseif {$y eq $anc || !$dl($x)} {
+ set dl($y) 0
+ lappend anclist $y
+ } else {
+ set dl($y) 1
+ lappend anclist $y
+ incr nnh
+ }
+ }
+ }
+ }
+ foreach x [array names growanc] {
+ if {$dl($x)} {
+ return 0
+ }
+ return 0
+ }
+ return 1
+}
+
+proc validate_arctags {a} {
+ global arctags idtags
+
+ set i -1
+ set na $arctags($a)
+ foreach id $arctags($a) {
+ incr i
+ if {![info exists idtags($id)]} {
+ set na [lreplace $na $i $i]
+ incr i -1
+ }
+ }
+ set arctags($a) $na
+}
+
+proc validate_archeads {a} {
+ global archeads idheads
+
+ set i -1
+ set na $archeads($a)
+ foreach id $archeads($a) {
+ incr i
+ if {![info exists idheads($id)]} {
+ set na [lreplace $na $i $i]
+ incr i -1
+ }
+ }
+ set archeads($a) $na
+}
+
+# Return the list of IDs that have tags that are descendents of id,
+# ignoring IDs that are descendents of IDs already reported.
+proc desctags {id} {
+ global arcnos arcstart arcids arctags idtags allparents
+ global growing cached_dtags
+
+ if {![info exists allparents($id)]} {
+ return {}
+ }
+ set t1 [clock clicks -milliseconds]
+ set argid $id
+ if {[llength $arcnos($id)] == 1 && [llength $allparents($id)] == 1} {
+ # part-way along an arc; check that arc first
+ set a [lindex $arcnos($id) 0]
+ if {$arctags($a) ne {}} {
+ validate_arctags $a
+ set i [lsearch -exact $arcids($a) $id]
+ set tid {}
+ foreach t $arctags($a) {
+ set j [lsearch -exact $arcids($a) $t]
+ if {$j >= $i} break
+ set tid $t
+ }
+ if {$tid ne {}} {
+ return $tid
+ }
+ }
+ set id $arcstart($a)
+ if {[info exists idtags($id)]} {
+ return $id
+ }
+ }
+ if {[info exists cached_dtags($id)]} {
+ return $cached_dtags($id)
+ }
+
+ set origid $id
+ set todo [list $id]
+ set queued($id) 1
+ set nc 1
+ for {set i 0} {$i < [llength $todo] && $nc > 0} {incr i} {
+ set id [lindex $todo $i]
+ set done($id) 1
+ set ta [info exists hastaggedancestor($id)]
+ if {!$ta} {
+ incr nc -1
+ }
+ # ignore tags on starting node
+ if {!$ta && $i > 0} {
+ if {[info exists idtags($id)]} {
+ set tagloc($id) $id
+ set ta 1
+ } elseif {[info exists cached_dtags($id)]} {
+ set tagloc($id) $cached_dtags($id)
+ set ta 1
+ }
+ }
+ foreach a $arcnos($id) {
+ set d $arcstart($a)
+ if {!$ta && $arctags($a) ne {}} {
+ validate_arctags $a
+ if {$arctags($a) ne {}} {
+ lappend tagloc($id) [lindex $arctags($a) end]
+ }
+ }
+ if {$ta || $arctags($a) ne {}} {
+ set tomark [list $d]
+ for {set j 0} {$j < [llength $tomark]} {incr j} {
+ set dd [lindex $tomark $j]
+ if {![info exists hastaggedancestor($dd)]} {
+ if {[info exists done($dd)]} {
+ foreach b $arcnos($dd) {
+ lappend tomark $arcstart($b)
+ }
+ if {[info exists tagloc($dd)]} {
+ unset tagloc($dd)
+ }
+ } elseif {[info exists queued($dd)]} {
+ incr nc -1
+ }
+ set hastaggedancestor($dd) 1
+ }
+ }
+ }
+ if {![info exists queued($d)]} {
+ lappend todo $d
+ set queued($d) 1
+ if {![info exists hastaggedancestor($d)]} {
+ incr nc
+ }
+ }
+ }
+ }
+ set tags {}
+ foreach id [array names tagloc] {
+ if {![info exists hastaggedancestor($id)]} {
+ foreach t $tagloc($id) {
+ if {[lsearch -exact $tags $t] < 0} {
+ lappend tags $t
+ }
+ }
+ }
+ }
+ set t2 [clock clicks -milliseconds]
+ set loopix $i
+
+ # remove tags that are descendents of other tags
+ for {set i 0} {$i < [llength $tags]} {incr i} {
+ set a [lindex $tags $i]
+ for {set j 0} {$j < $i} {incr j} {
+ set b [lindex $tags $j]
+ set r [anc_or_desc $a $b]
+ if {$r == 1} {
+ set tags [lreplace $tags $j $j]
+ incr j -1
+ incr i -1
+ } elseif {$r == -1} {
+ set tags [lreplace $tags $i $i]
+ incr i -1
+ break
+ }
+ }
+ }
+
+ if {[array names growing] ne {}} {
+ # graph isn't finished, need to check if any tag could get
+ # eclipsed by another tag coming later. Simply ignore any
+ # tags that could later get eclipsed.
+ set ctags {}
+ foreach t $tags {
+ if {[is_certain $t $origid]} {
+ lappend ctags $t
+ }
+ }
+ if {$tags eq $ctags} {
+ set cached_dtags($origid) $tags
+ } else {
+ set tags $ctags
+ }
+ } else {
+ set cached_dtags($origid) $tags
+ }
+ set t3 [clock clicks -milliseconds]
+ if {0 && $t3 - $t1 >= 100} {
+ puts "iterating descendents ($loopix/[llength $todo] nodes) took\
+ [expr {$t2-$t1}]+[expr {$t3-$t2}]ms, $nc candidates left"
+ }
+ return $tags
+}
+
+proc anctags {id} {
+ global arcnos arcids arcout arcend arctags idtags allparents
+ global growing cached_atags
+
+ if {![info exists allparents($id)]} {
+ return {}
+ }
+ set t1 [clock clicks -milliseconds]
+ set argid $id
+ if {[llength $arcnos($id)] == 1 && [llength $allparents($id)] == 1} {
+ # part-way along an arc; check that arc first
+ set a [lindex $arcnos($id) 0]
+ if {$arctags($a) ne {}} {
+ validate_arctags $a
+ set i [lsearch -exact $arcids($a) $id]
+ foreach t $arctags($a) {
+ set j [lsearch -exact $arcids($a) $t]
+ if {$j > $i} {
+ return $t
+ }
+ }
+ }
+ if {![info exists arcend($a)]} {
+ return {}
+ }
+ set id $arcend($a)
+ if {[info exists idtags($id)]} {
+ return $id
+ }
+ }
+ if {[info exists cached_atags($id)]} {
+ return $cached_atags($id)
+ }
+
+ set origid $id
+ set todo [list $id]
+ set queued($id) 1
+ set taglist {}
+ set nc 1
+ for {set i 0} {$i < [llength $todo] && $nc > 0} {incr i} {
+ set id [lindex $todo $i]
+ set done($id) 1
+ set td [info exists hastaggeddescendent($id)]
+ if {!$td} {
+ incr nc -1
+ }
+ # ignore tags on starting node
+ if {!$td && $i > 0} {
+ if {[info exists idtags($id)]} {
+ set tagloc($id) $id
+ set td 1
+ } elseif {[info exists cached_atags($id)]} {
+ set tagloc($id) $cached_atags($id)
+ set td 1
+ }
+ }
+ foreach a $arcout($id) {
+ if {!$td && $arctags($a) ne {}} {
+ validate_arctags $a
+ if {$arctags($a) ne {}} {
+ lappend tagloc($id) [lindex $arctags($a) 0]
+ }
+ }
+ if {![info exists arcend($a)]} continue
+ set d $arcend($a)
+ if {$td || $arctags($a) ne {}} {
+ set tomark [list $d]
+ for {set j 0} {$j < [llength $tomark]} {incr j} {
+ set dd [lindex $tomark $j]
+ if {![info exists hastaggeddescendent($dd)]} {
+ if {[info exists done($dd)]} {
+ foreach b $arcout($dd) {
+ if {[info exists arcend($b)]} {
+ lappend tomark $arcend($b)
+ }
+ }
+ if {[info exists tagloc($dd)]} {
+ unset tagloc($dd)
+ }
+ } elseif {[info exists queued($dd)]} {
+ incr nc -1
+ }
+ set hastaggeddescendent($dd) 1
+ }
+ }
+ }
+ if {![info exists queued($d)]} {
+ lappend todo $d
+ set queued($d) 1
+ if {![info exists hastaggeddescendent($d)]} {
+ incr nc
+ }
+ }
+ }
+ }
+ set t2 [clock clicks -milliseconds]
+ set loopix $i
+ set tags {}
+ foreach id [array names tagloc] {
+ if {![info exists hastaggeddescendent($id)]} {
+ foreach t $tagloc($id) {
+ if {[lsearch -exact $tags $t] < 0} {
+ lappend tags $t
+ }
+ }
+ }
+ }
+
+ # remove tags that are ancestors of other tags
+ for {set i 0} {$i < [llength $tags]} {incr i} {
+ set a [lindex $tags $i]
+ for {set j 0} {$j < $i} {incr j} {
+ set b [lindex $tags $j]
+ set r [anc_or_desc $a $b]
+ if {$r == -1} {
+ set tags [lreplace $tags $j $j]
+ incr j -1
+ incr i -1
+ } elseif {$r == 1} {
+ set tags [lreplace $tags $i $i]
+ incr i -1
+ break
+ }
+ }
+ }
+
+ if {[array names growing] ne {}} {
+ # graph isn't finished, need to check if any tag could get
+ # eclipsed by another tag coming later. Simply ignore any
+ # tags that could later get eclipsed.
+ set ctags {}
+ foreach t $tags {
+ if {[is_certain $origid $t]} {
+ lappend ctags $t
+ }
+ }
+ if {$tags eq $ctags} {
+ set cached_atags($origid) $tags
+ } else {
+ set tags $ctags
+ }
+ } else {
+ set cached_atags($origid) $tags
+ }
+ set t3 [clock clicks -milliseconds]
+ if {0 && $t3 - $t1 >= 100} {
+ puts "iterating ancestors ($loopix/[llength $todo] nodes) took\
+ [expr {$t2-$t1}]+[expr {$t3-$t2}]ms, $nc candidates left"
+ }
+ return $tags
+}
+
+# Return the list of IDs that have heads that are descendents of id,
+# including id itself if it has a head.
+proc descheads {id} {
+ global arcnos arcstart arcids archeads idheads cached_dheads
+ global allparents
+
+ if {![info exists allparents($id)]} {
+ return {}
+ }
+ set aret {}
+ if {[llength $arcnos($id)] == 1 && [llength $allparents($id)] == 1} {
+ # part-way along an arc; check it first
+ set a [lindex $arcnos($id) 0]
+ if {$archeads($a) ne {}} {
+ validate_archeads $a
+ set i [lsearch -exact $arcids($a) $id]
+ foreach t $archeads($a) {
+ set j [lsearch -exact $arcids($a) $t]
+ if {$j > $i} break
+ lappend aret $t
+ }
+ }
+ set id $arcstart($a)
+ }
+ set origid $id
+ set todo [list $id]
+ set seen($id) 1
+ set ret {}
+ for {set i 0} {$i < [llength $todo]} {incr i} {
+ set id [lindex $todo $i]
+ if {[info exists cached_dheads($id)]} {
+ set ret [concat $ret $cached_dheads($id)]
+ } else {
+ if {[info exists idheads($id)]} {
+ lappend ret $id
+ }
+ foreach a $arcnos($id) {
+ if {$archeads($a) ne {}} {
+ validate_archeads $a
+ if {$archeads($a) ne {}} {
+ set ret [concat $ret $archeads($a)]
+ }
+ }
+ set d $arcstart($a)
+ if {![info exists seen($d)]} {
+ lappend todo $d
+ set seen($d) 1
+ }
+ }
+ }
+ }
+ set ret [lsort -unique $ret]
+ set cached_dheads($origid) $ret
+ return [concat $ret $aret]
+}
+
+proc addedtag {id} {
+ global arcnos arcout cached_dtags cached_atags
+
+ if {![info exists arcnos($id)]} return
+ if {![info exists arcout($id)]} {
+ recalcarc [lindex $arcnos($id) 0]
+ }
+ catch {unset cached_dtags}
+ catch {unset cached_atags}
+}
+
+proc addedhead {hid head} {
+ global arcnos arcout cached_dheads
+
+ if {![info exists arcnos($hid)]} return
+ if {![info exists arcout($hid)]} {
+ recalcarc [lindex $arcnos($hid) 0]
+ }
+ catch {unset cached_dheads}
+}
+
+proc removedhead {hid head} {
+ global cached_dheads
+
+ catch {unset cached_dheads}
+}
+
+proc movedhead {hid head} {
+ global arcnos arcout cached_dheads
+
+ if {![info exists arcnos($hid)]} return
+ if {![info exists arcout($hid)]} {
+ recalcarc [lindex $arcnos($hid) 0]
+ }
+ catch {unset cached_dheads}
+}
+
+proc changedrefs {} {
+ global cached_dheads cached_dtags cached_atags
+ global arctags archeads arcnos arcout idheads idtags
+
+ foreach id [concat [array names idheads] [array names idtags]] {
+ if {[info exists arcnos($id)] && ![info exists arcout($id)]} {
+ set a [lindex $arcnos($id) 0]
+ if {![info exists donearc($a)]} {
+ recalcarc $a
+ set donearc($a) 1
+ }
+ }
+ }
+ catch {unset cached_dtags}
+ catch {unset cached_atags}
+ catch {unset cached_dheads}
+}
+
+proc rereadrefs {} {
+ global idtags idheads idotherrefs mainhead
+
+ set refids [concat [array names idtags] \
+ [array names idheads] [array names idotherrefs]]
+ foreach id $refids {
+ if {![info exists ref($id)]} {
+ set ref($id) [listrefs $id]
+ }
+ }
+ set oldmainhead $mainhead
+ readrefs
+ changedrefs
+ set refids [lsort -unique [concat $refids [array names idtags] \
+ [array names idheads] [array names idotherrefs]]]
+ foreach id $refids {
+ set v [listrefs $id]
+ if {![info exists ref($id)] || $ref($id) != $v ||
+ ($id eq $oldmainhead && $id ne $mainhead) ||
+ ($id eq $mainhead && $id ne $oldmainhead)} {
+ redrawtags $id
+ }
+ }
+ run refill_reflist
+}
+
+proc listrefs {id} {
+ global idtags idheads idotherrefs
+
+ set x {}
+ if {[info exists idtags($id)]} {
+ set x $idtags($id)
+ }
+ set y {}
+ if {[info exists idheads($id)]} {
+ set y $idheads($id)
+ }
+ set z {}
+ if {[info exists idotherrefs($id)]} {
+ set z $idotherrefs($id)
+ }
+ return [list $x $y $z]
+}
+
+proc showtag {tag isnew} {
+ global ctext tagcontents tagids linknum tagobjid
+
+ if {$isnew} {
+ addtohistory [list showtag $tag 0]
+ }
+ $ctext conf -state normal
+ clear_ctext
+ settabs 0
+ set linknum 0
+ if {![info exists tagcontents($tag)]} {
+ catch {
+ set tagcontents($tag) [exec git cat-file tag $tagobjid($tag)]
+ }
+ }
+ if {[info exists tagcontents($tag)]} {
+ set text $tagcontents($tag)
+ } else {
+ set text "Tag: $tag\nId: $tagids($tag)"
+ }
+ appendwithlinks $text {}
+ $ctext conf -state disabled
+ init_flist {}
+}
+
+proc doquit {} {
+ global stopped
+ set stopped 100
+ savestuff .
+ destroy .
+}
+
+proc mkfontdisp {font top which} {
+ global fontattr fontpref $font
+
+ set fontpref($font) [set $font]
+ button $top.${font}but -text $which -font optionfont \
+ -command [list choosefont $font $which]
+ label $top.$font -relief flat -font $font \
+ -text $fontattr($font,family) -justify left
+ grid x $top.${font}but $top.$font -sticky w
+}
+
+proc choosefont {font which} {
+ global fontparam fontlist fonttop fontattr
+
+ set fontparam(which) $which
+ set fontparam(font) $font
+ set fontparam(family) [font actual $font -family]
+ set fontparam(size) $fontattr($font,size)
+ set fontparam(weight) $fontattr($font,weight)
+ set fontparam(slant) $fontattr($font,slant)
+ set top .gitkfont
+ set fonttop $top
+ if {![winfo exists $top]} {
+ font create sample
+ eval font config sample [font actual $font]
+ toplevel $top
+ wm title $top "Gitk font chooser"
+ label $top.l -textvariable fontparam(which) -font uifont
+ pack $top.l -side top
+ set fontlist [lsort [font families]]
+ frame $top.f
+ listbox $top.f.fam -listvariable fontlist \
+ -yscrollcommand [list $top.f.sb set]
+ bind $top.f.fam <<ListboxSelect>> selfontfam
+ scrollbar $top.f.sb -command [list $top.f.fam yview]
+ pack $top.f.sb -side right -fill y
+ pack $top.f.fam -side left -fill both -expand 1
+ pack $top.f -side top -fill both -expand 1
+ frame $top.g
+ spinbox $top.g.size -from 4 -to 40 -width 4 \
+ -textvariable fontparam(size) \
+ -validatecommand {string is integer -strict %s}
+ checkbutton $top.g.bold -padx 5 \
+ -font {{Times New Roman} 12 bold} -text "B" -indicatoron 0 \
+ -variable fontparam(weight) -onvalue bold -offvalue normal
+ checkbutton $top.g.ital -padx 5 \
+ -font {{Times New Roman} 12 italic} -text "I" -indicatoron 0 \
+ -variable fontparam(slant) -onvalue italic -offvalue roman
+ pack $top.g.size $top.g.bold $top.g.ital -side left
+ pack $top.g -side top
+ canvas $top.c -width 150 -height 50 -border 2 -relief sunk \
+ -background white
+ $top.c create text 100 25 -anchor center -text $which -font sample \
+ -fill black -tags text
+ bind $top.c <Configure> [list centertext $top.c]
+ pack $top.c -side top -fill x
+ frame $top.buts
+ button $top.buts.ok -text "OK" -command fontok -default active \
+ -font uifont
+ button $top.buts.can -text "Cancel" -command fontcan -default normal \
+ -font uifont
+ grid $top.buts.ok $top.buts.can
+ grid columnconfigure $top.buts 0 -weight 1 -uniform a
+ grid columnconfigure $top.buts 1 -weight 1 -uniform a
+ pack $top.buts -side bottom -fill x
+ trace add variable fontparam write chg_fontparam
+ } else {
+ raise $top
+ $top.c itemconf text -text $which
+ }
+ set i [lsearch -exact $fontlist $fontparam(family)]
+ if {$i >= 0} {
+ $top.f.fam selection set $i
+ $top.f.fam see $i
+ }
+}
+
+proc centertext {w} {
+ $w coords text [expr {[winfo width $w] / 2}] [expr {[winfo height $w] / 2}]
+}
+
+proc fontok {} {
+ global fontparam fontpref prefstop
+
+ set f $fontparam(font)
+ set fontpref($f) [list $fontparam(family) $fontparam(size)]
+ if {$fontparam(weight) eq "bold"} {
+ lappend fontpref($f) "bold"
+ }
+ if {$fontparam(slant) eq "italic"} {
+ lappend fontpref($f) "italic"
+ }
+ set w $prefstop.$f
+ $w conf -text $fontparam(family) -font $fontpref($f)
+
+ fontcan
+}
+
+proc fontcan {} {
+ global fonttop fontparam
+
+ if {[info exists fonttop]} {
+ catch {destroy $fonttop}
+ catch {font delete sample}
+ unset fonttop
+ unset fontparam
+ }
+}
+
+proc selfontfam {} {
+ global fonttop fontparam
+
+ set i [$fonttop.f.fam curselection]
+ if {$i ne {}} {
+ set fontparam(family) [$fonttop.f.fam get $i]
+ }
+}
+
+proc chg_fontparam {v sub op} {
+ global fontparam
+
+ font config sample -$sub $fontparam($sub)
+}
+
+proc doprefs {} {
+ global maxwidth maxgraphpct
+ global oldprefs prefstop showneartags showlocalchanges
+ global bgcolor fgcolor ctext diffcolors selectbgcolor
+ global uifont tabstop limitdiffs
+
+ set top .gitkprefs
+ set prefstop $top
+ if {[winfo exists $top]} {
+ raise $top
+ return
+ }
+ foreach v {maxwidth maxgraphpct showneartags showlocalchanges \
+ limitdiffs tabstop} {
+ set oldprefs($v) [set $v]
+ }
+ toplevel $top
+ wm title $top "Gitk preferences"
+ label $top.ldisp -text "Commit list display options"
+ $top.ldisp configure -font uifont
+ grid $top.ldisp - -sticky w -pady 10
+ label $top.spacer -text " "
+ label $top.maxwidthl -text "Maximum graph width (lines)" \
+ -font optionfont
+ spinbox $top.maxwidth -from 0 -to 100 -width 4 -textvariable maxwidth
+ grid $top.spacer $top.maxwidthl $top.maxwidth -sticky w
+ label $top.maxpctl -text "Maximum graph width (% of pane)" \
+ -font optionfont
+ spinbox $top.maxpct -from 1 -to 100 -width 4 -textvariable maxgraphpct
+ grid x $top.maxpctl $top.maxpct -sticky w
+ frame $top.showlocal
+ label $top.showlocal.l -text "Show local changes" -font optionfont
+ checkbutton $top.showlocal.b -variable showlocalchanges
+ pack $top.showlocal.b $top.showlocal.l -side left
+ grid x $top.showlocal -sticky w
+
+ label $top.ddisp -text "Diff display options"
+ $top.ddisp configure -font uifont
+ grid $top.ddisp - -sticky w -pady 10
+ label $top.tabstopl -text "Tab spacing" -font optionfont
+ spinbox $top.tabstop -from 1 -to 20 -width 4 -textvariable tabstop
+ grid x $top.tabstopl $top.tabstop -sticky w
+ frame $top.ntag
+ label $top.ntag.l -text "Display nearby tags" -font optionfont
+ checkbutton $top.ntag.b -variable showneartags
+ pack $top.ntag.b $top.ntag.l -side left
+ grid x $top.ntag -sticky w
+ frame $top.ldiff
+ label $top.ldiff.l -text "Limit diffs to listed paths" -font optionfont
+ checkbutton $top.ldiff.b -variable limitdiffs
+ pack $top.ldiff.b $top.ldiff.l -side left
+ grid x $top.ldiff -sticky w
+
+ label $top.cdisp -text "Colors: press to choose"
+ $top.cdisp configure -font uifont
+ grid $top.cdisp - -sticky w -pady 10
+ label $top.bg -padx 40 -relief sunk -background $bgcolor
+ button $top.bgbut -text "Background" -font optionfont \
+ -command [list choosecolor bgcolor 0 $top.bg background setbg]
+ grid x $top.bgbut $top.bg -sticky w
+ label $top.fg -padx 40 -relief sunk -background $fgcolor
+ button $top.fgbut -text "Foreground" -font optionfont \
+ -command [list choosecolor fgcolor 0 $top.fg foreground setfg]
+ grid x $top.fgbut $top.fg -sticky w
+ label $top.diffold -padx 40 -relief sunk -background [lindex $diffcolors 0]
+ button $top.diffoldbut -text "Diff: old lines" -font optionfont \
+ -command [list choosecolor diffcolors 0 $top.diffold "diff old lines" \
+ [list $ctext tag conf d0 -foreground]]
+ grid x $top.diffoldbut $top.diffold -sticky w
+ label $top.diffnew -padx 40 -relief sunk -background [lindex $diffcolors 1]
+ button $top.diffnewbut -text "Diff: new lines" -font optionfont \
+ -command [list choosecolor diffcolors 1 $top.diffnew "diff new lines" \
+ [list $ctext tag conf d1 -foreground]]
+ grid x $top.diffnewbut $top.diffnew -sticky w
+ label $top.hunksep -padx 40 -relief sunk -background [lindex $diffcolors 2]
+ button $top.hunksepbut -text "Diff: hunk header" -font optionfont \
+ -command [list choosecolor diffcolors 2 $top.hunksep \
+ "diff hunk header" \
+ [list $ctext tag conf hunksep -foreground]]
+ grid x $top.hunksepbut $top.hunksep -sticky w
+ label $top.selbgsep -padx 40 -relief sunk -background $selectbgcolor
+ button $top.selbgbut -text "Select bg" -font optionfont \
+ -command [list choosecolor selectbgcolor 0 $top.selbgsep background setselbg]
+ grid x $top.selbgbut $top.selbgsep -sticky w
+
+ label $top.cfont -text "Fonts: press to choose"
+ $top.cfont configure -font uifont
+ grid $top.cfont - -sticky w -pady 10
+ mkfontdisp mainfont $top "Main font"
+ mkfontdisp textfont $top "Diff display font"
+ mkfontdisp uifont $top "User interface font"
+
+ frame $top.buts
+ button $top.buts.ok -text "OK" -command prefsok -default active
+ $top.buts.ok configure -font uifont
+ button $top.buts.can -text "Cancel" -command prefscan -default normal
+ $top.buts.can configure -font uifont
+ grid $top.buts.ok $top.buts.can
+ grid columnconfigure $top.buts 0 -weight 1 -uniform a
+ grid columnconfigure $top.buts 1 -weight 1 -uniform a
+ grid $top.buts - - -pady 10 -sticky ew
+ bind $top <Visibility> "focus $top.buts.ok"
+}
+
+proc choosecolor {v vi w x cmd} {
+ global $v
+
+ set c [tk_chooseColor -initialcolor [lindex [set $v] $vi] \
+ -title "Gitk: choose color for $x"]
+ if {$c eq {}} return
+ $w conf -background $c
+ lset $v $vi $c
+ eval $cmd $c
+}
+
+proc setselbg {c} {
+ global bglist cflist
+ foreach w $bglist {
+ $w configure -selectbackground $c
+ }
+ $cflist tag configure highlight \
+ -background [$cflist cget -selectbackground]
+ allcanvs itemconf secsel -fill $c
+}
+
+proc setbg {c} {
+ global bglist
+
+ foreach w $bglist {
+ $w conf -background $c
+ }
+}
+
+proc setfg {c} {
+ global fglist canv
+
+ foreach w $fglist {
+ $w conf -foreground $c
+ }
+ allcanvs itemconf text -fill $c
+ $canv itemconf circle -outline $c
+}
+
+proc prefscan {} {
+ global oldprefs prefstop
+
+ foreach v {maxwidth maxgraphpct showneartags showlocalchanges \
+ limitdiffs tabstop} {
+ global $v
+ set $v $oldprefs($v)
+ }
+ catch {destroy $prefstop}
+ unset prefstop
+ fontcan
+}
+
+proc prefsok {} {
+ global maxwidth maxgraphpct
+ global oldprefs prefstop showneartags showlocalchanges
+ global fontpref mainfont textfont uifont
+ global limitdiffs treediffs
+
+ catch {destroy $prefstop}
+ unset prefstop
+ fontcan
+ set fontchanged 0
+ if {$mainfont ne $fontpref(mainfont)} {
+ set mainfont $fontpref(mainfont)
+ parsefont mainfont $mainfont
+ eval font configure mainfont [fontflags mainfont]
+ eval font configure mainfontbold [fontflags mainfont 1]
+ setcoords
+ set fontchanged 1
+ }
+ if {$textfont ne $fontpref(textfont)} {
+ set textfont $fontpref(textfont)
+ parsefont textfont $textfont
+ eval font configure textfont [fontflags textfont]
+ eval font configure textfontbold [fontflags textfont 1]
+ }
+ if {$uifont ne $fontpref(uifont)} {
+ set uifont $fontpref(uifont)
+ parsefont uifont $uifont
+ eval font configure uifont [fontflags uifont]
+ }
+ settabs
+ if {$showlocalchanges != $oldprefs(showlocalchanges)} {
+ if {$showlocalchanges} {
+ doshowlocalchanges
+ } else {
+ dohidelocalchanges
+ }
+ }
+ if {$limitdiffs != $oldprefs(limitdiffs)} {
+ # treediffs elements are limited by path
+ catch {unset treediffs}
+ }
+ if {$fontchanged || $maxwidth != $oldprefs(maxwidth)
+ || $maxgraphpct != $oldprefs(maxgraphpct)} {
+ redisplay
+ } elseif {$showneartags != $oldprefs(showneartags) ||
+ $limitdiffs != $oldprefs(limitdiffs)} {
+ reselectline
+ }
+}
+
+proc formatdate {d} {
+ global datetimeformat
+ if {$d ne {}} {
+ set d [clock format $d -format $datetimeformat]
+ }
+ return $d
+}
+
+# This list of encoding names and aliases is distilled from
+# http://www.iana.org/assignments/character-sets.
+# Not all of them are supported by Tcl.
+set encoding_aliases {
+ { ANSI_X3.4-1968 iso-ir-6 ANSI_X3.4-1986 ISO_646.irv:1991 ASCII
+ ISO646-US US-ASCII us IBM367 cp367 csASCII }
+ { ISO-10646-UTF-1 csISO10646UTF1 }
+ { ISO_646.basic:1983 ref csISO646basic1983 }
+ { INVARIANT csINVARIANT }
+ { ISO_646.irv:1983 iso-ir-2 irv csISO2IntlRefVersion }
+ { BS_4730 iso-ir-4 ISO646-GB gb uk csISO4UnitedKingdom }
+ { NATS-SEFI iso-ir-8-1 csNATSSEFI }
+ { NATS-SEFI-ADD iso-ir-8-2 csNATSSEFIADD }
+ { NATS-DANO iso-ir-9-1 csNATSDANO }
+ { NATS-DANO-ADD iso-ir-9-2 csNATSDANOADD }
+ { SEN_850200_B iso-ir-10 FI ISO646-FI ISO646-SE se csISO10Swedish }
+ { SEN_850200_C iso-ir-11 ISO646-SE2 se2 csISO11SwedishForNames }
+ { KS_C_5601-1987 iso-ir-149 KS_C_5601-1989 KSC_5601 korean csKSC56011987 }
+ { ISO-2022-KR csISO2022KR }
+ { EUC-KR csEUCKR }
+ { ISO-2022-JP csISO2022JP }
+ { ISO-2022-JP-2 csISO2022JP2 }
+ { JIS_C6220-1969-jp JIS_C6220-1969 iso-ir-13 katakana x0201-7
+ csISO13JISC6220jp }
+ { JIS_C6220-1969-ro iso-ir-14 jp ISO646-JP csISO14JISC6220ro }
+ { IT iso-ir-15 ISO646-IT csISO15Italian }
+ { PT iso-ir-16 ISO646-PT csISO16Portuguese }
+ { ES iso-ir-17 ISO646-ES csISO17Spanish }
+ { greek7-old iso-ir-18 csISO18Greek7Old }
+ { latin-greek iso-ir-19 csISO19LatinGreek }
+ { DIN_66003 iso-ir-21 de ISO646-DE csISO21German }
+ { NF_Z_62-010_(1973) iso-ir-25 ISO646-FR1 csISO25French }
+ { Latin-greek-1 iso-ir-27 csISO27LatinGreek1 }
+ { ISO_5427 iso-ir-37 csISO5427Cyrillic }
+ { JIS_C6226-1978 iso-ir-42 csISO42JISC62261978 }
+ { BS_viewdata iso-ir-47 csISO47BSViewdata }
+ { INIS iso-ir-49 csISO49INIS }
+ { INIS-8 iso-ir-50 csISO50INIS8 }
+ { INIS-cyrillic iso-ir-51 csISO51INISCyrillic }
+ { ISO_5427:1981 iso-ir-54 ISO5427Cyrillic1981 }
+ { ISO_5428:1980 iso-ir-55 csISO5428Greek }
+ { GB_1988-80 iso-ir-57 cn ISO646-CN csISO57GB1988 }
+ { GB_2312-80 iso-ir-58 chinese csISO58GB231280 }
+ { NS_4551-1 iso-ir-60 ISO646-NO no csISO60DanishNorwegian
+ csISO60Norwegian1 }
+ { NS_4551-2 ISO646-NO2 iso-ir-61 no2 csISO61Norwegian2 }
+ { NF_Z_62-010 iso-ir-69 ISO646-FR fr csISO69French }
+ { videotex-suppl iso-ir-70 csISO70VideotexSupp1 }
+ { PT2 iso-ir-84 ISO646-PT2 csISO84Portuguese2 }
+ { ES2 iso-ir-85 ISO646-ES2 csISO85Spanish2 }
+ { MSZ_7795.3 iso-ir-86 ISO646-HU hu csISO86Hungarian }
+ { JIS_C6226-1983 iso-ir-87 x0208 JIS_X0208-1983 csISO87JISX0208 }
+ { greek7 iso-ir-88 csISO88Greek7 }
+ { ASMO_449 ISO_9036 arabic7 iso-ir-89 csISO89ASMO449 }
+ { iso-ir-90 csISO90 }
+ { JIS_C6229-1984-a iso-ir-91 jp-ocr-a csISO91JISC62291984a }
+ { JIS_C6229-1984-b iso-ir-92 ISO646-JP-OCR-B jp-ocr-b
+ csISO92JISC62991984b }
+ { JIS_C6229-1984-b-add iso-ir-93 jp-ocr-b-add csISO93JIS62291984badd }
+ { JIS_C6229-1984-hand iso-ir-94 jp-ocr-hand csISO94JIS62291984hand }
+ { JIS_C6229-1984-hand-add iso-ir-95 jp-ocr-hand-add
+ csISO95JIS62291984handadd }
+ { JIS_C6229-1984-kana iso-ir-96 csISO96JISC62291984kana }
+ { ISO_2033-1983 iso-ir-98 e13b csISO2033 }
+ { ANSI_X3.110-1983 iso-ir-99 CSA_T500-1983 NAPLPS csISO99NAPLPS }
+ { ISO_8859-1:1987 iso-ir-100 ISO_8859-1 ISO-8859-1 latin1 l1 IBM819
+ CP819 csISOLatin1 }
+ { ISO_8859-2:1987 iso-ir-101 ISO_8859-2 ISO-8859-2 latin2 l2 csISOLatin2 }
+ { T.61-7bit iso-ir-102 csISO102T617bit }
+ { T.61-8bit T.61 iso-ir-103 csISO103T618bit }
+ { ISO_8859-3:1988 iso-ir-109 ISO_8859-3 ISO-8859-3 latin3 l3 csISOLatin3 }
+ { ISO_8859-4:1988 iso-ir-110 ISO_8859-4 ISO-8859-4 latin4 l4 csISOLatin4 }
+ { ECMA-cyrillic iso-ir-111 KOI8-E csISO111ECMACyrillic }
+ { CSA_Z243.4-1985-1 iso-ir-121 ISO646-CA csa7-1 ca csISO121Canadian1 }
+ { CSA_Z243.4-1985-2 iso-ir-122 ISO646-CA2 csa7-2 csISO122Canadian2 }
+ { CSA_Z243.4-1985-gr iso-ir-123 csISO123CSAZ24341985gr }
+ { ISO_8859-6:1987 iso-ir-127 ISO_8859-6 ISO-8859-6 ECMA-114 ASMO-708
+ arabic csISOLatinArabic }
+ { ISO_8859-6-E csISO88596E ISO-8859-6-E }
+ { ISO_8859-6-I csISO88596I ISO-8859-6-I }
+ { ISO_8859-7:1987 iso-ir-126 ISO_8859-7 ISO-8859-7 ELOT_928 ECMA-118
+ greek greek8 csISOLatinGreek }
+ { T.101-G2 iso-ir-128 csISO128T101G2 }
+ { ISO_8859-8:1988 iso-ir-138 ISO_8859-8 ISO-8859-8 hebrew
+ csISOLatinHebrew }
+ { ISO_8859-8-E csISO88598E ISO-8859-8-E }
+ { ISO_8859-8-I csISO88598I ISO-8859-8-I }
+ { CSN_369103 iso-ir-139 csISO139CSN369103 }
+ { JUS_I.B1.002 iso-ir-141 ISO646-YU js yu csISO141JUSIB1002 }
+ { ISO_6937-2-add iso-ir-142 csISOTextComm }
+ { IEC_P27-1 iso-ir-143 csISO143IECP271 }
+ { ISO_8859-5:1988 iso-ir-144 ISO_8859-5 ISO-8859-5 cyrillic
+ csISOLatinCyrillic }
+ { JUS_I.B1.003-serb iso-ir-146 serbian csISO146Serbian }
+ { JUS_I.B1.003-mac macedonian iso-ir-147 csISO147Macedonian }
+ { ISO_8859-9:1989 iso-ir-148 ISO_8859-9 ISO-8859-9 latin5 l5 csISOLatin5 }
+ { greek-ccitt iso-ir-150 csISO150 csISO150GreekCCITT }
+ { NC_NC00-10:81 cuba iso-ir-151 ISO646-CU csISO151Cuba }
+ { ISO_6937-2-25 iso-ir-152 csISO6937Add }
+ { GOST_19768-74 ST_SEV_358-88 iso-ir-153 csISO153GOST1976874 }
+ { ISO_8859-supp iso-ir-154 latin1-2-5 csISO8859Supp }
+ { ISO_10367-box iso-ir-155 csISO10367Box }
+ { ISO-8859-10 iso-ir-157 l6 ISO_8859-10:1992 csISOLatin6 latin6 }
+ { latin-lap lap iso-ir-158 csISO158Lap }
+ { JIS_X0212-1990 x0212 iso-ir-159 csISO159JISX02121990 }
+ { DS_2089 DS2089 ISO646-DK dk csISO646Danish }
+ { us-dk csUSDK }
+ { dk-us csDKUS }
+ { JIS_X0201 X0201 csHalfWidthKatakana }
+ { KSC5636 ISO646-KR csKSC5636 }
+ { ISO-10646-UCS-2 csUnicode }
+ { ISO-10646-UCS-4 csUCS4 }
+ { DEC-MCS dec csDECMCS }
+ { hp-roman8 roman8 r8 csHPRoman8 }
+ { macintosh mac csMacintosh }
+ { IBM037 cp037 ebcdic-cp-us ebcdic-cp-ca ebcdic-cp-wt ebcdic-cp-nl
+ csIBM037 }
+ { IBM038 EBCDIC-INT cp038 csIBM038 }
+ { IBM273 CP273 csIBM273 }
+ { IBM274 EBCDIC-BE CP274 csIBM274 }
+ { IBM275 EBCDIC-BR cp275 csIBM275 }
+ { IBM277 EBCDIC-CP-DK EBCDIC-CP-NO csIBM277 }
+ { IBM278 CP278 ebcdic-cp-fi ebcdic-cp-se csIBM278 }
+ { IBM280 CP280 ebcdic-cp-it csIBM280 }
+ { IBM281 EBCDIC-JP-E cp281 csIBM281 }
+ { IBM284 CP284 ebcdic-cp-es csIBM284 }
+ { IBM285 CP285 ebcdic-cp-gb csIBM285 }
+ { IBM290 cp290 EBCDIC-JP-kana csIBM290 }
+ { IBM297 cp297 ebcdic-cp-fr csIBM297 }
+ { IBM420 cp420 ebcdic-cp-ar1 csIBM420 }
+ { IBM423 cp423 ebcdic-cp-gr csIBM423 }
+ { IBM424 cp424 ebcdic-cp-he csIBM424 }
+ { IBM437 cp437 437 csPC8CodePage437 }
+ { IBM500 CP500 ebcdic-cp-be ebcdic-cp-ch csIBM500 }
+ { IBM775 cp775 csPC775Baltic }
+ { IBM850 cp850 850 csPC850Multilingual }
+ { IBM851 cp851 851 csIBM851 }
+ { IBM852 cp852 852 csPCp852 }
+ { IBM855 cp855 855 csIBM855 }
+ { IBM857 cp857 857 csIBM857 }
+ { IBM860 cp860 860 csIBM860 }
+ { IBM861 cp861 861 cp-is csIBM861 }
+ { IBM862 cp862 862 csPC862LatinHebrew }
+ { IBM863 cp863 863 csIBM863 }
+ { IBM864 cp864 csIBM864 }
+ { IBM865 cp865 865 csIBM865 }
+ { IBM866 cp866 866 csIBM866 }
+ { IBM868 CP868 cp-ar csIBM868 }
+ { IBM869 cp869 869 cp-gr csIBM869 }
+ { IBM870 CP870 ebcdic-cp-roece ebcdic-cp-yu csIBM870 }
+ { IBM871 CP871 ebcdic-cp-is csIBM871 }
+ { IBM880 cp880 EBCDIC-Cyrillic csIBM880 }
+ { IBM891 cp891 csIBM891 }
+ { IBM903 cp903 csIBM903 }
+ { IBM904 cp904 904 csIBBM904 }
+ { IBM905 CP905 ebcdic-cp-tr csIBM905 }
+ { IBM918 CP918 ebcdic-cp-ar2 csIBM918 }
+ { IBM1026 CP1026 csIBM1026 }
+ { EBCDIC-AT-DE csIBMEBCDICATDE }
+ { EBCDIC-AT-DE-A csEBCDICATDEA }
+ { EBCDIC-CA-FR csEBCDICCAFR }
+ { EBCDIC-DK-NO csEBCDICDKNO }
+ { EBCDIC-DK-NO-A csEBCDICDKNOA }
+ { EBCDIC-FI-SE csEBCDICFISE }
+ { EBCDIC-FI-SE-A csEBCDICFISEA }
+ { EBCDIC-FR csEBCDICFR }
+ { EBCDIC-IT csEBCDICIT }
+ { EBCDIC-PT csEBCDICPT }
+ { EBCDIC-ES csEBCDICES }
+ { EBCDIC-ES-A csEBCDICESA }
+ { EBCDIC-ES-S csEBCDICESS }
+ { EBCDIC-UK csEBCDICUK }
+ { EBCDIC-US csEBCDICUS }
+ { UNKNOWN-8BIT csUnknown8BiT }
+ { MNEMONIC csMnemonic }
+ { MNEM csMnem }
+ { VISCII csVISCII }
+ { VIQR csVIQR }
+ { KOI8-R csKOI8R }
+ { IBM00858 CCSID00858 CP00858 PC-Multilingual-850+euro }
+ { IBM00924 CCSID00924 CP00924 ebcdic-Latin9--euro }
+ { IBM01140 CCSID01140 CP01140 ebcdic-us-37+euro }
+ { IBM01141 CCSID01141 CP01141 ebcdic-de-273+euro }
+ { IBM01142 CCSID01142 CP01142 ebcdic-dk-277+euro ebcdic-no-277+euro }
+ { IBM01143 CCSID01143 CP01143 ebcdic-fi-278+euro ebcdic-se-278+euro }
+ { IBM01144 CCSID01144 CP01144 ebcdic-it-280+euro }
+ { IBM01145 CCSID01145 CP01145 ebcdic-es-284+euro }
+ { IBM01146 CCSID01146 CP01146 ebcdic-gb-285+euro }
+ { IBM01147 CCSID01147 CP01147 ebcdic-fr-297+euro }
+ { IBM01148 CCSID01148 CP01148 ebcdic-international-500+euro }
+ { IBM01149 CCSID01149 CP01149 ebcdic-is-871+euro }
+ { IBM1047 IBM-1047 }
+ { PTCP154 csPTCP154 PT154 CP154 Cyrillic-Asian }
+ { Amiga-1251 Ami1251 Amiga1251 Ami-1251 }
+ { UNICODE-1-1 csUnicode11 }
+ { CESU-8 csCESU-8 }
+ { BOCU-1 csBOCU-1 }
+ { UNICODE-1-1-UTF-7 csUnicode11UTF7 }
+ { ISO-8859-14 iso-ir-199 ISO_8859-14:1998 ISO_8859-14 latin8 iso-celtic
+ l8 }
+ { ISO-8859-15 ISO_8859-15 Latin-9 }
+ { ISO-8859-16 iso-ir-226 ISO_8859-16:2001 ISO_8859-16 latin10 l10 }
+ { GBK CP936 MS936 windows-936 }
+ { JIS_Encoding csJISEncoding }
+ { Shift_JIS MS_Kanji csShiftJIS }
+ { Extended_UNIX_Code_Packed_Format_for_Japanese csEUCPkdFmtJapanese
+ EUC-JP }
+ { Extended_UNIX_Code_Fixed_Width_for_Japanese csEUCFixWidJapanese }
+ { ISO-10646-UCS-Basic csUnicodeASCII }
+ { ISO-10646-Unicode-Latin1 csUnicodeLatin1 ISO-10646 }
+ { ISO-Unicode-IBM-1261 csUnicodeIBM1261 }
+ { ISO-Unicode-IBM-1268 csUnicodeIBM1268 }
+ { ISO-Unicode-IBM-1276 csUnicodeIBM1276 }
+ { ISO-Unicode-IBM-1264 csUnicodeIBM1264 }
+ { ISO-Unicode-IBM-1265 csUnicodeIBM1265 }
+ { ISO-8859-1-Windows-3.0-Latin-1 csWindows30Latin1 }
+ { ISO-8859-1-Windows-3.1-Latin-1 csWindows31Latin1 }
+ { ISO-8859-2-Windows-Latin-2 csWindows31Latin2 }
+ { ISO-8859-9-Windows-Latin-5 csWindows31Latin5 }
+ { Adobe-Standard-Encoding csAdobeStandardEncoding }
+ { Ventura-US csVenturaUS }
+ { Ventura-International csVenturaInternational }
+ { PC8-Danish-Norwegian csPC8DanishNorwegian }
+ { PC8-Turkish csPC8Turkish }
+ { IBM-Symbols csIBMSymbols }
+ { IBM-Thai csIBMThai }
+ { HP-Legal csHPLegal }
+ { HP-Pi-font csHPPiFont }
+ { HP-Math8 csHPMath8 }
+ { Adobe-Symbol-Encoding csHPPSMath }
+ { HP-DeskTop csHPDesktop }
+ { Ventura-Math csVenturaMath }
+ { Microsoft-Publishing csMicrosoftPublishing }
+ { Windows-31J csWindows31J }
+ { GB2312 csGB2312 }
+ { Big5 csBig5 }
+}
+
+proc tcl_encoding {enc} {
+ global encoding_aliases
+ set names [encoding names]
+ set lcnames [string tolower $names]
+ set enc [string tolower $enc]
+ set i [lsearch -exact $lcnames $enc]
+ if {$i < 0} {
+ # look for "isonnn" instead of "iso-nnn" or "iso_nnn"
+ if {[regsub {^iso[-_]} $enc iso encx]} {
+ set i [lsearch -exact $lcnames $encx]
+ }
+ }
+ if {$i < 0} {
+ foreach l $encoding_aliases {
+ set ll [string tolower $l]
+ if {[lsearch -exact $ll $enc] < 0} continue
+ # look through the aliases for one that tcl knows about
+ foreach e $ll {
+ set i [lsearch -exact $lcnames $e]
+ if {$i < 0} {
+ if {[regsub {^iso[-_]} $e iso ex]} {
+ set i [lsearch -exact $lcnames $ex]
+ }
+ }
+ if {$i >= 0} break
+ }
+ break
+ }
+ }
+ if {$i >= 0} {
+ return [lindex $names $i]
+ }
+ return {}
+}
+
+# First check that Tcl/Tk is recent enough
+if {[catch {package require Tk 8.4} err]} {
+ show_error {} . "Sorry, gitk cannot run with this version of Tcl/Tk.\n\
+ Gitk requires at least Tcl/Tk 8.4."
+ exit 1
+}
+
+# defaults...
+set datemode 0
+set wrcomcmd "git diff-tree --stdin -p --pretty"
+
+set gitencoding {}
+catch {
+ set gitencoding [exec git config --get i18n.commitencoding]
+}
+if {$gitencoding == ""} {
+ set gitencoding "utf-8"
+}
+set tclencoding [tcl_encoding $gitencoding]
+if {$tclencoding == {}} {
+ puts stderr "Warning: encoding $gitencoding is not supported by Tcl/Tk"
+}
+
+set mainfont {Helvetica 9}
+set textfont {Courier 9}
+set uifont {Helvetica 9 bold}
+set tabstop 8
+set findmergefiles 0
+set maxgraphpct 50
+set maxwidth 16
+set revlistorder 0
+set fastdate 0
+set uparrowlen 5
+set downarrowlen 5
+set mingaplen 100
+set cmitmode "patch"
+set wrapcomment "none"
+set showneartags 1
+set maxrefs 20
+set maxlinelen 200
+set showlocalchanges 1
+set limitdiffs 1
+set datetimeformat "%Y-%m-%d %H:%M:%S"
+
+set colors {green red blue magenta darkgrey brown orange}
+set bgcolor white
+set fgcolor black
+set diffcolors {red "#00a000" blue}
+set diffcontext 3
+set selectbgcolor gray85
+
+catch {source ~/.gitk}
+
+font create optionfont -family sans-serif -size -12
+
+parsefont mainfont $mainfont
+eval font create mainfont [fontflags mainfont]
+eval font create mainfontbold [fontflags mainfont 1]
+
+parsefont textfont $textfont
+eval font create textfont [fontflags textfont]
+eval font create textfontbold [fontflags textfont 1]
+
+parsefont uifont $uifont
+eval font create uifont [fontflags uifont]
+
+# check that we can find a .git directory somewhere...
+if {[catch {set gitdir [gitdir]}]} {
+ show_error {} . "Cannot find a git repository here."
+ exit 1
+}
+if {![file isdirectory $gitdir]} {
+ show_error {} . "Cannot find the git directory \"$gitdir\"."
+ exit 1
+}
+
+set mergeonly 0
+set revtreeargs {}
+set cmdline_files {}
+set i 0
+foreach arg $argv {
+ switch -- $arg {
+ "" { }
+ "-d" { set datemode 1 }
+ "--merge" {
+ set mergeonly 1
+ lappend revtreeargs $arg
+ }
+ "--" {
+ set cmdline_files [lrange $argv [expr {$i + 1}] end]
+ break
+ }
+ default {
+ lappend revtreeargs $arg
+ }
+ }
+ incr i
+}
+
+if {$i >= [llength $argv] && $revtreeargs ne {}} {
+ # no -- on command line, but some arguments (other than -d)
+ if {[catch {
+ set f [eval exec git rev-parse --no-revs --no-flags $revtreeargs]
+ set cmdline_files [split $f "\n"]
+ set n [llength $cmdline_files]
+ set revtreeargs [lrange $revtreeargs 0 end-$n]
+ # Unfortunately git rev-parse doesn't produce an error when
+ # something is both a revision and a filename. To be consistent
+ # with git log and git rev-list, check revtreeargs for filenames.
+ foreach arg $revtreeargs {
+ if {[file exists $arg]} {
+ show_error {} . "Ambiguous argument '$arg': both revision\
+ and filename"
+ exit 1
+ }
+ }
+ } err]} {
+ # unfortunately we get both stdout and stderr in $err,
+ # so look for "fatal:".
+ set i [string first "fatal:" $err]
+ if {$i > 0} {
+ set err [string range $err [expr {$i + 6}] end]
+ }
+ show_error {} . "Bad arguments to gitk:\n$err"
+ exit 1
+ }
+}
+
+if {$mergeonly} {
+ # find the list of unmerged files
+ set mlist {}
+ set nr_unmerged 0
+ if {[catch {
+ set fd [open "| git ls-files -u" r]
+ } err]} {
+ show_error {} . "Couldn't get list of unmerged files: $err"
+ exit 1
+ }
+ while {[gets $fd line] >= 0} {
+ set i [string first "\t" $line]
+ if {$i < 0} continue
+ set fname [string range $line [expr {$i+1}] end]
+ if {[lsearch -exact $mlist $fname] >= 0} continue
+ incr nr_unmerged
+ if {$cmdline_files eq {} || [path_filter $cmdline_files $fname]} {
+ lappend mlist $fname
+ }
+ }
+ catch {close $fd}
+ if {$mlist eq {}} {
+ if {$nr_unmerged == 0} {
+ show_error {} . "No files selected: --merge specified but\
+ no files are unmerged."
+ } else {
+ show_error {} . "No files selected: --merge specified but\
+ no unmerged files are within file limit."
+ }
+ exit 1
+ }
+ set cmdline_files $mlist
+}
+
+set nullid "0000000000000000000000000000000000000000"
+set nullid2 "0000000000000000000000000000000000000001"
+
+set have_tk85 [expr {[package vcompare $tk_version "8.5"] >= 0}]
+
+set runq {}
+set history {}
+set historyindex 0
+set fh_serial 0
+set nhl_names {}
+set highlight_paths {}
+set findpattern {}
+set searchdirn -forwards
+set boldrows {}
+set boldnamerows {}
+set diffelide {0 0}
+set markingmatches 0
+set linkentercount 0
+set need_redisplay 0
+set nrows_drawn 0
+set firsttabstop 0
+
+set nextviewnum 1
+set curview 0
+set selectedview 0
+set selectedhlview None
+set highlight_related None
+set highlight_files {}
+set viewfiles(0) {}
+set viewperm(0) 0
+set viewargs(0) {}
+
+set cmdlineok 0
+set stopped 0
+set stuffsaved 0
+set patchnum 0
+set localirow -1
+set localfrow -1
+set lserial 0
+setcoords
+makewindow
+# wait for the window to become visible
+tkwait visibility .
+wm title . "[file tail $argv0]: [file tail [pwd]]"
+readrefs
+
+if {$cmdline_files ne {} || $revtreeargs ne {}} {
+ # create a view for the files/dirs specified on the command line
+ set curview 1
+ set selectedview 1
+ set nextviewnum 2
+ set viewname(1) "Command line"
+ set viewfiles(1) $cmdline_files
+ set viewargs(1) $revtreeargs
+ set viewperm(1) 0
+ addviewmenu 1
+ .bar.view entryconf Edit* -state normal
+ .bar.view entryconf Delete* -state normal
+}
+
+if {[info exists permviews]} {
+ foreach v $permviews {
+ set n $nextviewnum
+ incr nextviewnum
+ set viewname($n) [lindex $v 0]
+ set viewfiles($n) [lindex $v 1]
+ set viewargs($n) [lindex $v 2]
+ set viewperm($n) 1
+ addviewmenu $n
+ }
+}
+getcommits
How to configure gitweb for your local system
---------------------------------------------
+See also "Build time configuration" section in INSTALL
+file for gitweb (in gitweb/INSTALL).
+
You can specify the following configuration variables when building GIT:
+ * GIT_BINDIR
+ Points out where to find git executable. You should set up it to
+ the place where git binary was installed (usually /usr/bin) if you
+ don't install git from sources together with gitweb. [Default: $(bindir)]
* GITWEB_SITENAME
- Shown in the title of all generated pages, defaults to the servers name.
+ Shown in the title of all generated pages, defaults to the server name
+ (SERVER_NAME CGI environment variable) if not set. [No default]
* GITWEB_PROJECTROOT
- The root directory for all projects shown by gitweb.
+ The root directory for all projects shown by gitweb. Must be set
+ correctly for gitweb to find repositories to display. See also
+ "Gitweb repositories" in INSTALL file for gitweb. [Default: /pub/git]
+ * GITWEB_PROJECT_MAXDEPTH
+ The filesystem traversing limit for getting projects list; the number
+ is taken as depth relative to the projectroot. It is used when
+ GITWEB_LIST is a directory (or is not set; then project root is used).
+ Is is meant to speed up project listing on large work trees by limiting
+ find depth. [Default: 2007]
* GITWEB_LIST
- points to a directory to scan for projects (defaults to project root)
- or to a file for explicit listing of projects.
+ Points to a directory to scan for projects (defaults to project root
+ if not set / if empty) or to a file with explicit listing of projects
+ (together with projects' ownership). See "Generating projects list
+ using gitweb" in INSTALL file for gitweb to find out how to generate
+ such file from scan of a directory. [No default, which means use root
+ directory for projects]
+ * GITWEB_EXPORT_OK
+ Show repository only if this file exists (in repository). Only
+ effective if this variable evaluates to true. [No default / Not set]
+ * GITWEB_STRICT_EXPORT
+ Only allow viewing of repositories also shown on the overview page.
+ This for example makes GITWEB_EXPORT_OK to decide if repository is
+ available and not only if it is shown. If GITWEB_LIST points to
+ file with list of project, only those repositories listed would be
+ available for gitweb. [No default]
* GITWEB_HOMETEXT
- points to an .html file which is included on the gitweb project
- overview page.
+ Points to an .html file which is included on the gitweb project
+ overview page ('projects_list' view), if it exists. Relative to
+ gitweb.cgi script. [Default: indextext.html]
+ * GITWEB_SITE_HEADER
+ Filename of html text to include at top of each page. Relative to
+ gitweb.cgi script. [No default]
+ * GITWEB_SITE_FOOTER
+ Filename of html text to include at bottom of each page. Relative to
+ gitweb.cgi script. [No default]
+ * GITWEB_HOME_LINK_STR
+ String of the home link on top of all pages, leading to $home_link
+ (usually main gitweb page, which means projects list). Used as first
+ part of gitweb view "breadcrumb trail": <home> / <project> / <view>.
+ [Default: projects]
+ * GITWEB_SITENAME
+ Name of your site or organization to appear in page titles. Set it
+ to something descriptive for clearer bookmarks etc. If not set
+ (if empty) gitweb uses "$SERVER_NAME Git", or "Untitled Git" if
+ SERVER_NAME CGI environment variable is not set (e.g. if running
+ gitweb as standalone script). [No default]
+ * GITWEB_BASE_URL
+ Git base URLs used for URL to where fetch project from, i.e. full
+ URL is "$git_base_url/$project". Shown on projects summary page.
+ Repository URL for project can be also configured per repository; this
+ takes precendence over URL composed from base URL and project name.
+ Note that you can setup multiple base URLs (for example one for
+ git:// protocol access, one for http:// access) from gitweb config
+ file. [No default]
* GITWEB_CSS
- Points to the location where you put gitweb.css on your web server.
+ Points to the location where you put gitweb.css on your web server
+ (or to be more generic URI of gitweb stylesheet). Relative to base
+ URI of gitweb. Note that you can setup multiple stylesheets from
+ gitweb config file. [Default: gitweb.css]
* GITWEB_LOGO
- Points to the location where you put git-logo.png on your web server.
+ Points to the location where you put git-logo.png on your web server
+ (or to be more generic URI of logo, 72x27 size, displayed in top right
+ corner of each gitweb page, and used as logo for Atom feed). Relative
+ to base URI of gitweb. [Default: git-logo.png]
+ * GITWEB_FAVICON
+ Points to the location where you put git-favicon.png on your web server
+ (or to be more generic URI of favicon, assumed to be image/png type;
+ web browsers that support favicons (website icons) may display them
+ in the browser's URL bar and next to site name in bookmarks). Relative
+ to base URI of gitweb. [Default: git-favicon.png]
* GITWEB_CONFIG
- This file will be loaded using 'require' and can be used to override any
- of the options above as well as some other options - see the top of
- 'gitweb.cgi' for their full list and description. If the environment
- $GITWEB_CONFIG is set when gitweb.cgi is executed the file in the
- environment variable will be loaded instead of the file
- specified when gitweb.cgi was created.
+ This Perl file will be loaded using 'do' and can be used to override any
+ of the options above as well as some other options -- see the "Runtime
+ gitweb configuration" section below, and top of 'gitweb.cgi' for their
+ full list and description. If the environment variable GITWEB_CONFIG
+ is set when gitweb.cgi is executed, then the file specified in the
+ environment variable will be loaded instead of the file specified
+ when gitweb.cgi was created. [Default: gitweb_config.perl]
Runtime gitweb configuration
You can adjust gitweb behaviour using the file specified in `GITWEB_CONFIG`
(defaults to 'gitweb_config.perl' in the same directory as the CGI).
-See the top of 'gitweb.cgi' for the list of variables and some description.
The most notable thing that is not configurable at compile time are the
-optional features, stored in the '%features' variable. You can find further
-description on how to reconfigure the default features setting in your
-`GITWEB_CONFIG` or per-project in `project.git/config` inside 'gitweb.cgi'.
+optional features, stored in the '%features' variable.
+
+Ultimate description on how to reconfigure the default features setting
+in your `GITWEB_CONFIG` or per-project in `project.git/config` can be found
+as comments inside 'gitweb.cgi'.
+
+See also "Gitweb config file" (with example of gitweb config file), and
+"Gitweb repositories" sections in INSTALL file for gitweb.
+
+
+Gitweb config file is [fragment] of perl code. You can set variables
+using "our $variable = value"; text from "#" character until the end
+of a line is ignored. See perlsyn(1) man page for details.
+
+Below there is list of vaiables which you might want to set in gitweb config.
+See the top of 'gitweb.cgi' for the full list of variables and their
+descriptions.
+
+Gitweb config file variables
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+You can set, among others, the following variables in gitweb config files:
+ * $GIT
+ Cure git executable to use. By default set to "$GIT_BINDIR/git", which
+ in turn is by default set to "$(bindir)/git". If you use git from binary
+ package, set this to "/usr/bin/git". This can just be "git" if your
+ webserver has a sensible PATH. If you have multiple git versions
+ installed it is / can be used to choose which one to use.
+ * $version
+ Gitweb version, set automatically when creating gitweb.cgi from
+ gitweb.perl. You might want to modify it if you are running modified
+ gitweb.
+ * $my_url, $my_uri
+ URL and absolute URL of gitweb script; you might need to set those
+ variables if you are using 'pathinfo' feature: see also below.
+ * $home_link
+ Target of the home link on top of all pages (the first part of view
+ "breadcrumbs"). By default set to absolute URI of a page; you might
+ need to set it up to [base] gitweb URI if you use 'pathinfo' feature
+ (alternative format of the URLs, with project name embedded directly
+ in the path part of URL).
+ * @stylesheets
+ List of URIs of stylesheets (relative to base URI of a page). You
+ might specify more than one stylesheet, for example use gitweb.css
+ as base, with site specific modifications in separate stylesheet
+ to make it easier to upgrade gitweb. You can add 'site' stylesheet
+ for example by using
+ push @stylesheets, "gitweb-site.css";
+ in gitweb config file.
+ * $logo_url, $logo_label
+ URI and label (title) of GIT logo link (or your site logo, if you choose
+ to use different logo image). By default they point to git homepage;
+ in the past they pointed to git documentation at www.kernel.org.
+ * $projects_list_description_width
+ The width (in characters) of the projects list "Description" column.
+ Longer descriptions will be cut (trying to cut at word boundary);
+ full description is available as 'title' attribute (usually shown on
+ mouseover). By default set to 25, which might be too small if you
+ use long project descriptions.
+ * @git_base_url_list
+ List of git base URLs used for URL to where fetch project from, shown
+ in project summary page. Full URL is "$git_base_url/$project".
+ You can setup multiple base URLs (for example one for git:// protocol
+ access, and one for http:// "dumb" protocol access). Note that per
+ repository configuration in 'cloneurl' file, or as values of gitweb.url
+ project config.
+ * $default_blob_plain_mimetype
+ Default mimetype for blob_plain (raw) view, if mimetype checking
+ doesn't result in some other type; by default 'text/plain'.
+ * $default_text_plain_charset
+ Default charset for text files. If not set, web serwer configuration
+ would be used.
+ * $mimetypes_file
+ File to use for (filename extension based) guessing of MIME types before
+ trying /etc/mime.types. Path, if relative, is taken currently as taken
+ relative to current git repositoy.
+ * $fallback_encoding
+ Gitweb assumes this charset if line contains non-UTF-8 characters.
+ Fallback decoding is used without error checking, so it can be even
+ 'utf-8'. Value mist be valid encodig; see Encoding::Supported(3pm) man
+ page for a list. By default 'latin1', aka. 'iso-8859-1'.
+ * @diff_opts
+ Rename detection options for git-diff and git-diff-tree. By default
+ ('-M'); set it to ('-C') or ('-C', '-C') to also detect copies, or
+ set it to () if you don't want to have renames detection.
+
+Per-repository gitweb configuration
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+You can also configure individual repositories shown in gitweb by creating
+file in the GIT_DIR of git repository, or by setting some repo configuration
+variable (in GIT_DIR/config).
+
+You can use the following files in repository:
+ * README.html
+ A .html file (HTML fragment) which is included on the gitweb project
+ summary page inside <div> block element. You can use it for longer
+ description of a project, to provide links for example to projects
+ homepage, etc.
+ * description (or gitweb.description)
+ Short (shortened by default to 25 characters in the projects list page)
+ single line description of a project (of a repository). Plain text file;
+ HTML will be escaped. By default set to
+ Unnamed repository; edit this file to name it for gitweb.
+ from the template during creating repository. You can use
+ gitweb.description repo configuration variable, but the file takes
+ precendence.
+ * cloneurl (or multiple-valued gitweb.url)
+ File with repository URL (used for clone and fetch), one per line.
+ Displayed in the project summary page. You can use multiple-valued
+ gitweb.url repository configuration variable for that, but the file
+ takes precendence.
+ * various gitweb.* config variables (in config)
+ Read description of %feature hash for detailed list, and some
+ descriptions.
Webserver configuration
# in utf-8 thanks to "binmode STDOUT, ':utf8'" at beginning
sub to_utf8 {
my $str = shift;
- my $res;
- eval { $res = decode_utf8($str, Encode::FB_CROAK); };
- if (defined $res) {
- return $res;
+ if (utf8::valid($str)) {
+ utf8::decode($str);
+ return $str;
} else {
return decode($fallback_encoding, $str, Encode::FB_DEFAULT);
}
"<td class=\"link\">" .
$cgi->a({-href => href(action=>"commit", hash=>$co{'id'})}, "commit") .
" | " .
+ $cgi->a({-href => href(action=>"commitdiff", hash=>$co{'id'})}, "commitdiff") .
+ " | " .
$cgi->a({-href => href(action=>"tree", hash=>$co{'tree'}, hash_base=>$co{'id'})}, "tree");
print "</td>\n" .
"</tr>\n";
#include "builtin.h"
#include "exec_cmd.h"
#include "common-cmds.h"
-#include <sys/ioctl.h>
/* most GUI terminals set COLUMNS (although some don't export it) */
static int term_columns(void)
mput_char(' ', longest - strlen(common_cmds[i].name));
puts(common_cmds[i].help);
}
- puts("(use 'git help -a' to get a list of all installed git commands)");
}
static void show_man_page(const char *git_cmd)
static struct curl_slist *default_headers;
static int push_verbosely;
-static int push_all;
+static int push_all = MATCH_REFS_NONE;
static int force_all;
static int dry_run;
packfile = fopen(request->tmpfile, "a");
if (!packfile) {
fprintf(stderr, "Unable to open local file %s for pack",
- filename);
+ request->tmpfile);
remote->can_update_info_refs = 0;
free(url);
return;
indexfile = fopen(tmpfile, "a");
if (!indexfile)
return error("Unable to open local file %s for pack index",
- filename);
+ tmpfile);
slot = get_active_slot();
slot->results = &results;
if (*arg == '-') {
if (!strcmp(arg, "--all")) {
- push_all = 1;
+ push_all = MATCH_REFS_ALL;
continue;
}
if (!strcmp(arg, "--force")) {
if (!remote_tail)
remote_tail = &remote_refs;
if (match_refs(local_refs, remote_refs, &remote_tail,
- nr_refspec, refspec, push_all))
+ nr_refspec, (const char **) refspec, push_all))
return -1;
if (!remote_refs) {
fprintf(stderr, "No refs in common and none specified; doing nothing.\n");
indexfile = fopen(tmpfile, "a");
if (!indexfile)
return error("Unable to open local file %s for pack index",
- filename);
+ tmpfile);
slot = get_active_slot();
slot->results = &results;
packfile = fopen(tmpfile, "a");
if (!packfile)
return error("Unable to open local file %s for pack",
- filename);
+ tmpfile);
slot = get_active_slot();
slot->results = &results;
long curl_low_speed_limit = -1;
long curl_low_speed_time = -1;
int curl_ftp_no_epsv = 0;
+char *curl_http_proxy = NULL;
struct curl_slist *pragma_header;
curl_ftp_no_epsv = git_config_bool(var, value);
return 0;
}
+ if (!strcmp("http.proxy", var)) {
+ if (curl_http_proxy == NULL) {
+ curl_http_proxy = xmalloc(strlen(value)+1);
+ strcpy(curl_http_proxy, value);
+ }
+ return 0;
+ }
/* Fall back on the default ones */
return git_default_config(var, value);
if (curl_ftp_no_epsv)
curl_easy_setopt(result, CURLOPT_FTP_USE_EPSV, 0);
+ if (curl_http_proxy)
+ curl_easy_setopt(result, CURLOPT_PROXY, curl_http_proxy);
+
return result;
}
static int crud(unsigned char c)
{
- static char crud_array[256];
- static int crud_array_initialized = 0;
-
- if (!crud_array_initialized) {
- int k;
-
- for (k = 0; k <= 31; ++k) crud_array[k] = 1;
- crud_array[' '] = 1;
- crud_array['.'] = 1;
- crud_array[','] = 1;
- crud_array[':'] = 1;
- crud_array[';'] = 1;
- crud_array['<'] = 1;
- crud_array['>'] = 1;
- crud_array['"'] = 1;
- crud_array['\''] = 1;
- crud_array_initialized = 1;
- }
- return crud_array[c];
+ return c <= 32 ||
+ c == '.' ||
+ c == ',' ||
+ c == ':' ||
+ c == ';' ||
+ c == '<' ||
+ c == '>' ||
+ c == '"' ||
+ c == '\'';
}
/*
while (lock_file_list) {
if (lock_file_list->owner == me &&
- lock_file_list->filename[0])
+ lock_file_list->filename[0]) {
+ close(lock_file_list->fd);
unlink(lock_file_list->filename);
+ }
lock_file_list = lock_file_list->next;
}
}
return p;
}
- if (link[0] == '/') {
+ if (is_absolute_path(link)) {
/* absolute path simply replaces p */
if (link_len < s)
strcpy(p, link);
static int lock_file(struct lock_file *lk, const char *path)
{
- int fd;
-
if (strlen(path) >= sizeof(lk->filename)) return -1;
strcpy(lk->filename, path);
/*
*/
resolve_symlink(lk->filename, sizeof(lk->filename)-5);
strcat(lk->filename, ".lock");
- fd = open(lk->filename, O_RDWR | O_CREAT | O_EXCL, 0666);
- if (0 <= fd) {
+ lk->fd = open(lk->filename, O_RDWR | O_CREAT | O_EXCL, 0666);
+ if (0 <= lk->fd) {
if (!lock_file_list) {
signal(SIGINT, remove_lock_file_on_signal);
atexit(remove_lock_file);
}
else
lk->filename[0] = 0;
- return fd;
+ return lk->fd;
}
int hold_lock_file_for_update(struct lock_file *lk, const char *path, int die_on_error)
{
char result_file[PATH_MAX];
int i;
+ close(lk->fd);
strcpy(result_file, lk->filename);
i = strlen(result_file) - 5; /* .lock */
result_file[i] = 0;
void rollback_lock_file(struct lock_file *lk)
{
- if (lk->filename[0])
+ if (lk->filename[0]) {
+ close(lk->fd);
unlink(lk->filename);
+ }
lk->filename[0] = 0;
}
#include "cache.h"
-#include <sys/select.h>
-
/*
* This is split up from the rest of git so that we might do
* something different on Windows, for example.
return error("unknown option `%s'", arg);
}
+static NORETURN void usage_with_options_internal(const char * const *,
+ const struct option *, int);
+
int parse_options(int argc, const char **argv, const struct option *options,
const char * const usagestr[], int flags)
{
break;
}
+ if (!strcmp(arg + 2, "help-all"))
+ usage_with_options_internal(usagestr, options, 1);
if (!strcmp(arg + 2, "help"))
usage_with_options(usagestr, options);
if (parse_long_opt(&args, arg + 2, options))
#define USAGE_OPTS_WIDTH 24
#define USAGE_GAP 2
-void usage_with_options(const char * const *usagestr,
- const struct option *opts)
+void usage_with_options_internal(const char * const *usagestr,
+ const struct option *opts, int full)
{
fprintf(stderr, "usage: %s\n", *usagestr++);
while (*usagestr && **usagestr)
fprintf(stderr, "%s\n", opts->help);
continue;
}
+ if (!full && (opts->flags & PARSE_OPT_HIDDEN))
+ continue;
pos = fprintf(stderr, " ");
if (opts->short_name)
exit(129);
}
+void usage_with_options(const char * const *usagestr,
+ const struct option *opts)
+{
+ usage_with_options_internal(usagestr, opts, 0);
+}
+
/*----- some often used options -----*/
#include "cache.h"
PARSE_OPT_OPTARG = 1,
PARSE_OPT_NOARG = 2,
PARSE_OPT_NONEG = 4,
+ PARSE_OPT_HIDDEN = 8,
};
struct option;
* PARSE_OPT_OPTARG: says that the argument is optionnal (not for BOOLEANs)
* PARSE_OPT_NOARG: says that this option takes no argument, for CALLBACKs
* PARSE_OPT_NONEG: says that this option cannot be negated
+ * PARSE_OPT_HIDDEN this option is skipped in the default usage, showed in
+ * the long one.
*
* `callback`::
* pointer to the callback to use for OPTION_CALLBACK.
+++ /dev/null
-#include "cache.h"
-#include "refs.h"
-#include "pkt-line.h"
-
-static const char peek_remote_usage[] =
-"git-peek-remote [--upload-pack=<git-upload-pack>] [<host>:]<directory>";
-static const char *uploadpack = "git-upload-pack";
-
-static int peek_remote(int fd[2], unsigned flags)
-{
- struct ref *ref;
-
- get_remote_heads(fd[0], &ref, 0, NULL, flags);
- packet_flush(fd[1]);
-
- while (ref) {
- printf("%s %s\n", sha1_to_hex(ref->old_sha1), ref->name);
- ref = ref->next;
- }
- return 0;
-}
-
-int main(int argc, char **argv)
-{
- int i, ret;
- char *dest = NULL;
- int fd[2];
- struct child_process *conn;
- int nongit = 0;
- unsigned flags = 0;
-
- setup_git_directory_gently(&nongit);
-
- for (i = 1; i < argc; i++) {
- char *arg = argv[i];
-
- if (*arg == '-') {
- if (!prefixcmp(arg, "--upload-pack=")) {
- uploadpack = arg + 14;
- continue;
- }
- if (!prefixcmp(arg, "--exec=")) {
- uploadpack = arg + 7;
- continue;
- }
- if (!strcmp("--tags", arg)) {
- flags |= REF_TAGS;
- continue;
- }
- if (!strcmp("--heads", arg)) {
- flags |= REF_HEADS;
- continue;
- }
- if (!strcmp("--refs", arg)) {
- flags |= REF_NORMAL;
- continue;
- }
- usage(peek_remote_usage);
- }
- dest = arg;
- break;
- }
-
- if (!dest || i != argc - 1)
- usage(peek_remote_usage);
-
- conn = git_connect(fd, dest, uploadpack, 0);
- ret = peek_remote(fd, flags);
- close(fd[0]);
- close(fd[1]);
- ret |= finish_connect(conn);
- return !!ret;
-}
};
}
+=item config_int ( VARIABLE )
+
+Retrieve the integer configuration C<VARIABLE>. The return value
+is simple decimal number. An optional value suffix of 'k', 'm',
+or 'g' in the config file will cause the value to be multiplied
+by 1024, 1048576 (1024^2), or 1073741824 (1024^3) prior to output.
+It would return C<undef> if configuration variable is not defined,
+
+Must be called on a repository instance.
+
+This currently wraps command('config') so it is not so fast.
+
+=cut
+
+sub config_int {
+ my ($self, $var) = @_;
+ $self->repo_path()
+ or throw Error::Simple("not a repository");
+
+ try {
+ return $self->command_oneline('config', '--int', '--get', $var);
+ } catch Git::Error::Command with {
+ my $E = shift;
+ if ($E->value() == 1) {
+ # Key not found.
+ return undef;
+ } else {
+ throw $E;
+ }
+ };
+}
=item ident ( TYPE | IDENTSTR )
fputc('\'', stream);
}
-void sq_quote_argv(struct strbuf *dst, const char** argv, int count,
- size_t maxlen)
+void sq_quote_argv(struct strbuf *dst, const char** argv, size_t maxlen)
{
int i;
- /* Count argv if needed. */
- if (count < 0) {
- for (count = 0; argv[count]; count++)
- ; /* just counting */
- }
-
/* Copy into destination buffer. */
- strbuf_grow(dst, 32 * count);
- for (i = 0; i < count; ++i) {
+ strbuf_grow(dst, 255);
+ for (i = 0; argv[i]; ++i) {
strbuf_addch(dst, ' ');
sq_quote_buf(dst, argv[i]);
if (maxlen && dst->len > maxlen)
extern void sq_quote_print(FILE *stream, const char *src);
extern void sq_quote_buf(struct strbuf *, const char *src);
-extern void sq_quote_argv(struct strbuf *, const char **argv, int count,
- size_t maxlen);
+extern void sq_quote_argv(struct strbuf *, const char **argv, size_t maxlen);
/* This unwraps what sq_quote() produces in place, but returns
* NULL if the input does not look like what sq_quote would have
}
if (is_null_sha1(new_sha1)) {
+ if (!parse_object(old_sha1)) {
+ warning ("Allowing deletion of corrupt ref.");
+ old_sha1 = NULL;
+ }
if (delete_ref(name, old_sha1)) {
error("failed to delete %s", name);
return "failed to delete";
}
- fprintf(stderr, "%s: %s -> deleted\n", name,
- sha1_to_hex(old_sha1));
return NULL; /* good */
}
else {
if (write_ref_sha1(lock, new_sha1, "push")) {
return "failed to write"; /* error() already called */
}
- fprintf(stderr, "%s: %s -> %s\n", name,
- sha1_to_hex(old_sha1), sha1_to_hex(new_sha1));
return NULL; /* good */
}
}
}
}
+const char *ref_rev_parse_rules[] = {
+ "%.*s",
+ "refs/%.*s",
+ "refs/tags/%.*s",
+ "refs/heads/%.*s",
+ "refs/remotes/%.*s",
+ "refs/remotes/%.*s/HEAD",
+ NULL
+};
+
+const char *ref_fetch_rules[] = {
+ "%.*s",
+ "refs/%.*s",
+ "refs/heads/%.*s",
+ NULL
+};
+
+int refname_match(const char *abbrev_name, const char *full_name, const char **rules)
+{
+ const char **p;
+ const int abbrev_name_len = strlen(abbrev_name);
+
+ for (p = rules; *p; p++) {
+ if (!strcmp(full_name, mkpath(*p, abbrev_name_len, abbrev_name))) {
+ return 1;
+ }
+ }
+
+ return 0;
+}
+
static struct ref_lock *verify_lock(struct ref_lock *lock,
const unsigned char *old_sha1, int mustexist)
{
}
return 0;
}
+
+struct ref *find_ref_by_name(struct ref *list, const char *name)
+{
+ for ( ; list; list = list->next)
+ if (!strcmp(list->name, name))
+ return list;
+ return NULL;
+}
} else if (!strcmp(subkey, ".tagopt")) {
if (!strcmp(value, "--no-tags"))
remote->fetch_tags = -1;
+ } else if (!strcmp(subkey, ".proxy")) {
+ remote->http_proxy = xstrdup(value);
}
return 0;
}
return 0;
}
-/*
- * Returns true if, under the matching rules for fetching, name is the
- * same as the given full name.
- */
-static int ref_matches_abbrev(const char *name, const char *full)
-{
- if (!prefixcmp(name, "refs/") || !strcmp(name, "HEAD"))
- return !strcmp(name, full);
- if (prefixcmp(full, "refs/"))
- return 0;
- if (!prefixcmp(name, "heads/") ||
- !prefixcmp(name, "tags/") ||
- !prefixcmp(name, "remotes/"))
- return !strcmp(name, full + 5);
- if (prefixcmp(full + 5, "heads/"))
- return 0;
- return !strcmp(full + 11, name);
-}
-
int remote_find_tracking(struct remote *remote, struct refspec *refspec)
{
int find_src = refspec->src == NULL;
return ret;
}
-static struct ref *copy_ref(struct ref *ref)
+static struct ref *copy_ref(const struct ref *ref)
{
struct ref *ret = xmalloc(sizeof(struct ref) + strlen(ref->name) + 1);
memcpy(ret, ref, sizeof(struct ref) + strlen(ref->name) + 1);
return ret;
}
+struct ref *copy_ref_list(const struct ref *ref)
+{
+ struct ref *ret = NULL;
+ struct ref **tail = &ret;
+ while (ref) {
+ *tail = copy_ref(ref);
+ ref = ref->next;
+ tail = &((*tail)->next);
+ }
+ return ret;
+}
+
void free_refs(struct ref *ref)
{
struct ref *next;
char *name = refs->name;
int namelen = strlen(name);
- if (namelen < patlen ||
- memcmp(name + namelen - patlen, pattern, patlen))
- continue;
- if (namelen != patlen && name[namelen - patlen - 1] != '/')
+ if (!refname_match(pattern, name, ref_rev_parse_rules))
continue;
/* A match is "weak" if it is with refs outside
return -errs;
}
-static struct ref *find_ref_by_name(struct ref *list, const char *name)
-{
- for ( ; list; list = list->next)
- if (!strcmp(list->name, name))
- return list;
- return NULL;
-}
-
static const struct refspec *check_pattern_match(const struct refspec *rs,
int rs_nr,
const struct ref *src)
* without thinking.
*/
int match_refs(struct ref *src, struct ref *dst, struct ref ***dst_tail,
- int nr_refspec, char **refspec, int all)
+ int nr_refspec, const char **refspec, int flags)
{
struct refspec *rs =
parse_ref_spec(nr_refspec, (const char **) refspec);
+ int send_all = flags & MATCH_REFS_ALL;
+ int send_mirror = flags & MATCH_REFS_MIRROR;
if (match_explicit_refs(src, dst, dst_tail, rs, nr_refspec))
return -1;
if (!pat)
continue;
}
- else if (prefixcmp(src->name, "refs/heads/"))
+ else if (!send_mirror && prefixcmp(src->name, "refs/heads/"))
/*
* "matching refs"; traditionally we pushed everything
* including refs outside refs/heads/ hierarchy, but
if (dst_peer && dst_peer->peer_ref)
/* We're already sending something to this ref. */
goto free_name;
- if (!dst_peer && !nr_refspec && !all)
- /* Remote doesn't have it, and we have no
+
+ if (!dst_peer && !nr_refspec && !(send_all || send_mirror))
+ /*
+ * Remote doesn't have it, and we have no
* explicit pattern, and we don't have
- * --all. */
+ * --all nor --mirror.
+ */
goto free_name;
if (!dst_peer) {
/* Create a new one and link it */
{
if (!branch || i < 0 || i >= branch->merge_nr)
return 0;
- return ref_matches_abbrev(branch->merge[i]->src, refname);
+ return refname_match(branch->merge[i]->src, refname, ref_fetch_rules);
}
-static struct ref *get_expanded_map(struct ref *remote_refs,
+static struct ref *get_expanded_map(const struct ref *remote_refs,
const struct refspec *refspec)
{
- struct ref *ref;
+ const struct ref *ref;
struct ref *ret = NULL;
struct ref **tail = &ret;
if (strchr(ref->name, '^'))
continue; /* a dereference item */
if (!prefixcmp(ref->name, refspec->src)) {
- char *match;
+ const char *match;
struct ref *cpy = copy_ref(ref);
match = ref->name + remote_prefix_len;
return ret;
}
-static struct ref *find_ref_by_name_abbrev(struct ref *refs, const char *name)
+static const struct ref *find_ref_by_name_abbrev(const struct ref *refs, const char *name)
{
- struct ref *ref;
+ const struct ref *ref;
for (ref = refs; ref; ref = ref->next) {
- if (ref_matches_abbrev(name, ref->name))
+ if (refname_match(name, ref->name, ref_fetch_rules))
return ref;
}
return NULL;
}
-struct ref *get_remote_ref(struct ref *remote_refs, const char *name)
+struct ref *get_remote_ref(const struct ref *remote_refs, const char *name)
{
- struct ref *ref = find_ref_by_name_abbrev(remote_refs, name);
+ const struct ref *ref = find_ref_by_name_abbrev(remote_refs, name);
if (!ref)
return NULL;
return ret;
}
-int get_fetch_map(struct ref *remote_refs,
+int get_fetch_map(const struct ref *remote_refs,
const struct refspec *refspec,
struct ref ***tail,
int missing_ok)
const char *receivepack;
const char *uploadpack;
+
+ /*
+ * for curl remotes only
+ */
+ char *http_proxy;
};
struct remote *remote_get(const char *name);
struct ref *alloc_ref(unsigned namelen);
+struct ref *copy_ref_list(const struct ref *ref);
+
+int check_ref_type(const struct ref *ref, int flags);
+
/*
* Frees the entire list and peers of elements.
*/
struct refspec *parse_ref_spec(int nr_refspec, const char **refspec);
int match_refs(struct ref *src, struct ref *dst, struct ref ***dst_tail,
- int nr_refspec, char **refspec, int all);
+ int nr_refspec, const char **refspec, int all);
/*
* Given a list of the remote refs and the specification of things to
* missing_ok is usually false, but when we are adding branch.$name.merge
* it is Ok if the branch is not at the remote anymore.
*/
-int get_fetch_map(struct ref *remote_refs, const struct refspec *refspec,
+int get_fetch_map(const struct ref *remote_refs, const struct refspec *refspec,
struct ref ***tail, int missing_ok);
-struct ref *get_remote_ref(struct ref *remote_refs, const char *name);
+struct ref *get_remote_ref(const struct ref *remote_refs, const char *name);
/*
* For the given remote, reads the refspec's src and sets the other fields.
int branch_has_merge_config(struct branch *branch);
int branch_merge_matches(struct branch *, int n, const char *);
+/* Flags to match_refs. */
+enum match_refs_flags {
+ MATCH_REFS_NONE = 0,
+ MATCH_REFS_ALL = (1 << 0),
+ MATCH_REFS_MIRROR = (1 << 1),
+};
+
#endif
+++ /dev/null
-#include "cache.h"
-#include "commit.h"
-#include "tag.h"
-#include "refs.h"
-#include "pkt-line.h"
-#include "run-command.h"
-#include "remote.h"
-
-static const char send_pack_usage[] =
-"git-send-pack [--all] [--dry-run] [--force] [--receive-pack=<git-receive-pack>] [--verbose] [--thin] [<host>:]<directory> [<ref>...]\n"
-" --all and explicit <ref> specification are mutually exclusive.";
-static const char *receivepack = "git-receive-pack";
-static int verbose;
-static int send_all;
-static int force_update;
-static int use_thin_pack;
-static int dry_run;
-
-/*
- * Make a pack stream and spit it out into file descriptor fd
- */
-static int pack_objects(int fd, struct ref *refs)
-{
- /*
- * The child becomes pack-objects --revs; we feed
- * the revision parameters to it via its stdin and
- * let its stdout go back to the other end.
- */
- const char *args[] = {
- "pack-objects",
- "--all-progress",
- "--revs",
- "--stdout",
- NULL,
- NULL,
- };
- struct child_process po;
-
- if (use_thin_pack)
- args[4] = "--thin";
- memset(&po, 0, sizeof(po));
- po.argv = args;
- po.in = -1;
- po.out = fd;
- po.git_cmd = 1;
- if (start_command(&po))
- die("git-pack-objects failed (%s)", strerror(errno));
-
- /*
- * We feed the pack-objects we just spawned with revision
- * parameters by writing to the pipe.
- */
- while (refs) {
- char buf[42];
-
- if (!is_null_sha1(refs->old_sha1) &&
- has_sha1_file(refs->old_sha1)) {
- memcpy(buf + 1, sha1_to_hex(refs->old_sha1), 40);
- buf[0] = '^';
- buf[41] = '\n';
- if (!write_or_whine(po.in, buf, 42,
- "send-pack: send refs"))
- break;
- }
- if (!is_null_sha1(refs->new_sha1)) {
- memcpy(buf, sha1_to_hex(refs->new_sha1), 40);
- buf[40] = '\n';
- if (!write_or_whine(po.in, buf, 41,
- "send-pack: send refs"))
- break;
- }
- refs = refs->next;
- }
-
- if (finish_command(&po))
- return error("pack-objects died with strange error");
- return 0;
-}
-
-static void unmark_and_free(struct commit_list *list, unsigned int mark)
-{
- while (list) {
- struct commit_list *temp = list;
- temp->item->object.flags &= ~mark;
- list = temp->next;
- free(temp);
- }
-}
-
-static int ref_newer(const unsigned char *new_sha1,
- const unsigned char *old_sha1)
-{
- struct object *o;
- struct commit *old, *new;
- struct commit_list *list, *used;
- int found = 0;
-
- /* Both new and old must be commit-ish and new is descendant of
- * old. Otherwise we require --force.
- */
- o = deref_tag(parse_object(old_sha1), NULL, 0);
- if (!o || o->type != OBJ_COMMIT)
- return 0;
- old = (struct commit *) o;
-
- o = deref_tag(parse_object(new_sha1), NULL, 0);
- if (!o || o->type != OBJ_COMMIT)
- return 0;
- new = (struct commit *) o;
-
- if (parse_commit(new) < 0)
- return 0;
-
- used = list = NULL;
- commit_list_insert(new, &list);
- while (list) {
- new = pop_most_recent_commit(&list, 1);
- commit_list_insert(new, &used);
- if (new == old) {
- found = 1;
- break;
- }
- }
- unmark_and_free(list, 1);
- unmark_and_free(used, 1);
- return found;
-}
-
-static struct ref *local_refs, **local_tail;
-static struct ref *remote_refs, **remote_tail;
-
-static int one_local_ref(const char *refname, const unsigned char *sha1, int flag, void *cb_data)
-{
- struct ref *ref;
- int len = strlen(refname) + 1;
- ref = xcalloc(1, sizeof(*ref) + len);
- hashcpy(ref->new_sha1, sha1);
- memcpy(ref->name, refname, len);
- *local_tail = ref;
- local_tail = &ref->next;
- return 0;
-}
-
-static void get_local_heads(void)
-{
- local_tail = &local_refs;
- for_each_ref(one_local_ref, NULL);
-}
-
-static int receive_status(int in)
-{
- char line[1000];
- int ret = 0;
- int len = packet_read_line(in, line, sizeof(line));
- if (len < 10 || memcmp(line, "unpack ", 7)) {
- fprintf(stderr, "did not receive status back\n");
- return -1;
- }
- if (memcmp(line, "unpack ok\n", 10)) {
- fputs(line, stderr);
- ret = -1;
- }
- while (1) {
- len = packet_read_line(in, line, sizeof(line));
- if (!len)
- break;
- if (len < 3 ||
- (memcmp(line, "ok", 2) && memcmp(line, "ng", 2))) {
- fprintf(stderr, "protocol error: %s\n", line);
- ret = -1;
- break;
- }
- if (!memcmp(line, "ok", 2))
- continue;
- fputs(line, stderr);
- ret = -1;
- }
- return ret;
-}
-
-static void update_tracking_ref(struct remote *remote, struct ref *ref)
-{
- struct refspec rs;
- int will_delete_ref;
-
- rs.src = ref->name;
- rs.dst = NULL;
-
- if (!ref->peer_ref)
- return;
-
- will_delete_ref = is_null_sha1(ref->peer_ref->new_sha1);
-
- if (!will_delete_ref &&
- !hashcmp(ref->old_sha1, ref->peer_ref->new_sha1))
- return;
-
- if (!remote_find_tracking(remote, &rs)) {
- fprintf(stderr, "updating local tracking ref '%s'\n", rs.dst);
- if (is_null_sha1(ref->peer_ref->new_sha1)) {
- if (delete_ref(rs.dst, NULL))
- error("Failed to delete");
- } else
- update_ref("update by push", rs.dst,
- ref->new_sha1, NULL, 0, 0);
- free(rs.dst);
- }
-}
-
-static int send_pack(int in, int out, struct remote *remote, int nr_refspec, char **refspec)
-{
- struct ref *ref;
- int new_refs;
- int ret = 0;
- int ask_for_status_report = 0;
- int allow_deleting_refs = 0;
- int expect_status_report = 0;
-
- /* No funny business with the matcher */
- remote_tail = get_remote_heads(in, &remote_refs, 0, NULL, REF_NORMAL);
- get_local_heads();
-
- /* Does the other end support the reporting? */
- if (server_supports("report-status"))
- ask_for_status_report = 1;
- if (server_supports("delete-refs"))
- allow_deleting_refs = 1;
-
- /* match them up */
- if (!remote_tail)
- remote_tail = &remote_refs;
- if (match_refs(local_refs, remote_refs, &remote_tail,
- nr_refspec, refspec, send_all))
- return -1;
-
- if (!remote_refs) {
- fprintf(stderr, "No refs in common and none specified; doing nothing.\n"
- "Perhaps you should specify a branch such as 'master'.\n");
- return 0;
- }
-
- /*
- * Finally, tell the other end!
- */
- new_refs = 0;
- for (ref = remote_refs; ref; ref = ref->next) {
- char old_hex[60], *new_hex;
- int will_delete_ref;
-
- if (!ref->peer_ref)
- continue;
-
-
- will_delete_ref = is_null_sha1(ref->peer_ref->new_sha1);
- if (will_delete_ref && !allow_deleting_refs) {
- error("remote does not support deleting refs");
- ret = -2;
- continue;
- }
- if (!will_delete_ref &&
- !hashcmp(ref->old_sha1, ref->peer_ref->new_sha1)) {
- if (verbose)
- fprintf(stderr, "'%s': up-to-date\n", ref->name);
- continue;
- }
-
- /* This part determines what can overwrite what.
- * The rules are:
- *
- * (0) you can always use --force or +A:B notation to
- * selectively force individual ref pairs.
- *
- * (1) if the old thing does not exist, it is OK.
- *
- * (2) if you do not have the old thing, you are not allowed
- * to overwrite it; you would not know what you are losing
- * otherwise.
- *
- * (3) if both new and old are commit-ish, and new is a
- * descendant of old, it is OK.
- *
- * (4) regardless of all of the above, removing :B is
- * always allowed.
- */
-
- if (!force_update &&
- !will_delete_ref &&
- !is_null_sha1(ref->old_sha1) &&
- !ref->force) {
- if (!has_sha1_file(ref->old_sha1) ||
- !ref_newer(ref->peer_ref->new_sha1,
- ref->old_sha1)) {
- /* We do not have the remote ref, or
- * we know that the remote ref is not
- * an ancestor of what we are trying to
- * push. Either way this can be losing
- * commits at the remote end and likely
- * we were not up to date to begin with.
- */
- error("remote '%s' is not an ancestor of\n"
- " local '%s'.\n"
- " Maybe you are not up-to-date and "
- "need to pull first?",
- ref->name,
- ref->peer_ref->name);
- ret = -2;
- continue;
- }
- }
- hashcpy(ref->new_sha1, ref->peer_ref->new_sha1);
- if (!will_delete_ref)
- new_refs++;
- strcpy(old_hex, sha1_to_hex(ref->old_sha1));
- new_hex = sha1_to_hex(ref->new_sha1);
-
- if (!dry_run) {
- if (ask_for_status_report) {
- packet_write(out, "%s %s %s%c%s",
- old_hex, new_hex, ref->name, 0,
- "report-status");
- ask_for_status_report = 0;
- expect_status_report = 1;
- }
- else
- packet_write(out, "%s %s %s",
- old_hex, new_hex, ref->name);
- }
- if (will_delete_ref)
- fprintf(stderr, "deleting '%s'\n", ref->name);
- else {
- fprintf(stderr, "updating '%s'", ref->name);
- if (strcmp(ref->name, ref->peer_ref->name))
- fprintf(stderr, " using '%s'",
- ref->peer_ref->name);
- fprintf(stderr, "\n from %s\n to %s\n",
- old_hex, new_hex);
- }
- }
-
- packet_flush(out);
- if (new_refs && !dry_run)
- ret = pack_objects(out, remote_refs);
- close(out);
-
- if (expect_status_report) {
- if (receive_status(in))
- ret = -4;
- }
-
- if (!dry_run && remote && ret == 0) {
- for (ref = remote_refs; ref; ref = ref->next)
- update_tracking_ref(remote, ref);
- }
-
- if (!new_refs && ret == 0)
- fprintf(stderr, "Everything up-to-date\n");
- return ret;
-}
-
-static void verify_remote_names(int nr_heads, char **heads)
-{
- int i;
-
- for (i = 0; i < nr_heads; i++) {
- const char *remote = strchr(heads[i], ':');
-
- remote = remote ? (remote + 1) : heads[i];
- switch (check_ref_format(remote)) {
- case 0: /* ok */
- case -2: /* ok but a single level -- that is fine for
- * a match pattern.
- */
- case -3: /* ok but ends with a pattern-match character */
- continue;
- }
- die("remote part of refspec is not a valid name in %s",
- heads[i]);
- }
-}
-
-int main(int argc, char **argv)
-{
- int i, nr_heads = 0;
- char *dest = NULL;
- char **heads = NULL;
- int fd[2], ret;
- struct child_process *conn;
- char *remote_name = NULL;
- struct remote *remote = NULL;
-
- setup_git_directory();
- git_config(git_default_config);
-
- argv++;
- for (i = 1; i < argc; i++, argv++) {
- char *arg = *argv;
-
- if (*arg == '-') {
- if (!prefixcmp(arg, "--receive-pack=")) {
- receivepack = arg + 15;
- continue;
- }
- if (!prefixcmp(arg, "--exec=")) {
- receivepack = arg + 7;
- continue;
- }
- if (!prefixcmp(arg, "--remote=")) {
- remote_name = arg + 9;
- continue;
- }
- if (!strcmp(arg, "--all")) {
- send_all = 1;
- continue;
- }
- if (!strcmp(arg, "--dry-run")) {
- dry_run = 1;
- continue;
- }
- if (!strcmp(arg, "--force")) {
- force_update = 1;
- continue;
- }
- if (!strcmp(arg, "--verbose")) {
- verbose = 1;
- continue;
- }
- if (!strcmp(arg, "--thin")) {
- use_thin_pack = 1;
- continue;
- }
- usage(send_pack_usage);
- }
- if (!dest) {
- dest = arg;
- continue;
- }
- heads = argv;
- nr_heads = argc - i;
- break;
- }
- if (!dest)
- usage(send_pack_usage);
- if (heads && send_all)
- usage(send_pack_usage);
- verify_remote_names(nr_heads, heads);
-
- if (remote_name) {
- remote = remote_get(remote_name);
- if (!remote_has_url(remote, dest)) {
- die("Destination %s is not a uri for %s",
- dest, remote_name);
- }
- }
-
- conn = git_connect(fd, dest, receivepack, verbose ? CONNECT_VERBOSE : 0);
- ret = send_pack(fd[0], fd[1], remote, nr_heads, heads);
- close(fd[0]);
- close(fd[1]);
- ret |= finish_connect(conn);
- return !!ret;
-}
--- /dev/null
+#ifndef SEND_PACK_H
+#define SEND_PACK_H
+
+struct send_pack_args {
+ const char *receivepack;
+ unsigned verbose:1,
+ send_all:1,
+ send_mirror:1,
+ force_update:1,
+ use_thin_pack:1,
+ dry_run:1;
+};
+
+int send_pack(struct send_pack_args *args,
+ const char *dest, struct remote *remote,
+ int nr_heads, const char **heads);
+
+#endif
safe_create_leading_directories(path0);
info_ref_fp = fopen(path1, "w");
if (!info_ref_fp)
- return error("unable to update %s", path0);
+ return error("unable to update %s", path1);
for_each_ref(add_info_ref, NULL);
fclose(info_ref_fp);
adjust_shared_perm(path1);
const char *prefix_filename(const char *pfx, int pfx_len, const char *arg)
{
static char path[PATH_MAX];
- if (!pfx || !*pfx || arg[0] == '/')
+ if (!pfx || !*pfx || is_absolute_path(arg))
return arg;
memcpy(path, pfx, pfx_len);
strcpy(path + pfx_len, arg);
#ifdef NO_C99_FORMAT
#define SZ_FMT "lu"
+static unsigned long sz_fmt(size_t s) { return (unsigned long)s; }
#else
#define SZ_FMT "zu"
+static size_t sz_fmt(size_t s) { return s; }
#endif
const unsigned char null_sha1[20];
char *pos = path;
struct stat st;
- if (*pos == '/')
+ if (is_absolute_path(path))
pos++;
while (pos) {
int entlen = pfxlen + 43;
int base_len = -1;
- if (*entry != '/' && relative_base) {
+ if (!is_absolute_path(entry) && relative_base) {
/* Relative alt-odb */
if (base_len < 0)
base_len = strlen(relative_base) + 1;
}
ent = xmalloc(sizeof(*ent) + entlen);
- if (*entry != '/' && relative_base) {
+ if (!is_absolute_path(entry) && relative_base) {
memcpy(ent->base, relative_base, base_len - 1);
ent->base[base_len - 1] = '/';
memcpy(ent->base + base_len, entry, len);
while (cp < ep && *cp != sep)
cp++;
if (last != cp) {
- if ((*last != '/') && depth) {
+ if (!is_absolute_path(last) && depth) {
error("%s: ignoring relative alternate object store %s",
relative_base, last);
} else {
"pack_report: getpagesize() = %10" SZ_FMT "\n"
"pack_report: core.packedGitWindowSize = %10" SZ_FMT "\n"
"pack_report: core.packedGitLimit = %10" SZ_FMT "\n",
- (size_t) getpagesize(),
- packed_git_window_size,
- packed_git_limit);
+ sz_fmt(getpagesize()),
+ sz_fmt(packed_git_window_size),
+ sz_fmt(packed_git_limit));
fprintf(stderr,
"pack_report: pack_used_ctr = %10u\n"
"pack_report: pack_mmap_calls = %10u\n"
pack_used_ctr,
pack_mmap_calls,
pack_open_windows, peak_pack_open_windows,
- pack_mapped, peak_pack_mapped);
+ sz_fmt(pack_mapped), sz_fmt(peak_pack_mapped));
}
static int check_packed_git_idx(const char *path, struct packed_git *p)
return slash;
}
-static const char *ref_fmt[] = {
- "%.*s",
- "refs/%.*s",
- "refs/tags/%.*s",
- "refs/heads/%.*s",
- "refs/remotes/%.*s",
- "refs/remotes/%.*s/HEAD",
- NULL
-};
-
int dwim_ref(const char *str, int len, unsigned char *sha1, char **ref)
{
const char **p, *r;
int refs_found = 0;
*ref = NULL;
- for (p = ref_fmt; *p; p++) {
+ for (p = ref_rev_parse_rules; *p; p++) {
unsigned char sha1_from_ref[20];
unsigned char *this_result;
int logs_found = 0;
*log = NULL;
- for (p = ref_fmt; *p; p++) {
+ for (p = ref_rev_parse_rules; *p; p++) {
struct stat st;
unsigned char hash[20];
char path[PATH_MAX];
{
struct commit_list *list = NULL, *backup = NULL, *l;
int retval = -1;
+ char *temp_commit_buffer = NULL;
if (prefix[0] == '!') {
if (prefix[1] != '!')
die ("Invalid search pattern: %s", prefix);
prefix++;
}
- if (!save_commit_buffer)
- return error("Could not expand oneline-name.");
for_each_ref(handle_one_ref, &list);
for (l = list; l; l = l->next)
commit_list_insert(l->item, &backup);
while (list) {
char *p;
struct commit *commit;
+ enum object_type type;
+ unsigned long size;
commit = pop_most_recent_commit(&list, ONELINE_SEEN);
parse_object(commit->object.sha1);
- if (!commit->buffer || !(p = strstr(commit->buffer, "\n\n")))
+ if (temp_commit_buffer)
+ free(temp_commit_buffer);
+ if (commit->buffer)
+ p = commit->buffer;
+ else {
+ p = read_sha1_file(commit->object.sha1, &type, &size);
+ if (!p)
+ continue;
+ temp_commit_buffer = p;
+ }
+ if (!(p = strstr(p, "\n\n")))
continue;
if (!prefixcmp(p + 2, prefix)) {
hashcpy(sha1, commit->object.sha1);
break;
}
}
+ if (temp_commit_buffer)
+ free(temp_commit_buffer);
free_commit_list(list);
for (l = backup; l; l = l->next)
clear_commit_marks(l->item, ONELINE_SEEN);
test_expect_success 'plain' '
(
- unset GIT_DIR GIT_WORK_TREE &&
+ unset GIT_DIR GIT_WORK_TREE
mkdir plain &&
cd plain &&
git init
test_expect_success 'plain with GIT_WORK_TREE' '
if (
- unset GIT_DIR &&
+ unset GIT_DIR
mkdir plain-wt &&
cd plain-wt &&
GIT_WORK_TREE=$(pwd) git init
test_expect_success 'plain bare' '
(
- unset GIT_DIR GIT_WORK_TREE GIT_CONFIG &&
+ unset GIT_DIR GIT_WORK_TREE GIT_CONFIG
mkdir plain-bare-1 &&
cd plain-bare-1 &&
git --bare init
test_expect_success 'plain bare with GIT_WORK_TREE' '
if (
- unset GIT_DIR GIT_CONFIG &&
+ unset GIT_DIR GIT_CONFIG
mkdir plain-bare-2 &&
cd plain-bare-2 &&
GIT_WORK_TREE=$(pwd) git --bare init
test_expect_success 'GIT_DIR bare' '
(
- unset GIT_CONFIG &&
+ unset GIT_CONFIG
mkdir git-dir-bare.git &&
GIT_DIR=git-dir-bare.git git init
) &&
test_expect_success 'GIT_DIR non-bare' '
(
- unset GIT_CONFIG &&
+ unset GIT_CONFIG
mkdir non-bare &&
cd non-bare &&
GIT_DIR=.git git init
test_expect_success 'GIT_DIR & GIT_WORK_TREE (1)' '
(
- unset GIT_CONFIG &&
+ unset GIT_CONFIG
mkdir git-dir-wt-1.git &&
GIT_WORK_TREE=$(pwd) GIT_DIR=git-dir-wt-1.git git init
) &&
test_expect_success 'GIT_DIR & GIT_WORK_TREE (2)' '
if (
- unset GIT_CONFIG &&
+ unset GIT_CONFIG
mkdir git-dir-wt-2.git &&
GIT_WORK_TREE=$(pwd) GIT_DIR=git-dir-wt-2.git git --bare init
)
'
+test_expect_success 'prune --expire' '
+
+ before=$(git count-objects | sed "s/ .*//") &&
+ BLOB=$(echo aleph | git hash-object -w --stdin) &&
+ BLOB_FILE=.git/objects/$(echo $BLOB | sed "s/^../&\//") &&
+ test $((1 + $before)) = $(git count-objects | sed "s/ .*//") &&
+ test -f $BLOB_FILE &&
+ git reset --hard &&
+ git prune --expire=1.hour.ago &&
+ test $((1 + $before)) = $(git count-objects | sed "s/ .*//") &&
+ test -f $BLOB_FILE &&
+ test-chmtime -86500 $BLOB_FILE &&
+ git prune --expire 1.day &&
+ test $before = $(git count-objects | sed "s/ .*//") &&
+ ! test -f $BLOB_FILE
+
+'
+
test_done
--- /dev/null
+#!/bin/sh
+
+test_description='branch --contains <commit>'
+
+. ./test-lib.sh
+
+test_expect_success setup '
+
+ >file &&
+ git add file &&
+ test_tick &&
+ git commit -m initial &&
+ git branch side &&
+
+ echo 1 >file &&
+ test_tick &&
+ git commit -a -m "second on master" &&
+
+ git checkout side &&
+ echo 1 >file &&
+ test_tick &&
+ git commit -a -m "second on side" &&
+
+ git merge master
+
+'
+
+test_expect_success 'branch --contains=master' '
+
+ git branch --contains=master >actual &&
+ {
+ echo " master" && echo "* side"
+ } >expect &&
+ diff -u expect actual
+
+'
+
+test_expect_success 'branch --contains master' '
+
+ git branch --contains master >actual &&
+ {
+ echo " master" && echo "* side"
+ } >expect &&
+ diff -u expect actual
+
+'
+
+test_expect_success 'branch --contains=side' '
+
+ git branch --contains=side >actual &&
+ {
+ echo "* side"
+ } >expect &&
+ diff -u expect actual
+
+'
+
+test_done
'
test_expect_success 'rebase --skip with am -3' '
- git reset --hard HEAD &&
git rebase --skip
'
test_expect_failure 'rebase with --merge' 'git rebase --merge master'
test_expect_success 'rebase --skip with --merge' '
- git reset --hard HEAD &&
git rebase --skip
'
'
DQ='"'
+echo foo > "Name and an${HT}HT"
+test -f "Name and an${HT}HT" || {
+ # since FAT/NTFS does not allow tabs in filenames, skip this test
+ say 'Your filesystem does not allow tabs in filenames, test skipped.'
+ test_done
+}
+
for_each_name () {
for name in \
Name "Name and a${LF}LF" "Name and an${HT}HT" "Name${DQ}" \
chmod +x path1
test_expect_success \
- 'update-cache --add two files with and without +x.' \
+ 'update-index --add two files with and without +x.' \
'git update-index --add path0 path1'
mv path0 path0-
'
test_expect_success \
- 'update-cache --add a file.' \
+ 'update-index --add a file.' \
'git update-index --add path0'
test_expect_success \
'compare_diff_raw expected current'
test_expect_success \
- 'run diff with -B' \
+ 'run diff with -B -M' \
'git diff-index -B -M "$tree" >current'
-# This should not mistake file0 as the copy source of new file1
-# due to type differences.
+# file0 changed from regular to symlink. file1 is very close to the preimage of file0.
+# because we break file0, file1 can become a rename of it.
cat >expected <<\EOF
:100644 120000 f5deac7be59e7eeab8657fd9ae706fd6a57daed2 67be421f88824578857624f7b3dc75e99a8a1481 T file0
-:100644 100644 6ff87c4664981e4397625791c8ea3bbb5f2279a3 f5deac7be59e7eeab8657fd9ae706fd6a57daed2 M100 file1
+:100644 100644 6ff87c4664981e4397625791c8ea3bbb5f2279a3 f5deac7be59e7eeab8657fd9ae706fd6a57daed2 R file0 file1
EOF
test_expect_success \
--- /dev/null
+#!/bin/sh
+
+test_description='typechange rename detection'
+
+. ./test-lib.sh
+
+test_expect_success setup '
+
+ rm -f foo bar &&
+ cat ../../COPYING >foo &&
+ ln -s linklink bar &&
+ git add foo bar &&
+ git commit -a -m Initial &&
+ git tag one &&
+
+ rm -f foo bar &&
+ cat ../../COPYING >bar &&
+ ln -s linklink foo &&
+ git add foo bar &&
+ git commit -a -m Second &&
+ git tag two &&
+
+ rm -f foo bar &&
+ cat ../../COPYING >foo &&
+ git add foo &&
+ git commit -a -m Third &&
+ git tag three &&
+
+ mv foo bar &&
+ ln -s linklink foo &&
+ git add foo bar &&
+ git commit -a -m Fourth &&
+ git tag four &&
+
+ # This is purely for sanity check
+
+ rm -f foo bar &&
+ cat ../../COPYING >foo &&
+ cat ../../Makefile >bar &&
+ git add foo bar &&
+ git commit -a -m Fifth &&
+ git tag five &&
+
+ rm -f foo bar &&
+ cat ../../Makefile >foo &&
+ cat ../../COPYING >bar &&
+ git add foo bar &&
+ git commit -a -m Sixth &&
+ git tag six
+
+'
+
+test_expect_success 'cross renames to be detected for regular files' '
+
+ git diff-tree five six -r --name-status -B -M | sort >actual &&
+ {
+ echo "R100 foo bar"
+ echo "R100 bar foo"
+ } | sort >expect &&
+ diff -u expect actual
+
+'
+
+test_expect_success 'cross renames to be detected for typechange' '
+
+ git diff-tree one two -r --name-status -B -M | sort >actual &&
+ {
+ echo "R100 foo bar"
+ echo "R100 bar foo"
+ } | sort >expect &&
+ diff -u expect actual
+
+'
+
+test_expect_success 'moves and renames' '
+
+ git diff-tree three four -r --name-status -B -M | sort >actual &&
+ {
+ echo "R100 foo bar"
+ echo "T100 foo"
+ } | sort >expect &&
+ diff -u expect actual
+
+'
+
+test_done
diff --git a/Makefile b/Makefile
--- a/Makefile
+++ b/Makefile
-@@ -30,7 +30,7 @@ PROG= git-update-cache git-diff-files
+@@ -30,7 +30,7 @@ PROG= git-update-index git-diff-files
git-checkout-cache git-diff-tree git-rev-tree git-ls-files \
git-check-files git-ls-tree git-merge-base git-merge-cache \
git-unpack-file git-export git-diff-cache git-convert-cache \
- git-deltafy-script
+ git-deltafy-script git-fetch-script
- PROG= git-update-cache git-diff-files git-init-db git-write-tree \
+ PROG= git-update-index git-diff-files git-init-db git-write-tree \
git-read-tree git-commit-tree git-cat-file git-fsck-cache \
diff --git a/git-pull-script b/git-fetch-script
similarity index 87%
diff a/Makefile b/Makefile
--- a/Makefile
+++ b/Makefile
-@@ -30,7 +30,7 @@ PROG= git-update-cache git-diff-files
+@@ -30,7 +30,7 @@ PROG= git-update-index git-diff-files
git-checkout-cache git-diff-tree git-rev-tree git-ls-files \
git-check-files git-ls-tree git-merge-base git-merge-cache \
git-unpack-file git-export git-diff-cache git-convert-cache \
- git-deltafy-script
+ git-deltafy-script git-fetch-script
- PROG= git-update-cache git-diff-files git-init-db git-write-tree \
+ PROG= git-update-index git-diff-files git-init-db git-write-tree \
git-read-tree git-commit-tree git-cat-file git-fsck-cache \
diff a/git-fetch-script b/git-fetch-script
--- /dev/null
+++ file1+ 2007-02-21 01:07:44.000000000 -0800
@@ -1 +1 @@
-A
-+B
++B
EOF
sed -e 's|file1|sub/&|' gpatch.file >gpatch-sub.file &&
test-3-${packname_3}.idx'
test_expect_success \
- 'corrupt a pack and see if verify catches' \
+ 'verify-pack catches mismatched .idx and .pack files' \
'cat test-1-${packname_1}.idx >test-3.idx &&
cat test-2-${packname_2}.pack >test-3.pack &&
if git verify-pack test-3.idx
then false
else :;
- fi &&
+ fi'
- : PACK_SIGNATURE &&
- cat test-1-${packname_1}.pack >test-3.pack &&
+test_expect_success \
+ 'verify-pack catches a corrupted pack signature' \
+ 'cat test-1-${packname_1}.pack >test-3.pack &&
dd if=/dev/zero of=test-3.pack count=1 bs=1 conv=notrunc seek=2 &&
if git verify-pack test-3.idx
then false
else :;
- fi &&
+ fi'
- : PACK_VERSION &&
- cat test-1-${packname_1}.pack >test-3.pack &&
+test_expect_success \
+ 'verify-pack catches a corrupted pack version' \
+ 'cat test-1-${packname_1}.pack >test-3.pack &&
dd if=/dev/zero of=test-3.pack count=1 bs=1 conv=notrunc seek=7 &&
if git verify-pack test-3.idx
then false
else :;
- fi &&
+ fi'
- : TYPE/SIZE byte of the first packed object data &&
- cat test-1-${packname_1}.pack >test-3.pack &&
+test_expect_success \
+ 'verify-pack catches a corrupted type/size of the 1st packed object data' \
+ 'cat test-1-${packname_1}.pack >test-3.pack &&
dd if=/dev/zero of=test-3.pack count=1 bs=1 conv=notrunc seek=12 &&
if git verify-pack test-3.idx
then false
else :;
- fi &&
+ fi'
- : sum of the index file itself &&
- l=`wc -c <test-3.idx` &&
+test_expect_success \
+ 'verify-pack catches a corrupted sum of the index file itself' \
+ 'l=`wc -c <test-3.idx` &&
l=`expr $l - 20` &&
cat test-1-${packname_1}.pack >test-3.pack &&
dd if=/dev/zero of=test-3.idx count=20 bs=1 conv=notrunc seek=$l &&
if git verify-pack test-3.pack
then false
else :;
- fi &&
-
- :'
+ fi'
test_expect_success \
'build pack index for an existing pack' \
test_expect_success \
'index v2: force some 64-bit offsets with pack-objects' \
- 'pack3=$(git pack-objects --index-version=2,0x40000 test-3 <obj-list) &&
- git verify-pack -v "test-3-${pack3}.pack"'
+ 'pack3=$(git pack-objects --index-version=2,0x40000 test-3 <obj-list)'
+
+have_64bits=
+if msg=$(git verify-pack -v "test-3-${pack3}.pack" 2>&1) ||
+ ! echo "$msg" | grep "pack too large .* off_t"
+then
+ have_64bits=t
+else
+ say "skipping tests concerning 64-bit offsets"
+fi
+
+test "$have_64bits" &&
+test_expect_success \
+ 'index v2: verify a pack with some 64-bit offsets' \
+ 'git verify-pack -v "test-3-${pack3}.pack"'
+test "$have_64bits" &&
test_expect_failure \
'64-bit offsets: should be different from previous index v2 results' \
'cmp "test-2-${pack2}.idx" "test-3-${pack3}.idx"'
+test "$have_64bits" &&
test_expect_success \
'index v2: force some 64-bit offsets with index-pack' \
'git-index-pack --index-version=2,0x40000 -o 3.idx "test-1-${pack1}.pack"'
+test "$have_64bits" &&
test_expect_success \
'64-bit offsets: index-pack result should match pack-objects one' \
'cmp "test-3-${pack3}.idx" "3.idx"'
test_expect_success \
'[index v2] 1) stream pack to repository' \
'rm -f .git/objects/pack/* &&
- git-index-pack --index-version=2,0x40000 --stdin < "test-1-${pack1}.pack" &&
+ git-index-pack --index-version=2 --stdin < "test-1-${pack1}.pack" &&
git prune-packed &&
git count-objects | ( read nr rest && test "$nr" -eq 1 ) &&
cmp "test-1-${pack1}.pack" ".git/objects/pack/pack-${pack1}.pack" &&
- cmp "test-3-${pack1}.idx" ".git/objects/pack/pack-${pack1}.idx"'
+ cmp "test-2-${pack1}.idx" ".git/objects/pack/pack-${pack1}.idx"'
test_expect_success \
'[index v2] 2) create a stealth corruption in a delta base reference' \
--- /dev/null
+#!/bin/sh
+
+test_description='tracking branch update checks for git push'
+
+. ./test-lib.sh
+
+test_expect_success 'setup' '
+ echo 1 >file &&
+ git add file &&
+ git commit -m 1 &&
+ git branch b1 &&
+ git branch b2 &&
+ git clone . aa &&
+ git checkout b1 &&
+ echo b1 >>file &&
+ git commit -a -m b1 &&
+ git checkout b2 &&
+ echo b2 >>file &&
+ git commit -a -m b2
+'
+
+test_expect_success 'prepare pushable branches' '
+ cd aa &&
+ b1=$(git rev-parse origin/b1) &&
+ b2=$(git rev-parse origin/b2) &&
+ git checkout -b b1 origin/b1 &&
+ echo aa-b1 >>file &&
+ git commit -a -m aa-b1 &&
+ git checkout -b b2 origin/b2 &&
+ echo aa-b2 >>file &&
+ git commit -a -m aa-b2 &&
+ git checkout master &&
+ echo aa-master >>file &&
+ git commit -a -m aa-master
+'
+
+test_expect_success 'mixed-success push returns error' '! git push'
+
+test_expect_success 'check tracking branches updated correctly after push' '
+ test "$(git rev-parse origin/master)" = "$(git rev-parse master)"
+'
+
+test_expect_success 'check tracking branches not updated for failed refs' '
+ test "$(git rev-parse origin/b1)" = "$b1" &&
+ test "$(git rev-parse origin/b2)" = "$b2"
+'
+
+test_expect_success 'deleted branches have their tracking branches removed' '
+ git push origin :b1 &&
+ test "$(git rev-parse origin/b1)" = "origin/b1"
+'
+
+test_done
--- /dev/null
+#!/bin/sh
+
+test_description='forced push to replace commit we do not have'
+
+. ./test-lib.sh
+
+test_expect_success setup '
+
+ >file1 && git add file1 && test_tick &&
+ git commit -m Initial &&
+
+ mkdir another && (
+ cd another &&
+ git init &&
+ git fetch .. master:master
+ ) &&
+
+ >file2 && git add file2 && test_tick &&
+ git commit -m Second
+
+'
+
+test_expect_success 'non forced push should die not segfault' '
+
+ (
+ cd another &&
+ git push .. master:master
+ test $? = 1
+ )
+
+'
+
+test_expect_success 'forced push should succeed' '
+
+ (
+ cd another &&
+ git push .. +master:master
+ )
+
+'
+
+test_done
--- /dev/null
+#!/bin/sh
+
+test_description='remote push rejects are reported by client'
+
+. ./test-lib.sh
+
+test_expect_success 'setup' '
+ mkdir .git/hooks &&
+ (echo "#!/bin/sh" ; echo "exit 1") >.git/hooks/update &&
+ chmod +x .git/hooks/update &&
+ echo 1 >file &&
+ git add file &&
+ git commit -m 1 &&
+ git clone . child &&
+ cd child &&
+ echo 2 >file &&
+ git commit -a -m 2
+'
+
+test_expect_success 'push reports error' '! git push 2>stderr'
+
+test_expect_success 'individual ref reports error' 'grep rejected stderr'
+
+test_done
'
+test_expect_failure 'fetch must not resolve short tag name' '
+
+ cd "$D" &&
+
+ mkdir five &&
+ cd five &&
+ git init &&
+
+ git fetch .. anno:five
+
+'
+
+test_expect_failure 'fetch must not resolve short remote name' '
+
+ cd "$D" &&
+ git-update-ref refs/remotes/six/HEAD HEAD
+
+ mkdir six &&
+ cd six &&
+ git init &&
+
+ git fetch .. six:six
+
+'
+
test_expect_success 'create bundle 1' '
cd "$D" &&
echo >file updated again by origin &&
--- /dev/null
+#!/bin/sh
+
+test_description='git ls-remote'
+
+. ./test-lib.sh
+
+test_expect_success setup '
+
+ >file &&
+ git add file &&
+ test_tick &&
+ git commit -m initial &&
+ git tag mark &&
+ git show-ref --tags -d | sed -e "s/ / /" >expected.tag &&
+ (
+ echo "$(git rev-parse HEAD) HEAD"
+ git show-ref -d | sed -e "s/ / /"
+ ) >expected.all &&
+
+ git remote add self $(pwd)/.git
+
+'
+
+test_expect_success 'ls-remote --tags .git' '
+
+ git ls-remote --tags .git >actual &&
+ diff -u expected.tag actual
+
+'
+
+test_expect_success 'ls-remote .git' '
+
+ git ls-remote .git >actual &&
+ diff -u expected.all actual
+
+'
+
+test_expect_success 'ls-remote --tags self' '
+
+ git ls-remote --tags self >actual &&
+ diff -u expected.tag actual
+
+'
+
+test_expect_success 'ls-remote self' '
+
+ git ls-remote self >actual &&
+ diff -u expected.all actual
+
+'
+
+test_done
test_expect_success 'push with no ambiguity (2)' '
mk_test remotes/origin/master &&
- git push testrepo master:master &&
+ git push testrepo master:origin/master &&
check_push_result $the_commit remotes/origin/master
'
+test_expect_success 'push with colon-less refspec, no ambiguity' '
+
+ mk_test heads/master heads/t/master &&
+ git branch -f t/master master &&
+ git push testrepo master &&
+ check_push_result $the_commit heads/master &&
+ check_push_result $the_first_commit heads/t/master
+
+'
+
test_expect_success 'push with weak ambiguity (1)' '
mk_test heads/master remotes/origin/master &&
'
+test_expect_success 'push with HEAD' '
+
+ mk_test heads/master &&
+ git checkout master &&
+ git push testrepo HEAD &&
+ check_push_result $the_commit heads/master
+
+'
+
+test_expect_success 'push with HEAD nonexisting at remote' '
+
+ mk_test heads/master &&
+ git checkout -b local master &&
+ git push testrepo HEAD &&
+ check_push_result $the_commit heads/local
+'
+
test_expect_success 'push with dry-run' '
mk_test heads/master &&
- cd testrepo &&
- old_commit=$(git show-ref -s --verify refs/heads/master) &&
- cd .. &&
+ (cd testrepo &&
+ old_commit=$(git show-ref -s --verify refs/heads/master)) &&
git push --dry-run testrepo &&
check_push_result $old_commit heads/master
'
test_expect_success 'push updates local refs' '
rm -rf parent child &&
- mkdir parent && cd parent && git init &&
- echo one >foo && git add foo && git commit -m one &&
- cd .. &&
- git clone parent child && cd child &&
+ mkdir parent &&
+ (cd parent && git init &&
+ echo one >foo && git add foo && git commit -m one) &&
+ git clone parent child &&
+ (cd child &&
echo two >foo && git commit -a -m two &&
git push &&
- test $(git rev-parse master) = $(git rev-parse remotes/origin/master)
+ test $(git rev-parse master) = $(git rev-parse remotes/origin/master))
'
test_expect_success 'push does not update local refs on failure' '
rm -rf parent child &&
- mkdir parent && cd parent && git init &&
+ mkdir parent &&
+ (cd parent && git init &&
echo one >foo && git add foo && git commit -m one &&
echo exit 1 >.git/hooks/pre-receive &&
- chmod +x .git/hooks/pre-receive &&
- cd .. &&
- git clone parent child && cd child &&
- echo two >foo && git commit -a -m two || exit 1
- git push && exit 1
- test $(git rev-parse master) != $(git rev-parse remotes/origin/master)
+ chmod +x .git/hooks/pre-receive) &&
+ git clone parent child &&
+ (cd child &&
+ echo two >foo && git commit -a -m two &&
+ ! git push &&
+ test $(git rev-parse master) != \
+ $(git rev-parse remotes/origin/master))
+
+'
+
+test_expect_success 'allow deleting an invalid remote ref' '
+
+ pwd &&
+ rm -f testrepo/.git/objects/??/* &&
+ git push testrepo :refs/heads/master &&
+ (cd testrepo && ! git rev-parse --verify refs/heads/master)
'
--- /dev/null
+#!/bin/sh
+
+test_description='pushing to a mirror repository'
+
+. ./test-lib.sh
+
+D=`pwd`
+
+invert () {
+ if "$@"; then
+ return 1
+ else
+ return 0
+ fi
+}
+
+mk_repo_pair () {
+ rm -rf master mirror &&
+ mkdir mirror &&
+ (
+ cd mirror &&
+ git init
+ ) &&
+ mkdir master &&
+ (
+ cd master &&
+ git init &&
+ git config remote.up.url ../mirror
+ )
+}
+
+
+# BRANCH tests
+test_expect_success 'push mirror creates new branches' '
+
+ mk_repo_pair &&
+ (
+ cd master &&
+ echo one >foo && git add foo && git commit -m one &&
+ git push --mirror up
+ ) &&
+ master_master=$(cd master && git show-ref -s --verify refs/heads/master) &&
+ mirror_master=$(cd mirror && git show-ref -s --verify refs/heads/master) &&
+ test "$master_master" = "$mirror_master"
+
+'
+
+test_expect_success 'push mirror updates existing branches' '
+
+ mk_repo_pair &&
+ (
+ cd master &&
+ echo one >foo && git add foo && git commit -m one &&
+ git push --mirror up &&
+ echo two >foo && git add foo && git commit -m two &&
+ git push --mirror up
+ ) &&
+ master_master=$(cd master && git show-ref -s --verify refs/heads/master) &&
+ mirror_master=$(cd mirror && git show-ref -s --verify refs/heads/master) &&
+ test "$master_master" = "$mirror_master"
+
+'
+
+test_expect_success 'push mirror force updates existing branches' '
+
+ mk_repo_pair &&
+ (
+ cd master &&
+ echo one >foo && git add foo && git commit -m one &&
+ git push --mirror up &&
+ echo two >foo && git add foo && git commit -m two &&
+ git push --mirror up &&
+ git reset --hard HEAD^
+ git push --mirror up
+ ) &&
+ master_master=$(cd master && git show-ref -s --verify refs/heads/master) &&
+ mirror_master=$(cd mirror && git show-ref -s --verify refs/heads/master) &&
+ test "$master_master" = "$mirror_master"
+
+'
+
+test_expect_success 'push mirror removes branches' '
+
+ mk_repo_pair &&
+ (
+ cd master &&
+ echo one >foo && git add foo && git commit -m one &&
+ git branch remove master &&
+ git push --mirror up &&
+ git branch -D remove
+ git push --mirror up
+ ) &&
+ (
+ cd mirror &&
+ invert git show-ref -s --verify refs/heads/remove
+ )
+
+'
+
+test_expect_success 'push mirror adds, updates and removes branches together' '
+
+ mk_repo_pair &&
+ (
+ cd master &&
+ echo one >foo && git add foo && git commit -m one &&
+ git branch remove master &&
+ git push --mirror up &&
+ git branch -D remove &&
+ git branch add master &&
+ echo two >foo && git add foo && git commit -m two &&
+ git push --mirror up
+ ) &&
+ master_master=$(cd master && git show-ref -s --verify refs/heads/master) &&
+ master_add=$(cd master && git show-ref -s --verify refs/heads/add) &&
+ mirror_master=$(cd mirror && git show-ref -s --verify refs/heads/master) &&
+ mirror_add=$(cd mirror && git show-ref -s --verify refs/heads/add) &&
+ test "$master_master" = "$mirror_master" &&
+ test "$master_add" = "$mirror_add" &&
+ (
+ cd mirror &&
+ invert git show-ref -s --verify refs/heads/remove
+ )
+
+'
+
+
+# TAG tests
+test_expect_success 'push mirror creates new tags' '
+
+ mk_repo_pair &&
+ (
+ cd master &&
+ echo one >foo && git add foo && git commit -m one &&
+ git tag -f tmaster master &&
+ git push --mirror up
+ ) &&
+ master_master=$(cd master && git show-ref -s --verify refs/tags/tmaster) &&
+ mirror_master=$(cd mirror && git show-ref -s --verify refs/tags/tmaster) &&
+ test "$master_master" = "$mirror_master"
+
+'
+
+test_expect_success 'push mirror updates existing tags' '
+
+ mk_repo_pair &&
+ (
+ cd master &&
+ echo one >foo && git add foo && git commit -m one &&
+ git tag -f tmaster master &&
+ git push --mirror up &&
+ echo two >foo && git add foo && git commit -m two &&
+ git tag -f tmaster master &&
+ git push --mirror up
+ ) &&
+ master_master=$(cd master && git show-ref -s --verify refs/tags/tmaster) &&
+ mirror_master=$(cd mirror && git show-ref -s --verify refs/tags/tmaster) &&
+ test "$master_master" = "$mirror_master"
+
+'
+
+test_expect_success 'push mirror force updates existing tags' '
+
+ mk_repo_pair &&
+ (
+ cd master &&
+ echo one >foo && git add foo && git commit -m one &&
+ git tag -f tmaster master &&
+ git push --mirror up &&
+ echo two >foo && git add foo && git commit -m two &&
+ git tag -f tmaster master &&
+ git push --mirror up &&
+ git reset --hard HEAD^
+ git tag -f tmaster master &&
+ git push --mirror up
+ ) &&
+ master_master=$(cd master && git show-ref -s --verify refs/tags/tmaster) &&
+ mirror_master=$(cd mirror && git show-ref -s --verify refs/tags/tmaster) &&
+ test "$master_master" = "$mirror_master"
+
+'
+
+test_expect_success 'push mirror removes tags' '
+
+ mk_repo_pair &&
+ (
+ cd master &&
+ echo one >foo && git add foo && git commit -m one &&
+ git tag -f tremove master &&
+ git push --mirror up &&
+ git tag -d tremove
+ git push --mirror up
+ ) &&
+ (
+ cd mirror &&
+ invert git show-ref -s --verify refs/tags/tremove
+ )
+
+'
+
+test_expect_success 'push mirror adds, updates and removes tags together' '
+
+ mk_repo_pair &&
+ (
+ cd master &&
+ echo one >foo && git add foo && git commit -m one &&
+ git tag -f tmaster master &&
+ git tag -f tremove master &&
+ git push --mirror up &&
+ git tag -d tremove &&
+ git tag tadd master &&
+ echo two >foo && git add foo && git commit -m two &&
+ git tag -f tmaster master &&
+ git push --mirror up
+ ) &&
+ master_master=$(cd master && git show-ref -s --verify refs/tags/tmaster) &&
+ master_add=$(cd master && git show-ref -s --verify refs/tags/tadd) &&
+ mirror_master=$(cd mirror && git show-ref -s --verify refs/tags/tmaster) &&
+ mirror_add=$(cd mirror && git show-ref -s --verify refs/tags/tadd) &&
+ test "$master_master" = "$mirror_master" &&
+ test "$master_add" = "$mirror_add" &&
+ (
+ cd mirror &&
+ invert git show-ref -s --verify refs/tags/tremove
+ )
+
+'
+
+test_done
test `cat file` = modified
'
+test_expect_success '--rebase' '
+ git branch to-rebase &&
+ echo modified again > file &&
+ git commit -m file file &&
+ git checkout to-rebase &&
+ echo new > file2 &&
+ git add file2 &&
+ git commit -m "new file" &&
+ git tag before-rebase &&
+ git pull --rebase . copy &&
+ test $(git rev-parse HEAD^) = $(git rev-parse copy) &&
+ test new = $(git show HEAD:file2)
+'
+
+test_expect_success 'branch.to-rebase.rebase' '
+ git reset --hard before-rebase &&
+ git config branch.to-rebase.rebase 1 &&
+ git pull . copy &&
+ test $(git rev-parse HEAD^) = $(git rev-parse copy) &&
+ test new = $(git show HEAD:file2)
+'
+
test_done
git bisect next
'
+test_expect_success 'bisect reset: back in the master branch' '
+ git bisect reset &&
+ echo "* master" > branch.expect &&
+ git branch > branch.output &&
+ cmp branch.expect branch.output
+'
+
+test_expect_success 'bisect reset: back in another branch' '
+ git checkout -b other &&
+ git bisect start &&
+ git bisect good $HASH1 &&
+ git bisect bad $HASH3 &&
+ git bisect reset &&
+ echo " master" > branch.expect &&
+ echo "* other" >> branch.expect &&
+ git branch > branch.output &&
+ cmp branch.expect branch.output
+'
+
+test_expect_success 'bisect reset when not bisecting' '
+ git bisect reset &&
+ git branch > branch.output &&
+ cmp branch.expect branch.output
+'
+
+test_expect_success 'bisect reset removes packed refs' '
+ git bisect reset &&
+ git bisect start &&
+ git bisect good $HASH1 &&
+ git bisect bad $HASH3 &&
+ git pack-refs --all --prune &&
+ git bisect next &&
+ git bisect reset &&
+ test -z "$(git for-each-ref "refs/bisect/*")" &&
+ test -z "$(git for-each-ref "refs/heads/bisect")"
+'
+
# $HASH1 is good, $HASH4 is bad, we skip $HASH3
# but $HASH2 is bad,
# so we should find $HASH2 as the first bad commit
git bisect skip &&
git bisect good > my_bisect_log.txt &&
grep "$HASH5 is first bad commit" my_bisect_log.txt &&
- git bisect log > log_to_replay.txt
+ git bisect log > log_to_replay.txt &&
git bisect reset
'
test_expect_success 'stops when msg filter fails' '
old=$(git rev-parse HEAD) &&
- ! git-filter-branch -f --msg-filter false &&
+ ! git-filter-branch -f --msg-filter false HEAD &&
test $old = $(git rev-parse HEAD) &&
rm -rf .git-rewrite
'
'
test_expect_success \
- 'trying to create tags giving many -m or -F options should fail' '
+ 'trying to create tags giving both -m or -F options should fail' '
echo "message file 1" >msgfile1 &&
echo "message file 2" >msgfile2 &&
! tag_exists msgtag &&
- ! git-tag -m "message 1" -m "message 2" msgtag &&
- ! tag_exists msgtag &&
- ! git-tag -F msgfile1 -F msgfile2 msgtag &&
- ! tag_exists msgtag &&
! git-tag -m "message 1" -F msgfile1 msgtag &&
! tag_exists msgtag &&
! git-tag -F msgfile1 -m "message 1" msgtag &&
! tag_exists msgtag &&
- ! git-tag -F msgfile1 -m "message 1" -F msgfile2 msgtag &&
- ! tag_exists msgtag &&
! git-tag -m "message 1" -F msgfile1 -m "message 2" msgtag &&
! tag_exists msgtag
'
git diff expect actual
'
+cat >fakeeditor <<'EOF'
+#!/bin/sh
+test -n "$1" && exec >"$1"
+echo A signed tag message
+echo from a fake editor.
+EOF
+chmod +x fakeeditor
+get_tag_header implied-annotate $commit commit $time >expect
+./fakeeditor >>expect
+echo '-----BEGIN PGP SIGNATURE-----' >>expect
+test_expect_success '-s implies annotated tag' '
+ GIT_EDITOR=./fakeeditor git-tag -s implied-annotate &&
+ get_tag_msg implied-annotate >actual &&
+ git diff expect actual
+'
+
test_expect_success \
'trying to create a signed tag with non-existing -F file should fail' '
! test -f nonexistingfile &&
cat >editor <<\EOF
#!/bin/sh
-sed -i -e "s/a file/an amend commit/g" $1
+sed -e "s/a file/an amend commit/g" < $1 > $1-
+mv $1- $1
EOF
chmod 755 editor
cat >editor <<\EOF
#!/bin/sh
-sed -i -e "s/amend/older/g" $1
+sed -e "s/amend/older/g" < $1 > $1-
+mv $1- $1
EOF
chmod 755 editor
git diff --cached | grep chz
'
+test_expect_success 'same tree (single parent)' '
+
+ git reset --hard
+
+ if git commit -m empty
+ then
+ echo oops -- should have complained
+ false
+ else
+ : happy
+ fi
+
+'
+
+test_expect_success 'same tree (single parent) --allow-empty' '
+
+ git commit --allow-empty -m "forced empty" &&
+ git cat-file commit HEAD | grep forced
+
+'
+
+test_expect_success 'same tree (merge and amend merge)' '
+
+ git checkout -b side HEAD^ &&
+ echo zero >zero &&
+ git add zero &&
+ git commit -m "add zero" &&
+ git checkout master &&
+
+ git merge -s ours side -m "empty ok" &&
+ git diff HEAD^ HEAD >actual &&
+ : >expected &&
+ diff -u expected actual &&
+
+ git commit --amend -m "empty really ok" &&
+ git diff HEAD^ HEAD >actual &&
+ : >expected &&
+ diff -u expected actual
+
+'
+
test_done
--- /dev/null
+#!/bin/sh
+#
+# Copyright (c) 2007 Johannes E. Schindelin
+#
+
+test_description='git-fast-export'
+. ./test-lib.sh
+
+test_expect_success 'setup' '
+
+ echo Wohlauf > file &&
+ git add file &&
+ test_tick &&
+ git commit -m initial &&
+ echo die Luft > file &&
+ echo geht frisch > file2 &&
+ git add file file2 &&
+ test_tick &&
+ git commit -m second &&
+ echo und > file2 &&
+ test_tick &&
+ git commit -m third file2 &&
+ test_tick &&
+ git tag rein &&
+ git checkout -b wer HEAD^ &&
+ echo lange > file2
+ test_tick &&
+ git commit -m sitzt file2 &&
+ test_tick &&
+ git tag -a -m valentin muss &&
+ git merge -s ours master
+
+'
+
+test_expect_success 'fast-export | fast-import' '
+
+ MASTER=$(git rev-parse --verify master) &&
+ REIN=$(git rev-parse --verify rein) &&
+ WER=$(git rev-parse --verify wer) &&
+ MUSS=$(git rev-parse --verify muss) &&
+ mkdir new &&
+ git --git-dir=new/.git init &&
+ git fast-export --all |
+ (cd new &&
+ git fast-import &&
+ test $MASTER = $(git rev-parse --verify refs/heads/master) &&
+ test $REIN = $(git rev-parse --verify refs/tags/rein) &&
+ test $WER = $(git rev-parse --verify refs/heads/wer) &&
+ test $MUSS = $(git rev-parse --verify refs/tags/muss))
+
+'
+
+test_expect_success 'fast-export master~2..master' '
+
+ git fast-export master~2..master |
+ sed "s/master/partial/" |
+ (cd new &&
+ git fast-import &&
+ test $MASTER != $(git rev-parse --verify refs/heads/partial) &&
+ git diff master..partial &&
+ git diff master^..partial^ &&
+ ! git rev-parse partial~2)
+
+'
+
+test_expect_success 'iso-8859-1' '
+
+ git config i18n.commitencoding ISO-8859-1 &&
+ # use author and committer name in ISO-8859-1 to match it.
+ . ../t3901-8859-1.txt &&
+ test_tick &&
+ echo rosten >file &&
+ git commit -s -m den file &&
+ git fast-export wer^..wer |
+ sed "s/wer/i18n/" |
+ (cd new &&
+ git fast-import &&
+ git cat-file commit i18n | grep "Áéí óú")
+
+'
+
+cat > signed-tag-import << EOF
+tag sign-your-name
+from $(git rev-parse HEAD)
+tagger C O Mitter <committer@example.com> 1112911993 -0700
+data 210
+A message for a sign
+-----BEGIN PGP SIGNATURE-----
+Version: GnuPG v1.4.5 (GNU/Linux)
+
+fakedsignaturefakedsignaturefakedsignaturefakedsignaturfakedsign
+aturefakedsignaturefake=
+=/59v
+-----END PGP SIGNATURE-----
+EOF
+
+test_expect_success 'set up faked signed tag' '
+
+ cat signed-tag-import | git fast-import
+
+'
+
+test_expect_success 'signed-tags=abort' '
+
+ ! git fast-export --signed-tags=abort sign-your-name
+
+'
+
+test_expect_success 'signed-tags=verbatim' '
+
+ git fast-export --signed-tags=verbatim sign-your-name > output &&
+ grep PGP output
+
+'
+
+test_expect_success 'signed-tags=strip' '
+
+ git fast-export --signed-tags=strip sign-your-name > output &&
+ ! grep PGP output
+
+'
+
+test_done
--- /dev/null
+#!/bin/sh
+
+test_description='git-cvsimport basic tests'
+. ./test-lib.sh
+
+if ! type cvs >/dev/null 2>&1
+then
+ say 'skipping cvsimport tests, cvs not found'
+ test_done
+ exit
+fi
+
+cvsps_version=`cvsps -h 2>&1 | sed -ne 's/cvsps version //p'`
+case "$cvsps_version" in
+2.1)
+ ;;
+'')
+ say 'skipping cvsimport tests, cvsps not found'
+ test_done
+ exit
+ ;;
+*)
+ say 'skipping cvsimport tests, cvsps too old'
+ test_done
+ exit
+ ;;
+esac
+
+CVSROOT=$(pwd)/cvsroot
+export CVSROOT
+# for clean cvsps cache
+HOME=$(pwd)
+export HOME
+
+test_expect_success 'setup cvsroot' 'cvs init'
+
+test_expect_success 'setup a cvs module' '
+
+ mkdir $CVSROOT/module &&
+ cvs co -d module-cvs module &&
+ cd module-cvs &&
+ cat <<EOF >o_fortuna &&
+O Fortuna
+velut luna
+statu variabilis,
+
+semper crescis
+aut decrescis;
+vita detestabilis
+
+nunc obdurat
+et tunc curat
+ludo mentis aciem,
+
+egestatem,
+potestatem
+dissolvit ut glaciem.
+EOF
+ cvs add o_fortuna &&
+ cat <<EOF >message &&
+add "O Fortuna" lyrics
+
+These public domain lyrics make an excellent sample text.
+EOF
+ cvs commit -F message &&
+ cd ..
+'
+
+test_expect_success 'import a trivial module' '
+
+ git cvsimport -a -z 0 -C module-git module &&
+ git diff module-cvs/o_fortuna module-git/o_fortuna
+
+'
+
+test_expect_success 'pack refs' 'cd module-git && git gc && cd ..'
+
+test_expect_success 'update cvs module' '
+
+ cd module-cvs &&
+ cat <<EOF >o_fortuna &&
+O Fortune,
+like the moon
+you are changeable,
+
+ever waxing
+and waning;
+hateful life
+
+first oppresses
+and then soothes
+as fancy takes it;
+
+poverty
+and power
+it melts them like ice.
+EOF
+ cat <<EOF >message &&
+translate to English
+
+My Latin is terrible.
+EOF
+ cvs commit -F message &&
+ cd ..
+'
+
+test_expect_success 'update git module' '
+
+ cd module-git &&
+ git cvsimport -a -z 0 module &&
+ git merge origin &&
+ cd .. &&
+ git diff module-cvs/o_fortuna module-git/o_fortuna
+
+'
+
+test_expect_success 'update cvs module' '
+
+ cd module-cvs &&
+ echo 1 >tick &&
+ cvs add tick &&
+ cvs commit -m 1
+ cd ..
+
+'
+
+test_expect_success 'cvsimport.module config works' '
+
+ cd module-git &&
+ git config cvsimport.module module &&
+ git cvsimport -a -z0 &&
+ git merge origin &&
+ cd .. &&
+ git diff module-cvs/tick module-git/tick
+
+'
+
+test_expect_success 'import from a CVS working tree' '
+
+ cvs co -d import-from-wt module &&
+ cd import-from-wt &&
+ git cvsimport -a -z0 &&
+ echo 1 >expect &&
+ git log -1 --pretty=format:%s%n >actual &&
+ git diff actual expect &&
+ cd ..
+
+'
+
+test_done
$(RM) -r blt boilerplates.made
install: all
- $(INSTALL) -d -m755 '$(DESTDIR_SQ)$(template_dir_SQ)'
+ $(INSTALL) -d -m 755 '$(DESTDIR_SQ)$(template_dir_SQ)'
(cd blt && $(TAR) cf - .) | \
(cd '$(DESTDIR_SQ)$(template_dir_SQ)' && $(TAR) xf -)
if git-rev-parse --verify HEAD 2>/dev/null
then
- git-diff-index -p -M --cached HEAD
+ git-diff-index -p -M --cached HEAD --
else
# NEEDSWORK: we should produce a diff with an empty tree here
# if we want to do the same verification for the initial import.
return STDERR_FILENO;
if (strlen(trace) == 1 && isdigit(*trace))
return atoi(trace);
- if (*trace == '/') {
+ if (is_absolute_path(trace)) {
int fd = open(trace, O_WRONLY | O_APPEND | O_CREAT, 0666);
if (fd == -1) {
fprintf(stderr,
close(fd);
}
-void trace_argv_printf(const char **argv, int count, const char *fmt, ...)
+void trace_argv_printf(const char **argv, const char *fmt, ...)
{
struct strbuf buf;
va_list ap;
}
strbuf_setlen(&buf, len);
- sq_quote_argv(&buf, argv, count, 0);
+ sq_quote_argv(&buf, argv, 0);
strbuf_addch(&buf, '\n');
write_or_whine_pipe(fd, buf.buf, buf.len, err_msg);
strbuf_release(&buf);
#endif
#include "pkt-line.h"
#include "fetch-pack.h"
+#include "send-pack.h"
#include "walker.h"
#include "bundle.h"
#include "dir.h"
}
}
-static struct ref *get_refs_via_rsync(const struct transport *transport)
+static struct ref *get_refs_via_rsync(struct transport *transport)
{
struct strbuf buf = STRBUF_INIT, temp_dir = STRBUF_INIT;
struct ref dummy, *tail = &dummy;
struct child_process rsync;
const char *args[10];
+ if (flags & TRANSPORT_PUSH_MIRROR)
+ return error("rsync transport does not support mirror mode");
+
/* first push the objects */
strbuf_addstr(&buf, transport->url);
int argc;
int err;
+ if (flags & TRANSPORT_PUSH_MIRROR)
+ return error("http transport does not support mirror mode");
+
argv = xmalloc((refspec_nr + 12) * sizeof(char *));
argv[0] = "http-push";
argc = 1;
#define missing_target(a) missing__target((a)->http_code, (a)->curl_result)
-static struct ref *get_refs_via_curl(const struct transport *transport)
+static struct ref *get_refs_via_curl(struct transport *transport)
{
struct buffer buffer;
char *data, *start, *mid;
curl_easy_setopt(slot->curl, CURLOPT_WRITEFUNCTION, fwrite_buffer);
curl_easy_setopt(slot->curl, CURLOPT_URL, refs_url);
curl_easy_setopt(slot->curl, CURLOPT_HTTPHEADER, NULL);
+ if (transport->remote->http_proxy)
+ curl_easy_setopt(slot->curl, CURLOPT_PROXY,
+ transport->remote->http_proxy);
+
if (start_active_slot(slot)) {
run_active_slot(slot);
if (results.curl_result != CURLE_OK) {
struct bundle_header header;
};
-static struct ref *get_refs_from_bundle(const struct transport *transport)
+static struct ref *get_refs_from_bundle(struct transport *transport)
{
struct bundle_transport_data *data = transport->data;
struct ref *result = NULL;
return 1;
}
-static struct ref *get_refs_via_connect(const struct transport *transport)
+static struct ref *get_refs_via_connect(struct transport *transport)
{
struct git_transport_data *data = transport->data;
struct ref *refs;
static int git_transport_push(struct transport *transport, int refspec_nr, const char **refspec, int flags)
{
struct git_transport_data *data = transport->data;
- const char **argv;
- char *rem;
- int argc;
- int err;
+ struct send_pack_args args;
- argv = xmalloc((refspec_nr + 12) * sizeof(char *));
- argv[0] = "send-pack";
- argc = 1;
- if (flags & TRANSPORT_PUSH_ALL)
- argv[argc++] = "--all";
- if (flags & TRANSPORT_PUSH_FORCE)
- argv[argc++] = "--force";
- if (flags & TRANSPORT_PUSH_DRY_RUN)
- argv[argc++] = "--dry-run";
- if (flags & TRANSPORT_PUSH_VERBOSE)
- argv[argc++] = "--verbose";
- if (data->receivepack) {
- char *rp = xmalloc(strlen(data->receivepack) + 16);
- sprintf(rp, "--receive-pack=%s", data->receivepack);
- argv[argc++] = rp;
- }
- if (data->thin)
- argv[argc++] = "--thin";
- rem = xmalloc(strlen(transport->remote->name) + 10);
- sprintf(rem, "--remote=%s", transport->remote->name);
- argv[argc++] = rem;
- argv[argc++] = transport->url;
- while (refspec_nr--)
- argv[argc++] = *refspec++;
- argv[argc] = NULL;
- err = run_command_v_opt(argv, RUN_GIT_CMD);
- switch (err) {
- case -ERR_RUN_COMMAND_FORK:
- error("unable to fork for %s", argv[0]);
- case -ERR_RUN_COMMAND_EXEC:
- error("unable to exec %s", argv[0]);
- break;
- case -ERR_RUN_COMMAND_WAITPID:
- case -ERR_RUN_COMMAND_WAITPID_WRONG_PID:
- case -ERR_RUN_COMMAND_WAITPID_SIGNAL:
- case -ERR_RUN_COMMAND_WAITPID_NOEXIT:
- error("%s died with strange error", argv[0]);
- }
- return !!err;
+ args.receivepack = data->receivepack;
+ args.send_all = !!(flags & TRANSPORT_PUSH_ALL);
+ args.send_mirror = !!(flags & TRANSPORT_PUSH_MIRROR);
+ args.force_update = !!(flags & TRANSPORT_PUSH_FORCE);
+ args.use_thin_pack = data->thin;
+ args.verbose = !!(flags & TRANSPORT_PUSH_VERBOSE);
+ args.dry_run = !!(flags & TRANSPORT_PUSH_DRY_RUN);
+
+ return send_pack(&args, transport->url, transport->remote, refspec_nr, refspec);
}
static int disconnect_git(struct transport *transport)
return transport->push(transport, refspec_nr, refspec, flags);
}
-struct ref *transport_get_remote_refs(struct transport *transport)
+const struct ref *transport_get_remote_refs(struct transport *transport)
{
if (!transport->remote_refs)
transport->remote_refs = transport->get_refs_list(transport);
struct remote *remote;
const char *url;
void *data;
- struct ref *remote_refs;
+ const struct ref *remote_refs;
/**
* Returns 0 if successful, positive if the option is not
int (*set_option)(struct transport *connection, const char *name,
const char *value);
- struct ref *(*get_refs_list)(const struct transport *transport);
+ struct ref *(*get_refs_list)(struct transport *transport);
int (*fetch)(struct transport *transport, int refs_nr, struct ref **refs);
int (*push)(struct transport *connection, int refspec_nr, const char **refspec, int flags);
#define TRANSPORT_PUSH_ALL 1
#define TRANSPORT_PUSH_FORCE 2
#define TRANSPORT_PUSH_DRY_RUN 4
-#define TRANSPORT_PUSH_VERBOSE 8
+#define TRANSPORT_PUSH_MIRROR 8
+#define TRANSPORT_PUSH_VERBOSE 16
/* Returns a transport suitable for the url */
struct transport *transport_get(struct remote *, const char *);
int transport_push(struct transport *connection,
int refspec_nr, const char **refspec, int flags);
-struct ref *transport_get_remote_refs(struct transport *transport);
+const struct ref *transport_get_remote_refs(struct transport *transport);
int transport_fetch_refs(struct transport *transport, struct ref *refs);
void transport_unlock_pack(struct transport *transport);
unsigned int mode;
};
-static inline enum object_type object_type(unsigned int mode)
-{
- return S_ISDIR(mode) ? OBJ_TREE :
- S_ISGITLINK(mode) ? OBJ_COMMIT :
- OBJ_BLOB;
-}
-
struct tree_desc {
const void *buffer;
struct name_entry entry;
int remove;
int baselen = strlen(base);
int src_size = len + 1;
- int i_stk = i_stk;
int retval = 0;
- if (o->dir)
- i_stk = push_exclude_per_directory(o->dir, base, strlen(base));
-
do {
int i;
const char *first;
} while (1);
leave_directory:
- if (o->dir)
- pop_exclude_per_directory(o->dir, i_stk);
return retval;
}
rev.diffopt.format_callback_data = s;
rev.diffopt.detect_rename = 1;
rev.diffopt.rename_limit = 100;
+ rev.diffopt.break_opt = 0;
wt_read_cache(s);
run_diff_index(&rev, 1);
}