2005-06-13 17:06:50 +00:00
|
|
|
/*
|
|
|
|
* rev-parse.c
|
|
|
|
*
|
|
|
|
* Copyright (C) Linus Torvalds, 2005
|
|
|
|
*/
|
|
|
|
#include "cache.h"
|
2005-06-21 03:28:09 +00:00
|
|
|
#include "commit.h"
|
2005-07-03 20:07:52 +00:00
|
|
|
#include "refs.h"
|
2005-09-20 21:13:24 +00:00
|
|
|
#include "quote.h"
|
2006-06-03 16:45:43 +00:00
|
|
|
#include "builtin.h"
|
2007-11-04 10:30:53 +00:00
|
|
|
#include "parse-options.h"
|
2005-06-21 03:28:09 +00:00
|
|
|
|
2005-08-24 21:30:04 +00:00
|
|
|
#define DO_REVS 1
|
|
|
|
#define DO_NOREV 2
|
|
|
|
#define DO_FLAGS 4
|
|
|
|
#define DO_NONFLAGS 8
|
|
|
|
static int filter = ~0;
|
|
|
|
|
2006-08-15 17:23:48 +00:00
|
|
|
static const char *def;
|
2005-06-24 17:12:55 +00:00
|
|
|
|
2005-06-26 18:34:30 +00:00
|
|
|
#define NORMAL 0
|
|
|
|
#define REVERSED 1
|
|
|
|
static int show_type = NORMAL;
|
2008-01-05 20:09:55 +00:00
|
|
|
|
|
|
|
#define SHOW_SYMBOLIC_ASIS 1
|
|
|
|
#define SHOW_SYMBOLIC_FULL 2
|
2006-08-15 17:23:48 +00:00
|
|
|
static int symbolic;
|
|
|
|
static int abbrev;
|
2009-04-13 11:20:26 +00:00
|
|
|
static int abbrev_ref;
|
|
|
|
static int abbrev_ref_strict;
|
2006-08-15 17:23:48 +00:00
|
|
|
static int output_sq;
|
2005-08-24 21:30:04 +00:00
|
|
|
|
2005-06-13 18:14:20 +00:00
|
|
|
/*
|
|
|
|
* Some arguments are relevant "revision" arguments,
|
|
|
|
* others are about output format or other details.
|
|
|
|
* This sorts it all out.
|
|
|
|
*/
|
|
|
|
static int is_rev_argument(const char *arg)
|
|
|
|
{
|
|
|
|
static const char *rev_args[] = {
|
2005-10-05 21:49:54 +00:00
|
|
|
"--all",
|
2005-08-24 21:30:04 +00:00
|
|
|
"--bisect",
|
2005-10-30 09:08:35 +00:00
|
|
|
"--dense",
|
2010-01-20 09:48:26 +00:00
|
|
|
"--branches=",
|
2006-05-14 01:43:00 +00:00
|
|
|
"--branches",
|
2005-08-24 21:30:04 +00:00
|
|
|
"--header",
|
2005-06-13 18:14:20 +00:00
|
|
|
"--max-age=",
|
2005-08-24 21:30:04 +00:00
|
|
|
"--max-count=",
|
|
|
|
"--min-age=",
|
2005-08-09 02:31:37 +00:00
|
|
|
"--no-merges",
|
2005-08-24 21:30:04 +00:00
|
|
|
"--objects",
|
2006-02-19 11:32:31 +00:00
|
|
|
"--objects-edge",
|
2005-08-24 21:30:04 +00:00
|
|
|
"--parents",
|
|
|
|
"--pretty",
|
2010-01-20 09:48:26 +00:00
|
|
|
"--remotes=",
|
2006-05-14 01:43:00 +00:00
|
|
|
"--remotes",
|
2010-01-20 09:48:25 +00:00
|
|
|
"--glob=",
|
2005-10-30 09:08:35 +00:00
|
|
|
"--sparse",
|
2010-01-20 09:48:26 +00:00
|
|
|
"--tags=",
|
2006-05-14 01:43:00 +00:00
|
|
|
"--tags",
|
2005-08-24 21:30:04 +00:00
|
|
|
"--topo-order",
|
2006-02-16 06:05:33 +00:00
|
|
|
"--date-order",
|
2005-08-24 21:30:04 +00:00
|
|
|
"--unpacked",
|
2005-06-13 18:14:20 +00:00
|
|
|
NULL
|
|
|
|
};
|
|
|
|
const char **p = rev_args;
|
|
|
|
|
2006-01-30 00:28:02 +00:00
|
|
|
/* accept -<digit>, like traditional "head" */
|
|
|
|
if ((*arg == '-') && isdigit(arg[1]))
|
|
|
|
return 1;
|
|
|
|
|
2005-06-13 18:14:20 +00:00
|
|
|
for (;;) {
|
|
|
|
const char *str = *p++;
|
|
|
|
int len;
|
|
|
|
if (!str)
|
|
|
|
return 0;
|
|
|
|
len = strlen(str);
|
2005-08-24 21:30:04 +00:00
|
|
|
if (!strcmp(arg, str) ||
|
|
|
|
(str[len-1] == '=' && !strncmp(arg, str, len)))
|
2005-06-13 18:14:20 +00:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-08-24 21:30:04 +00:00
|
|
|
/* Output argument as a string, either SQ or normal */
|
[PATCH] Help scripts that use git-rev-parse to grok args with SP/TAB/LF
The git-rev-parse command uses LF to separate each argument it
parses, so its users at least need to set IFS to LF to be able
to handle filenames with embedded SPs and TABs. Some commands,
however, can take and do expect arguments with embedded LF,
notably, "-S" (pickaxe) of diff family, so even this workaround
does not work for them.
When --sq flag to git-rev-parse is given, instead of showing one
argument per line, it outputs arguments quoted for consumption
with "eval" by the caller, to remedy this situation.
As an example, this patch converts git-whatchanged to use this
new feature.
Signed-off-by: Junio C Hamano <junkio@cox.net>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-07-23 02:08:32 +00:00
|
|
|
static void show(const char *arg)
|
|
|
|
{
|
|
|
|
if (output_sq) {
|
|
|
|
int sq = '\'', ch;
|
|
|
|
|
|
|
|
putchar(sq);
|
|
|
|
while ((ch = *arg++)) {
|
|
|
|
if (ch == sq)
|
|
|
|
fputs("'\\'", stdout);
|
|
|
|
putchar(ch);
|
|
|
|
}
|
|
|
|
putchar(sq);
|
|
|
|
putchar(' ');
|
|
|
|
}
|
|
|
|
else
|
|
|
|
puts(arg);
|
|
|
|
}
|
|
|
|
|
2008-05-23 14:13:05 +00:00
|
|
|
/* Like show(), but with a negation prefix according to type */
|
|
|
|
static void show_with_type(int type, const char *arg)
|
|
|
|
{
|
|
|
|
if (type != show_type)
|
|
|
|
putchar('^');
|
|
|
|
show(arg);
|
|
|
|
}
|
|
|
|
|
2005-08-24 21:30:04 +00:00
|
|
|
/* Output a revision, only if filter allows it */
|
2005-08-16 19:36:46 +00:00
|
|
|
static void show_rev(int type, const unsigned char *sha1, const char *name)
|
2005-06-24 17:12:55 +00:00
|
|
|
{
|
2005-08-24 21:30:04 +00:00
|
|
|
if (!(filter & DO_REVS))
|
2005-06-24 17:12:55 +00:00
|
|
|
return;
|
2005-08-24 21:30:04 +00:00
|
|
|
def = NULL;
|
[PATCH] Help scripts that use git-rev-parse to grok args with SP/TAB/LF
The git-rev-parse command uses LF to separate each argument it
parses, so its users at least need to set IFS to LF to be able
to handle filenames with embedded SPs and TABs. Some commands,
however, can take and do expect arguments with embedded LF,
notably, "-S" (pickaxe) of diff family, so even this workaround
does not work for them.
When --sq flag to git-rev-parse is given, instead of showing one
argument per line, it outputs arguments quoted for consumption
with "eval" by the caller, to remedy this situation.
As an example, this patch converts git-whatchanged to use this
new feature.
Signed-off-by: Junio C Hamano <junkio@cox.net>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-07-23 02:08:32 +00:00
|
|
|
|
2009-04-13 11:20:26 +00:00
|
|
|
if ((symbolic || abbrev_ref) && name) {
|
|
|
|
if (symbolic == SHOW_SYMBOLIC_FULL || abbrev_ref) {
|
2008-01-05 20:09:55 +00:00
|
|
|
unsigned char discard[20];
|
|
|
|
char *full;
|
|
|
|
|
|
|
|
switch (dwim_ref(name, strlen(name), discard, &full)) {
|
|
|
|
case 0:
|
|
|
|
/*
|
|
|
|
* Not found -- not a ref. We could
|
|
|
|
* emit "name" here, but symbolic-full
|
|
|
|
* users are interested in finding the
|
|
|
|
* refs spelled in full, and they would
|
|
|
|
* need to filter non-refs if we did so.
|
|
|
|
*/
|
|
|
|
break;
|
|
|
|
case 1: /* happy */
|
2009-04-13 11:20:26 +00:00
|
|
|
if (abbrev_ref)
|
|
|
|
full = shorten_unambiguous_ref(full,
|
|
|
|
abbrev_ref_strict);
|
2008-05-23 14:13:05 +00:00
|
|
|
show_with_type(type, full);
|
2008-01-05 20:09:55 +00:00
|
|
|
break;
|
|
|
|
default: /* ambiguous */
|
|
|
|
error("refname '%s' is ambiguous", name);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
} else {
|
2008-05-23 14:13:05 +00:00
|
|
|
show_with_type(type, name);
|
2008-01-05 20:09:55 +00:00
|
|
|
}
|
|
|
|
}
|
2006-01-25 09:35:38 +00:00
|
|
|
else if (abbrev)
|
2008-05-23 14:13:05 +00:00
|
|
|
show_with_type(type, find_unique_abbrev(sha1, abbrev));
|
2005-08-16 19:36:46 +00:00
|
|
|
else
|
2008-05-23 14:13:05 +00:00
|
|
|
show_with_type(type, sha1_to_hex(sha1));
|
2005-06-24 17:12:55 +00:00
|
|
|
}
|
|
|
|
|
2005-08-24 21:30:04 +00:00
|
|
|
/* Output a flag, only if filter allows it. */
|
2006-06-06 05:36:21 +00:00
|
|
|
static int show_flag(const char *arg)
|
2005-06-24 17:12:55 +00:00
|
|
|
{
|
2005-08-24 21:30:04 +00:00
|
|
|
if (!(filter & DO_FLAGS))
|
2006-02-05 19:58:34 +00:00
|
|
|
return 0;
|
|
|
|
if (filter & (is_rev_argument(arg) ? DO_REVS : DO_NOREV)) {
|
2005-08-23 17:47:54 +00:00
|
|
|
show(arg);
|
2006-02-05 19:58:34 +00:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
return 0;
|
2005-06-24 17:12:55 +00:00
|
|
|
}
|
|
|
|
|
2008-05-11 16:28:25 +00:00
|
|
|
static int show_default(void)
|
2005-06-24 17:12:55 +00:00
|
|
|
{
|
2006-06-06 05:36:21 +00:00
|
|
|
const char *s = def;
|
2005-06-24 17:12:55 +00:00
|
|
|
|
|
|
|
if (s) {
|
|
|
|
unsigned char sha1[20];
|
|
|
|
|
|
|
|
def = NULL;
|
2005-08-04 05:15:49 +00:00
|
|
|
if (!get_sha1(s, sha1)) {
|
2005-08-16 19:36:46 +00:00
|
|
|
show_rev(NORMAL, sha1, s);
|
2008-05-11 16:28:25 +00:00
|
|
|
return 1;
|
2005-06-24 17:12:55 +00:00
|
|
|
}
|
|
|
|
}
|
2008-05-11 16:28:25 +00:00
|
|
|
return 0;
|
2005-06-24 17:12:55 +00:00
|
|
|
}
|
|
|
|
|
2006-09-21 05:02:01 +00:00
|
|
|
static int show_reference(const char *refname, const unsigned char *sha1, int flag, void *cb_data)
|
2005-07-03 20:07:52 +00:00
|
|
|
{
|
2005-08-16 19:36:46 +00:00
|
|
|
show_rev(NORMAL, sha1, refname);
|
2005-07-03 20:07:52 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-10-27 18:28:07 +00:00
|
|
|
static int anti_reference(const char *refname, const unsigned char *sha1, int flag, void *cb_data)
|
|
|
|
{
|
|
|
|
show_rev(REVERSED, sha1, refname);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-09-20 21:13:24 +00:00
|
|
|
static void show_datestring(const char *flag, const char *datestr)
|
|
|
|
{
|
|
|
|
static char buffer[100];
|
|
|
|
|
|
|
|
/* date handling requires both flags and revs */
|
|
|
|
if ((filter & (DO_FLAGS | DO_REVS)) != (DO_FLAGS | DO_REVS))
|
|
|
|
return;
|
git's rev-parse.c function show_datestring presumes gnu date
Ok. This is the insane patch to do this.
It really isn't very careful, and the reason I call it "approxidate()"
will become obvious when you look at the code. It is very liberal in what
it accepts, to the point where sometimes the results may not make a whole
lot of sense.
It accepts "last week" as a date string, by virtue of "last" parsing as
the number 1, and it totally ignoring superfluous fluff like "ago", so
"last week" ends up being exactly the same thing as "1 week ago". Fine so
far.
It has strange side effects: "last december" will actually parse as "Dec
1", which actually _does_ turn out right, because it will then notice that
it's not December yet, so it will decide that you must be talking about a
date last year. So it actually gets it right, but it's kind of for the
"wrong" reasons.
It also accepts the numbers 1..10 in string format ("one" .. "ten"), so
you can do "ten weeks ago" or "ten hours ago" and it will do the right
thing.
But it will do some really strange thigns too: the string "this will last
forever", will not recognize anyting but "last", which is recognized as
"1", which since it doesn't understand anything else it will think is the
day of the month. So if you do
gitk --since="this will last forever"
the date will actually parse as the first day of the current month.
And it will parse the string "now" as "now", but only because it doesn't
understand it at all, and it makes everything relative to "now".
Similarly, it doesn't actually parse the "ago" or "from now", so "2 weeks
ago" is exactly the same as "2 weeks from now". It's the current date
minus 14 days.
But hey, it's probably better (and certainly faster) than depending on GNU
date. So now you can portably do things like
gitk --since="two weeks and three days ago"
git log --since="July 5"
git-whatchanged --since="10 hours ago"
git log --since="last october"
and it will actually do exactly what you thought it would do (I think). It
will count 17 days backwards, and it will do so even if you don't have GNU
date installed.
(I don't do "last monday" or similar yet, but I can extend it to that too
if people want).
It was kind of fun trying to write code that uses such totally relaxed
"understanding" of dates yet tries to get it right for the trivial cases.
The result should be mixed with a few strange preprocessor tricks, and be
submitted for the IOCCC ;)
Feel free to try it out, and see how many strange dates it gets right. Or
wrong.
And if you find some interesting (and valid - not "interesting" as in
"strange", but "interesting" as in "I'd be interested in actually doing
this) thing it gets wrong - usually by not understanding it and silently
just doing some strange things - please holler.
Now, as usual this certainly hasn't been getting a lot of testing. But my
code always works, no?
Linus
Signed-off-by: Junio C Hamano <junkio@cox.net>
2005-11-15 03:29:06 +00:00
|
|
|
snprintf(buffer, sizeof(buffer), "%s%lu", flag, approxidate(datestr));
|
2005-09-20 21:13:24 +00:00
|
|
|
show(buffer);
|
|
|
|
}
|
|
|
|
|
2006-02-06 05:41:47 +00:00
|
|
|
static int show_file(const char *arg)
|
2005-10-18 07:16:45 +00:00
|
|
|
{
|
2005-10-25 22:24:55 +00:00
|
|
|
show_default();
|
2006-02-06 05:41:47 +00:00
|
|
|
if ((filter & (DO_NONFLAGS|DO_NOREV)) == (DO_NONFLAGS|DO_NOREV)) {
|
2005-10-18 07:16:45 +00:00
|
|
|
show(arg);
|
2006-02-06 05:41:47 +00:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
return 0;
|
2005-10-18 07:16:45 +00:00
|
|
|
}
|
|
|
|
|
2006-07-06 07:16:35 +00:00
|
|
|
static int try_difference(const char *arg)
|
2006-07-04 09:02:22 +00:00
|
|
|
{
|
|
|
|
char *dotdot;
|
|
|
|
unsigned char sha1[20];
|
|
|
|
unsigned char end[20];
|
|
|
|
const char *next;
|
|
|
|
const char *this;
|
|
|
|
int symmetric;
|
|
|
|
|
|
|
|
if (!(dotdot = strstr(arg, "..")))
|
|
|
|
return 0;
|
|
|
|
next = dotdot + 2;
|
|
|
|
this = arg;
|
|
|
|
symmetric = (*next == '.');
|
|
|
|
|
|
|
|
*dotdot = 0;
|
|
|
|
next += symmetric;
|
|
|
|
|
|
|
|
if (!*next)
|
|
|
|
next = "HEAD";
|
|
|
|
if (dotdot == arg)
|
|
|
|
this = "HEAD";
|
|
|
|
if (!get_sha1(this, sha1) && !get_sha1(next, end)) {
|
|
|
|
show_rev(NORMAL, end, next);
|
|
|
|
show_rev(symmetric ? NORMAL : REVERSED, sha1, this);
|
|
|
|
if (symmetric) {
|
|
|
|
struct commit_list *exclude;
|
|
|
|
struct commit *a, *b;
|
|
|
|
a = lookup_commit_reference(sha1);
|
|
|
|
b = lookup_commit_reference(end);
|
|
|
|
exclude = get_merge_bases(a, b, 1);
|
|
|
|
while (exclude) {
|
|
|
|
struct commit_list *n = exclude->next;
|
|
|
|
show_rev(REVERSED,
|
|
|
|
exclude->item->object.sha1,NULL);
|
|
|
|
free(exclude);
|
|
|
|
exclude = n;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
*dotdot = '.';
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-07-26 16:37:56 +00:00
|
|
|
static int try_parent_shorthands(const char *arg)
|
|
|
|
{
|
|
|
|
char *dotdot;
|
|
|
|
unsigned char sha1[20];
|
|
|
|
struct commit *commit;
|
|
|
|
struct commit_list *parents;
|
|
|
|
int parents_only;
|
|
|
|
|
|
|
|
if ((dotdot = strstr(arg, "^!")))
|
|
|
|
parents_only = 0;
|
|
|
|
else if ((dotdot = strstr(arg, "^@")))
|
|
|
|
parents_only = 1;
|
|
|
|
|
|
|
|
if (!dotdot || dotdot[2])
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
*dotdot = 0;
|
|
|
|
if (get_sha1(arg, sha1))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (!parents_only)
|
|
|
|
show_rev(NORMAL, sha1, arg);
|
|
|
|
commit = lookup_commit_reference(sha1);
|
|
|
|
for (parents = commit->parents; parents; parents = parents->next)
|
|
|
|
show_rev(parents_only ? NORMAL : REVERSED,
|
|
|
|
parents->item->object.sha1, arg);
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2007-11-04 10:30:53 +00:00
|
|
|
static int parseopt_dump(const struct option *o, const char *arg, int unset)
|
|
|
|
{
|
|
|
|
struct strbuf *parsed = o->value;
|
|
|
|
if (unset)
|
|
|
|
strbuf_addf(parsed, " --no-%s", o->long_name);
|
|
|
|
else if (o->short_name)
|
|
|
|
strbuf_addf(parsed, " -%c", o->short_name);
|
|
|
|
else
|
|
|
|
strbuf_addf(parsed, " --%s", o->long_name);
|
|
|
|
if (arg) {
|
|
|
|
strbuf_addch(parsed, ' ');
|
|
|
|
sq_quote_buf(parsed, arg);
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static const char *skipspaces(const char *s)
|
|
|
|
{
|
|
|
|
while (isspace(*s))
|
|
|
|
s++;
|
|
|
|
return s;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int cmd_parseopt(int argc, const char **argv, const char *prefix)
|
|
|
|
{
|
2009-06-13 23:58:43 +00:00
|
|
|
static int keep_dashdash = 0, stop_at_non_option = 0;
|
2007-11-04 10:30:53 +00:00
|
|
|
static char const * const parseopt_usage[] = {
|
2008-07-13 13:36:15 +00:00
|
|
|
"git rev-parse --parseopt [options] -- [<args>...]",
|
2007-11-04 10:30:53 +00:00
|
|
|
NULL
|
|
|
|
};
|
|
|
|
static struct option parseopt_opts[] = {
|
|
|
|
OPT_BOOLEAN(0, "keep-dashdash", &keep_dashdash,
|
|
|
|
"keep the `--` passed as an arg"),
|
2009-06-13 23:58:43 +00:00
|
|
|
OPT_BOOLEAN(0, "stop-at-non-option", &stop_at_non_option,
|
|
|
|
"stop parsing after the "
|
|
|
|
"first non-option argument"),
|
2007-11-04 10:30:53 +00:00
|
|
|
OPT_END(),
|
|
|
|
};
|
|
|
|
|
2008-10-09 19:12:12 +00:00
|
|
|
struct strbuf sb = STRBUF_INIT, parsed = STRBUF_INIT;
|
2007-11-04 10:30:53 +00:00
|
|
|
const char **usage = NULL;
|
|
|
|
struct option *opts = NULL;
|
|
|
|
int onb = 0, osz = 0, unb = 0, usz = 0;
|
|
|
|
|
|
|
|
strbuf_addstr(&parsed, "set --");
|
2009-05-23 18:53:12 +00:00
|
|
|
argc = parse_options(argc, argv, prefix, parseopt_opts, parseopt_usage,
|
2007-11-04 10:30:53 +00:00
|
|
|
PARSE_OPT_KEEP_DASHDASH);
|
|
|
|
if (argc < 1 || strcmp(argv[0], "--"))
|
|
|
|
usage_with_options(parseopt_usage, parseopt_opts);
|
|
|
|
|
|
|
|
/* get the usage up to the first line with a -- on it */
|
|
|
|
for (;;) {
|
|
|
|
if (strbuf_getline(&sb, stdin, '\n') == EOF)
|
|
|
|
die("premature end of input");
|
|
|
|
ALLOC_GROW(usage, unb + 1, usz);
|
|
|
|
if (!strcmp("--", sb.buf)) {
|
|
|
|
if (unb < 1)
|
|
|
|
die("no usage string given before the `--' separator");
|
|
|
|
usage[unb] = NULL;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
usage[unb++] = strbuf_detach(&sb, NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* parse: (<short>|<short>,<long>|<long>)[=?]? SP+ <help> */
|
|
|
|
while (strbuf_getline(&sb, stdin, '\n') != EOF) {
|
|
|
|
const char *s;
|
|
|
|
struct option *o;
|
|
|
|
|
|
|
|
if (!sb.len)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
ALLOC_GROW(opts, onb + 1, osz);
|
|
|
|
memset(opts + onb, 0, sizeof(opts[onb]));
|
|
|
|
|
|
|
|
o = &opts[onb++];
|
|
|
|
s = strchr(sb.buf, ' ');
|
|
|
|
if (!s || *sb.buf == ' ') {
|
|
|
|
o->type = OPTION_GROUP;
|
2008-02-26 04:07:39 +00:00
|
|
|
o->help = xstrdup(skipspaces(sb.buf));
|
2007-11-04 10:30:53 +00:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
o->type = OPTION_CALLBACK;
|
|
|
|
o->help = xstrdup(skipspaces(s));
|
|
|
|
o->value = &parsed;
|
2008-03-02 08:21:38 +00:00
|
|
|
o->flags = PARSE_OPT_NOARG;
|
2007-11-04 10:30:53 +00:00
|
|
|
o->callback = &parseopt_dump;
|
2008-03-02 08:21:38 +00:00
|
|
|
while (s > sb.buf && strchr("*=?!", s[-1])) {
|
|
|
|
switch (*--s) {
|
|
|
|
case '=':
|
|
|
|
o->flags &= ~PARSE_OPT_NOARG;
|
|
|
|
break;
|
|
|
|
case '?':
|
|
|
|
o->flags &= ~PARSE_OPT_NOARG;
|
|
|
|
o->flags |= PARSE_OPT_OPTARG;
|
|
|
|
break;
|
|
|
|
case '!':
|
|
|
|
o->flags |= PARSE_OPT_NONEG;
|
|
|
|
break;
|
|
|
|
case '*':
|
|
|
|
o->flags |= PARSE_OPT_HIDDEN;
|
|
|
|
break;
|
|
|
|
}
|
2007-11-04 10:30:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (s - sb.buf == 1) /* short option only */
|
|
|
|
o->short_name = *sb.buf;
|
|
|
|
else if (sb.buf[1] != ',') /* long option only */
|
|
|
|
o->long_name = xmemdupz(sb.buf, s - sb.buf);
|
|
|
|
else {
|
|
|
|
o->short_name = *sb.buf;
|
|
|
|
o->long_name = xmemdupz(sb.buf + 2, s - sb.buf - 2);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
strbuf_release(&sb);
|
|
|
|
|
|
|
|
/* put an OPT_END() */
|
|
|
|
ALLOC_GROW(opts, onb + 1, osz);
|
|
|
|
memset(opts + onb, 0, sizeof(opts[onb]));
|
2009-05-23 18:53:12 +00:00
|
|
|
argc = parse_options(argc, argv, prefix, opts, usage,
|
2009-06-13 23:58:43 +00:00
|
|
|
keep_dashdash ? PARSE_OPT_KEEP_DASHDASH : 0 |
|
|
|
|
stop_at_non_option ? PARSE_OPT_STOP_AT_NON_OPTION : 0);
|
2007-11-04 10:30:53 +00:00
|
|
|
|
|
|
|
strbuf_addf(&parsed, " --");
|
2007-12-03 04:51:50 +00:00
|
|
|
sq_quote_argv(&parsed, argv, 0);
|
2007-11-04 10:30:53 +00:00
|
|
|
puts(parsed.buf);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-04-25 04:55:26 +00:00
|
|
|
static int cmd_sq_quote(int argc, const char **argv)
|
|
|
|
{
|
|
|
|
struct strbuf buf = STRBUF_INIT;
|
|
|
|
|
|
|
|
if (argc)
|
|
|
|
sq_quote_argv(&buf, argv, 0);
|
|
|
|
printf("%s\n", buf.buf);
|
|
|
|
strbuf_release(&buf);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-04-26 11:57:23 +00:00
|
|
|
static void die_no_single_rev(int quiet)
|
|
|
|
{
|
|
|
|
if (quiet)
|
|
|
|
exit(1);
|
|
|
|
else
|
|
|
|
die("Needed a single revision");
|
|
|
|
}
|
|
|
|
|
2009-11-09 15:04:54 +00:00
|
|
|
static const char builtin_rev_parse_usage[] =
|
|
|
|
"git rev-parse --parseopt [options] -- [<args>...]\n"
|
|
|
|
" or: git rev-parse --sq-quote [<arg>...]\n"
|
|
|
|
" or: git rev-parse [options] [<arg>...]\n"
|
|
|
|
"\n"
|
|
|
|
"Run \"git rev-parse --parseopt -h\" for more information on the first usage.";
|
|
|
|
|
2006-07-29 05:44:25 +00:00
|
|
|
int cmd_rev_parse(int argc, const char **argv, const char *prefix)
|
2005-06-13 17:06:50 +00:00
|
|
|
{
|
2008-05-11 16:28:25 +00:00
|
|
|
int i, as_is = 0, verify = 0, quiet = 0, revs_count = 0, type = 0;
|
2005-06-13 17:06:50 +00:00
|
|
|
unsigned char sha1[20];
|
2008-05-11 16:28:25 +00:00
|
|
|
const char *name = NULL;
|
2006-05-14 01:43:00 +00:00
|
|
|
|
2007-11-04 10:30:53 +00:00
|
|
|
if (argc > 1 && !strcmp("--parseopt", argv[1]))
|
|
|
|
return cmd_parseopt(argc - 1, argv + 1, prefix);
|
|
|
|
|
2009-04-25 04:55:26 +00:00
|
|
|
if (argc > 1 && !strcmp("--sq-quote", argv[1]))
|
|
|
|
return cmd_sq_quote(argc - 2, argv + 2);
|
|
|
|
|
2010-02-24 23:34:15 +00:00
|
|
|
if (argc == 2 && !strcmp("--local-env-vars", argv[1])) {
|
|
|
|
int i;
|
|
|
|
for (i = 0; local_repo_env[i]; i++)
|
|
|
|
printf("%s\n", local_repo_env[i]);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-11-09 15:04:54 +00:00
|
|
|
if (argc > 1 && !strcmp("-h", argv[1]))
|
|
|
|
usage(builtin_rev_parse_usage);
|
|
|
|
|
2007-11-06 20:23:14 +00:00
|
|
|
prefix = setup_git_directory();
|
2008-05-14 17:46:53 +00:00
|
|
|
git_config(git_default_config, NULL);
|
2005-06-13 17:06:50 +00:00
|
|
|
for (i = 1; i < argc; i++) {
|
2006-06-06 05:36:21 +00:00
|
|
|
const char *arg = argv[i];
|
2006-03-27 00:28:20 +00:00
|
|
|
|
2005-06-13 17:06:50 +00:00
|
|
|
if (as_is) {
|
2006-03-27 00:28:20 +00:00
|
|
|
if (show_file(arg) && as_is < 2)
|
2006-04-26 17:15:54 +00:00
|
|
|
verify_filename(prefix, arg);
|
2005-06-13 17:06:50 +00:00
|
|
|
continue;
|
|
|
|
}
|
2006-01-30 00:26:40 +00:00
|
|
|
if (!strcmp(arg,"-n")) {
|
|
|
|
if (++i >= argc)
|
|
|
|
die("-n requires an argument");
|
|
|
|
if ((filter & DO_FLAGS) && (filter & DO_REVS)) {
|
|
|
|
show(arg);
|
|
|
|
show(argv[i]);
|
|
|
|
}
|
|
|
|
continue;
|
|
|
|
}
|
2007-02-20 09:55:07 +00:00
|
|
|
if (!prefixcmp(arg, "-n")) {
|
2006-01-30 00:26:40 +00:00
|
|
|
if ((filter & DO_FLAGS) && (filter & DO_REVS))
|
|
|
|
show(arg);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2005-06-13 17:06:50 +00:00
|
|
|
if (*arg == '-') {
|
|
|
|
if (!strcmp(arg, "--")) {
|
2006-03-27 00:28:20 +00:00
|
|
|
as_is = 2;
|
2005-10-21 00:16:30 +00:00
|
|
|
/* Pass on the "--" if we show anything but files.. */
|
|
|
|
if (filter & (DO_FLAGS | DO_REVS))
|
|
|
|
show_file(arg);
|
2005-08-24 21:30:04 +00:00
|
|
|
continue;
|
2005-06-13 17:06:50 +00:00
|
|
|
}
|
|
|
|
if (!strcmp(arg, "--default")) {
|
|
|
|
def = argv[i+1];
|
|
|
|
i++;
|
|
|
|
continue;
|
|
|
|
}
|
2005-06-13 17:21:11 +00:00
|
|
|
if (!strcmp(arg, "--revs-only")) {
|
2005-08-24 21:30:04 +00:00
|
|
|
filter &= ~DO_NOREV;
|
2005-06-13 17:21:11 +00:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (!strcmp(arg, "--no-revs")) {
|
2005-08-24 21:30:04 +00:00
|
|
|
filter &= ~DO_REVS;
|
2005-06-13 17:21:11 +00:00
|
|
|
continue;
|
|
|
|
}
|
2005-07-06 17:08:08 +00:00
|
|
|
if (!strcmp(arg, "--flags")) {
|
2005-08-24 21:30:04 +00:00
|
|
|
filter &= ~DO_NONFLAGS;
|
2005-07-06 17:08:08 +00:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (!strcmp(arg, "--no-flags")) {
|
2005-08-24 21:30:04 +00:00
|
|
|
filter &= ~DO_FLAGS;
|
2005-07-06 17:08:08 +00:00
|
|
|
continue;
|
|
|
|
}
|
2005-06-24 17:12:55 +00:00
|
|
|
if (!strcmp(arg, "--verify")) {
|
2005-08-24 21:30:04 +00:00
|
|
|
filter &= ~(DO_FLAGS|DO_NOREV);
|
|
|
|
verify = 1;
|
2005-06-24 17:12:55 +00:00
|
|
|
continue;
|
2005-06-13 18:14:20 +00:00
|
|
|
}
|
2008-04-26 11:57:23 +00:00
|
|
|
if (!strcmp(arg, "--quiet") || !strcmp(arg, "-q")) {
|
|
|
|
quiet = 1;
|
|
|
|
continue;
|
|
|
|
}
|
2006-01-27 01:02:07 +00:00
|
|
|
if (!strcmp(arg, "--short") ||
|
Mechanical conversion to use prefixcmp()
This mechanically converts strncmp() to use prefixcmp(), but only when
the parameters match specific patterns, so that they can be verified
easily. Leftover from this will be fixed in a separate step, including
idiotic conversions like
if (!strncmp("foo", arg, 3))
=>
if (!(-prefixcmp(arg, "foo")))
This was done by using this script in px.perl
#!/usr/bin/perl -i.bak -p
if (/strncmp\(([^,]+), "([^\\"]*)", (\d+)\)/ && (length($2) == $3)) {
s|strncmp\(([^,]+), "([^\\"]*)", (\d+)\)|prefixcmp($1, "$2")|;
}
if (/strncmp\("([^\\"]*)", ([^,]+), (\d+)\)/ && (length($1) == $3)) {
s|strncmp\("([^\\"]*)", ([^,]+), (\d+)\)|(-prefixcmp($2, "$1"))|;
}
and running:
$ git grep -l strncmp -- '*.c' | xargs perl px.perl
Signed-off-by: Junio C Hamano <junkio@cox.net>
2007-02-20 09:53:29 +00:00
|
|
|
!prefixcmp(arg, "--short=")) {
|
2006-01-25 09:35:38 +00:00
|
|
|
filter &= ~(DO_FLAGS|DO_NOREV);
|
|
|
|
verify = 1;
|
|
|
|
abbrev = DEFAULT_ABBREV;
|
2006-02-18 01:10:53 +00:00
|
|
|
if (arg[7] == '=')
|
|
|
|
abbrev = strtoul(arg + 8, NULL, 10);
|
2006-01-26 08:48:19 +00:00
|
|
|
if (abbrev < MINIMUM_ABBREV)
|
|
|
|
abbrev = MINIMUM_ABBREV;
|
|
|
|
else if (40 <= abbrev)
|
|
|
|
abbrev = 40;
|
2006-01-25 09:35:38 +00:00
|
|
|
continue;
|
|
|
|
}
|
[PATCH] Help scripts that use git-rev-parse to grok args with SP/TAB/LF
The git-rev-parse command uses LF to separate each argument it
parses, so its users at least need to set IFS to LF to be able
to handle filenames with embedded SPs and TABs. Some commands,
however, can take and do expect arguments with embedded LF,
notably, "-S" (pickaxe) of diff family, so even this workaround
does not work for them.
When --sq flag to git-rev-parse is given, instead of showing one
argument per line, it outputs arguments quoted for consumption
with "eval" by the caller, to remedy this situation.
As an example, this patch converts git-whatchanged to use this
new feature.
Signed-off-by: Junio C Hamano <junkio@cox.net>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-07-23 02:08:32 +00:00
|
|
|
if (!strcmp(arg, "--sq")) {
|
|
|
|
output_sq = 1;
|
|
|
|
continue;
|
|
|
|
}
|
2005-06-26 18:34:30 +00:00
|
|
|
if (!strcmp(arg, "--not")) {
|
|
|
|
show_type ^= REVERSED;
|
|
|
|
continue;
|
|
|
|
}
|
2005-08-16 19:36:46 +00:00
|
|
|
if (!strcmp(arg, "--symbolic")) {
|
2008-01-05 20:09:55 +00:00
|
|
|
symbolic = SHOW_SYMBOLIC_ASIS;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (!strcmp(arg, "--symbolic-full-name")) {
|
|
|
|
symbolic = SHOW_SYMBOLIC_FULL;
|
2005-08-16 19:36:46 +00:00
|
|
|
continue;
|
|
|
|
}
|
2009-04-13 11:20:26 +00:00
|
|
|
if (!prefixcmp(arg, "--abbrev-ref") &&
|
|
|
|
(!arg[12] || arg[12] == '=')) {
|
|
|
|
abbrev_ref = 1;
|
|
|
|
abbrev_ref_strict = warn_ambiguous_refs;
|
|
|
|
if (arg[12] == '=') {
|
|
|
|
if (!strcmp(arg + 13, "strict"))
|
|
|
|
abbrev_ref_strict = 1;
|
|
|
|
else if (!strcmp(arg + 13, "loose"))
|
|
|
|
abbrev_ref_strict = 0;
|
|
|
|
else
|
|
|
|
die("unknown mode for %s", arg);
|
|
|
|
}
|
|
|
|
continue;
|
|
|
|
}
|
2005-07-03 20:07:52 +00:00
|
|
|
if (!strcmp(arg, "--all")) {
|
2006-09-21 04:47:42 +00:00
|
|
|
for_each_ref(show_reference, NULL);
|
2005-07-03 20:07:52 +00:00
|
|
|
continue;
|
|
|
|
}
|
2009-10-27 18:28:07 +00:00
|
|
|
if (!strcmp(arg, "--bisect")) {
|
|
|
|
for_each_ref_in("refs/bisect/bad", show_reference, NULL);
|
|
|
|
for_each_ref_in("refs/bisect/good", anti_reference, NULL);
|
|
|
|
continue;
|
|
|
|
}
|
2010-01-20 09:48:26 +00:00
|
|
|
if (!prefixcmp(arg, "--branches=")) {
|
|
|
|
for_each_glob_ref_in(show_reference, arg + 11,
|
|
|
|
"refs/heads/", NULL);
|
|
|
|
continue;
|
|
|
|
}
|
2006-05-14 01:43:00 +00:00
|
|
|
if (!strcmp(arg, "--branches")) {
|
2006-09-21 04:47:42 +00:00
|
|
|
for_each_branch_ref(show_reference, NULL);
|
2006-05-14 01:43:00 +00:00
|
|
|
continue;
|
|
|
|
}
|
2010-01-20 09:48:26 +00:00
|
|
|
if (!prefixcmp(arg, "--tags=")) {
|
|
|
|
for_each_glob_ref_in(show_reference, arg + 7,
|
|
|
|
"refs/tags/", NULL);
|
|
|
|
continue;
|
|
|
|
}
|
2006-05-14 01:43:00 +00:00
|
|
|
if (!strcmp(arg, "--tags")) {
|
2006-09-21 04:47:42 +00:00
|
|
|
for_each_tag_ref(show_reference, NULL);
|
2006-05-14 01:43:00 +00:00
|
|
|
continue;
|
|
|
|
}
|
2010-01-20 09:48:25 +00:00
|
|
|
if (!prefixcmp(arg, "--glob=")) {
|
|
|
|
for_each_glob_ref(show_reference, arg + 7, NULL);
|
|
|
|
continue;
|
|
|
|
}
|
2010-01-20 09:48:26 +00:00
|
|
|
if (!prefixcmp(arg, "--remotes=")) {
|
|
|
|
for_each_glob_ref_in(show_reference, arg + 10,
|
|
|
|
"refs/remotes/", NULL);
|
|
|
|
continue;
|
|
|
|
}
|
2006-05-14 01:43:00 +00:00
|
|
|
if (!strcmp(arg, "--remotes")) {
|
2006-09-21 04:47:42 +00:00
|
|
|
for_each_remote_ref(show_reference, NULL);
|
2006-05-14 01:43:00 +00:00
|
|
|
continue;
|
|
|
|
}
|
2010-01-11 22:33:48 +00:00
|
|
|
if (!strcmp(arg, "--show-toplevel")) {
|
|
|
|
const char *work_tree = get_git_work_tree();
|
|
|
|
if (work_tree)
|
|
|
|
puts(work_tree);
|
|
|
|
continue;
|
|
|
|
}
|
2005-08-17 01:06:34 +00:00
|
|
|
if (!strcmp(arg, "--show-prefix")) {
|
2005-08-24 21:30:04 +00:00
|
|
|
if (prefix)
|
|
|
|
puts(prefix);
|
2005-08-17 01:06:34 +00:00
|
|
|
continue;
|
|
|
|
}
|
2005-12-23 06:35:38 +00:00
|
|
|
if (!strcmp(arg, "--show-cdup")) {
|
|
|
|
const char *pfx = prefix;
|
Clean up work-tree handling
The old version of work-tree support was an unholy mess, barely readable,
and not to the point.
For example, why do you have to provide a worktree, when it is not used?
As in "git status". Now it works.
Another riddle was: if you can have work trees inside the git dir, why
are some programs complaining that they need a work tree?
IOW it is allowed to call
$ git --git-dir=../ --work-tree=. bla
when you really want to. In this case, you are both in the git directory
and in the working tree. So, programs have to actually test for the right
thing, namely if they are inside a working tree, and not if they are
inside a git directory.
Also, GIT_DIR=../.git should behave the same as if no GIT_DIR was
specified, unless there is a repository in the current working directory.
It does now.
The logic to determine if a repository is bare, or has a work tree
(tertium non datur), is this:
--work-tree=bla overrides GIT_WORK_TREE, which overrides core.bare = true,
which overrides core.worktree, which overrides GIT_DIR/.. when GIT_DIR
ends in /.git, which overrides the directory in which .git/ was found.
In related news, a long standing bug was fixed: when in .git/bla/x.git/,
which is a bare repository, git formerly assumed ../.. to be the
appropriate git dir. This problem was reported by Shawn Pearce to have
caused much pain, where a colleague mistakenly ran "git init" in "/" a
long time ago, and bare repositories just would not work.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2007-08-01 00:30:14 +00:00
|
|
|
if (!is_inside_work_tree()) {
|
|
|
|
const char *work_tree =
|
|
|
|
get_git_work_tree();
|
|
|
|
if (work_tree)
|
|
|
|
printf("%s\n", work_tree);
|
|
|
|
continue;
|
|
|
|
}
|
2005-12-23 06:35:38 +00:00
|
|
|
while (pfx) {
|
|
|
|
pfx = strchr(pfx, '/');
|
|
|
|
if (pfx) {
|
|
|
|
pfx++;
|
|
|
|
printf("../");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
putchar('\n');
|
|
|
|
continue;
|
|
|
|
}
|
2005-09-18 18:18:30 +00:00
|
|
|
if (!strcmp(arg, "--git-dir")) {
|
|
|
|
const char *gitdir = getenv(GIT_DIR_ENVIRONMENT);
|
|
|
|
static char cwd[PATH_MAX];
|
|
|
|
if (gitdir) {
|
|
|
|
puts(gitdir);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (!prefix) {
|
|
|
|
puts(".git");
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (!getcwd(cwd, PATH_MAX))
|
2009-06-27 15:58:47 +00:00
|
|
|
die_errno("unable to get current working directory");
|
2005-09-18 18:18:30 +00:00
|
|
|
printf("%s/.git\n", cwd);
|
|
|
|
continue;
|
|
|
|
}
|
2007-01-23 12:30:20 +00:00
|
|
|
if (!strcmp(arg, "--is-inside-git-dir")) {
|
|
|
|
printf("%s\n", is_inside_git_dir() ? "true"
|
|
|
|
: "false");
|
|
|
|
continue;
|
|
|
|
}
|
2007-06-06 07:10:42 +00:00
|
|
|
if (!strcmp(arg, "--is-inside-work-tree")) {
|
|
|
|
printf("%s\n", is_inside_work_tree() ? "true"
|
|
|
|
: "false");
|
|
|
|
continue;
|
|
|
|
}
|
2007-06-03 14:46:36 +00:00
|
|
|
if (!strcmp(arg, "--is-bare-repository")) {
|
|
|
|
printf("%s\n", is_bare_repository() ? "true"
|
|
|
|
: "false");
|
|
|
|
continue;
|
|
|
|
}
|
Mechanical conversion to use prefixcmp()
This mechanically converts strncmp() to use prefixcmp(), but only when
the parameters match specific patterns, so that they can be verified
easily. Leftover from this will be fixed in a separate step, including
idiotic conversions like
if (!strncmp("foo", arg, 3))
=>
if (!(-prefixcmp(arg, "foo")))
This was done by using this script in px.perl
#!/usr/bin/perl -i.bak -p
if (/strncmp\(([^,]+), "([^\\"]*)", (\d+)\)/ && (length($2) == $3)) {
s|strncmp\(([^,]+), "([^\\"]*)", (\d+)\)|prefixcmp($1, "$2")|;
}
if (/strncmp\("([^\\"]*)", ([^,]+), (\d+)\)/ && (length($1) == $3)) {
s|strncmp\("([^\\"]*)", ([^,]+), (\d+)\)|(-prefixcmp($2, "$1"))|;
}
and running:
$ git grep -l strncmp -- '*.c' | xargs perl px.perl
Signed-off-by: Junio C Hamano <junkio@cox.net>
2007-02-20 09:53:29 +00:00
|
|
|
if (!prefixcmp(arg, "--since=")) {
|
2005-09-20 21:13:24 +00:00
|
|
|
show_datestring("--max-age=", arg+8);
|
|
|
|
continue;
|
|
|
|
}
|
Mechanical conversion to use prefixcmp()
This mechanically converts strncmp() to use prefixcmp(), but only when
the parameters match specific patterns, so that they can be verified
easily. Leftover from this will be fixed in a separate step, including
idiotic conversions like
if (!strncmp("foo", arg, 3))
=>
if (!(-prefixcmp(arg, "foo")))
This was done by using this script in px.perl
#!/usr/bin/perl -i.bak -p
if (/strncmp\(([^,]+), "([^\\"]*)", (\d+)\)/ && (length($2) == $3)) {
s|strncmp\(([^,]+), "([^\\"]*)", (\d+)\)|prefixcmp($1, "$2")|;
}
if (/strncmp\("([^\\"]*)", ([^,]+), (\d+)\)/ && (length($1) == $3)) {
s|strncmp\("([^\\"]*)", ([^,]+), (\d+)\)|(-prefixcmp($2, "$1"))|;
}
and running:
$ git grep -l strncmp -- '*.c' | xargs perl px.perl
Signed-off-by: Junio C Hamano <junkio@cox.net>
2007-02-20 09:53:29 +00:00
|
|
|
if (!prefixcmp(arg, "--after=")) {
|
2005-09-20 21:13:24 +00:00
|
|
|
show_datestring("--max-age=", arg+8);
|
|
|
|
continue;
|
|
|
|
}
|
Mechanical conversion to use prefixcmp()
This mechanically converts strncmp() to use prefixcmp(), but only when
the parameters match specific patterns, so that they can be verified
easily. Leftover from this will be fixed in a separate step, including
idiotic conversions like
if (!strncmp("foo", arg, 3))
=>
if (!(-prefixcmp(arg, "foo")))
This was done by using this script in px.perl
#!/usr/bin/perl -i.bak -p
if (/strncmp\(([^,]+), "([^\\"]*)", (\d+)\)/ && (length($2) == $3)) {
s|strncmp\(([^,]+), "([^\\"]*)", (\d+)\)|prefixcmp($1, "$2")|;
}
if (/strncmp\("([^\\"]*)", ([^,]+), (\d+)\)/ && (length($1) == $3)) {
s|strncmp\("([^\\"]*)", ([^,]+), (\d+)\)|(-prefixcmp($2, "$1"))|;
}
and running:
$ git grep -l strncmp -- '*.c' | xargs perl px.perl
Signed-off-by: Junio C Hamano <junkio@cox.net>
2007-02-20 09:53:29 +00:00
|
|
|
if (!prefixcmp(arg, "--before=")) {
|
2005-09-20 21:13:24 +00:00
|
|
|
show_datestring("--min-age=", arg+9);
|
|
|
|
continue;
|
|
|
|
}
|
Mechanical conversion to use prefixcmp()
This mechanically converts strncmp() to use prefixcmp(), but only when
the parameters match specific patterns, so that they can be verified
easily. Leftover from this will be fixed in a separate step, including
idiotic conversions like
if (!strncmp("foo", arg, 3))
=>
if (!(-prefixcmp(arg, "foo")))
This was done by using this script in px.perl
#!/usr/bin/perl -i.bak -p
if (/strncmp\(([^,]+), "([^\\"]*)", (\d+)\)/ && (length($2) == $3)) {
s|strncmp\(([^,]+), "([^\\"]*)", (\d+)\)|prefixcmp($1, "$2")|;
}
if (/strncmp\("([^\\"]*)", ([^,]+), (\d+)\)/ && (length($1) == $3)) {
s|strncmp\("([^\\"]*)", ([^,]+), (\d+)\)|(-prefixcmp($2, "$1"))|;
}
and running:
$ git grep -l strncmp -- '*.c' | xargs perl px.perl
Signed-off-by: Junio C Hamano <junkio@cox.net>
2007-02-20 09:53:29 +00:00
|
|
|
if (!prefixcmp(arg, "--until=")) {
|
2005-09-20 21:13:24 +00:00
|
|
|
show_datestring("--min-age=", arg+8);
|
|
|
|
continue;
|
|
|
|
}
|
2006-02-05 19:58:34 +00:00
|
|
|
if (show_flag(arg) && verify)
|
2008-04-26 11:57:23 +00:00
|
|
|
die_no_single_rev(quiet);
|
2005-06-13 17:06:50 +00:00
|
|
|
continue;
|
|
|
|
}
|
2005-08-24 21:30:04 +00:00
|
|
|
|
|
|
|
/* Not a flag argument */
|
2006-07-04 09:02:22 +00:00
|
|
|
if (try_difference(arg))
|
|
|
|
continue;
|
2008-07-26 16:37:56 +00:00
|
|
|
if (try_parent_shorthands(arg))
|
|
|
|
continue;
|
2008-05-11 16:28:25 +00:00
|
|
|
name = arg;
|
|
|
|
type = NORMAL;
|
|
|
|
if (*arg == '^') {
|
|
|
|
name++;
|
|
|
|
type = REVERSED;
|
2005-06-20 15:29:13 +00:00
|
|
|
}
|
2008-05-11 16:28:25 +00:00
|
|
|
if (!get_sha1(name, sha1)) {
|
|
|
|
if (verify)
|
|
|
|
revs_count++;
|
|
|
|
else
|
|
|
|
show_rev(type, sha1, name);
|
2005-06-20 15:29:13 +00:00
|
|
|
continue;
|
|
|
|
}
|
2008-04-26 13:19:29 +00:00
|
|
|
if (verify)
|
|
|
|
die_no_single_rev(quiet);
|
2006-02-06 05:41:47 +00:00
|
|
|
as_is = 1;
|
|
|
|
if (!show_file(arg))
|
|
|
|
continue;
|
2006-04-26 17:15:54 +00:00
|
|
|
verify_filename(prefix, arg);
|
2005-06-24 17:12:55 +00:00
|
|
|
}
|
2008-05-11 16:28:25 +00:00
|
|
|
if (verify) {
|
|
|
|
if (revs_count == 1) {
|
|
|
|
show_rev(type, sha1, name);
|
|
|
|
return 0;
|
|
|
|
} else if (revs_count == 0 && show_default())
|
|
|
|
return 0;
|
2008-04-26 11:57:23 +00:00
|
|
|
die_no_single_rev(quiet);
|
2008-05-11 16:28:25 +00:00
|
|
|
} else
|
|
|
|
show_default();
|
2005-06-13 17:06:50 +00:00
|
|
|
return 0;
|
|
|
|
}
|