Andrew's git / gitweb.git / builtin-rev-parse.c
?
builtin-rev-parse.con commit Include a git-push example for creating a remote branch (4e56015)
   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
  12#define DO_REVS         1
  13#define DO_NOREV        2
  14#define DO_FLAGS        4
  15#define DO_NONFLAGS     8
  16static int filter = ~0;
  17
  18static const char *def;
  19
  20#define NORMAL 0
  21#define REVERSED 1
  22static int show_type = NORMAL;
  23static int symbolic;
  24static int abbrev;
  25static int output_sq;
  26
  27static int revs_count;
  28
  29/*
  30 * Some arguments are relevant "revision" arguments,
  31 * others are about output format or other details.
  32 * This sorts it all out.
  33 */
  34static int is_rev_argument(const char *arg)
  35{
  36        static const char *rev_args[] = {
  37                "--all",
  38                "--bisect",
  39                "--dense",
  40                "--branches",
  41                "--header",
  42                "--max-age=",
  43                "--max-count=",
  44                "--min-age=",
  45                "--no-merges",
  46                "--objects",
  47                "--objects-edge",
  48                "--parents",
  49                "--pretty",
  50                "--remotes",
  51                "--sparse",
  52                "--tags",
  53                "--topo-order",
  54                "--date-order",
  55                "--unpacked",
  56                NULL
  57        };
  58        const char **p = rev_args;
  59
  60        /* accept -<digit>, like traditional "head" */
  61        if ((*arg == '-') && isdigit(arg[1]))
  62                return 1;
  63
  64        for (;;) {
  65                const char *str = *p++;
  66                int len;
  67                if (!str)
  68                        return 0;
  69                len = strlen(str);
  70                if (!strcmp(arg, str) ||
  71                    (str[len-1] == '=' && !strncmp(arg, str, len)))
  72                        return 1;
  73        }
  74}
  75
  76/* Output argument as a string, either SQ or normal */
  77static void show(const char *arg)
  78{
  79        if (output_sq) {
  80                int sq = '\'', ch;
  81
  82                putchar(sq);
  83                while ((ch = *arg++)) {
  84                        if (ch == sq)
  85                                fputs("'\\'", stdout);
  86                        putchar(ch);
  87                }
  88                putchar(sq);
  89                putchar(' ');
  90        }
  91        else
  92                puts(arg);
  93}
  94
  95/* Output a revision, only if filter allows it */
  96static void show_rev(int type, const unsigned char *sha1, const char *name)
  97{
  98        if (!(filter & DO_REVS))
  99                return;
 100        def = NULL;
 101        revs_count++;
 102
 103        if (type != show_type)
 104                putchar('^');
 105        if (symbolic && name)
 106                show(name);
 107        else if (abbrev)
 108                show(find_unique_abbrev(sha1, abbrev));
 109        else
 110                show(sha1_to_hex(sha1));
 111}
 112
 113/* Output a flag, only if filter allows it. */
 114static int show_flag(const char *arg)
 115{
 116        if (!(filter & DO_FLAGS))
 117                return 0;
 118        if (filter & (is_rev_argument(arg) ? DO_REVS : DO_NOREV)) {
 119                show(arg);
 120                return 1;
 121        }
 122        return 0;
 123}
 124
 125static void show_default(void)
 126{
 127        const char *s = def;
 128
 129        if (s) {
 130                unsigned char sha1[20];
 131
 132                def = NULL;
 133                if (!get_sha1(s, sha1)) {
 134                        show_rev(NORMAL, sha1, s);
 135                        return;
 136                }
 137        }
 138}
 139
 140static int show_reference(const char *refname, const unsigned char *sha1, int flag, void *cb_data)
 141{
 142        show_rev(NORMAL, sha1, refname);
 143        return 0;
 144}
 145
 146static void show_datestring(const char *flag, const char *datestr)
 147{
 148        static char buffer[100];
 149
 150        /* date handling requires both flags and revs */
 151        if ((filter & (DO_FLAGS | DO_REVS)) != (DO_FLAGS | DO_REVS))
 152                return;
 153        snprintf(buffer, sizeof(buffer), "%s%lu", flag, approxidate(datestr));
 154        show(buffer);
 155}
 156
 157static int show_file(const char *arg)
 158{
 159        show_default();
 160        if ((filter & (DO_NONFLAGS|DO_NOREV)) == (DO_NONFLAGS|DO_NOREV)) {
 161                show(arg);
 162                return 1;
 163        }
 164        return 0;
 165}
 166
 167static int try_difference(const char *arg)
 168{
 169        char *dotdot;
 170        unsigned char sha1[20];
 171        unsigned char end[20];
 172        const char *next;
 173        const char *this;
 174        int symmetric;
 175
 176        if (!(dotdot = strstr(arg, "..")))
 177                return 0;
 178        next = dotdot + 2;
 179        this = arg;
 180        symmetric = (*next == '.');
 181
 182        *dotdot = 0;
 183        next += symmetric;
 184
 185        if (!*next)
 186                next = "HEAD";
 187        if (dotdot == arg)
 188                this = "HEAD";
 189        if (!get_sha1(this, sha1) && !get_sha1(next, end)) {
 190                show_rev(NORMAL, end, next);
 191                show_rev(symmetric ? NORMAL : REVERSED, sha1, this);
 192                if (symmetric) {
 193                        struct commit_list *exclude;
 194                        struct commit *a, *b;
 195                        a = lookup_commit_reference(sha1);
 196                        b = lookup_commit_reference(end);
 197                        exclude = get_merge_bases(a, b, 1);
 198                        while (exclude) {
 199                                struct commit_list *n = exclude->next;
 200                                show_rev(REVERSED,
 201                                         exclude->item->object.sha1,NULL);
 202                                free(exclude);
 203                                exclude = n;
 204                        }
 205                }
 206                return 1;
 207        }
 208        *dotdot = '.';
 209        return 0;
 210}
 211
 212int cmd_rev_parse(int argc, const char **argv, const char *prefix)
 213{
 214        int i, as_is = 0, verify = 0;
 215        unsigned char sha1[20];
 216
 217        git_config(git_default_config);
 218
 219        for (i = 1; i < argc; i++) {
 220                const char *arg = argv[i];
 221
 222                if (as_is) {
 223                        if (show_file(arg) && as_is < 2)
 224                                verify_filename(prefix, arg);
 225                        continue;
 226                }
 227                if (!strcmp(arg,"-n")) {
 228                        if (++i >= argc)
 229                                die("-n requires an argument");
 230                        if ((filter & DO_FLAGS) && (filter & DO_REVS)) {
 231                                show(arg);
 232                                show(argv[i]);
 233                        }
 234                        continue;
 235                }
 236                if (!prefixcmp(arg, "-n")) {
 237                        if ((filter & DO_FLAGS) && (filter & DO_REVS))
 238                                show(arg);
 239                        continue;
 240                }
 241
 242                if (*arg == '-') {
 243                        if (!strcmp(arg, "--")) {
 244                                as_is = 2;
 245                                /* Pass on the "--" if we show anything but files.. */
 246                                if (filter & (DO_FLAGS | DO_REVS))
 247                                        show_file(arg);
 248                                continue;
 249                        }
 250                        if (!strcmp(arg, "--default")) {
 251                                def = argv[i+1];
 252                                i++;
 253                                continue;
 254                        }
 255                        if (!strcmp(arg, "--revs-only")) {
 256                                filter &= ~DO_NOREV;
 257                                continue;
 258                        }
 259                        if (!strcmp(arg, "--no-revs")) {
 260                                filter &= ~DO_REVS;
 261                                continue;
 262                        }
 263                        if (!strcmp(arg, "--flags")) {
 264                                filter &= ~DO_NONFLAGS;
 265                                continue;
 266                        }
 267                        if (!strcmp(arg, "--no-flags")) {
 268                                filter &= ~DO_FLAGS;
 269                                continue;
 270                        }
 271                        if (!strcmp(arg, "--verify")) {
 272                                filter &= ~(DO_FLAGS|DO_NOREV);
 273                                verify = 1;
 274                                continue;
 275                        }
 276                        if (!strcmp(arg, "--short") ||
 277                            !prefixcmp(arg, "--short=")) {
 278                                filter &= ~(DO_FLAGS|DO_NOREV);
 279                                verify = 1;
 280                                abbrev = DEFAULT_ABBREV;
 281                                if (arg[7] == '=')
 282                                        abbrev = strtoul(arg + 8, NULL, 10);
 283                                if (abbrev < MINIMUM_ABBREV)
 284                                        abbrev = MINIMUM_ABBREV;
 285                                else if (40 <= abbrev)
 286                                        abbrev = 40;
 287                                continue;
 288                        }
 289                        if (!strcmp(arg, "--sq")) {
 290                                output_sq = 1;
 291                                continue;
 292                        }
 293                        if (!strcmp(arg, "--not")) {
 294                                show_type ^= REVERSED;
 295                                continue;
 296                        }
 297                        if (!strcmp(arg, "--symbolic")) {
 298                                symbolic = 1;
 299                                continue;
 300                        }
 301                        if (!strcmp(arg, "--all")) {
 302                                for_each_ref(show_reference, NULL);
 303                                continue;
 304                        }
 305                        if (!strcmp(arg, "--branches")) {
 306                                for_each_branch_ref(show_reference, NULL);
 307                                continue;
 308                        }
 309                        if (!strcmp(arg, "--tags")) {
 310                                for_each_tag_ref(show_reference, NULL);
 311                                continue;
 312                        }
 313                        if (!strcmp(arg, "--remotes")) {
 314                                for_each_remote_ref(show_reference, NULL);
 315                                continue;
 316                        }
 317                        if (!strcmp(arg, "--show-prefix")) {
 318                                if (prefix)
 319                                        puts(prefix);
 320                                continue;
 321                        }
 322                        if (!strcmp(arg, "--show-cdup")) {
 323                                const char *pfx = prefix;
 324                                if (!is_inside_work_tree()) {
 325                                        const char *work_tree =
 326                                                get_git_work_tree();
 327                                        if (work_tree)
 328                                                printf("%s\n", work_tree);
 329                                        continue;
 330                                }
 331                                while (pfx) {
 332                                        pfx = strchr(pfx, '/');
 333                                        if (pfx) {
 334                                                pfx++;
 335                                                printf("../");
 336                                        }
 337                                }
 338                                putchar('\n');
 339                                continue;
 340                        }
 341                        if (!strcmp(arg, "--git-dir")) {
 342                                const char *gitdir = getenv(GIT_DIR_ENVIRONMENT);
 343                                static char cwd[PATH_MAX];
 344                                if (gitdir) {
 345                                        puts(gitdir);
 346                                        continue;
 347                                }
 348                                if (!prefix) {
 349                                        puts(".git");
 350                                        continue;
 351                                }
 352                                if (!getcwd(cwd, PATH_MAX))
 353                                        die("unable to get current working directory");
 354                                printf("%s/.git\n", cwd);
 355                                continue;
 356                        }
 357                        if (!strcmp(arg, "--is-inside-git-dir")) {
 358                                printf("%s\n", is_inside_git_dir() ? "true"
 359                                                : "false");
 360                                continue;
 361                        }
 362                        if (!strcmp(arg, "--is-inside-work-tree")) {
 363                                printf("%s\n", is_inside_work_tree() ? "true"
 364                                                : "false");
 365                                continue;
 366                        }
 367                        if (!strcmp(arg, "--is-bare-repository")) {
 368                                printf("%s\n", is_bare_repository() ? "true"
 369                                                : "false");
 370                                continue;
 371                        }
 372                        if (!prefixcmp(arg, "--since=")) {
 373                                show_datestring("--max-age=", arg+8);
 374                                continue;
 375                        }
 376                        if (!prefixcmp(arg, "--after=")) {
 377                                show_datestring("--max-age=", arg+8);
 378                                continue;
 379                        }
 380                        if (!prefixcmp(arg, "--before=")) {
 381                                show_datestring("--min-age=", arg+9);
 382                                continue;
 383                        }
 384                        if (!prefixcmp(arg, "--until=")) {
 385                                show_datestring("--min-age=", arg+8);
 386                                continue;
 387                        }
 388                        if (show_flag(arg) && verify)
 389                                die("Needed a single revision");
 390                        continue;
 391                }
 392
 393                /* Not a flag argument */
 394                if (try_difference(arg))
 395                        continue;
 396                if (!get_sha1(arg, sha1)) {
 397                        show_rev(NORMAL, sha1, arg);
 398                        continue;
 399                }
 400                if (*arg == '^' && !get_sha1(arg+1, sha1)) {
 401                        show_rev(REVERSED, sha1, arg+1);
 402                        continue;
 403                }
 404                as_is = 1;
 405                if (!show_file(arg))
 406                        continue;
 407                if (verify)
 408                        die("Needed a single revision");
 409                verify_filename(prefix, arg);
 410        }
 411        show_default();
 412        if (verify && revs_count != 1)
 413                die("Needed a single revision");
 414        return 0;
 415}