![[tokkee]](http://tokkee.org/images/avatar.png){kind=avatar}
| author | Junio C Hamano <gitster@pobox.com> | |
| Thu, 9 Jul 2009 07:59:32 +0000 (00:59 -0700) | ||
| committer | Junio C Hamano <gitster@pobox.com> | |
| Thu, 9 Jul 2009 07:59:32 +0000 (00:59 -0700) |
* 'js/run-command-updates' (early part):
MinGW: truncate exit()'s argument to lowest 8 bits
MinGW: truncate exit()'s argument to lowest 8 bits
74 files changed:
index 2fecbe32a68bd981959735dd14e6e311d16b233a..bf97e1dee2b3507ded3ced00e9656bdf0b42f43b 100644 (file)
--- a/Documentation/config.txt
+++ b/Documentation/config.txt
it will be treated as a shell command. For example, defining
"alias.new = !gitk --all --not ORIG_HEAD", the invocation
"git new" is equivalent to running the shell command
-"gitk --all --not ORIG_HEAD".
+"gitk --all --not ORIG_HEAD". Note that shell commands will be
+executed from the top-level directory of a repository, which may
+not necessarily be the current directory.
apply.whitespace::
Tells 'git-apply' how to handle whitespaces, in the same way
index 4bbdd056da4ca5a3032b53afac820b86c74a54e4..82045a2522799ccf3a03479bf4f4cd1fa1809879 100644 (file)
Only meaningful in `--parseopt` mode. Tells the option parser to echo
out the first `--` met instead of skipping it.
+--stop-at-non-option::
+ Only meaningful in `--parseopt` mode. Lets the option parser stop at
+ the first non-option argument. This can be used to parse sub-commands
+ that take options themself.
+
--sq-quote::
Use 'git-rev-parse' in shell quoting mode (see SQ-QUOTE
section below). In contrast to the `--sq` option below, this
index 98e294aa869d39575ab32d859ca9fcc3bfcaf789..f4429bdc6863ce1d115b47282f2c04a4d9093d29 100644 (file)
--------
[verse]
'git show-ref' [-q|--quiet] [--verify] [-h|--head] [-d|--dereference]
- [-s|--hash] [--abbrev] [--tags] [--heads] [--] <pattern>...
-'git show-ref' --exclude-existing[=pattern]
+ [-s|--hash[=<n>]] [--abbrev[=<n>]] [--tags]
+ [--heads] [--] <pattern>...
+'git show-ref' --exclude-existing[=<pattern>] < ref-list
DESCRIPTION
-----------
appended.
-s::
---hash::
+--hash[=<n>]::
Only show the SHA1 hash, not the reference name. When combined with
--dereference the dereferenced tag will still be shown after the SHA1.
Aside from returning an error code of 1, it will also print an error
message if '--quiet' was not specified.
---abbrev::
---abbrev=len::
+--abbrev[=<n>]::
Abbreviate the object name. When using `--hash`, you do
- not have to say `--hash --abbrev`; `--hash=len` would do.
+ not have to say `--hash --abbrev`; `--hash=n` would do.
-q::
--quiet::
Do not print any results to stdout. When combined with '--verify' this
can be used to silently check if a reference exists.
---exclude-existing::
---exclude-existing=pattern::
+--exclude-existing[=<pattern>]::
Make 'git-show-ref' act as a filter that reads refs from stdin of the
form "^(?:<anything>\s)?<refname>(?:\^\{\})?$" and performs the
index 7e9b9a042347bf286c6ea523bef1952f0c72dec9..10af599b44a38981126af62652815b5d184e6774 100644 (file)
DESCRIPTION
-----------
-'git-svn' is a simple conduit for changesets between Subversion and git.
+'git svn' is a simple conduit for changesets between Subversion and git.
It provides a bidirectional flow of changes between a Subversion and a git
repository.
-'git-svn' can track a standard Subversion repository,
+'git svn' can track a standard Subversion repository,
following the common "trunk/branches/tags" layout, with the --stdlayout option.
It can also follow branches and tags in any layout with the -T/-t/-b options
(see options to 'init' below, and also the 'clone' command).
COMMANDS
--------
---
'init'::
Initializes an empty git repository with additional
- metadata directories for 'git-svn'. The Subversion URL
+ metadata directories for 'git svn'. The Subversion URL
may be specified as a command-line argument, or as full
URL arguments to -T/-t/-b. Optionally, the target
directory to operate on can be specified as a second
Set the 'useSvnsyncProps' option in the [svn-remote] config.
--rewrite-root=<URL>;;
Set the 'rewriteRoot' option in the [svn-remote] config.
---use-log-author;;
- When retrieving svn commits into git (as part of fetch, rebase, or
- dcommit operations), look for the first From: or Signed-off-by: line
- in the log message and use that as the author string.
---add-author-from;;
- When committing to svn from git (as part of commit or dcommit
- operations), if the existing log message doesn't already have a
- From: or Signed-off-by: line, append a From: line based on the
- git commit's author string. If you use this, then --use-log-author
- will retrieve a valid author string for all commits.
--username=<USER>;;
For transports that SVN handles authentication for (http,
https, and plain svn), specify the username. For other
--localtime;;
Store Git commit times in the local timezone instead of UTC. This
- makes 'git-log' (even without --date=local) show the same times
+ makes 'git log' (even without --date=local) show the same times
that `svn log` would in the local timezone.
--parent;;
Fetch only from the SVN parent of the current HEAD.
-
++
This doesn't interfere with interoperating with the Subversion
repository you cloned from, but if you wish for your local Git
repository to be able to interoperate with someone else's local Git
The '--ignore-paths' option should match for every 'fetch'
(including automatic fetches due to 'clone', 'dcommit',
'rebase', etc) on a given repository.
-
++
+[verse]
config key: svn-remote.<name>.ignore-paths
-
- If the ignore-paths config key is set and the command
- line option is also given, both regular expressions
- will be used.
-
++
+If the ignore-paths config key is set and the command line option is
+also given, both regular expressions will be used.
++
Examples:
++
+--
+Skip "doc*" directory for every fetch;;
++
+------------------------------------------------------------------------
+--ignore-paths="^doc"
+------------------------------------------------------------------------
- --ignore-paths="^doc" - skip "doc*" directory for every
- fetch.
+Skip "branches" and "tags" of first level directories;;
++
+------------------------------------------------------------------------
+--ignore-paths="^[^/]+/(?:branches|tags)"
+------------------------------------------------------------------------
+--
- --ignore-paths="^[^/]+/(?:branches|tags)" - skip
- "branches" and "tags" of first level directories.
+--use-log-author;;
+ When retrieving svn commits into git (as part of fetch, rebase, or
+ dcommit operations), look for the first From: or Signed-off-by: line
+ in the log message and use that as the author string.
+--add-author-from;;
+ When committing to svn from git (as part of commit or dcommit
+ operations), if the existing log message doesn't already have a
+ From: or Signed-off-by: line, append a From: line based on the
+ git commit's author string. If you use this, then --use-log-author
+ will retrieve a valid author string for all commits.
'clone'::
Runs 'init' and 'fetch'. It will automatically create a
or if a second argument is passed; it will create a directory
and work within that. It accepts all arguments that the
'init' and 'fetch' commands accept; with the exception of
- '--fetch-all'. After a repository is cloned, the 'fetch'
- command will be able to update revisions without affecting
- the working tree; and the 'rebase' command will be able
- to update the working tree with the latest changes.
+ '--fetch-all' and '--parent'. After a repository is cloned,
+ the 'fetch' command will be able to update revisions without
+ affecting the working tree; and the 'rebase' command will be
+ able to update the working tree with the latest changes.
'rebase'::
This fetches revisions from the SVN parent of the current HEAD
and rebases the current (uncommitted to SVN) work against it.
-
-This works similarly to `svn update` or 'git-pull' except that
-it preserves linear history with 'git-rebase' instead of
-'git-merge' for ease of dcommitting with 'git-svn'.
-
-This accepts all options that 'git-svn fetch' and 'git-rebase'
++
+This works similarly to `svn update` or 'git pull' except that
+it preserves linear history with 'git rebase' instead of
+'git merge' for ease of dcommitting with 'git svn'.
++
+This accepts all options that 'git svn fetch' and 'git rebase'
accept. However, '--fetch-all' only fetches from the current
[svn-remote], and not all [svn-remote] definitions.
-
-Like 'git-rebase'; this requires that the working tree be clean
++
+Like 'git rebase'; this requires that the working tree be clean
and have no uncommitted changes.
-l;;
--local;;
- Do not fetch remotely; only run 'git-rebase' against the
+ Do not fetch remotely; only run 'git rebase' against the
last fetched commit from the upstream SVN.
'dcommit'::
repository, and then rebase or reset (depending on whether or
not there is a diff between SVN and head). This will create
a revision in SVN for each commit in git.
- It is recommended that you run 'git-svn' fetch and rebase (not
+ It is recommended that you run 'git svn' fetch and rebase (not
pull or merge) your commits against the latest changes in the
SVN repository.
An optional revision or branch argument may be specified, and
- causes 'git-svn' to do all work on that revision/branch
+ causes 'git svn' to do all work on that revision/branch
instead of HEAD.
This is advantageous over 'set-tree' (below) because it produces
cleaner, more linear history.
After committing, do not rebase or reset.
--commit-url <URL>;;
Commit to this SVN URL (the full path). This is intended to
- allow existing git-svn repositories created with one transport
+ allow existing 'git svn' repositories created with one transport
method (e.g. `svn://` or `http://` for anonymous read) to be
reused if a user is later given access to an alternate transport
method (e.g. `svn+ssh://` or `https://`) for commit.
-
++
+[verse]
config key: svn-remote.<name>.commiturl
-
config key: svn.commiturl (overwrites all svn-remote.<name>.commiturl options)
-
- Using this option for any other purpose (don't ask)
- is very strongly discouraged.
---
++
+Using this option for any other purpose (don't ask) is very strongly
+discouraged.
'branch'::
Create a branch in the SVN repository.
@@ -232,10 +239,12 @@ where <name> is the name of the SVN repository as specified by the -R option to
The following features from `svn log' are supported:
+
--
--r/--revision=<n>[:<n>];;
+-r <n>[:<n>];;
+--revision=<n>[:<n>];;
is supported, non-numeric args are not:
HEAD, NEXT, BASE, PREV, etc ...
--v/--verbose;;
+-v;;
+--verbose;;
it's not completely compatible with the --verbose
output in svn log, but reasonably close.
--limit=<n>;;
client converts the UTC time to the local time (or based on the TZ=
environment). This command has the same behaviour.
+
-Any other arguments are passed directly to 'git-log'
+Any other arguments are passed directly to 'git log'
'blame'::
Show what revision and author last modified each line of a file. The
`svn blame' by default. Like the SVN blame command,
local uncommitted changes in the working copy are ignored;
the version of the file in the HEAD revision is annotated. Unknown
- arguments are passed directly to 'git-blame'.
+ arguments are passed directly to 'git blame'.
+
--git-format;;
- Produce output in the same format as 'git-blame', but with
+ Produce output in the same format as 'git blame', but with
SVN revision numbers instead of git commit hashes. In this mode,
changes that haven't been committed to SVN (including local
working-copy edits) are shown as revision 0.
---
'find-rev'::
When given an SVN revision number of the form 'rN', returns the
corresponding git commit hash (this can optionally be followed by a
absolutely no attempts to do patching when committing to SVN, it
simply overwrites files with those specified in the tree or
commit. All merging is assumed to have taken place
- independently of 'git-svn' functions.
+ independently of 'git svn' functions.
'create-ignore'::
Recursively finds the svn:ignore property on directories and
'commit-diff'::
Commits the diff of two tree-ish arguments from the
- command-line. This command does not rely on being inside an `git-svn
+ command-line. This command does not rely on being inside an `git svn
init`-ed repository. This command takes three arguments, (a) the
original tree to diff against, (b) the new tree result, (c) the
URL of the target Subversion repository. The final argument
- (URL) may be omitted if you are working from a 'git-svn'-aware
- repository (that has been `init`-ed with 'git-svn').
+ (URL) may be omitted if you are working from a 'git svn'-aware
+ repository (that has been `init`-ed with 'git svn').
The -r<revision> option is required for this.
'info'::
"checksum mismatch" (missed a modification). If the problem
file cannot be ignored forever (with --ignore-paths) the only
way to repair the repo is to use 'reset'.
-
++
Only the rev_map and refs/remotes/git-svn are changed. Follow 'reset'
-with a 'fetch' and then 'git-reset' or 'git-rebase' to move local
+with a 'fetch' and then 'git reset' or 'git rebase' to move local
branches onto the new tree.
--r/--revision=<n>;;
+-r <n>;;
+--revision=<n>;;
Specify the most recent revision to keep. All later revisions
are discarded.
--p/--parent;;
+-p;;
+--parent;;
Discard the specified revision as well, keeping the nearest
parent instead.
Example:;;
Assume you have local changes in "master", but you need to refetch "r2".
-
++
------------
r1---r2---r3 remotes/git-svn
\
A---B master
------------
-
++
Fix the ignore-paths or SVN permissions problem that caused "r2" to
be incomplete in the first place. Then:
-
++
[verse]
git svn reset -r2 -p
git svn fetch
-
++
------------
r1---r2'--r3' remotes/git-svn
\
r2---r3---A---B master
------------
-
-Then fixup "master" with 'git-rebase'.
-Do NOT use 'git-merge' or your history will not be compatible with a
++
+Then fixup "master" with 'git rebase'.
+Do NOT use 'git merge' or your history will not be compatible with a
future 'dcommit'!
-
++
[verse]
git rebase --onto remotes/git-svn A^ master
-
++
------------
r1---r2'--r3' remotes/git-svn
\
A'--B' master
------------
-
---
-
OPTIONS
-------
---
--shared[={false|true|umask|group|all|world|everybody}]::
--template=<template_directory>::
Only used with the 'init' command.
- These are passed directly to 'git-init'.
+ These are passed directly to 'git init'.
-r <ARG>::
--revision <ARG>::
-
-Used with the 'fetch' command.
-
+ Used with the 'fetch' command.
++
This allows revision ranges for partial/cauterized history
to be supported. $NUMBER, $NUMBER1:$NUMBER2 (numeric ranges),
$NUMBER:HEAD, and BASE:$NUMBER are all supported.
-
++
This can allow you to make partial mirrors when running fetch;
but is generally not recommended because history will be skipped
and lost.
-::
--stdin::
-
-Only used with the 'set-tree' command.
-
+ Only used with the 'set-tree' command.
++
Read a list of commits from stdin and commit them in reverse
order. Only the leading sha1 is read from each line, so
-'git-rev-list --pretty=oneline' output can be used.
+'git rev-list --pretty=oneline' output can be used.
--rmdir::
-
-Only used with the 'dcommit', 'set-tree' and 'commit-diff' commands.
-
+ Only used with the 'dcommit', 'set-tree' and 'commit-diff' commands.
++
Remove directories from the SVN tree if there are no files left
behind. SVN can version empty directories, and they are not
removed by default if there are no files left in them. git
cannot version empty directories. Enabling this flag will make
the commit to SVN act like git.
-
++
+[verse]
config key: svn.rmdir
-e::
--edit::
-
-Only used with the 'dcommit', 'set-tree' and 'commit-diff' commands.
-
+ Only used with the 'dcommit', 'set-tree' and 'commit-diff' commands.
++
Edit the commit message before committing to SVN. This is off by
default for objects that are commits, and forced on when committing
tree objects.
-
++
+[verse]
config key: svn.edit
-l<num>::
--find-copies-harder::
-
-Only used with the 'dcommit', 'set-tree' and 'commit-diff' commands.
-
-They are both passed directly to 'git-diff-tree'; see
+ Only used with the 'dcommit', 'set-tree' and 'commit-diff' commands.
++
+They are both passed directly to 'git diff-tree'; see
linkgit:git-diff-tree[1] for more information.
-
++
[verse]
config key: svn.l
config key: svn.findcopiesharder
-A<filename>::
--authors-file=<filename>::
-
-Syntax is compatible with the file used by 'git-cvsimport':
-
+ Syntax is compatible with the file used by 'git cvsimport':
++
------------------------------------------------------------------------
loginname = Joe User <user@example.com>
------------------------------------------------------------------------
-
-If this option is specified and 'git-svn' encounters an SVN
-committer name that does not exist in the authors-file, 'git-svn'
++
+If this option is specified and 'git svn' encounters an SVN
+committer name that does not exist in the authors-file, 'git svn'
will abort operation. The user will then have to add the
-appropriate entry. Re-running the previous 'git-svn' command
+appropriate entry. Re-running the previous 'git svn' command
after the authors-file is modified should continue operation.
-
++
+[verse]
config key: svn.authorsfile
--authors-prog=<filename>::
-
-If this option is specified, for each SVN committer name that does not
-exist in the authors file, the given file is executed with the committer
-name as the first argument. The program is expected to return a single
-line of the form "Name <email>", which will be treated as if included in
-the authors file.
+ If this option is specified, for each SVN committer name that
+ does not exist in the authors file, the given file is executed
+ with the committer name as the first argument. The program is
+ expected to return a single line of the form "Name <email>",
+ which will be treated as if included in the authors file.
-q::
--quiet::
- Make 'git-svn' less verbose. Specify a second time to make it
+ Make 'git svn' less verbose. Specify a second time to make it
even less verbose.
--repack[=<n>]::
--repack-flags=<flags>::
-
-These should help keep disk usage sane for large fetches
-with many revisions.
-
+ These should help keep disk usage sane for large fetches with
+ many revisions.
++
--repack takes an optional argument for the number of revisions
to fetch before repacking. This defaults to repacking every
1000 commits fetched if no argument is specified.
-
---repack-flags are passed directly to 'git-repack'.
-
++
+--repack-flags are passed directly to 'git repack'.
++
[verse]
config key: svn.repack
config key: svn.repackflags
--merge::
-s<strategy>::
--strategy=<strategy>::
-
-These are only used with the 'dcommit' and 'rebase' commands.
-
-Passed directly to 'git-rebase' when using 'dcommit' if a
-'git-reset' cannot be used (see 'dcommit').
+ These are only used with the 'dcommit' and 'rebase' commands.
++
+Passed directly to 'git rebase' when using 'dcommit' if a
+'git reset' cannot be used (see 'dcommit').
-n::
--dry-run::
-
-This can be used with the 'dcommit', 'rebase', 'branch' and 'tag'
-commands.
-
+ This can be used with the 'dcommit', 'rebase', 'branch' and
+ 'tag' commands.
++
For 'dcommit', print out the series of git arguments that would show
which diffs would be committed to SVN.
-
++
For 'rebase', display the local branch associated with the upstream svn
repository associated with the current branch and the URL of svn
repository that will be fetched from.
-
++
For 'branch' and 'tag', display the urls that will be used for copying when
creating the branch or tag.
---
ADVANCED OPTIONS
----------------
---
-i<GIT_SVN_ID>::
--id <GIT_SVN_ID>::
-
-This sets GIT_SVN_ID (instead of using the environment). This
-allows the user to override the default refname to fetch from
-when tracking a single URL. The 'log' and 'dcommit' commands
-no longer require this switch as an argument.
+ This sets GIT_SVN_ID (instead of using the environment). This
+ allows the user to override the default refname to fetch from
+ when tracking a single URL. The 'log' and 'dcommit' commands
+ no longer require this switch as an argument.
-R<remote name>::
--svn-remote <remote name>::
started tracking a branch and never tracked the trunk it was
descended from. This feature is enabled by default, use
--no-follow-parent to disable it.
-
++
+[verse]
config key: svn.followparent
---
CONFIG FILE-ONLY OPTIONS
------------------------
---
svn.noMetadata::
svn-remote.<name>.noMetadata::
-
-This gets rid of the 'git-svn-id:' lines at the end of every commit.
-
-If you lose your .git/svn/git-svn/.rev_db file, 'git-svn' will not
+ This gets rid of the 'git-svn-id:' lines at the end of every commit.
++
+If you lose your .git/svn/git-svn/.rev_db file, 'git svn' will not
be able to rebuild it and you won't be able to fetch again,
either. This is fine for one-shot imports.
-
-The 'git-svn log' command will not work on repositories using
++
+The 'git svn log' command will not work on repositories using
this, either. Using this conflicts with the 'useSvmProps'
option for (hopefully) obvious reasons.
svn.useSvmProps::
svn-remote.<name>.useSvmProps::
-
-This allows 'git-svn' to re-map repository URLs and UUIDs from
-mirrors created using SVN::Mirror (or svk) for metadata.
-
+ This allows 'git svn' to re-map repository URLs and UUIDs from
+ mirrors created using SVN::Mirror (or svk) for metadata.
++
If an SVN revision has a property, "svm:headrev", it is likely
that the revision was created by SVN::Mirror (also used by SVK).
The property contains a repository UUID and a revision. We want
svn-remote.<name>.rewriteRoot::
This allows users to create repositories from alternate
- URLs. For example, an administrator could run 'git-svn' on the
+ URLs. For example, an administrator could run 'git svn' on the
server locally (accessing via file://) but wish to distribute
the repository with a public http:// or svn:// URL in the
metadata so users of it will see the public URL.
svn.brokenSymlinkWorkaround::
-This disables potentially expensive checks to workaround broken symlinks
-checked into SVN by broken clients. Set this option to "false" if you
-track a SVN repository with many empty blobs that are not symlinks.
-This option may be changed while "git-svn" is running and take effect on
-the next revision fetched. If unset, git-svn assumes this option to be
-"true".
-
---
+ This disables potentially expensive checks to workaround
+ broken symlinks checked into SVN by broken clients. Set this
+ option to "false" if you track a SVN repository with many
+ empty blobs that are not symlinks. This option may be changed
+ while 'git svn' is running and take effect on the next
+ revision fetched. If unset, 'git svn' assumes this option to
+ be "true".
Since the noMetadata, rewriteRoot, useSvnsyncProps and useSvmProps
-options all affect the metadata generated and used by 'git-svn'; they
+options all affect the metadata generated and used by 'git svn'; they
*must* be set in the configuration file before any history is imported
and these settings should never be changed once they are set.
git svn clone http://svn.example.com/project/trunk
# Enter the newly cloned directory:
cd trunk
-# You should be on master branch, double-check with git-branch
+# You should be on master branch, double-check with 'git branch'
git branch
# Do some work and commit locally to git:
git commit ...
# of dcommit/rebase/show-ignore should be the same as above.
------------------------------------------------------------------------
-The initial 'git-svn clone' can be quite time-consuming
+The initial 'git svn clone' can be quite time-consuming
(especially for large Subversion repositories). If multiple
people (or one person with multiple machines) want to use
-'git-svn' to interact with the same Subversion repository, you can
-do the initial 'git-svn clone' to a repository on a server and
-have each person clone that repository with 'git-clone':
+'git svn' to interact with the same Subversion repository, you can
+do the initial 'git svn clone' to a repository on a server and
+have each person clone that repository with 'git clone':
------------------------------------------------------------------------
# Do the initial import on a server
git fetch
# Create a local branch from one of the branches just fetched
git checkout -b master FETCH_HEAD
-# Initialize git-svn locally (be sure to use the same URL and -T/-b/-t options as were used on server)
+# Initialize 'git svn' locally (be sure to use the same URL and -T/-b/-t options as were used on server)
git svn init http://svn.example.com/project
# Pull the latest changes from Subversion
git svn rebase
REBASE VS. PULL/MERGE
---------------------
-Originally, 'git-svn' recommended that the 'remotes/git-svn' branch be
+Originally, 'git svn' recommended that the 'remotes/git-svn' branch be
pulled or merged from. This is because the author favored
`git svn set-tree B` to commit a single head rather than the
`git svn set-tree A..B` notation to commit multiple commits.
DESIGN PHILOSOPHY
-----------------
Merge tracking in Subversion is lacking and doing branched development
-with Subversion can be cumbersome as a result. While 'git-svn' can track
+with Subversion can be cumbersome as a result. While 'git svn' can track
copy history (including branches and tags) for repositories adopting a
standard layout, it cannot yet represent merge history that happened
inside git back upstream to SVN users. Therefore it is advised that
-------
For the sake of simplicity and interoperating with a less-capable system
-(SVN), it is recommended that all 'git-svn' users clone, fetch and dcommit
-directly from the SVN server, and avoid all 'git-clone'/'pull'/'merge'/'push'
+(SVN), it is recommended that all 'git svn' users clone, fetch and dcommit
+directly from the SVN server, and avoid all 'git clone'/'pull'/'merge'/'push'
operations between git repositories and branches. The recommended
method of exchanging code between git branches and users is
-'git-format-patch' and 'git-am', or just 'dcommit'ing to the SVN repository.
+'git format-patch' and 'git am', or just 'dcommit'ing to the SVN repository.
-Running 'git-merge' or 'git-pull' is NOT recommended on a branch you
+Running 'git merge' or 'git pull' is NOT recommended on a branch you
plan to 'dcommit' from. Subversion does not represent merges in any
reasonable or useful fashion; so users using Subversion cannot see any
merges you've made. Furthermore, if you merge or pull from a git branch
that is a mirror of an SVN branch, 'dcommit' may commit to the wrong
branch.
-'git-clone' does not clone branches under the refs/remotes/ hierarchy or
-any 'git-svn' metadata, or config. So repositories created and managed with
-using 'git-svn' should use 'rsync' for cloning, if cloning is to be done
+'git clone' does not clone branches under the refs/remotes/ hierarchy or
+any 'git svn' metadata, or config. So repositories created and managed with
+using 'git svn' should use 'rsync' for cloning, if cloning is to be done
at all.
-Since 'dcommit' uses rebase internally, any git branches you 'git-push' to
+Since 'dcommit' uses rebase internally, any git branches you 'git push' to
before 'dcommit' on will require forcing an overwrite of the existing ref
on the remote repository. This is generally considered bad practice,
see the linkgit:git-push[1] documentation for details.
you've already pushed to a remote repository for other users, and
dcommit with SVN is analogous to that.
-When using multiple --branches or --tags, 'git-svn' does not automatically
+When using multiple --branches or --tags, 'git svn' does not automatically
handle name collisions (for example, if two branches from different paths have
the same name, or if a branch and a tag have the same name). In these cases,
use 'init' to set up your git repository then, before your first 'fetch', edit
CONFIGURATION
-------------
-'git-svn' stores [svn-remote] configuration information in the
+'git svn' stores [svn-remote] configuration information in the
repository .git/config file. It is similar the core git
[remote] sections except 'fetch' keys do not accept glob
arguments; but they are instead handled by the 'branches'
however the remote wildcard may be anywhere as long as it's an
independent path component (surrounded by '/' or EOL). This
type of configuration is not automatically created by 'init' and
-should be manually entered with a text-editor or using 'git-config'.
+should be manually entered with a text-editor or using 'git config'.
SEE ALSO
--------
diff --git a/Makefile b/Makefile
index cdc40d05ca758714e506c0a403790e61fa82125e..78cc11382a1e5f5d4d5b403015b8071c785a8501 100644 (file)
--- a/Makefile
+++ b/Makefile
#
# Define USE_NED_ALLOCATOR if you want to replace the platforms default
# memory allocators with the nedmalloc allocator written by Niall Douglas.
+#
+# Define NO_REGEX if you have no or inferior regex support in your C library.
GIT-VERSION-FILE: .FORCE-GIT-VERSION-FILE
@$(SHELL_PATH) ./GIT-VERSION-GEN
NO_MEMMEM = YesPlease
NO_MKDTEMP = YesPlease
NO_MKSTEMPS = YesPlease
+ NO_REGEX = YesPlease
ifeq ($(uname_R),5.7)
NEEDS_RESOLV = YesPlease
NO_IPV6 = YesPlease
endif
INSTALL = /usr/ucb/install
TAR = gtar
- BASIC_CFLAGS += -D__EXTENSIONS__ -D__sun__
+ BASIC_CFLAGS += -D__EXTENSIONS__ -D__sun__ -DHAVE_ALLOCA_H
endif
ifeq ($(uname_O),Cygwin)
NO_D_TYPE_IN_DIRENT = YesPlease
USE_NED_ALLOCATOR = YesPlease
UNRELIABLE_FSTAT = UnfortunatelyYes
OBJECT_CREATION_USES_RENAMES = UnfortunatelyNeedsTo
- COMPAT_CFLAGS += -D__USE_MINGW_ACCESS -DNOGDI -Icompat -Icompat/regex -Icompat/fnmatch
+ NO_REGEX = YesPlease
+ COMPAT_CFLAGS += -D__USE_MINGW_ACCESS -DNOGDI -Icompat -Icompat/fnmatch
COMPAT_CFLAGS += -DSTRIP_EXTENSION=\".exe\"
- COMPAT_OBJS += compat/mingw.o compat/fnmatch/fnmatch.o compat/regex/regex.o compat/winansi.o
+ COMPAT_OBJS += compat/mingw.o compat/fnmatch/fnmatch.o compat/winansi.o
EXTLIBS += -lws2_32
X = .exe
ifneq (,$(wildcard ../THIS_IS_MSYSGIT))
ifdef UNRELIABLE_FSTAT
BASIC_CFLAGS += -DUNRELIABLE_FSTAT
endif
+ifdef NO_REGEX
+ COMPAT_CFLAGS += -Icompat/regex
+ COMPAT_OBJS += compat/regex/regex.o
+endif
ifdef USE_NED_ALLOCATOR
COMPAT_CFLAGS += -DUSE_NED_ALLOCATOR -DOVERRIDE_STRDUP -DNDEBUG -DREPLACE_SYSTEM_ALLOCATOR -Icompat/nedmalloc
diff --git a/abspath.c b/abspath.c
index 649f34f83365db3513c5166b897c4f033831444d..4bee0ba1ec6fcf49e88b874f0a415f4220117c0a 100644 (file)
--- a/abspath.c
+++ b/abspath.c
if (*buf) {
if (!*cwd && !getcwd(cwd, sizeof(cwd)))
- die ("Could not get current working directory");
+ die_errno ("Could not get current working directory");
if (chdir(buf))
- die ("Could not switch to '%s'", buf);
+ die_errno ("Could not switch to '%s'", buf);
}
if (!getcwd(buf, PATH_MAX))
- die ("Could not get current working directory");
+ die_errno ("Could not get current working directory");
if (last_elem) {
int len = strlen(buf);
if (!lstat(buf, &st) && S_ISLNK(st.st_mode)) {
len = readlink(buf, next_buf, PATH_MAX);
if (len < 0)
- die ("Invalid symlink: %s", buf);
+ die_errno ("Invalid symlink '%s'", buf);
if (PATH_MAX <= len)
die("symbolic link too long: %s", buf);
next_buf[len] = '\0';
}
if (*cwd && chdir(cwd))
- die ("Could not change back to '%s'", cwd);
+ die_errno ("Could not change back to '%s'", cwd);
return buf;
}
} else {
const char *cwd = get_pwd_cwd();
if (!cwd)
- die("Cannot determine the current working directory");
+ die_errno("Cannot determine the current working directory");
if (snprintf(buf, PATH_MAX, "%s/%s", cwd, path) >= PATH_MAX)
die("Too long path: %.*s", 60, path);
}
diff --git a/bisect.c b/bisect.c
index 52220df751aaacec08792c01ad83f2a1b27aae5f..7f20acb4b9e391bd383597ec554ec58b70979fe5 100644 (file)
--- a/bisect.c
+++ b/bisect.c
FILE *fp = fopen(filename, "r");
if (!fp)
- die("Could not open file '%s': %s", filename, strerror(errno));
+ die_errno("Could not open file '%s'", filename);
while (strbuf_getline(&str, fp, '\n') != EOF) {
char *quoted;
int fd = open(filename, O_CREAT | O_TRUNC | O_WRONLY, 0600);
if (fd < 0)
- die("could not create file '%s': %s",
- filename, strerror(errno));
+ die_errno("could not create file '%s'", filename);
bisect_rev_hex[len] = '\n';
write_or_die(fd, bisect_rev_hex, len + 1);
diff --git a/branch.c b/branch.c
index 62030af4b51abbfb9c488dbf018770f3b3606789..05ef3f5c9ce6e1b55a7eb483a197fe9fd6e5437d 100644 (file)
--- a/branch.c
+++ b/branch.c
lock = lock_any_ref_for_update(ref.buf, NULL, 0);
if (!lock)
- die("Failed to lock ref for update: %s.", strerror(errno));
+ die_errno("Failed to lock ref for update");
if (reflog)
log_all_ref_updates = 1;
setup_tracking(name, real_ref, track);
if (write_ref_sha1(lock, sha1, msg) < 0)
- die("Failed to write ref: %s.", strerror(errno));
+ die_errno("Failed to write ref");
strbuf_release(&ref);
free(real_ref);
diff --git a/builtin-add.c b/builtin-add.c
index 4e44148e05843e03befc167f6bdf3a1567d3f8ad..78989dad8cb07dee00054c3ea98d16eb493a05c9 100644 (file)
--- a/builtin-add.c
+++ b/builtin-add.c
launch_editor(file, NULL, NULL);
if (stat(file, &st))
- die("Could not stat '%s'", file);
+ die_errno("Could not stat '%s'", file);
if (!st.st_size)
die("Empty patch. Aborted.");
diff --git a/builtin-apply.c b/builtin-apply.c
index 4cf819c7905d5997a6ce2a89b4ecce1176a4b045..dc0ff5e08ae73f2832fd4451cce2e849c88be5a8 100644 (file)
--- a/builtin-apply.c
+++ b/builtin-apply.c
static void read_patch_file(struct strbuf *sb, int fd)
{
if (strbuf_read(sb, fd, 0) < 0)
- die("git apply: read returned %s", strerror(errno));
+ die_errno("git apply: failed to read");
/*
* Make sure that we have some slop in the buffer
@@ -2823,8 +2823,8 @@ static void add_index_file(const char *path, unsigned mode, void *buf, unsigned
} else {
if (!cached) {
if (lstat(path, &st) < 0)
- die("unable to stat newly created file %s",
- path);
+ die_errno("unable to stat newly created file '%s'",
+ path);
fill_stat_cache_info(ce, &st);
}
if (write_sha1_file(buf, size, blob_type, ce->sha1) < 0)
@@ -2864,7 +2864,7 @@ static int try_create_file(const char *path, unsigned int mode, const char *buf,
strbuf_release(&nbuf);
if (close(fd) < 0)
- die("closing file %s: %s", path, strerror(errno));
+ die_errno("closing file '%s'", path);
return 0;
}
@@ -2913,7 +2913,7 @@ static void create_one_file(char *path, unsigned mode, const char *buf, unsigned
++nr;
}
}
- die("unable to write file %s mode %o", path, mode);
+ die_errno("unable to write file '%s' mode %o", path, mode);
}
static void create_file(struct patch *patch)
fd = open(arg, O_RDONLY);
if (fd < 0)
- die("can't open patch '%s': %s", arg, strerror(errno));
+ die_errno("can't open patch '%s'", arg);
read_stdin = 0;
set_default_whitespace_mode(whitespace_option);
errs |= apply_patch(fd, arg, options);
diff --git a/builtin-archive.c b/builtin-archive.c
index 3c5a5a7822afebf87ef6eb1f89c7c54d76844161..f9a4bea41e95b9a34f190fc2b696c7394d0e0971 100644 (file)
--- a/builtin-archive.c
+++ b/builtin-archive.c
{
int output_fd = open(output_file, O_CREAT | O_WRONLY | O_TRUNC, 0666);
if (output_fd < 0)
- die("could not create archive file: %s ", output_file);
+ die_errno("could not create archive file '%s'", output_file);
if (output_fd != 1) {
if (dup2(output_fd, 1) < 0)
- die("could not redirect output");
+ die_errno("could not redirect output");
else
close(output_fd);
}
diff --git a/builtin-blame.c b/builtin-blame.c
index 0c2d29a43005e0afe7c0b0754499a37156e235ef..fd6ca51eebb2234be429b47b572ae2f30592ff4e 100644 (file)
--- a/builtin-blame.c
+++ b/builtin-blame.c
@@ -2008,23 +2008,23 @@ static struct commit *fake_working_tree_commit(const char *path, const char *con
if (contents_from) {
if (stat(contents_from, &st) < 0)
- die("Cannot stat %s", contents_from);
+ die_errno("Cannot stat '%s'", contents_from);
read_from = contents_from;
}
else {
if (lstat(path, &st) < 0)
- die("Cannot lstat %s", path);
+ die_errno("Cannot lstat '%s'", path);
read_from = path;
}
mode = canon_mode(st.st_mode);
switch (st.st_mode & S_IFMT) {
case S_IFREG:
if (strbuf_read_file(&buf, read_from, st.st_size) != st.st_size)
- die("cannot open or read %s", read_from);
+ die_errno("cannot open or read '%s'", read_from);
break;
case S_IFLNK:
if (strbuf_readlink(&buf, read_from, st.st_size) < 0)
- die("cannot readlink %s", read_from);
+ die_errno("cannot readlink '%s'", read_from);
break;
default:
die("unsupported file type %s", read_from);
@@ -2035,7 +2035,7 @@ static struct commit *fake_working_tree_commit(const char *path, const char *con
contents_from = "standard input";
mode = 0;
if (strbuf_read(&buf, 0, 0) < 0)
- die("read error %s from stdin", strerror(errno));
+ die_errno("failed to read from stdin");
}
convert_to_git(path, buf.buf, buf.len, &buf, 0);
origin->file.ptr = buf.buf;
argc = parse_options_end(&ctx);
if (revs_file && read_ancestry(revs_file))
- die("reading graft file %s failed: %s",
- revs_file, strerror(errno));
+ die_errno("reading graft file '%s' failed", revs_file);
if (cmd_is_annotate) {
output_option |= OUTPUT_ANNOTATE_COMPAT;
setup_work_tree();
if (!has_string_in_work_tree(path))
- die("cannot stat path %s: %s", path, strerror(errno));
+ die_errno("cannot stat path '%s'", path);
}
setup_revisions(argc, argv, &revs, NULL);
diff --git a/builtin-clone.c b/builtin-clone.c
index 2ceacb7b3f34c78e64ed047833d8af5a061f065f..32dea74d78381ca1dffdac7f88e45a89a9825104 100644 (file)
--- a/builtin-clone.c
+++ b/builtin-clone.c
dir = opendir(src->buf);
if (!dir)
- die("failed to open %s", src->buf);
+ die_errno("failed to open '%s'", src->buf);
if (mkdir(dest->buf, 0777)) {
if (errno != EEXIST)
- die("failed to create directory %s", dest->buf);
+ die_errno("failed to create directory '%s'", dest->buf);
else if (stat(dest->buf, &buf))
- die("failed to stat %s", dest->buf);
+ die_errno("failed to stat '%s'", dest->buf);
else if (!S_ISDIR(buf.st_mode))
die("%s exists and is not a directory", dest->buf);
}
}
if (unlink(dest->buf) && errno != ENOENT)
- die("failed to unlink %s: %s",
- dest->buf, strerror(errno));
+ die_errno("failed to unlink '%s'", dest->buf);
if (!option_no_hardlinks) {
if (!link(src->buf, dest->buf))
continue;
if (option_local)
- die("failed to create link %s", dest->buf);
+ die_errno("failed to create link '%s'", dest->buf);
option_no_hardlinks = 1;
}
if (copy_file(dest->buf, src->buf, 0666))
- die("failed to copy file to %s", dest->buf);
+ die_errno("failed to copy file to '%s'", dest->buf);
}
closedir(dir);
}
if (!option_bare) {
junk_work_tree = work_tree;
if (safe_create_leading_directories_const(work_tree) < 0)
- die("could not create leading directories of '%s': %s",
- work_tree, strerror(errno));
+ die_errno("could not create leading directories of '%s'",
+ work_tree);
if (!dest_exists && mkdir(work_tree, 0755))
- die("could not create work tree dir '%s': %s.",
- work_tree, strerror(errno));
+ die_errno("could not create work tree dir '%s'.",
+ work_tree);
set_git_work_tree(work_tree);
}
junk_git_dir = git_dir;
diff --git a/builtin-commit-tree.c b/builtin-commit-tree.c
index 0453425c471f1d6793bc7f5f59d17e9d285ddfc6..64670777312c71d45b10f72a1efe9fceae3e3b89 100644 (file)
--- a/builtin-commit-tree.c
+++ b/builtin-commit-tree.c
}
if (strbuf_read(&buffer, 0, 0) < 0)
- die("git commit-tree: read returned %s", strerror(errno));
+ die_errno("git commit-tree: failed to read");
if (!commit_tree(buffer.buf, tree_sha1, parents, commit_sha1, NULL)) {
printf("%s\n", sha1_to_hex(commit_sha1));
diff --git a/builtin-commit.c b/builtin-commit.c
index 41e222d267ca952c3bc0c8d6b1e19c0171df0c62..4bcce06fbffdf10ec701dfbc0b6b90a11513f89e 100644 (file)
--- a/builtin-commit.c
+++ b/builtin-commit.c
if (isatty(0))
fprintf(stderr, "(reading log message from standard input)\n");
if (strbuf_read(&sb, 0, 0) < 0)
- die("could not read log from standard input");
+ die_errno("could not read log from standard input");
hook_arg1 = "message";
} else if (logfile) {
if (strbuf_read_file(&sb, logfile, 0) < 0)
- die("could not read log file '%s': %s",
- logfile, strerror(errno));
+ die_errno("could not read log file '%s'",
+ logfile);
hook_arg1 = "message";
} else if (use_message) {
buffer = strstr(use_message_buffer, "\n\n");
hook_arg2 = use_message;
} else if (!stat(git_path("MERGE_MSG"), &statbuf)) {
if (strbuf_read_file(&sb, git_path("MERGE_MSG"), 0) < 0)
- die("could not read MERGE_MSG: %s", strerror(errno));
+ die_errno("could not read MERGE_MSG");
hook_arg1 = "merge";
} else if (!stat(git_path("SQUASH_MSG"), &statbuf)) {
if (strbuf_read_file(&sb, git_path("SQUASH_MSG"), 0) < 0)
- die("could not read SQUASH_MSG: %s", strerror(errno));
+ die_errno("could not read SQUASH_MSG");
hook_arg1 = "squash";
} else if (template_file && !stat(template_file, &statbuf)) {
if (strbuf_read_file(&sb, template_file, 0) < 0)
- die("could not read %s: %s",
- template_file, strerror(errno));
+ die_errno("could not read '%s'", template_file);
hook_arg1 = "template";
}
fp = fopen(git_path(commit_editmsg), "w");
if (fp == NULL)
- die("could not open %s: %s",
- git_path(commit_editmsg), strerror(errno));
+ die_errno("could not open '%s'", git_path(commit_editmsg));
if (cleanup_mode != CLEANUP_NONE)
stripspace(&sb, 0);
}
if (fwrite(sb.buf, 1, sb.len, fp) < sb.len)
- die("could not write commit template: %s", strerror(errno));
+ die_errno("could not write commit template");
strbuf_release(&sb);
pptr = &commit_list_insert(lookup_commit(head_sha1), pptr)->next;
fp = fopen(git_path("MERGE_HEAD"), "r");
if (fp == NULL)
- die("could not open %s for reading: %s",
- git_path("MERGE_HEAD"), strerror(errno));
+ die_errno("could not open '%s' for reading",
+ git_path("MERGE_HEAD"));
while (strbuf_getline(&m, fp, '\n') != EOF) {
unsigned char sha1[20];
if (get_sha1_hex(m.buf, sha1) < 0)
strbuf_release(&m);
if (!stat(git_path("MERGE_MODE"), &statbuf)) {
if (strbuf_read_file(&sb, git_path("MERGE_MODE"), 0) < 0)
- die("could not read MERGE_MODE: %s",
- strerror(errno));
+ die_errno("could not read MERGE_MODE");
if (!strcmp(sb.buf, "no-ff"))
allow_fast_forward = 0;
}
/* Finally, get the commit message */
strbuf_reset(&sb);
if (strbuf_read_file(&sb, git_path(commit_editmsg), 0) < 0) {
+ int saved_errno = errno;
rollback_index_files();
- die("could not read commit message");
+ die("could not read commit message: %s", strerror(saved_errno));
}
/* Truncate the message just before the diff, if any. */
diff --git a/builtin-config.c b/builtin-config.c
index 60915f91caff02997222d18bc625d242d95c6bb1..a2d656edb383da47fb3622f1f7c2d1524285ac00 100644 (file)
--- a/builtin-config.c
+++ b/builtin-config.c
check_argc(argc, 0, 0);
if (git_config(show_all_config, NULL) < 0) {
if (config_exclusive_filename)
- die("unable to read config file %s: %s",
- config_exclusive_filename, strerror(errno));
+ die_errno("unable to read config file '%s'",
+ config_exclusive_filename);
else
die("error processing config file(s)");
}
diff --git a/builtin-diff.c b/builtin-diff.c
index d75d69bf5774ffd402bbeec47b9a0e0800554d63..2e51f408f9f3399195604fd23d430c180a7f20a4 100644 (file)
--- a/builtin-diff.c
+++ b/builtin-diff.c
usage(builtin_diff_usage);
if (lstat(path, &st))
- die("'%s': %s", path, strerror(errno));
+ die_errno("failed to stat '%s'", path);
if (!(S_ISREG(st.st_mode) || S_ISLNK(st.st_mode)))
die("'%s': not a regular file or symlink", path);
diff --git a/builtin-fast-export.c b/builtin-fast-export.c
index 6cef8103127a8748acb64ca7ec7a7a95fb639cd3..9a8a6fc6b1e98162a1548b40bd4281172e18d7b2 100644 (file)
--- a/builtin-fast-export.c
+++ b/builtin-fast-export.c
printf("blob\nmark :%"PRIu32"\ndata %lu\n", last_idnum, size);
if (size && fwrite(buf, size, 1, stdout) != 1)
- die ("Could not write blob %s", sha1_to_hex(sha1));
+ die_errno ("Could not write blob '%s'", sha1_to_hex(sha1));
printf("\n");
show_progress();
char line[512];
FILE *f = fopen(input_file, "r");
if (!f)
- die("cannot read %s: %s", input_file, strerror(errno));
+ die_errno("cannot read '%s'", input_file);
while (fgets(line, sizeof(line), f)) {
uint32_t mark;
diff --git a/builtin-fetch--tool.c b/builtin-fetch--tool.c
index 29356d25db910c6d90df46da87aa374467611350..3dbdf7a2887002f0d7a67a1db35bd3c72d7a9d30 100644 (file)
--- a/builtin-fetch--tool.c
+++ b/builtin-fetch--tool.c
{
struct strbuf buf = STRBUF_INIT;
if (strbuf_read(&buf, 0, 1024) < 0) {
- die("error reading standard input: %s", strerror(errno));
+ die_errno("error reading standard input");
}
return strbuf_detach(&buf, NULL);
}
index fbf9582e667dfd1e69027b35c3f307f3c7a08a99..9d524000b5ba4d9c7566edd5756b68d728ec362b 100644 (file)
--- a/builtin-fmt-merge-msg.c
+++ b/builtin-fmt-merge-msg.c
if (inpath && strcmp(inpath, "-")) {
in = fopen(inpath, "r");
if (!in)
- die("cannot open %s", inpath);
+ die_errno("cannot open '%s'", inpath);
}
if (strbuf_read(&input, fileno(in), 0) < 0)
- die("could not read input file %s", strerror(errno));
-
+ die_errno("could not read input file");
ret = fmt_merge_msg(merge_summary, &input, &output);
if (ret)
return ret;
diff --git a/builtin-fsck.c b/builtin-fsck.c
index e077e72dea94892e2f74ddd6be528b02bc6ccea4..b3d38fa277b3d0024b9c46a62cf15bc2448cc1e7 100644 (file)
--- a/builtin-fsck.c
+++ b/builtin-fsck.c
return;
}
if (!(f = fopen(filename, "w")))
- die("Could not open %s", filename);
+ die_errno("Could not open '%s'", filename);
if (obj->type == OBJ_BLOB) {
enum object_type type;
unsigned long size;
&type, &size);
if (buf) {
if (fwrite(buf, size, 1, f) != 1)
- die("Could not write %s: %s",
- filename, strerror(errno));
+ die_errno("Could not write '%s'",
+ filename);
free(buf);
}
} else
fprintf(f, "%s\n", sha1_to_hex(obj->sha1));
if (fclose(f))
- die("Could not finish %s: %s",
- filename, strerror(errno));
+ die_errno("Could not finish '%s'",
+ filename);
}
return;
}
diff --git a/builtin-grep.c b/builtin-grep.c
index 73fc922c4995369c0ca86c01200e2a0ea39161ab..e5583686a2daeb05def8358044f49f03ba3acbef 100644 (file)
--- a/builtin-grep.c
+++ b/builtin-grep.c
patterns = fopen(arg, "r");
if (!patterns)
- die("'%s': %s", arg, strerror(errno));
+ die_errno("cannot open '%s'", arg);
while (strbuf_getline(&sb, patterns, '\n') == 0) {
/* ignore empty line like grep does */
if (sb.len == 0)
diff --git a/builtin-init-db.c b/builtin-init-db.c
index d1fa12a59efb34256b2cc80b03c637cc844d84ff..4a5600631c5800d7f9d844118f37c0672b89b581 100644 (file)
--- a/builtin-init-db.c
+++ b/builtin-init-db.c
memcpy(template + template_baselen, de->d_name, namelen+1);
if (lstat(path, &st_git)) {
if (errno != ENOENT)
- die("cannot stat %s", path);
+ die_errno("cannot stat '%s'", path);
}
else
exists = 1;
if (lstat(template, &st_template))
- die("cannot stat template %s", template);
+ die_errno("cannot stat template '%s'", template);
if (S_ISDIR(st_template.st_mode)) {
DIR *subdir = opendir(template);
int baselen_sub = baselen + namelen;
int template_baselen_sub = template_baselen + namelen;
if (!subdir)
- die("cannot opendir %s", template);
+ die_errno("cannot opendir '%s'", template);
path[baselen_sub++] =
template[template_baselen_sub++] = '/';
path[baselen_sub] =
int len;
len = readlink(template, lnk, sizeof(lnk));
if (len < 0)
- die("cannot readlink %s", template);
+ die_errno("cannot readlink '%s'", template);
if (sizeof(lnk) <= len)
die("insanely long symlink %s", template);
lnk[len] = 0;
if (symlink(lnk, path))
- die("cannot symlink %s %s", lnk, path);
+ die_errno("cannot symlink '%s' '%s'", lnk, path);
}
else if (S_ISREG(st_template.st_mode)) {
if (copy_file(path, template, st_template.st_mode))
- die("cannot copy %s to %s", template, path);
+ die_errno("cannot copy '%s' to '%s'", template,
+ path);
}
else
error("ignoring template %s", template);
if (!strcmp(".", git_dir))
return 1;
if (!getcwd(cwd, sizeof(cwd)))
- die("cannot tell cwd");
+ die_errno("cannot tell cwd");
if (!strcmp(git_dir, cwd))
return 1;
/*
if (!git_work_tree_cfg) {
git_work_tree_cfg = xcalloc(PATH_MAX, 1);
if (!getcwd(git_work_tree_cfg, PATH_MAX))
- die ("Cannot access current working directory.");
+ die_errno ("Cannot access current working directory");
}
if (access(get_git_work_tree(), X_OK))
- die ("Cannot access work tree '%s'",
- get_git_work_tree());
+ die_errno ("Cannot access work tree '%s'",
+ get_git_work_tree());
}
set_git_dir(make_absolute_path(git_dir));
diff --git a/builtin-log.c b/builtin-log.c
index 44f9a27daec612db6d0f0e502c99d5e5ecaaf842..0c2fa0ae2dc3f23cd52d2e8d765805b07262a7d6 100644 (file)
--- a/builtin-log.c
+++ b/builtin-log.c
if (use_stdout)
die("standard output, or directory, which one?");
if (mkdir(output_directory, 0777) < 0 && errno != EEXIST)
- die("Could not create directory %s",
- output_directory);
+ die_errno("Could not create directory '%s'",
+ output_directory);
}
if (rev.pending.nr == 1) {
diff --git a/builtin-mailsplit.c b/builtin-mailsplit.c
index 71f3b3b8741e505fc652e6c74c75972f19211f71..ad5f6b593df45f01360f3daa8b37d024ee793e9e 100644 (file)
--- a/builtin-mailsplit.c
+++ b/builtin-mailsplit.c
fd = open(name, O_WRONLY | O_CREAT | O_EXCL, 0666);
if (fd < 0)
- die("cannot open output file %s", name);
+ die_errno("cannot open output file '%s'", name);
output = fdopen(fd, "w");
/* Copy it out, while searching for a line that begins with
int is_partial = len && buf[len-1] != '\n';
if (fwrite(buf, 1, len, output) != len)
- die("cannot write output");
+ die_errno("cannot write output");
len = read_line_with_nul(buf, sizeof(buf), mbox);
if (len == 0) {
status = 1;
break;
}
- die("cannot read mbox");
+ die_errno("cannot read mbox");
}
if (!is_partial && !is_bare && is_from_line(buf, len))
break; /* done with one message */
diff --git a/builtin-merge.c b/builtin-merge.c
index af9adab300de98026b23a58b1d8b40f9395ff11a..82b546689c500649285ea2c7825171f572c3758e 100644 (file)
--- a/builtin-merge.c
+++ b/builtin-merge.c
printf("Squash commit -- not updating HEAD\n");
fd = open(git_path("SQUASH_MSG"), O_WRONLY | O_CREAT, 0666);
if (fd < 0)
- die("Could not write to %s", git_path("SQUASH_MSG"));
+ die_errno("Could not write to '%s'", git_path("SQUASH_MSG"));
init_revisions(&rev, NULL);
rev.ignore_merges = 1;
NULL, NULL, rev.date_mode, 0);
}
if (write(fd, out.buf, out.len) < 0)
- die("Writing SQUASH_MSG: %s", strerror(errno));
+ die_errno("Writing SQUASH_MSG");
if (close(fd))
- die("Finishing SQUASH_MSG: %s", strerror(errno));
+ die_errno("Finishing SQUASH_MSG");
strbuf_release(&out);
}
fp = fopen(git_path("FETCH_HEAD"), "r");
if (!fp)
- die("could not open %s for reading: %s",
- git_path("FETCH_HEAD"), strerror(errno));
+ die_errno("could not open '%s' for reading",
+ git_path("FETCH_HEAD"));
strbuf_getline(&line, fp, '\n');
fclose(fp);
ptr = strstr(line.buf, "\tnot-for-merge\t");
fp = fopen(git_path("MERGE_MSG"), "a");
if (!fp)
- die("Could not open %s for writing", git_path("MERGE_MSG"));
+ die_errno("Could not open '%s' for writing",
+ git_path("MERGE_MSG"));
fprintf(fp, "\nConflicts:\n");
for (pos = 0; pos < active_nr; pos++) {
struct cache_entry *ce = active_cache[pos];
sha1_to_hex(j->item->object.sha1));
fd = open(git_path("MERGE_HEAD"), O_WRONLY | O_CREAT, 0666);
if (fd < 0)
- die("Could open %s for writing",
- git_path("MERGE_HEAD"));
+ die_errno("Could not open '%s' for writing",
+ git_path("MERGE_HEAD"));
if (write_in_full(fd, buf.buf, buf.len) != buf.len)
- die("Could not write to %s", git_path("MERGE_HEAD"));
+ die_errno("Could not write to '%s'", git_path("MERGE_HEAD"));
close(fd);
strbuf_addch(&merge_msg, '\n');
fd = open(git_path("MERGE_MSG"), O_WRONLY | O_CREAT, 0666);
if (fd < 0)
- die("Could open %s for writing", git_path("MERGE_MSG"));
+ die_errno("Could not open '%s' for writing",
+ git_path("MERGE_MSG"));
if (write_in_full(fd, merge_msg.buf, merge_msg.len) !=
merge_msg.len)
- die("Could not write to %s", git_path("MERGE_MSG"));
+ die_errno("Could not write to '%s'", git_path("MERGE_MSG"));
close(fd);
fd = open(git_path("MERGE_MODE"), O_WRONLY | O_CREAT | O_TRUNC, 0666);
if (fd < 0)
- die("Could open %s for writing", git_path("MERGE_MODE"));
+ die_errno("Could not open '%s' for writing",
+ git_path("MERGE_MODE"));
strbuf_reset(&buf);
if (!allow_fast_forward)
strbuf_addf(&buf, "no-ff");
if (write_in_full(fd, buf.buf, buf.len) != buf.len)
- die("Could not write to %s", git_path("MERGE_MODE"));
+ die_errno("Could not write to '%s'", git_path("MERGE_MODE"));
close(fd);
}
diff --git a/builtin-mv.c b/builtin-mv.c
index 68f47384dc1cc6404d4db73b6dbea8bceab38df9..b592c367b2cc016a50db6d49948e9efbbf0e8f2f 100644 (file)
--- a/builtin-mv.c
+++ b/builtin-mv.c
printf("Renaming %s to %s\n", src, dst);
if (!show_only && mode != INDEX &&
rename(src, dst) < 0 && !ignore_errors)
- die ("renaming %s failed: %s", src, strerror(errno));
+ die_errno ("renaming '%s' failed", src);
if (mode == WORKING_DIRECTORY)
continue;
diff --git a/builtin-pack-objects.c b/builtin-pack-objects.c
index 941cc2d73cf5ee6791a0cee8c409dcdb9756b448..a27c2f6277cd55951cec5d9b5b207df426ed9ff0 100644 (file)
--- a/builtin-pack-objects.c
+++ b/builtin-pack-objects.c
base_name, sha1_to_hex(sha1));
free_pack_by_name(tmpname);
if (adjust_perm(pack_tmp_name, mode))
- die("unable to make temporary pack file readable: %s",
- strerror(errno));
+ die_errno("unable to make temporary pack file readable");
if (rename(pack_tmp_name, tmpname))
- die("unable to rename temporary pack file: %s",
- strerror(errno));
+ die_errno("unable to rename temporary pack file");
/*
* Packs are runtime accessed in their mtime
snprintf(tmpname, sizeof(tmpname), "%s-%s.idx",
base_name, sha1_to_hex(sha1));
if (adjust_perm(idx_tmp_name, mode))
- die("unable to make temporary index file readable: %s",
- strerror(errno));
+ die_errno("unable to make temporary index file readable");
if (rename(idx_tmp_name, tmpname))
- die("unable to rename temporary index file: %s",
- strerror(errno));
+ die_errno("unable to rename temporary index file");
free(idx_tmp_name);
free(pack_tmp_name);
if (!ferror(stdin))
die("fgets returned NULL, not EOF, not error!");
if (errno != EINTR)
- die("fgets: %s", strerror(errno));
+ die_errno("fgets");
clearerr(stdin);
continue;
}
diff --git a/builtin-rev-parse.c b/builtin-rev-parse.c
index 112d622cda6f74f9752627d9adf3a1cdb04851c3..45bead65451e87a4b564e59fed3518a4de9198e9 100644 (file)
--- a/builtin-rev-parse.c
+++ b/builtin-rev-parse.c
static int cmd_parseopt(int argc, const char **argv, const char *prefix)
{
- static int keep_dashdash = 0;
+ static int keep_dashdash = 0, stop_at_non_option = 0;
static char const * const parseopt_usage[] = {
"git rev-parse --parseopt [options] -- [<args>...]",
NULL
static struct option parseopt_opts[] = {
OPT_BOOLEAN(0, "keep-dashdash", &keep_dashdash,
"keep the `--` passed as an arg"),
+ OPT_BOOLEAN(0, "stop-at-non-option", &stop_at_non_option,
+ "stop parsing after the "
+ "first non-option argument"),
OPT_END(),
};
ALLOC_GROW(opts, onb + 1, osz);
memset(opts + onb, 0, sizeof(opts[onb]));
argc = parse_options(argc, argv, prefix, opts, usage,
- keep_dashdash ? PARSE_OPT_KEEP_DASHDASH : 0);
+ keep_dashdash ? PARSE_OPT_KEEP_DASHDASH : 0 |
+ stop_at_non_option ? PARSE_OPT_STOP_AT_NON_OPTION : 0);
strbuf_addf(&parsed, " --");
sq_quote_argv(&parsed, argv, 0);
continue;
}
if (!getcwd(cwd, PATH_MAX))
- die("unable to get current working directory");
+ die_errno("unable to get current working directory");
printf("%s/.git\n", cwd);
continue;
}
diff --git a/builtin-revert.c b/builtin-revert.c
index c87115af30abd9515599586af860ccd07b96b264..151aa6a981832954120359f7c953015525b530d8 100644 (file)
--- a/builtin-revert.c
+++ b/builtin-revert.c
{
int len = strlen(string);
if (write_in_full(msg_fd, string, len) < 0)
- die ("Could not write to MERGE_MSG");
+ die_errno ("Could not write to MERGE_MSG");
}
static void add_message_to_msg(const char *message)
diff --git a/builtin-rm.c b/builtin-rm.c
index 0cc491271846214d73d55a4f528c8854e0460c8f..57975dbcfd7c0dbcba03b88a1bf403f1ec5f528c 100644 (file)
--- a/builtin-rm.c
+++ b/builtin-rm.c
continue;
}
if (!removed)
- die("git rm: %s: %s", path, strerror(errno));
+ die_errno("git rm: '%s'", path);
}
}
diff --git a/builtin-send-pack.c b/builtin-send-pack.c
index c375a3dbde0a75af592c8881965f255f66b599d1..47fb9f7baa9ad9c070e1a6d9c245300ba2402ce5 100644 (file)
--- a/builtin-send-pack.c
+++ b/builtin-send-pack.c
po.out = fd;
po.git_cmd = 1;
if (start_command(&po))
- die("git pack-objects failed (%s)", strerror(errno));
+ die_errno("git pack-objects failed");
/*
* We feed the pack-objects we just spawned with revision
diff --git a/builtin-show-ref.c b/builtin-show-ref.c
index dc76c5090f2367426201b37c5b13c2a5cbf00de2..c46550c9c01da8fe74145e16656a5163a7e4f07b 100644 (file)
--- a/builtin-show-ref.c
+++ b/builtin-show-ref.c
#include "object.h"
#include "tag.h"
#include "string-list.h"
+#include "parse-options.h"
-static const char show_ref_usage[] = "git show-ref [-q|--quiet] [--verify] [-h|--head] [-d|--dereference] [-s|--hash[=<length>]] [--abbrev[=<length>]] [--tags] [--heads] [--] [pattern*] < ref-list";
+static const char * const show_ref_usage[] = {
+ "git show-ref [-q|--quiet] [--verify] [-h|--head] [-d|--dereference] [-s|--hash[=<n>]] [--abbrev[=<n>]] [--tags] [--heads] [--] [pattern*] ",
+ "git show-ref --exclude-existing[=pattern] < ref-list",
+ NULL
+};
-static int deref_tags = 0, show_head = 0, tags_only = 0, heads_only = 0,
- found_match = 0, verify = 0, quiet = 0, hash_only = 0, abbrev = 0;
+static int deref_tags, show_head, tags_only, heads_only, found_match, verify,
+ quiet, hash_only, abbrev, exclude_arg;
static const char **pattern;
+static const char *exclude_existing_arg;
static void show_one(const char *refname, const unsigned char *sha1)
{
return 0;
}
+static int hash_callback(const struct option *opt, const char *arg, int unset)
+{
+ hash_only = 1;
+ /* Use full length SHA1 if no argument */
+ if (!arg)
+ return 0;
+ return parse_opt_abbrev_cb(opt, arg, unset);
+}
+
+static int exclude_existing_callback(const struct option *opt, const char *arg,
+ int unset)
+{
+ exclude_arg = 1;
+ *(const char **)opt->value = arg;
+ return 0;
+}
+
+static int help_callback(const struct option *opt, const char *arg, int unset)
+{
+ return -1;
+}
+
+static const struct option show_ref_options[] = {
+ OPT_BOOLEAN(0, "tags", &tags_only, "only show tags (can be combined with heads)"),
+ OPT_BOOLEAN(0, "heads", &heads_only, "only show heads (can be combined with tags)"),
+ OPT_BOOLEAN(0, "verify", &verify, "stricter reference checking, "
+ "requires exact ref path"),
+ OPT_BOOLEAN('h', "head", &show_head, "show the HEAD reference"),
+ OPT_BOOLEAN('d', "dereference", &deref_tags,
+ "dereference tags into object IDs"),
+ { OPTION_CALLBACK, 's', "hash", &abbrev, "n",
+ "only show SHA1 hash using <n> digits",
+ PARSE_OPT_OPTARG, &hash_callback },
+ OPT__ABBREV(&abbrev),
+ OPT__QUIET(&quiet),
+ { OPTION_CALLBACK, 0, "exclude-existing", &exclude_existing_arg,
+ "pattern", "show refs from stdin that aren't in local repository",
+ PARSE_OPT_OPTARG | PARSE_OPT_NONEG, exclude_existing_callback },
+ { OPTION_CALLBACK, 0, "help-all", NULL, NULL, "show usage",
+ PARSE_OPT_HIDDEN | PARSE_OPT_NOARG, help_callback },
+ OPT_END()
+};
+
int cmd_show_ref(int argc, const char **argv, const char *prefix)
{
- int i;
+ argc = parse_options(argc, argv, prefix, show_ref_options,
+ show_ref_usage, PARSE_OPT_NO_INTERNAL_HELP);
- for (i = 1; i < argc; i++) {
- const char *arg = argv[i];
- if (*arg != '-') {
- pattern = argv + i;
- break;
- }
- if (!strcmp(arg, "--")) {
- pattern = argv + i + 1;
- if (!*pattern)
- pattern = NULL;
- break;
- }
- if (!strcmp(arg, "-q") || !strcmp(arg, "--quiet")) {
- quiet = 1;
- continue;
- }
- if (!strcmp(arg, "-h") || !strcmp(arg, "--head")) {
- show_head = 1;
- continue;
- }
- if (!strcmp(arg, "-d") || !strcmp(arg, "--dereference")) {
- deref_tags = 1;
- continue;
- }
- if (!strcmp(arg, "-s") || !strcmp(arg, "--hash")) {
- hash_only = 1;
- continue;
- }
- if (!prefixcmp(arg, "--hash=") ||
- (!prefixcmp(arg, "--abbrev") &&
- (arg[8] == '=' || arg[8] == '\0'))) {
- if (arg[2] != 'h' && !arg[8])
- /* --abbrev only */
- abbrev = DEFAULT_ABBREV;
- else {
- /* --hash= or --abbrev= */
- char *end;
- if (arg[2] == 'h') {
- hash_only = 1;
- arg += 7;
- }
- else
- arg += 9;
- abbrev = strtoul(arg, &end, 10);
- if (*end || abbrev > 40)
- usage(show_ref_usage);
- if (abbrev < MINIMUM_ABBREV)
- abbrev = MINIMUM_ABBREV;
- }
- continue;
- }
- if (!strcmp(arg, "--verify")) {
- verify = 1;
- continue;
- }
- if (!strcmp(arg, "--tags")) {
- tags_only = 1;
- continue;
- }
- if (!strcmp(arg, "--heads")) {
- heads_only = 1;
- continue;
- }
- if (!strcmp(arg, "--exclude-existing"))
- return exclude_existing(NULL);
- if (!prefixcmp(arg, "--exclude-existing="))
- return exclude_existing(arg + 19);
- usage(show_ref_usage);
- }
+ if (exclude_arg)
+ return exclude_existing(exclude_existing_arg);
+
+ pattern = argv;
+ if (!*pattern)
+ pattern = NULL;
if (verify) {
if (!pattern)
diff --git a/builtin-stripspace.c b/builtin-stripspace.c
index d6e3896c006796ccca12c00de45e36583387f05b..1fd2205d530ad510a18ff5a441ca7b5cb1cc34a6 100644 (file)
--- a/builtin-stripspace.c
+++ b/builtin-stripspace.c
strip_comments = 1;
if (strbuf_read(&buf, 0, 1024) < 0)
- die("could not read the input");
+ die_errno("could not read the input");
stripspace(&buf, strip_comments);
diff --git a/builtin-tag.c b/builtin-tag.c
index 080e04a8fc6fc1fc3f10f59a4c1f1aa067b81aa1..a51a6d1ea21412f151238e48984bc13110fcbc6c 100644 (file)
--- a/builtin-tag.c
+++ b/builtin-tag.c
path = git_pathdup("TAG_EDITMSG");
fd = open(path, O_CREAT | O_TRUNC | O_WRONLY, 0600);
if (fd < 0)
- die("could not create file '%s': %s",
- path, strerror(errno));
+ die_errno("could not create file '%s'", path);
if (!is_null_sha1(prev))
write_tag_body(fd, prev);
else {
if (!strcmp(msgfile, "-")) {
if (strbuf_read(&buf, 0, 1024) < 0)
- die("cannot read %s", msgfile);
+ die_errno("cannot read '%s'", msgfile);
} else {
if (strbuf_read_file(&buf, msgfile, 1024) < 0)
- die("could not open or read '%s': %s",
- msgfile, strerror(errno));
+ die_errno("could not open or read '%s'",
+ msgfile);
}
}
}
diff --git a/builtin-tar-tree.c b/builtin-tar-tree.c
index f88e7219367c309dbc3d3e7ce2db32666703a91d..8b3a35e12da2cca8b632d4139bc2c5ba2409d322 100644 (file)
--- a/builtin-tar-tree.c
+++ b/builtin-tar-tree.c
n = write_in_full(1, content + 11, 41);
if (n < 41)
- die("git get-tar-commit-id: write error");
+ die_errno("git get-tar-commit-id: write error");
return 0;
}
index 7e3ea73006ecdc74c03580ac7297be4ebee174b3..557148a693c058f51222cb3d996c309791d43d8b 100644 (file)
--- a/builtin-unpack-objects.c
+++ b/builtin-unpack-objects.c
if (ret <= 0) {
if (!ret)
die("early EOF");
- die("read error on input: %s", strerror(errno));
+ die_errno("read error on input");
}
len += ret;
} while (len < min);
diff --git a/combine-diff.c b/combine-diff.c
index 60d03676bbd0dba7be79c7098d7cae553962ca98..bbf74fc42e4e72eb3df99272fb75a03bbeaf726a 100644 (file)
--- a/combine-diff.c
+++ b/combine-diff.c
done = read_in_full(fd, result, len);
if (done < 0)
- die("read error '%s'", elem->path);
+ die_errno("read error '%s'", elem->path);
else if (done < len)
die("early EOF '%s'", elem->path);
diff --git a/commit.c b/commit.c
index aa3b35b6a86891ac9d0628e20a6a46d506bf7700..a47fb4da271beaf5595b6bbbe41f94bad08f404d 100644 (file)
--- a/commit.c
+++ b/commit.c
static unsigned long parse_commit_date(const char *buf, const char *tail)
{
- unsigned long date;
const char *dateptr;
if (buf + 6 >= tail)
if (buf >= tail)
return 0;
/* dateptr < buf && buf[-1] == '\n', so strtoul will stop at buf-1 */
- date = strtoul(dateptr, NULL, 10);
- if (date == ULONG_MAX)
- date = 0;
- return date;
+ return strtoul(dateptr, NULL, 10);
}
static struct commit_graft **commit_graft;
index ddb71e26fe8e465dbfa60fa948a01d5ff5c0818b..9c488646d04f9fa08d9b2f2445b2a83d9bc4de40 100755 (executable)
$__git_log_shortlog_options
$__git_log_gitk_options
--root --topo-order --date-order --reverse
- --follow
+ --follow --full-diff
--abbrev-commit --abbrev=
--relative-date --date=
--pretty= --format= --oneline
c=$((--c))
done
- for i in $(git --git-dir="$(__gitdir)" config $config_file --list \
- 2>/dev/null); do
- case "$i" in
- *.*)
- echo "${i/=*/}"
+ git --git-dir="$(__gitdir)" config $config_file --list 2>/dev/null |
+ while read line
+ do
+ case "$line" in
+ *.*=*)
+ echo "${line/=*/}"
;;
esac
done
diff --git a/csum-file.c b/csum-file.c
index 2ddb12a0b70da87afe6fa8a33dce08c6c8ae7f71..4d50cc5ce18c24a1dc853d3050062b864fe0b943 100644 (file)
--- a/csum-file.c
+++ b/csum-file.c
}
if (!ret)
die("sha1 file '%s' write error. Out of diskspace", f->name);
- die("sha1 file '%s' write error (%s)", f->name, strerror(errno));
+ die_errno("sha1 file '%s' write error", f->name);
}
}
if (flags & CSUM_FSYNC)
fsync_or_die(f->fd, f->name);
if (close(f->fd))
- die("%s: sha1 file error on close (%s)",
- f->name, strerror(errno));
+ die_errno("%s: sha1 file error on close", f->name);
fd = 0;
} else
fd = f->fd;
diff --git a/daemon.c b/daemon.c
index 76a400557d0e8c615d6cceae511e3c7684131f04..1b5ada6648da66d14dec6c399898916920582852 100644 (file)
--- a/daemon.c
+++ b/daemon.c
case ECONNABORTED:
continue;
default:
- die("accept returned %s", strerror(errno));
+ die_errno("accept returned");
}
}
handle(incoming, (struct sockaddr *)&ss, sslen);
while (fd != -1 && fd < 2)
fd = dup(fd);
if (fd == -1)
- die("open /dev/null or dup failed: %s", strerror(errno));
+ die_errno("open /dev/null or dup failed");
if (fd > 2)
close(fd);
}
case 0:
break;
case -1:
- die("fork failed: %s", strerror(errno));
+ die_errno("fork failed");
default:
exit(0);
}
if (setsid() == -1)
- die("setsid failed: %s", strerror(errno));
+ die_errno("setsid failed");
close(0);
close(1);
close(2);
{
FILE *f = fopen(path, "w");
if (!f)
- die("cannot open pid file %s: %s", path, strerror(errno));
+ die_errno("cannot open pid file '%s'", path);
if (fprintf(f, "%"PRIuMAX"\n", (uintmax_t) getpid()) < 0 || fclose(f) != 0)
- die("failed to write pid file %s: %s", path, strerror(errno));
+ die_errno("failed to write pid file '%s'", path);
}
static int serve(char *listen_addr, int listen_port, struct passwd *pass, gid_t gid)
socklen_t slen = sizeof(ss);
if (!freopen("/dev/null", "w", stderr))
- die("failed to redirect stderr to /dev/null: %s",
- strerror(errno));
+ die_errno("failed to redirect stderr to /dev/null");
if (getpeername(0, peer, &slen))
peer = NULL;
index 43835d756c2c2c7ec579e1c38804fe33a706944f..0a020ffab4dcfbd88fbee31bb3c84e336a67b17c 100644 (file)
--- a/diff.c
+++ b/diff.c
fd = git_mkstemps(temp->tmp_path, PATH_MAX, template.buf,
strlen(base) + 1);
if (fd < 0)
- die("unable to create temp-file: %s", strerror(errno));
+ die_errno("unable to create temp-file");
if (convert_to_working_tree(path,
(const char *)blob, (size_t)size, &buf)) {
blob = buf.buf;
size = buf.len;
}
if (write_in_full(fd, blob, size) != size)
- die("unable to write temp-file");
+ die_errno("unable to write temp-file");
close(fd);
temp->name = temp->tmp_path;
strcpy(temp->hex, sha1_to_hex(sha1));
if (lstat(name, &st) < 0) {
if (errno == ENOENT)
goto not_a_valid_file;
- die("stat(%s): %s", name, strerror(errno));
+ die_errno("stat(%s)", name);
}
if (S_ISLNK(st.st_mode)) {
struct strbuf sb = STRBUF_INIT;
if (strbuf_readlink(&sb, name, st.st_size) < 0)
- die("readlink(%s)", name);
+ die_errno("readlink(%s)", name);
prep_temp_blob(name, temp, sb.buf, sb.len,
(one->sha1_valid ?
one->sha1 : null_sha1),
return;
}
if (lstat(one->path, &st) < 0)
- die("stat %s", one->path);
+ die_errno("stat '%s'", one->path);
if (index_path(one->sha1, one->path, &st, 0))
die("cannot hash %s", one->path);
}
index bbfcb566e63310d38848b0b76076fb051a7446c8..74b3bbf6fd557943e0e7b9027556312203e58d7a 100644 (file)
--- a/dir.c
+++ b/dir.c
if (!dir)
return NULL;
if (!getcwd(buffer, size))
- die("can't find the current directory: %s", strerror(errno));
+ die_errno("can't find the current directory");
if (!is_absolute_path(dir))
dir = make_absolute_path(dir);
index cc841edf9051460b3a382ea25c0097f245ec8884..d3e86c722a6663a65f69b73621f57aa6331a5e5b 100644 (file)
--- a/entry.c
+++ b/entry.c
if (errno == EEXIST && state->force &&
!unlink_or_warn(buf) && !mkdir(buf, 0777))
continue;
- die("cannot create directory at %s", buf);
+ die_errno("cannot create directory at '%s'", buf);
}
}
free(buf);
char *name;
if (!dir)
- die("cannot opendir %s (%s)", path, strerror(errno));
+ die_errno("cannot opendir '%s'", path);
strcpy(pathbuf, path);
name = pathbuf + strlen(path);
*name++ = '/';
continue;
strcpy(name, de->d_name);
if (lstat(pathbuf, &st))
- die("cannot lstat %s (%s)", pathbuf, strerror(errno));
+ die_errno("cannot lstat '%s'", pathbuf);
if (S_ISDIR(st.st_mode))
remove_subtree(pathbuf);
else if (unlink(pathbuf))
- die("cannot unlink %s (%s)", pathbuf, strerror(errno));
+ die_errno("cannot unlink '%s'", pathbuf);
}
closedir(dir);
if (rmdir(path))
- die("cannot rmdir %s (%s)", path, strerror(errno));
+ die_errno("cannot rmdir '%s'", path);
}
static int create_file(const char *path, unsigned int mode)
diff --git a/fast-import.c b/fast-import.c
index a2a24588a99957d5af759ca6d8858366430ab3a3..7ef9865aa6da794ab52cfc50f21f9f41f861fc4f 100644 (file)
--- a/fast-import.c
+++ b/fast-import.c
keep_fd = odb_pack_keep(name, sizeof(name), pack_data->sha1);
if (keep_fd < 0)
- die("cannot create keep file");
+ die_errno("cannot create keep file");
write_or_die(keep_fd, keep_msg, strlen(keep_msg));
if (close(keep_fd))
- die("failed to write keep file");
+ die_errno("failed to write keep file");
snprintf(name, sizeof(name), "%s/pack/pack-%s.pack",
get_object_directory(), sha1_to_hex(pack_data->sha1));
char line[512];
FILE *f = fopen(input_file, "r");
if (!f)
- die("cannot read %s: %s", input_file, strerror(errno));
+ die_errno("cannot read '%s'", input_file);
while (fgets(line, sizeof(line), f)) {
uintmax_t mark;
char *end;
fclose(pack_edges);
pack_edges = fopen(a + 20, "a");
if (!pack_edges)
- die("Cannot open %s: %s", a + 20, strerror(errno));
+ die_errno("Cannot open '%s'", a + 20);
} else if (!strcmp(a, "--force"))
force_update = 1;
else if (!strcmp(a, "--quiet"))
index 511b82cba9977c14d6dcba5efbd6d38591d3aacc..89278c1459d36a3e2b718661ca71483522f587fd 100644 (file)
--- a/fsck.c
+++ b/fsck.c
struct commit_graft *graft;
int parents = 0;
- if (!commit->date)
+ if (commit->date == ULONG_MAX)
return error_func(&commit->object, FSCK_ERROR, "invalid author/committer line");
if (memcmp(buffer, "tree ", 5))
diff --git a/git-am.sh b/git-am.sh
index 58d4eb6d2dc2eaa99ae0c70a414813cd0ce43e43..d64d9975358a6b9a18596c45b13434463903a344 100755 (executable)
--- a/git-am.sh
+++ b/git-am.sh
directory= pass it through git-apply
C= pass it through git-apply
p= pass it through git-apply
+patch-format= format the patch(es) are in
reject pass it through git-apply
resolvemsg= override error message when patch failure occurs
r,resolved to be used after a patch failure
unset GITHEAD_$his_tree
}
+clean_abort () {
+ test $# = 0 || echo >&2 "$@"
+ rm -fr "$dotest"
+ exit 1
+}
+
+patch_format=
+
+check_patch_format () {
+ # early return if patch_format was set from the command line
+ if test -n "$patch_format"
+ then
+ return 0
+ fi
+
+ # we default to mbox format if input is from stdin and for
+ # directories
+ if test $# = 0 || test "x$1" = "x-" || test -d "$1"
+ then
+ patch_format=mbox
+ return 0
+ fi
+
+ # otherwise, check the first few lines of the first patch to try
+ # to detect its format
+ {
+ read l1
+ read l2
+ read l3
+ case "$l1" in
+ "From "* | "From: "*)
+ patch_format=mbox
+ ;;
+ '# This series applies on GIT commit'*)
+ patch_format=stgit-series
+ ;;
+ "# HG changeset patch")
+ patch_format=hg
+ ;;
+ *)
+ # if the second line is empty and the third is
+ # a From, Author or Date entry, this is very
+ # likely an StGIT patch
+ case "$l2,$l3" in
+ ,"From: "* | ,"Author: "* | ,"Date: "*)
+ patch_format=stgit
+ ;;
+ *)
+ ;;
+ esac
+ ;;
+ esac
+ } < "$1" || clean_abort
+}
+
+split_patches () {
+ case "$patch_format" in
+ mbox)
+ git mailsplit -d"$prec" -o"$dotest" -b -- "$@" > "$dotest/last" ||
+ clean_abort
+ ;;
+ stgit-series)
+ if test $# -ne 1
+ then
+ clean_abort "Only one StGIT patch series can be applied at once"
+ fi
+ series_dir=`dirname "$1"`
+ series_file="$1"
+ shift
+ {
+ set x
+ while read filename
+ do
+ set "$@" "$series_dir/$filename"
+ done
+ # remove the safety x
+ shift
+ # remove the arg coming from the first-line comment
+ shift
+ } < "$series_file" || clean_abort
+ # set the patch format appropriately
+ patch_format=stgit
+ # now handle the actual StGIT patches
+ split_patches "$@"
+ ;;
+ stgit)
+ this=0
+ for stgit in "$@"
+ do
+ this=`expr "$this" + 1`
+ msgnum=`printf "%0${prec}d" $this`
+ # Perl version of StGIT parse_patch. The first nonemptyline
+ # not starting with Author, From or Date is the
+ # subject, and the body starts with the next nonempty
+ # line not starting with Author, From or Date
+ perl -ne 'BEGIN { $subject = 0 }
+ if ($subject > 1) { print ; }
+ elsif (/^\s+$/) { next ; }
+ elsif (/^Author:/) { print s/Author/From/ ; }
+ elsif (/^(From|Date)/) { print ; }
+ elsif ($subject) {
+ $subject = 2 ;
+ print "\n" ;
+ print ;
+ } else {
+ print "Subject: ", $_ ;
+ $subject = 1;
+ }
+ ' < "$stgit" > "$dotest/$msgnum" || clean_abort
+ done
+ echo "$this" > "$dotest/last"
+ this=
+ msgnum=
+ ;;
+ *)
+ clean_abort "Patch format $patch_format is not supported."
+ ;;
+ esac
+}
+
prec=4
dotest="$GIT_DIR/rebase-apply"
sign= utf8=t keep= skip= interactive= resolved= rebasing= abort=
git_apply_opt="$git_apply_opt $(sq "$1=$2")"; shift ;;
-C|-p)
git_apply_opt="$git_apply_opt $(sq "$1$2")"; shift ;;
+ --patch-format)
+ shift ; patch_format="$1" ;;
--reject)
git_apply_opt="$git_apply_opt $1" ;;
--committer-date-is-author-date)
done
shift
fi
- git mailsplit -d"$prec" -o"$dotest" -b -- "$@" > "$dotest/last" || {
- rm -fr "$dotest"
- exit 1
- }
+
+ check_patch_format "$@"
+
+ split_patches "$@"
# -s, -u, -k, --whitespace, -3, -C, -q and -p flags are kept
# for the resuming session after a patch failure.
diff --git a/git-compat-util.h b/git-compat-util.h
index 919b7f1ade9cab3c4ba907f9506e3cb518fb9e7f..9609eaa77f1dad589700bda222e0a81ad4f4d1ee 100644 (file)
--- a/git-compat-util.h
+++ b/git-compat-util.h
/* General helper functions */
extern void usage(const char *err) NORETURN;
extern void die(const char *err, ...) NORETURN __attribute__((format (printf, 1, 2)));
+extern void die_errno(const char *err, ...) NORETURN __attribute__((format (printf, 1, 2)));
extern int error(const char *err, ...) __attribute__((format (printf, 1, 2)));
extern void warning(const char *err, ...) __attribute__((format (printf, 1, 2)));
index a36df3392652b8a854ca48bdf71977dcf12b244b..59b672213bfc36f95db089f0e13bafc1c2f2ed71 100755 (executable)
--- a/git-cvsexportcommit.perl
+++ b/git-cvsexportcommit.perl
if $file =~ /^no file /
&& $status eq 'Up-to-date';
- $cvsstat{$fullname{$file}} = $status;
+ $cvsstat{$fullname{$file}} = $status
+ if defined $fullname{$file};
}
}
}
while (<FILTER_IN>)
{
my $line = $_;
- $line =~ s/\$([A-Z][a-z]+):[^\$]+\$/\$\1\$/g;
+ $line =~ s/\$([A-Z][a-z]+):[^\$]+\$/\$$1\$/g;
print FILTER_OUT $line;
}
close FILTER_IN;
index 65ed733fda86364b88a961093d5021c6d09934a6..807d875ae06ce7bbf61bb846c5b4cb5a51855eba 100644 (file)
--- a/git.c
+++ b/git.c
}
if (subdir && chdir(subdir))
- die("Cannot change to %s: %s", subdir, strerror(errno));
+ die_errno("Cannot change to '%s'", subdir);
errno = saved_errno;
/* Check for ENOSPC and EIO errors.. */
if (fflush(stdout))
- die("write failure on standard output: %s", strerror(errno));
+ die_errno("write failure on standard output");
if (ferror(stdout))
die("unknown write failure on standard output");
if (fclose(stdout))
- die("close failed on standard output: %s", strerror(errno));
+ die_errno("close failed on standard output");
return 0;
}
diff --git a/hash-object.c b/hash-object.c
index 47cf43c3cdd2bcd7638360a130fc8ef04ce132e9..9455dd0709aeb81436ef2e3e36422578d66ce8e7 100644 (file)
--- a/hash-object.c
+++ b/hash-object.c
int fd;
fd = open(path, O_RDONLY);
if (fd < 0)
- die("Cannot open %s", path);
+ die_errno("Cannot open '%s'", path);
hash_fd(fd, type, write_object, vpath);
}
diff --git a/http-push.c b/http-push.c
index 8cc8ee0dfd5c047b2523f63346bf9b30094c1386..00e83dcec1d973b069d4c75105aed96634b00994 100644 (file)
--- a/http-push.c
+++ b/http-push.c
case '&':
strbuf_addstr(&buf, "&");
break;
+ case 0:
+ return strbuf_detach(&buf, NULL);
}
s++;
}
diff --git a/index-pack.c b/index-pack.c
index c72cbd406a7880361f262f43daff62a9f453628d..340074fc793e8e7534bb168784a7051af6d81b34 100644 (file)
--- a/index-pack.c
+++ b/index-pack.c
if (ret <= 0) {
if (!ret)
die("early EOF");
- die("read error on input: %s", strerror(errno));
+ die_errno("read error on input");
}
input_len += ret;
if (from_stdin)
} else
output_fd = open(pack_name, O_CREAT|O_EXCL|O_RDWR, 0600);
if (output_fd < 0)
- die("unable to create %s: %s", pack_name, strerror(errno));
+ die_errno("unable to create '%s'", pack_name);
pack_fd = output_fd;
} else {
input_fd = open(pack_name, O_RDONLY);
if (input_fd < 0)
- die("cannot open packfile '%s': %s",
- pack_name, strerror(errno));
+ die_errno("cannot open packfile '%s'", pack_name);
output_fd = -1;
pack_fd = input_fd;
}
do {
ssize_t n = pread(pack_fd, data + rdy, len - rdy, from + rdy);
if (n < 0)
- die("cannot pread pack file: %s", strerror(errno));
+ die_errno("cannot pread pack file");
if (!n)
die("premature end of pack file, %lu bytes missing",
len - rdy);
/* If input_fd is a file, we should have reached its end now. */
if (fstat(input_fd, &st))
- die("cannot fstat packfile: %s", strerror(errno));
+ die_errno("cannot fstat packfile");
if (S_ISREG(st.st_mode) &&
lseek(input_fd, 0, SEEK_CUR) - input_len != st.st_size)
die("pack has junk at the end");
fsync_or_die(output_fd, curr_pack_name);
err = close(output_fd);
if (err)
- die("error while closing pack file: %s", strerror(errno));
+ die_errno("error while closing pack file");
}
if (keep_msg) {
if (keep_fd < 0) {
if (errno != EEXIST)
- die("cannot write keep file '%s' (%s)",
- keep_name, strerror(errno));
+ die_errno("cannot write keep file '%s'",
+ keep_name);
} else {
if (keep_msg_len > 0) {
write_or_die(keep_fd, keep_msg, keep_msg_len);
write_or_die(keep_fd, "\n", 1);
}
if (close(keep_fd) != 0)
- die("cannot close written keep file '%s' (%s)",
- keep_name, strerror(errno));
+ die_errno("cannot close written keep file '%s'",
+ keep_name);
report = "keep";
}
}
diff --git a/ll-merge.c b/ll-merge.c
index a2c13c4c087f7b4961f0507783d34d19ff4b2921..0571564ddfb336247c8268fbdecd8674d8bacd3e 100644 (file)
--- a/ll-merge.c
+++ b/ll-merge.c
strcpy(path, ".merge_file_XXXXXX");
fd = xmkstemp(path);
if (write_in_full(fd, src->ptr, src->size) != src->size)
- die("unable to write temp-file");
+ die_errno("unable to write temp-file");
close(fd);
}
diff --git a/merge-recursive.c b/merge-recursive.c
index 53cad9605bf1bb599b9c0ceb14788afa719dd5ac..d415c4188d181fbdc765fff90fbbc4897ced53ad 100644 (file)
--- a/merge-recursive.c
+++ b/merge-recursive.c
/* Ignore epipe */
if (errno == EPIPE)
break;
- die("merge-recursive: %s", strerror(errno));
+ die_errno("merge-recursive");
} else if (!ret) {
die("merge-recursive: disk full?");
}
mode = 0666;
fd = open(path, O_WRONLY | O_TRUNC | O_CREAT, mode);
if (fd < 0)
- die("failed to open %s: %s", path, strerror(errno));
+ die_errno("failed to open '%s'", path);
flush_buffer(fd, buf, size);
close(fd);
} else if (S_ISLNK(mode)) {
safe_create_leading_directories_const(path);
unlink(path);
if (symlink(lnk, path))
- die("failed to symlink %s: %s", path, strerror(errno));
+ die_errno("failed to symlink '%s'", path);
free(lnk);
} else
die("do not know what to do with %06o %s '%s'",
index 99a356e9ee75cb247d80ed6dc0b251ceb0bd9e46..a609e3ebd106ed985fa2065dc4af6565e5a379a6 100644 (file)
--- a/mktag.c
+++ b/mktag.c
setup_git_directory();
if (strbuf_read(&buf, 0, 4096) < 0) {
- die("could not read from stdin");
+ die_errno("could not read from stdin");
}
/* Verify it for some basic sanity: it needs to start with
diff --git a/pack-refs.c b/pack-refs.c
index 301fc60eae1ad53721851a272a0fbd0192881801..7f43f8ac3398fb2dbe393f08811989b0a8d4e2dd 100644 (file)
--- a/pack-refs.c
+++ b/pack-refs.c
LOCK_DIE_ON_ERROR);
cbdata.refs_file = fdopen(fd, "w");
if (!cbdata.refs_file)
- die("unable to create ref-pack file structure (%s)",
- strerror(errno));
+ die_errno("unable to create ref-pack file structure");
/* perhaps other traits later as well */
fprintf(cbdata.refs_file, "# pack-refs with: peeled \n");
if (ferror(cbdata.refs_file))
die("failed to write ref-pack file");
if (fflush(cbdata.refs_file) || fsync(fd) || fclose(cbdata.refs_file))
- die("failed to write ref-pack file (%s)", strerror(errno));
+ die_errno("failed to write ref-pack file");
/*
* Since the lock file was fdopen()'ed and then fclose()'ed above,
* assign -1 to the lock file descriptor so that commit_lock_file()
*/
packed.fd = -1;
if (commit_lock_file(&packed) < 0)
- die("unable to overwrite old ref-pack file (%s)", strerror(errno));
+ die_errno("unable to overwrite old ref-pack file");
if (cbdata.flags & PACK_REFS_PRUNE)
prune_refs(cbdata.ref_to_prune);
return 0;
diff --git a/pack-write.c b/pack-write.c
index 7053538f4cf44e15a788ab46dfb680ee85ce4fc2..741efcd93bd2a2c105bfe2d771d32857ce2ae816 100644 (file)
--- a/pack-write.c
+++ b/pack-write.c
fd = open(index_name, O_CREAT|O_EXCL|O_WRONLY, 0600);
}
if (fd < 0)
- die("unable to create %s: %s", index_name, strerror(errno));
+ die_errno("unable to create '%s'", index_name);
f = sha1fd(fd, index_name);
/* if last object's offset is >= 2^31 we should use index V2 */
git_SHA1_Init(&new_sha1_ctx);
if (lseek(pack_fd, 0, SEEK_SET) != 0)
- die("Failed seeking to start of %s: %s", pack_name, strerror(errno));
+ die_errno("Failed seeking to start of '%s'", pack_name);
if (read_in_full(pack_fd, &hdr, sizeof(hdr)) != sizeof(hdr))
- die("Unable to reread header of %s: %s", pack_name, strerror(errno));
+ die_errno("Unable to reread header of '%s'", pack_name);
if (lseek(pack_fd, 0, SEEK_SET) != 0)
- die("Failed seeking to start of %s: %s", pack_name, strerror(errno));
+ die_errno("Failed seeking to start of '%s'", pack_name);
git_SHA1_Update(&old_sha1_ctx, &hdr, sizeof(hdr));
hdr.hdr_entries = htonl(object_count);
git_SHA1_Update(&new_sha1_ctx, &hdr, sizeof(hdr));
if (!n)
break;
if (n < 0)
- die("Failed to checksum %s: %s", pack_name, strerror(errno));
+ die_errno("Failed to checksum '%s'", pack_name);
git_SHA1_Update(&new_sha1_ctx, buf, n);
aligned_sz -= n;
diff --git a/pkt-line.c b/pkt-line.c
index f5d00863a6234c16db33637d19fefd2014780e87..b691abebd79b40f096b28b5dbcb433f01bc0e949 100644 (file)
--- a/pkt-line.c
+++ b/pkt-line.c
}
if (!ret)
die("write error (disk full?)");
- die("write error (%s)", strerror(errno));
+ die_errno("write error");
}
return nn;
}
{
ssize_t ret = read_in_full(fd, buffer, size);
if (ret < 0)
- die("read error (%s)", strerror(errno));
+ die_errno("read error");
else if (ret < size)
die("The remote end hung up unexpectedly");
}
diff --git a/read-cache.c b/read-cache.c
index 3f587110cb9d7be1890b7db68a0bdac35d48cd35..4e3e272ee409de66de2059a8be475fddcaa4dc28 100644 (file)
--- a/read-cache.c
+++ b/read-cache.c
{
struct stat st;
if (lstat(path, &st))
- die("%s: unable to stat (%s)", path, strerror(errno));
+ die_errno("unable to stat '%s'", path);
return add_to_index(istate, path, &st, flags);
}
if (fd < 0) {
if (errno == ENOENT)
return 0;
- die("index file open failed (%s)", strerror(errno));
+ die_errno("index file open failed");
}
if (fstat(fd, &st))
- die("cannot stat the open index (%s)", strerror(errno));
+ die_errno("cannot stat the open index");
errno = EINVAL;
mmap_size = xsize_t(st.st_size);
mmap = xmmap(NULL, mmap_size, PROT_READ | PROT_WRITE, MAP_PRIVATE, fd, 0);
close(fd);
if (mmap == MAP_FAILED)
- die("unable to map index file");
+ die_errno("unable to map index file");
hdr = mmap;
if (verify_hdr(hdr, mmap_size) < 0)
index 24438c652fe4e09aaa1ba6dab283b8e59c24c1a7..dffe395a97a12f2489dc5bbec1f822e3b8f08de5 100644 (file)
--- a/refs.c
+++ b/refs.c
@@ -1418,7 +1418,7 @@ int read_ref_at(const char *ref, unsigned long at_time, int cnt, unsigned char *
logfile = git_path("logs/%s", ref);
logfd = open(logfile, O_RDONLY, 0);
if (logfd < 0)
- die("Unable to read log %s: %s", logfile, strerror(errno));
+ die_errno("Unable to read log '%s'", logfile);
fstat(logfd, &st);
if (!st.st_size)
die("Log %s is empty.", logfile);
diff --git a/remote.c b/remote.c
index 733ba57494715e00427350af4175fe67c390ec34..c3ada2d72b9b3f7411ffe420030768e73a003923 100644 (file)
--- a/remote.c
+++ b/remote.c
static struct ref *get_local_ref(const char *name)
{
- if (!name)
+ if (!name || name[0] == '\0')
return NULL;
if (!prefixcmp(name, "refs/"))
diff --git a/run-command.c b/run-command.c
index eb2efc33073512efd14b65e67db8cf814ca3fa33..ff3d8e2d8bf3208b7ad0f29d7cf76cc84a4ad0e6 100644 (file)
--- a/run-command.c
+++ b/run-command.c
}
if (cmd->dir && chdir(cmd->dir))
- die("exec %s: cd to %s failed (%s)", cmd->argv[0],
- cmd->dir, strerror(errno));
+ die_errno("exec '%s': cd to '%s' failed", cmd->argv[0],
+ cmd->dir);
if (cmd->env) {
for (; *cmd->env; cmd->env++) {
if (strchr(*cmd->env, '='))
index ebd60de9ce5b52f348819a6a390c15b8dc08d2ff..e3781b656d77be94e04c5229e6a190c5fc496490 100644 (file)
--- a/setup.c
+++ b/setup.c
if (errno == ENOENT)
die("ambiguous argument '%s': unknown revision or path not in the working tree.\n"
"Use '--' to separate paths from revisions", arg);
- die("'%s': %s", arg, strerror(errno));
+ die_errno("failed to stat '%s'", arg);
}
/*
die("ambiguous argument '%s': both revision and filename\n"
"Use '--' to separate filenames from revisions", arg);
if (errno != ENOENT && errno != ENOTDIR)
- die("'%s': %s", arg, strerror(errno));
+ die_errno("failed to stat '%s'", arg);
}
const char **get_pathspec(const char *prefix, const char **pathspec)
return NULL;
fd = open(path, O_RDONLY);
if (fd < 0)
- die("Error opening %s: %s", path, strerror(errno));
+ die_errno("Error opening '%s'", path);
buf = xmalloc(st.st_size + 1);
len = read_in_full(fd, buf, st.st_size);
close(fd);
return NULL;
set_git_dir(make_absolute_path(gitdirenv));
if (chdir(work_tree_env) < 0)
- die ("Could not chdir to %s", work_tree_env);
+ die_errno ("Could not chdir to '%s'", work_tree_env);
strcat(buffer, "/");
return retval;
}
}
if (!getcwd(cwd, sizeof(cwd)-1))
- die("Unable to read current working directory");
+ die_errno("Unable to read current working directory");
ceil_offset = longest_ancestor_length(cwd, env_ceiling_dirs);
if (ceil_offset < 0 && has_dos_drive_prefix(cwd))
if (offset <= ceil_offset) {
if (nongit_ok) {
if (chdir(cwd))
- die("Cannot come back to cwd");
+ die_errno("Cannot come back to cwd");
*nongit_ok = 1;
return NULL;
}
die("Not a git repository (or any of the parent directories): %s", DEFAULT_GIT_DIR_ENVIRONMENT);
}
if (chdir(".."))
- die("Cannot change to %s/..: %s", cwd, strerror(errno));
+ die_errno("Cannot change to '%s/..'", cwd);
}
inside_git_dir = 0;
static char buffer[PATH_MAX + 1];
char *rel;
if (retval && chdir(retval))
- die ("Could not jump back into original cwd");
+ die_errno ("Could not jump back into original cwd");
rel = get_relative_cwd(buffer, PATH_MAX, get_git_work_tree());
if (rel && *rel && chdir(get_git_work_tree()))
- die ("Could not jump to working directory");
+ die_errno ("Could not jump to working directory");
return rel && *rel ? strcat(rel, "/") : NULL;
}
diff --git a/sha1_file.c b/sha1_file.c
index 8f5fe62d545ace21c338cd554c76bac5d5acb431..4576ff77f3ceec7231b14261f7386abb2289cd5c 100644 (file)
--- a/sha1_file.c
+++ b/sha1_file.c
if (fsync_object_files)
fsync_or_die(fd, "sha1 file");
if (close(fd) != 0)
- die("error when closing sha1 file (%s)", strerror(errno));
+ die_errno("error when closing sha1 file");
}
/* Size of directory component, including the ending '/' */
index b968be79f487f8d93e205fd0a844a206e24f21f8..e4864e04da3b0e237342c2ca0548c0ec0082c171 100644 (file)
--- a/shell.c
+++ b/shell.c
while (devnull_fd >= 0 && devnull_fd <= 2)
devnull_fd = dup(devnull_fd);
if (devnull_fd == -1)
- die("opening /dev/null failed (%s)", strerror(errno));
+ die_errno("opening /dev/null failed");
close (devnull_fd);
/*
index 997002d4c40dd8e66e3be5a701e3d99bab1c57c4..e5040580626f4df6159c929c1ad54f085f03d830 100755 (executable)
EOF
-test_expect_success 'test --parseopt help output' '
- git rev-parse --parseopt -- -h 2> output.err <<EOF
+cat > optionspec << EOF
some-command [options] <args>...
some-command does foo and bar!
Extras
extra1 line above used to cause a segfault but no longer does
EOF
+
+test_expect_success 'test --parseopt help output' '
+ git rev-parse --parseopt -- -h 2> output.err < optionspec
test_cmp expect.err output.err
'
+cat > expect <<EOF
+set -- --foo --bar 'ham' -- 'arg'
+EOF
+
+test_expect_success 'test --parseopt' '
+ git rev-parse --parseopt -- --foo --bar=ham arg < optionspec > output &&
+ test_cmp expect output
+'
+
+test_expect_success 'test --parseopt with mixed options and arguments' '
+ git rev-parse --parseopt -- --foo arg --bar=ham < optionspec > output &&
+ test_cmp expect output
+'
+
+cat > expect <<EOF
+set -- --foo -- 'arg' '--bar=ham'
+EOF
+
+test_expect_success 'test --parseopt with --' '
+ git rev-parse --parseopt -- --foo -- arg --bar=ham < optionspec > output &&
+ test_cmp expect output
+'
+
+test_expect_success 'test --parseopt --stop-at-non-option' '
+ git rev-parse --parseopt --stop-at-non-option -- --foo arg --bar=ham < optionspec > output &&
+ test_cmp expect output
+'
+
+cat > expect <<EOF
+set -- --foo -- '--' 'arg' '--bar=ham'
+EOF
+
+test_expect_success 'test --parseopt --keep-dashdash' '
+ git rev-parse --parseopt --keep-dashdash -- --foo -- arg --bar=ham < optionspec > output &&
+ test_cmp expect output
+'
+
test_done
diff --git a/test-sha1.c b/test-sha1.c
index 9b98d07c786b36f005f4b3ffd51926f3c1a343dd..80daba980ecd85852ee3a23c155602e4cd1ba07a 100644 (file)
--- a/test-sha1.c
+++ b/test-sha1.c
if (sz == 0)
break;
if (sz < 0)
- die("test-sha1: %s", strerror(errno));
+ die_errno("test-sha1");
this_sz += sz;
cp += sz;
room -= sz;
diff --git a/transport.c b/transport.c
index 501a77b2418c4c5f5ca49a9fdecba3165129c1b2..ccf788de8b59b825abc369911d1a913fd3fe42c3 100644 (file)
--- a/transport.c
+++ b/transport.c
@@ -158,7 +158,7 @@ static struct ref *get_refs_via_rsync(struct transport *transport, int for_push)
strbuf_addstr(&temp_dir, git_path("rsync-refs-XXXXXX"));
if (!mkdtemp(temp_dir.buf))
- die ("Could not make temporary directory");
+ die_errno ("Could not make temporary directory");
temp_dir_len = temp_dir.len;
strbuf_addstr(&buf, rsync_url(transport->url));
strbuf_addstr(&temp_dir, git_path("rsync-refs-XXXXXX"));
if (!mkdtemp(temp_dir.buf))
- die ("Could not make temporary directory");
+ die_errno ("Could not make temporary directory");
strbuf_addch(&temp_dir, '/');
if (flags & TRANSPORT_PUSH_ALL) {
diff --git a/unpack-file.c b/unpack-file.c
index 75cd2f1a6adf3ea773a6acc3f1e7f122e30676e5..ac9cbf7cd8ed1367151de0e8b96668f498b7f1a1 100644 (file)
--- a/unpack-file.c
+++ b/unpack-file.c
strcpy(path, ".merge_file_XXXXXX");
fd = xmkstemp(path);
if (write_in_full(fd, buf, size) != size)
- die("unable to write temp-file");
+ die_errno("unable to write temp-file");
close(fd);
return path;
}
index 820d09f92b03b6cc96fbe9a954c37fd2d5e5a417..b6aea45280bf2aa4c06a0130f912a61377165016 100644 (file)
--- a/usage.c
+++ b/usage.c
va_end(params);
}
+void die_errno(const char *fmt, ...)
+{
+ va_list params;
+ char fmt_with_err[1024];
+ char str_error[256], *err;
+ int i, j;
+
+ err = strerror(errno);
+ for (i = j = 0; err[i] && j < sizeof(str_error) - 1; ) {
+ if ((str_error[j++] = err[i++]) != '%')
+ continue;
+ if (j < sizeof(str_error) - 1) {
+ str_error[j++] = '%';
+ } else {
+ /* No room to double the '%', so we overwrite it with
+ * '\0' below */
+ j--;
+ break;
+ }
+ }
+ str_error[j] = 0;
+ snprintf(fmt_with_err, sizeof(fmt_with_err), "%s: %s", fmt, str_error);
+
+ va_start(params, fmt);
+ die_routine(fmt_with_err, params);
+ va_end(params);
+}
+
int error(const char *err, ...)
{
va_list params;
diff --git a/wrapper.c b/wrapper.c
index 7eb3218ee995991881252e4bb599452d7214ae4f..c9be1400c005e25b003acecc0cb037dd2f07e56f 100644 (file)
--- a/wrapper.c
+++ b/wrapper.c
release_pack_memory(length, fd);
ret = mmap(start, length, prot, flags, fd, offset);
if (ret == MAP_FAILED)
- die("Out of memory? mmap failed: %s", strerror(errno));
+ die_errno("Out of memory? mmap failed");
}
return ret;
}
{
int ret = dup(fd);
if (ret < 0)
- die("dup failed: %s", strerror(errno));
+ die_errno("dup failed");
return ret;
}
{
FILE *stream = fdopen(fd, mode);
if (stream == NULL)
- die("Out of memory? fdopen failed: %s", strerror(errno));
+ die_errno("Out of memory? fdopen failed");
return stream;
}
fd = mkstemp(template);
if (fd < 0)
- die("Unable to create temporary file: %s", strerror(errno));
+ die_errno("Unable to create temporary file");
return fd;
}
diff --git a/write_or_die.c b/write_or_die.c
index 4c29255df1b637f93ab3d59e0dcab1fa3b40e10b..d45b536021e15c5a674f7969be39f238194bef99 100644 (file)
--- a/write_or_die.c
+++ b/write_or_die.c
*/
if (errno == EPIPE || errno == EINVAL)
exit(0);
- die("write failure on %s: %s", desc, strerror(errno));
+ die_errno("write failure on '%s'", desc);
}
}
void fsync_or_die(int fd, const char *msg)
{
if (fsync(fd) < 0) {
- die("%s: fsync error (%s)", msg, strerror(errno));
+ die_errno("fsync error on '%s'", msg);
}
}
if (write_in_full(fd, buf, count) < 0) {
if (errno == EPIPE)
exit(0);
- die("write error (%s)", strerror(errno));
+ die_errno("write error");
}
}