Merge branch 'maint-1.5.4' into maint
[git] / builtin-rev-parse.c
1 /*
2  * rev-parse.c
3  *
4  * Copyright (C) Linus Torvalds, 2005
5  */
6 #include "cache.h"
7 #include "commit.h"
8 #include "refs.h"
9 #include "quote.h"
10 #include "builtin.h"
11 #include "parse-options.h"
12
13 #define DO_REVS         1
14 #define DO_NOREV        2
15 #define DO_FLAGS        4
16 #define DO_NONFLAGS     8
17 static int filter = ~0;
18
19 static const char *def;
20
21 #define NORMAL 0
22 #define REVERSED 1
23 static int show_type = NORMAL;
24
25 #define SHOW_SYMBOLIC_ASIS 1
26 #define SHOW_SYMBOLIC_FULL 2
27 static int symbolic;
28 static int abbrev;
29 static int output_sq;
30
31 static int revs_count;
32
33 /*
34  * Some arguments are relevant "revision" arguments,
35  * others are about output format or other details.
36  * This sorts it all out.
37  */
38 static int is_rev_argument(const char *arg)
39 {
40         static const char *rev_args[] = {
41                 "--all",
42                 "--bisect",
43                 "--dense",
44                 "--branches",
45                 "--header",
46                 "--max-age=",
47                 "--max-count=",
48                 "--min-age=",
49                 "--no-merges",
50                 "--objects",
51                 "--objects-edge",
52                 "--parents",
53                 "--pretty",
54                 "--remotes",
55                 "--sparse",
56                 "--tags",
57                 "--topo-order",
58                 "--date-order",
59                 "--unpacked",
60                 NULL
61         };
62         const char **p = rev_args;
63
64         /* accept -<digit>, like traditional "head" */
65         if ((*arg == '-') && isdigit(arg[1]))
66                 return 1;
67
68         for (;;) {
69                 const char *str = *p++;
70                 int len;
71                 if (!str)
72                         return 0;
73                 len = strlen(str);
74                 if (!strcmp(arg, str) ||
75                     (str[len-1] == '=' && !strncmp(arg, str, len)))
76                         return 1;
77         }
78 }
79
80 /* Output argument as a string, either SQ or normal */
81 static void show(const char *arg)
82 {
83         if (output_sq) {
84                 int sq = '\'', ch;
85
86                 putchar(sq);
87                 while ((ch = *arg++)) {
88                         if (ch == sq)
89                                 fputs("'\\'", stdout);
90                         putchar(ch);
91                 }
92                 putchar(sq);
93                 putchar(' ');
94         }
95         else
96                 puts(arg);
97 }
98
99 /* Like show(), but with a negation prefix according to type */
100 static void show_with_type(int type, const char *arg)
101 {
102         if (type != show_type)
103                 putchar('^');
104         show(arg);
105 }
106
107 /* Output a revision, only if filter allows it */
108 static void show_rev(int type, const unsigned char *sha1, const char *name)
109 {
110         if (!(filter & DO_REVS))
111                 return;
112         def = NULL;
113         revs_count++;
114
115         if (symbolic && name) {
116                 if (symbolic == SHOW_SYMBOLIC_FULL) {
117                         unsigned char discard[20];
118                         char *full;
119
120                         switch (dwim_ref(name, strlen(name), discard, &full)) {
121                         case 0:
122                                 /*
123                                  * Not found -- not a ref.  We could
124                                  * emit "name" here, but symbolic-full
125                                  * users are interested in finding the
126                                  * refs spelled in full, and they would
127                                  * need to filter non-refs if we did so.
128                                  */
129                                 break;
130                         case 1: /* happy */
131                                 show_with_type(type, full);
132                                 break;
133                         default: /* ambiguous */
134                                 error("refname '%s' is ambiguous", name);
135                                 break;
136                         }
137                 } else {
138                         show_with_type(type, name);
139                 }
140         }
141         else if (abbrev)
142                 show_with_type(type, find_unique_abbrev(sha1, abbrev));
143         else
144                 show_with_type(type, sha1_to_hex(sha1));
145 }
146
147 /* Output a flag, only if filter allows it. */
148 static int show_flag(const char *arg)
149 {
150         if (!(filter & DO_FLAGS))
151                 return 0;
152         if (filter & (is_rev_argument(arg) ? DO_REVS : DO_NOREV)) {
153                 show(arg);
154                 return 1;
155         }
156         return 0;
157 }
158
159 static void show_default(void)
160 {
161         const char *s = def;
162
163         if (s) {
164                 unsigned char sha1[20];
165
166                 def = NULL;
167                 if (!get_sha1(s, sha1)) {
168                         show_rev(NORMAL, sha1, s);
169                         return;
170                 }
171         }
172 }
173
174 static int show_reference(const char *refname, const unsigned char *sha1, int flag, void *cb_data)
175 {
176         show_rev(NORMAL, sha1, refname);
177         return 0;
178 }
179
180 static void show_datestring(const char *flag, const char *datestr)
181 {
182         static char buffer[100];
183
184         /* date handling requires both flags and revs */
185         if ((filter & (DO_FLAGS | DO_REVS)) != (DO_FLAGS | DO_REVS))
186                 return;
187         snprintf(buffer, sizeof(buffer), "%s%lu", flag, approxidate(datestr));
188         show(buffer);
189 }
190
191 static int show_file(const char *arg)
192 {
193         show_default();
194         if ((filter & (DO_NONFLAGS|DO_NOREV)) == (DO_NONFLAGS|DO_NOREV)) {
195                 show(arg);
196                 return 1;
197         }
198         return 0;
199 }
200
201 static int try_difference(const char *arg)
202 {
203         char *dotdot;
204         unsigned char sha1[20];
205         unsigned char end[20];
206         const char *next;
207         const char *this;
208         int symmetric;
209
210         if (!(dotdot = strstr(arg, "..")))
211                 return 0;
212         next = dotdot + 2;
213         this = arg;
214         symmetric = (*next == '.');
215
216         *dotdot = 0;
217         next += symmetric;
218
219         if (!*next)
220                 next = "HEAD";
221         if (dotdot == arg)
222                 this = "HEAD";
223         if (!get_sha1(this, sha1) && !get_sha1(next, end)) {
224                 show_rev(NORMAL, end, next);
225                 show_rev(symmetric ? NORMAL : REVERSED, sha1, this);
226                 if (symmetric) {
227                         struct commit_list *exclude;
228                         struct commit *a, *b;
229                         a = lookup_commit_reference(sha1);
230                         b = lookup_commit_reference(end);
231                         exclude = get_merge_bases(a, b, 1);
232                         while (exclude) {
233                                 struct commit_list *n = exclude->next;
234                                 show_rev(REVERSED,
235                                          exclude->item->object.sha1,NULL);
236                                 free(exclude);
237                                 exclude = n;
238                         }
239                 }
240                 return 1;
241         }
242         *dotdot = '.';
243         return 0;
244 }
245
246 static int parseopt_dump(const struct option *o, const char *arg, int unset)
247 {
248         struct strbuf *parsed = o->value;
249         if (unset)
250                 strbuf_addf(parsed, " --no-%s", o->long_name);
251         else if (o->short_name)
252                 strbuf_addf(parsed, " -%c", o->short_name);
253         else
254                 strbuf_addf(parsed, " --%s", o->long_name);
255         if (arg) {
256                 strbuf_addch(parsed, ' ');
257                 sq_quote_buf(parsed, arg);
258         }
259         return 0;
260 }
261
262 static const char *skipspaces(const char *s)
263 {
264         while (isspace(*s))
265                 s++;
266         return s;
267 }
268
269 static int cmd_parseopt(int argc, const char **argv, const char *prefix)
270 {
271         static int keep_dashdash = 0;
272         static char const * const parseopt_usage[] = {
273                 "git-rev-parse --parseopt [options] -- [<args>...]",
274                 NULL
275         };
276         static struct option parseopt_opts[] = {
277                 OPT_BOOLEAN(0, "keep-dashdash", &keep_dashdash,
278                                         "keep the `--` passed as an arg"),
279                 OPT_END(),
280         };
281
282         struct strbuf sb, parsed;
283         const char **usage = NULL;
284         struct option *opts = NULL;
285         int onb = 0, osz = 0, unb = 0, usz = 0;
286
287         strbuf_init(&parsed, 0);
288         strbuf_addstr(&parsed, "set --");
289         argc = parse_options(argc, argv, parseopt_opts, parseopt_usage,
290                              PARSE_OPT_KEEP_DASHDASH);
291         if (argc < 1 || strcmp(argv[0], "--"))
292                 usage_with_options(parseopt_usage, parseopt_opts);
293
294         strbuf_init(&sb, 0);
295         /* get the usage up to the first line with a -- on it */
296         for (;;) {
297                 if (strbuf_getline(&sb, stdin, '\n') == EOF)
298                         die("premature end of input");
299                 ALLOC_GROW(usage, unb + 1, usz);
300                 if (!strcmp("--", sb.buf)) {
301                         if (unb < 1)
302                                 die("no usage string given before the `--' separator");
303                         usage[unb] = NULL;
304                         break;
305                 }
306                 usage[unb++] = strbuf_detach(&sb, NULL);
307         }
308
309         /* parse: (<short>|<short>,<long>|<long>)[=?]? SP+ <help> */
310         while (strbuf_getline(&sb, stdin, '\n') != EOF) {
311                 const char *s;
312                 struct option *o;
313
314                 if (!sb.len)
315                         continue;
316
317                 ALLOC_GROW(opts, onb + 1, osz);
318                 memset(opts + onb, 0, sizeof(opts[onb]));
319
320                 o = &opts[onb++];
321                 s = strchr(sb.buf, ' ');
322                 if (!s || *sb.buf == ' ') {
323                         o->type = OPTION_GROUP;
324                         o->help = xstrdup(skipspaces(sb.buf));
325                         continue;
326                 }
327
328                 o->type = OPTION_CALLBACK;
329                 o->help = xstrdup(skipspaces(s));
330                 o->value = &parsed;
331                 o->flags = PARSE_OPT_NOARG;
332                 o->callback = &parseopt_dump;
333                 while (s > sb.buf && strchr("*=?!", s[-1])) {
334                         switch (*--s) {
335                         case '=':
336                                 o->flags &= ~PARSE_OPT_NOARG;
337                                 break;
338                         case '?':
339                                 o->flags &= ~PARSE_OPT_NOARG;
340                                 o->flags |= PARSE_OPT_OPTARG;
341                                 break;
342                         case '!':
343                                 o->flags |= PARSE_OPT_NONEG;
344                                 break;
345                         case '*':
346                                 o->flags |= PARSE_OPT_HIDDEN;
347                                 break;
348                         }
349                 }
350
351                 if (s - sb.buf == 1) /* short option only */
352                         o->short_name = *sb.buf;
353                 else if (sb.buf[1] != ',') /* long option only */
354                         o->long_name = xmemdupz(sb.buf, s - sb.buf);
355                 else {
356                         o->short_name = *sb.buf;
357                         o->long_name = xmemdupz(sb.buf + 2, s - sb.buf - 2);
358                 }
359         }
360         strbuf_release(&sb);
361
362         /* put an OPT_END() */
363         ALLOC_GROW(opts, onb + 1, osz);
364         memset(opts + onb, 0, sizeof(opts[onb]));
365         argc = parse_options(argc, argv, opts, usage,
366                              keep_dashdash ? PARSE_OPT_KEEP_DASHDASH : 0);
367
368         strbuf_addf(&parsed, " --");
369         sq_quote_argv(&parsed, argv, 0);
370         puts(parsed.buf);
371         return 0;
372 }
373
374 int cmd_rev_parse(int argc, const char **argv, const char *prefix)
375 {
376         int i, as_is = 0, verify = 0;
377         unsigned char sha1[20];
378
379         if (argc > 1 && !strcmp("--parseopt", argv[1]))
380                 return cmd_parseopt(argc - 1, argv + 1, prefix);
381
382         prefix = setup_git_directory();
383         git_config(git_default_config);
384         for (i = 1; i < argc; i++) {
385                 const char *arg = argv[i];
386
387                 if (as_is) {
388                         if (show_file(arg) && as_is < 2)
389                                 verify_filename(prefix, arg);
390                         continue;
391                 }
392                 if (!strcmp(arg,"-n")) {
393                         if (++i >= argc)
394                                 die("-n requires an argument");
395                         if ((filter & DO_FLAGS) && (filter & DO_REVS)) {
396                                 show(arg);
397                                 show(argv[i]);
398                         }
399                         continue;
400                 }
401                 if (!prefixcmp(arg, "-n")) {
402                         if ((filter & DO_FLAGS) && (filter & DO_REVS))
403                                 show(arg);
404                         continue;
405                 }
406
407                 if (*arg == '-') {
408                         if (!strcmp(arg, "--")) {
409                                 as_is = 2;
410                                 /* Pass on the "--" if we show anything but files.. */
411                                 if (filter & (DO_FLAGS | DO_REVS))
412                                         show_file(arg);
413                                 continue;
414                         }
415                         if (!strcmp(arg, "--default")) {
416                                 def = argv[i+1];
417                                 i++;
418                                 continue;
419                         }
420                         if (!strcmp(arg, "--revs-only")) {
421                                 filter &= ~DO_NOREV;
422                                 continue;
423                         }
424                         if (!strcmp(arg, "--no-revs")) {
425                                 filter &= ~DO_REVS;
426                                 continue;
427                         }
428                         if (!strcmp(arg, "--flags")) {
429                                 filter &= ~DO_NONFLAGS;
430                                 continue;
431                         }
432                         if (!strcmp(arg, "--no-flags")) {
433                                 filter &= ~DO_FLAGS;
434                                 continue;
435                         }
436                         if (!strcmp(arg, "--verify")) {
437                                 filter &= ~(DO_FLAGS|DO_NOREV);
438                                 verify = 1;
439                                 continue;
440                         }
441                         if (!strcmp(arg, "--short") ||
442                             !prefixcmp(arg, "--short=")) {
443                                 filter &= ~(DO_FLAGS|DO_NOREV);
444                                 verify = 1;
445                                 abbrev = DEFAULT_ABBREV;
446                                 if (arg[7] == '=')
447                                         abbrev = strtoul(arg + 8, NULL, 10);
448                                 if (abbrev < MINIMUM_ABBREV)
449                                         abbrev = MINIMUM_ABBREV;
450                                 else if (40 <= abbrev)
451                                         abbrev = 40;
452                                 continue;
453                         }
454                         if (!strcmp(arg, "--sq")) {
455                                 output_sq = 1;
456                                 continue;
457                         }
458                         if (!strcmp(arg, "--not")) {
459                                 show_type ^= REVERSED;
460                                 continue;
461                         }
462                         if (!strcmp(arg, "--symbolic")) {
463                                 symbolic = SHOW_SYMBOLIC_ASIS;
464                                 continue;
465                         }
466                         if (!strcmp(arg, "--symbolic-full-name")) {
467                                 symbolic = SHOW_SYMBOLIC_FULL;
468                                 continue;
469                         }
470                         if (!strcmp(arg, "--all")) {
471                                 for_each_ref(show_reference, NULL);
472                                 continue;
473                         }
474                         if (!strcmp(arg, "--branches")) {
475                                 for_each_branch_ref(show_reference, NULL);
476                                 continue;
477                         }
478                         if (!strcmp(arg, "--tags")) {
479                                 for_each_tag_ref(show_reference, NULL);
480                                 continue;
481                         }
482                         if (!strcmp(arg, "--remotes")) {
483                                 for_each_remote_ref(show_reference, NULL);
484                                 continue;
485                         }
486                         if (!strcmp(arg, "--show-prefix")) {
487                                 if (prefix)
488                                         puts(prefix);
489                                 continue;
490                         }
491                         if (!strcmp(arg, "--show-cdup")) {
492                                 const char *pfx = prefix;
493                                 if (!is_inside_work_tree()) {
494                                         const char *work_tree =
495                                                 get_git_work_tree();
496                                         if (work_tree)
497                                                 printf("%s\n", work_tree);
498                                         continue;
499                                 }
500                                 while (pfx) {
501                                         pfx = strchr(pfx, '/');
502                                         if (pfx) {
503                                                 pfx++;
504                                                 printf("../");
505                                         }
506                                 }
507                                 putchar('\n');
508                                 continue;
509                         }
510                         if (!strcmp(arg, "--git-dir")) {
511                                 const char *gitdir = getenv(GIT_DIR_ENVIRONMENT);
512                                 static char cwd[PATH_MAX];
513                                 if (gitdir) {
514                                         puts(gitdir);
515                                         continue;
516                                 }
517                                 if (!prefix) {
518                                         puts(".git");
519                                         continue;
520                                 }
521                                 if (!getcwd(cwd, PATH_MAX))
522                                         die("unable to get current working directory");
523                                 printf("%s/.git\n", cwd);
524                                 continue;
525                         }
526                         if (!strcmp(arg, "--is-inside-git-dir")) {
527                                 printf("%s\n", is_inside_git_dir() ? "true"
528                                                 : "false");
529                                 continue;
530                         }
531                         if (!strcmp(arg, "--is-inside-work-tree")) {
532                                 printf("%s\n", is_inside_work_tree() ? "true"
533                                                 : "false");
534                                 continue;
535                         }
536                         if (!strcmp(arg, "--is-bare-repository")) {
537                                 printf("%s\n", is_bare_repository() ? "true"
538                                                 : "false");
539                                 continue;
540                         }
541                         if (!prefixcmp(arg, "--since=")) {
542                                 show_datestring("--max-age=", arg+8);
543                                 continue;
544                         }
545                         if (!prefixcmp(arg, "--after=")) {
546                                 show_datestring("--max-age=", arg+8);
547                                 continue;
548                         }
549                         if (!prefixcmp(arg, "--before=")) {
550                                 show_datestring("--min-age=", arg+9);
551                                 continue;
552                         }
553                         if (!prefixcmp(arg, "--until=")) {
554                                 show_datestring("--min-age=", arg+8);
555                                 continue;
556                         }
557                         if (show_flag(arg) && verify)
558                                 die("Needed a single revision");
559                         continue;
560                 }
561
562                 /* Not a flag argument */
563                 if (try_difference(arg))
564                         continue;
565                 if (!get_sha1(arg, sha1)) {
566                         show_rev(NORMAL, sha1, arg);
567                         continue;
568                 }
569                 if (*arg == '^' && !get_sha1(arg+1, sha1)) {
570                         show_rev(REVERSED, sha1, arg+1);
571                         continue;
572                 }
573                 as_is = 1;
574                 if (!show_file(arg))
575                         continue;
576                 if (verify)
577                         die("Needed a single revision");
578                 verify_filename(prefix, arg);
579         }
580         show_default();
581         if (verify && revs_count != 1)
582                 die("Needed a single revision");
583         return 0;
584 }