Matthias Kestenholz | d6b64ed | 2006-08-03 17:24:35 +0200 | [diff] [blame] | 1 | #include "builtin.h" |
Johannes Schindelin | bd321bc | 2005-10-26 15:10:20 +0200 | [diff] [blame] | 2 | #include "cache.h" |
| 3 | #include "commit.h" |
| 4 | #include "tag.h" |
| 5 | #include "refs.h" |
Pierre Habouzit | edefb1a | 2007-10-15 22:57:59 +0200 | [diff] [blame] | 6 | #include "parse-options.h" |
Johannes Schindelin | bd321bc | 2005-10-26 15:10:20 +0200 | [diff] [blame] | 7 | |
Junio C Hamano | c075aea | 2007-05-24 12:20:42 -0700 | [diff] [blame] | 8 | #define CUTOFF_DATE_SLOP 86400 /* one day */ |
| 9 | |
Johannes Schindelin | bd321bc | 2005-10-26 15:10:20 +0200 | [diff] [blame] | 10 | typedef struct rev_name { |
| 11 | const char *tip_name; |
Johannes Schindelin | bd321bc | 2005-10-26 15:10:20 +0200 | [diff] [blame] | 12 | int generation; |
Johannes Schindelin | ac076c2 | 2007-08-27 12:37:33 +0100 | [diff] [blame] | 13 | int distance; |
Johannes Schindelin | bd321bc | 2005-10-26 15:10:20 +0200 | [diff] [blame] | 14 | } rev_name; |
| 15 | |
| 16 | static long cutoff = LONG_MAX; |
| 17 | |
Johannes Schindelin | ac076c2 | 2007-08-27 12:37:33 +0100 | [diff] [blame] | 18 | /* How many generations are maximally preferred over _one_ merge traversal? */ |
| 19 | #define MERGE_TRAVERSAL_WEIGHT 65535 |
| 20 | |
Johannes Schindelin | bd321bc | 2005-10-26 15:10:20 +0200 | [diff] [blame] | 21 | static void name_rev(struct commit *commit, |
Johannes Schindelin | ac076c2 | 2007-08-27 12:37:33 +0100 | [diff] [blame] | 22 | const char *tip_name, int generation, int distance, |
Johannes Schindelin | bd321bc | 2005-10-26 15:10:20 +0200 | [diff] [blame] | 23 | int deref) |
| 24 | { |
Linus Torvalds | d3ff6f5 | 2006-06-17 18:26:18 -0700 | [diff] [blame] | 25 | struct rev_name *name = (struct rev_name *)commit->util; |
Johannes Schindelin | bd321bc | 2005-10-26 15:10:20 +0200 | [diff] [blame] | 26 | struct commit_list *parents; |
Junio C Hamano | f2e6f1c | 2005-11-28 20:51:44 -0800 | [diff] [blame] | 27 | int parent_number = 1; |
Johannes Schindelin | bd321bc | 2005-10-26 15:10:20 +0200 | [diff] [blame] | 28 | |
| 29 | if (!commit->object.parsed) |
| 30 | parse_commit(commit); |
| 31 | |
| 32 | if (commit->date < cutoff) |
| 33 | return; |
| 34 | |
| 35 | if (deref) { |
| 36 | char *new_name = xmalloc(strlen(tip_name)+3); |
| 37 | strcpy(new_name, tip_name); |
| 38 | strcat(new_name, "^0"); |
| 39 | tip_name = new_name; |
| 40 | |
| 41 | if (generation) |
| 42 | die("generation: %d, but deref?", generation); |
| 43 | } |
| 44 | |
| 45 | if (name == NULL) { |
| 46 | name = xmalloc(sizeof(rev_name)); |
Linus Torvalds | d3ff6f5 | 2006-06-17 18:26:18 -0700 | [diff] [blame] | 47 | commit->util = name; |
Johannes Schindelin | bd321bc | 2005-10-26 15:10:20 +0200 | [diff] [blame] | 48 | goto copy_data; |
Johannes Schindelin | ac076c2 | 2007-08-27 12:37:33 +0100 | [diff] [blame] | 49 | } else if (name->distance > distance) { |
Johannes Schindelin | bd321bc | 2005-10-26 15:10:20 +0200 | [diff] [blame] | 50 | copy_data: |
| 51 | name->tip_name = tip_name; |
Johannes Schindelin | bd321bc | 2005-10-26 15:10:20 +0200 | [diff] [blame] | 52 | name->generation = generation; |
Johannes Schindelin | ac076c2 | 2007-08-27 12:37:33 +0100 | [diff] [blame] | 53 | name->distance = distance; |
Johannes Schindelin | bd321bc | 2005-10-26 15:10:20 +0200 | [diff] [blame] | 54 | } else |
| 55 | return; |
| 56 | |
| 57 | for (parents = commit->parents; |
| 58 | parents; |
| 59 | parents = parents->next, parent_number++) { |
Junio C Hamano | f2e6f1c | 2005-11-28 20:51:44 -0800 | [diff] [blame] | 60 | if (parent_number > 1) { |
Johannes Schindelin | 59d3f54 | 2007-02-20 01:08:48 +0100 | [diff] [blame] | 61 | int len = strlen(tip_name); |
Andy Whitcroft | cf606e3 | 2007-05-15 17:33:25 +0100 | [diff] [blame] | 62 | char *new_name = xmalloc(len + |
| 63 | 1 + decimal_length(generation) + /* ~<n> */ |
| 64 | 1 + 2 + /* ^NN */ |
| 65 | 1); |
Johannes Schindelin | bd321bc | 2005-10-26 15:10:20 +0200 | [diff] [blame] | 66 | |
Johannes Schindelin | 59d3f54 | 2007-02-20 01:08:48 +0100 | [diff] [blame] | 67 | if (len > 2 && !strcmp(tip_name + len - 2, "^0")) |
| 68 | len -= 2; |
Johannes Schindelin | bd321bc | 2005-10-26 15:10:20 +0200 | [diff] [blame] | 69 | if (generation > 0) |
Johannes Schindelin | 59d3f54 | 2007-02-20 01:08:48 +0100 | [diff] [blame] | 70 | sprintf(new_name, "%.*s~%d^%d", len, tip_name, |
Johannes Schindelin | bd321bc | 2005-10-26 15:10:20 +0200 | [diff] [blame] | 71 | generation, parent_number); |
| 72 | else |
Johannes Schindelin | 59d3f54 | 2007-02-20 01:08:48 +0100 | [diff] [blame] | 73 | sprintf(new_name, "%.*s^%d", len, tip_name, |
| 74 | parent_number); |
Johannes Schindelin | bd321bc | 2005-10-26 15:10:20 +0200 | [diff] [blame] | 75 | |
Johannes Schindelin | ac076c2 | 2007-08-27 12:37:33 +0100 | [diff] [blame] | 76 | name_rev(parents->item, new_name, 0, |
| 77 | distance + MERGE_TRAVERSAL_WEIGHT, 0); |
Johannes Schindelin | bd321bc | 2005-10-26 15:10:20 +0200 | [diff] [blame] | 78 | } else { |
Johannes Schindelin | ac076c2 | 2007-08-27 12:37:33 +0100 | [diff] [blame] | 79 | name_rev(parents->item, tip_name, generation + 1, |
| 80 | distance + 1, 0); |
Johannes Schindelin | bd321bc | 2005-10-26 15:10:20 +0200 | [diff] [blame] | 81 | } |
| 82 | } |
| 83 | } |
| 84 | |
Johannes Schindelin | 2afc29a | 2007-02-17 19:22:35 +0100 | [diff] [blame] | 85 | struct name_ref_data { |
| 86 | int tags_only; |
Shawn O. Pearce | 2361570 | 2007-05-21 03:20:25 -0400 | [diff] [blame] | 87 | int name_only; |
Johannes Schindelin | 2afc29a | 2007-02-17 19:22:35 +0100 | [diff] [blame] | 88 | const char *ref_filter; |
| 89 | }; |
| 90 | |
Junio C Hamano | 8da1977 | 2006-09-20 22:02:01 -0700 | [diff] [blame] | 91 | static int name_ref(const char *path, const unsigned char *sha1, int flags, void *cb_data) |
Johannes Schindelin | bd321bc | 2005-10-26 15:10:20 +0200 | [diff] [blame] | 92 | { |
| 93 | struct object *o = parse_object(sha1); |
Johannes Schindelin | 2afc29a | 2007-02-17 19:22:35 +0100 | [diff] [blame] | 94 | struct name_ref_data *data = cb_data; |
Johannes Schindelin | bd321bc | 2005-10-26 15:10:20 +0200 | [diff] [blame] | 95 | int deref = 0; |
| 96 | |
Junio C Hamano | cc44c76 | 2007-02-20 01:53:29 -0800 | [diff] [blame] | 97 | if (data->tags_only && prefixcmp(path, "refs/tags/")) |
Johannes Schindelin | 2afc29a | 2007-02-17 19:22:35 +0100 | [diff] [blame] | 98 | return 0; |
| 99 | |
| 100 | if (data->ref_filter && fnmatch(data->ref_filter, path, 0)) |
Johannes Schindelin | bd321bc | 2005-10-26 15:10:20 +0200 | [diff] [blame] | 101 | return 0; |
| 102 | |
Linus Torvalds | 1974632 | 2006-07-11 20:45:31 -0700 | [diff] [blame] | 103 | while (o && o->type == OBJ_TAG) { |
Johannes Schindelin | bd321bc | 2005-10-26 15:10:20 +0200 | [diff] [blame] | 104 | struct tag *t = (struct tag *) o; |
| 105 | if (!t->tagged) |
| 106 | break; /* broken repository */ |
| 107 | o = parse_object(t->tagged->sha1); |
| 108 | deref = 1; |
| 109 | } |
Linus Torvalds | 1974632 | 2006-07-11 20:45:31 -0700 | [diff] [blame] | 110 | if (o && o->type == OBJ_COMMIT) { |
Johannes Schindelin | bd321bc | 2005-10-26 15:10:20 +0200 | [diff] [blame] | 111 | struct commit *commit = (struct commit *)o; |
Johannes Schindelin | bd321bc | 2005-10-26 15:10:20 +0200 | [diff] [blame] | 112 | |
Junio C Hamano | cc44c76 | 2007-02-20 01:53:29 -0800 | [diff] [blame] | 113 | if (!prefixcmp(path, "refs/heads/")) |
Junio C Hamano | 2c817df | 2006-01-11 14:20:09 -0800 | [diff] [blame] | 114 | path = path + 11; |
Shawn O. Pearce | 2361570 | 2007-05-21 03:20:25 -0400 | [diff] [blame] | 115 | else if (data->tags_only |
| 116 | && data->name_only |
| 117 | && !prefixcmp(path, "refs/tags/")) |
| 118 | path = path + 10; |
Junio C Hamano | cc44c76 | 2007-02-20 01:53:29 -0800 | [diff] [blame] | 119 | else if (!prefixcmp(path, "refs/")) |
Junio C Hamano | 2c817df | 2006-01-11 14:20:09 -0800 | [diff] [blame] | 120 | path = path + 5; |
Johannes Schindelin | bd321bc | 2005-10-26 15:10:20 +0200 | [diff] [blame] | 121 | |
Shawn Pearce | 9befac4 | 2006-09-02 00:16:31 -0400 | [diff] [blame] | 122 | name_rev(commit, xstrdup(path), 0, 0, deref); |
Johannes Schindelin | bd321bc | 2005-10-26 15:10:20 +0200 | [diff] [blame] | 123 | } |
| 124 | return 0; |
| 125 | } |
| 126 | |
| 127 | /* returns a static buffer */ |
Junio C Hamano | da2478d | 2008-03-02 08:51:57 -0800 | [diff] [blame] | 128 | static const char *get_rev_name(const struct object *o) |
Johannes Schindelin | bd321bc | 2005-10-26 15:10:20 +0200 | [diff] [blame] | 129 | { |
| 130 | static char buffer[1024]; |
Linus Torvalds | d3ff6f5 | 2006-06-17 18:26:18 -0700 | [diff] [blame] | 131 | struct rev_name *n; |
| 132 | struct commit *c; |
| 133 | |
Linus Torvalds | 1974632 | 2006-07-11 20:45:31 -0700 | [diff] [blame] | 134 | if (o->type != OBJ_COMMIT) |
Pierre Habouzit | a2cf9f4 | 2007-12-24 12:18:22 +0100 | [diff] [blame] | 135 | return NULL; |
Linus Torvalds | d3ff6f5 | 2006-06-17 18:26:18 -0700 | [diff] [blame] | 136 | c = (struct commit *) o; |
| 137 | n = c->util; |
Johannes Schindelin | bd321bc | 2005-10-26 15:10:20 +0200 | [diff] [blame] | 138 | if (!n) |
Pierre Habouzit | a2cf9f4 | 2007-12-24 12:18:22 +0100 | [diff] [blame] | 139 | return NULL; |
Johannes Schindelin | bd321bc | 2005-10-26 15:10:20 +0200 | [diff] [blame] | 140 | |
| 141 | if (!n->generation) |
| 142 | return n->tip_name; |
Johannes Schindelin | 59d3f54 | 2007-02-20 01:08:48 +0100 | [diff] [blame] | 143 | else { |
| 144 | int len = strlen(n->tip_name); |
| 145 | if (len > 2 && !strcmp(n->tip_name + len - 2, "^0")) |
| 146 | len -= 2; |
| 147 | snprintf(buffer, sizeof(buffer), "%.*s~%d", len, n->tip_name, |
| 148 | n->generation); |
Johannes Schindelin | bd321bc | 2005-10-26 15:10:20 +0200 | [diff] [blame] | 149 | |
Johannes Schindelin | 59d3f54 | 2007-02-20 01:08:48 +0100 | [diff] [blame] | 150 | return buffer; |
| 151 | } |
Johannes Schindelin | bd321bc | 2005-10-26 15:10:20 +0200 | [diff] [blame] | 152 | } |
Linus Torvalds | 1f1e895 | 2006-06-19 17:42:35 -0700 | [diff] [blame] | 153 | |
Junio C Hamano | da2478d | 2008-03-02 08:51:57 -0800 | [diff] [blame] | 154 | static void show_name(const struct object *obj, |
| 155 | const char *caller_name, |
| 156 | int always, int allow_undefined, int name_only) |
| 157 | { |
| 158 | const char *name; |
| 159 | const unsigned char *sha1 = obj->sha1; |
| 160 | |
| 161 | if (!name_only) |
| 162 | printf("%s ", caller_name ? caller_name : sha1_to_hex(sha1)); |
| 163 | name = get_rev_name(obj); |
| 164 | if (name) |
| 165 | printf("%s\n", name); |
| 166 | else if (allow_undefined) |
| 167 | printf("undefined\n"); |
| 168 | else if (always) |
| 169 | printf("%s\n", find_unique_abbrev(sha1, DEFAULT_ABBREV)); |
| 170 | else |
| 171 | die("cannot describe '%s'", sha1_to_hex(sha1)); |
| 172 | } |
| 173 | |
Pierre Habouzit | edefb1a | 2007-10-15 22:57:59 +0200 | [diff] [blame] | 174 | static char const * const name_rev_usage[] = { |
Stephan Beyer | 1b1dd23 | 2008-07-13 15:36:15 +0200 | [diff] [blame] | 175 | "git name-rev [options] ( --all | --stdin | <commit>... )", |
Pierre Habouzit | edefb1a | 2007-10-15 22:57:59 +0200 | [diff] [blame] | 176 | NULL |
| 177 | }; |
| 178 | |
Junio C Hamano | e8b55fa | 2008-08-02 11:04:22 -0700 | [diff] [blame] | 179 | static void name_rev_line(char *p, struct name_ref_data *data) |
| 180 | { |
| 181 | int forty = 0; |
| 182 | char *p_start; |
| 183 | for (p_start = p; *p; p++) { |
| 184 | #define ishex(x) (isdigit((x)) || ((x) >= 'a' && (x) <= 'f')) |
| 185 | if (!ishex(*p)) |
| 186 | forty = 0; |
| 187 | else if (++forty == 40 && |
| 188 | !ishex(*(p+1))) { |
| 189 | unsigned char sha1[40]; |
| 190 | const char *name = NULL; |
| 191 | char c = *(p+1); |
René Scharfe | 7c5b167 | 2008-08-03 15:44:33 +0200 | [diff] [blame] | 192 | int p_len = p - p_start + 1; |
Junio C Hamano | e8b55fa | 2008-08-02 11:04:22 -0700 | [diff] [blame] | 193 | |
| 194 | forty = 0; |
| 195 | |
| 196 | *(p+1) = 0; |
| 197 | if (!get_sha1(p - 39, sha1)) { |
| 198 | struct object *o = |
| 199 | lookup_object(sha1); |
| 200 | if (o) |
| 201 | name = get_rev_name(o); |
| 202 | } |
| 203 | *(p+1) = c; |
| 204 | |
| 205 | if (!name) |
| 206 | continue; |
| 207 | |
René Scharfe | 7c5b167 | 2008-08-03 15:44:33 +0200 | [diff] [blame] | 208 | if (data->name_only) |
| 209 | printf("%.*s%s", p_len - 40, p_start, name); |
| 210 | else |
| 211 | printf("%.*s (%s)", p_len, p_start, name); |
Junio C Hamano | e8b55fa | 2008-08-02 11:04:22 -0700 | [diff] [blame] | 212 | p_start = p + 1; |
| 213 | } |
| 214 | } |
| 215 | |
| 216 | /* flush */ |
| 217 | if (p_start != p) |
| 218 | fwrite(p_start, p - p_start, 1, stdout); |
| 219 | } |
| 220 | |
Matthias Kestenholz | d6b64ed | 2006-08-03 17:24:35 +0200 | [diff] [blame] | 221 | int cmd_name_rev(int argc, const char **argv, const char *prefix) |
Johannes Schindelin | bd321bc | 2005-10-26 15:10:20 +0200 | [diff] [blame] | 222 | { |
Linus Torvalds | 1f1e895 | 2006-06-19 17:42:35 -0700 | [diff] [blame] | 223 | struct object_array revs = { 0, 0, NULL }; |
Junio C Hamano | da2478d | 2008-03-02 08:51:57 -0800 | [diff] [blame] | 224 | int all = 0, transform_stdin = 0, allow_undefined = 1, always = 0; |
Shawn O. Pearce | 2361570 | 2007-05-21 03:20:25 -0400 | [diff] [blame] | 225 | struct name_ref_data data = { 0, 0, NULL }; |
Pierre Habouzit | edefb1a | 2007-10-15 22:57:59 +0200 | [diff] [blame] | 226 | struct option opts[] = { |
| 227 | OPT_BOOLEAN(0, "name-only", &data.name_only, "print only names (no SHA-1)"), |
| 228 | OPT_BOOLEAN(0, "tags", &data.tags_only, "only use tags to name the commits"), |
| 229 | OPT_STRING(0, "refs", &data.ref_filter, "pattern", |
| 230 | "only use refs matching <pattern>"), |
| 231 | OPT_GROUP(""), |
| 232 | OPT_BOOLEAN(0, "all", &all, "list all commits reachable from all refs"), |
| 233 | OPT_BOOLEAN(0, "stdin", &transform_stdin, "read from stdin"), |
Pierre Habouzit | a2cf9f4 | 2007-12-24 12:18:22 +0100 | [diff] [blame] | 234 | OPT_BOOLEAN(0, "undefined", &allow_undefined, "allow to print `undefined` names"), |
Junio C Hamano | da2478d | 2008-03-02 08:51:57 -0800 | [diff] [blame] | 235 | OPT_BOOLEAN(0, "always", &always, |
| 236 | "show abbreviated commit object as fallback"), |
Pierre Habouzit | edefb1a | 2007-10-15 22:57:59 +0200 | [diff] [blame] | 237 | OPT_END(), |
| 238 | }; |
Johannes Schindelin | bd321bc | 2005-10-26 15:10:20 +0200 | [diff] [blame] | 239 | |
Johannes Schindelin | ef90d6d | 2008-05-14 18:46:53 +0100 | [diff] [blame] | 240 | git_config(git_default_config, NULL); |
Stephen Boyd | 3778292 | 2009-05-23 11:53:12 -0700 | [diff] [blame] | 241 | argc = parse_options(argc, argv, prefix, opts, name_rev_usage, 0); |
Pierre Habouzit | edefb1a | 2007-10-15 22:57:59 +0200 | [diff] [blame] | 242 | if (!!all + !!transform_stdin + !!argc > 1) { |
| 243 | error("Specify either a list, or --all, not both!"); |
| 244 | usage_with_options(name_rev_usage, opts); |
| 245 | } |
| 246 | if (all || transform_stdin) |
| 247 | cutoff = 0; |
Johannes Schindelin | bd321bc | 2005-10-26 15:10:20 +0200 | [diff] [blame] | 248 | |
Pierre Habouzit | edefb1a | 2007-10-15 22:57:59 +0200 | [diff] [blame] | 249 | for (; argc; argc--, argv++) { |
Johannes Schindelin | bd321bc | 2005-10-26 15:10:20 +0200 | [diff] [blame] | 250 | unsigned char sha1[20]; |
| 251 | struct object *o; |
| 252 | struct commit *commit; |
| 253 | |
Johannes Schindelin | bd321bc | 2005-10-26 15:10:20 +0200 | [diff] [blame] | 254 | if (get_sha1(*argv, sha1)) { |
| 255 | fprintf(stderr, "Could not get sha1 for %s. Skipping.\n", |
| 256 | *argv); |
| 257 | continue; |
| 258 | } |
| 259 | |
Junio C Hamano | 9534f40 | 2005-11-02 15:19:13 -0800 | [diff] [blame] | 260 | o = deref_tag(parse_object(sha1), *argv, 0); |
Linus Torvalds | 1974632 | 2006-07-11 20:45:31 -0700 | [diff] [blame] | 261 | if (!o || o->type != OBJ_COMMIT) { |
Johannes Schindelin | bd321bc | 2005-10-26 15:10:20 +0200 | [diff] [blame] | 262 | fprintf(stderr, "Could not get commit for %s. Skipping.\n", |
| 263 | *argv); |
| 264 | continue; |
| 265 | } |
| 266 | |
| 267 | commit = (struct commit *)o; |
Johannes Schindelin | bd321bc | 2005-10-26 15:10:20 +0200 | [diff] [blame] | 268 | if (cutoff > commit->date) |
| 269 | cutoff = commit->date; |
Linus Torvalds | 1f1e895 | 2006-06-19 17:42:35 -0700 | [diff] [blame] | 270 | add_object_array((struct object *)commit, *argv, &revs); |
Johannes Schindelin | bd321bc | 2005-10-26 15:10:20 +0200 | [diff] [blame] | 271 | } |
| 272 | |
Junio C Hamano | c075aea | 2007-05-24 12:20:42 -0700 | [diff] [blame] | 273 | if (cutoff) |
| 274 | cutoff = cutoff - CUTOFF_DATE_SLOP; |
Johannes Schindelin | 2afc29a | 2007-02-17 19:22:35 +0100 | [diff] [blame] | 275 | for_each_ref(name_ref, &data); |
Johannes Schindelin | bd321bc | 2005-10-26 15:10:20 +0200 | [diff] [blame] | 276 | |
| 277 | if (transform_stdin) { |
| 278 | char buffer[2048]; |
Johannes Schindelin | bd321bc | 2005-10-26 15:10:20 +0200 | [diff] [blame] | 279 | |
| 280 | while (!feof(stdin)) { |
Junio C Hamano | e8b55fa | 2008-08-02 11:04:22 -0700 | [diff] [blame] | 281 | char *p = fgets(buffer, sizeof(buffer), stdin); |
Johannes Schindelin | bd321bc | 2005-10-26 15:10:20 +0200 | [diff] [blame] | 282 | if (!p) |
| 283 | break; |
Junio C Hamano | e8b55fa | 2008-08-02 11:04:22 -0700 | [diff] [blame] | 284 | name_rev_line(p, &data); |
Johannes Schindelin | bd321bc | 2005-10-26 15:10:20 +0200 | [diff] [blame] | 285 | } |
| 286 | } else if (all) { |
Linus Torvalds | fc046a7 | 2006-06-29 21:38:55 -0700 | [diff] [blame] | 287 | int i, max; |
Johannes Schindelin | bd321bc | 2005-10-26 15:10:20 +0200 | [diff] [blame] | 288 | |
Linus Torvalds | fc046a7 | 2006-06-29 21:38:55 -0700 | [diff] [blame] | 289 | max = get_max_object_index(); |
Björn Steinbrink | a83123d | 2008-06-06 01:31:55 +0200 | [diff] [blame] | 290 | for (i = 0; i < max; i++) { |
| 291 | struct object *obj = get_indexed_object(i); |
| 292 | if (!obj) |
| 293 | continue; |
| 294 | show_name(obj, NULL, |
Junio C Hamano | da2478d | 2008-03-02 08:51:57 -0800 | [diff] [blame] | 295 | always, allow_undefined, data.name_only); |
Björn Steinbrink | a83123d | 2008-06-06 01:31:55 +0200 | [diff] [blame] | 296 | } |
Linus Torvalds | 1f1e895 | 2006-06-19 17:42:35 -0700 | [diff] [blame] | 297 | } else { |
| 298 | int i; |
Junio C Hamano | da2478d | 2008-03-02 08:51:57 -0800 | [diff] [blame] | 299 | for (i = 0; i < revs.nr; i++) |
| 300 | show_name(revs.objects[i].item, revs.objects[i].name, |
| 301 | always, allow_undefined, data.name_only); |
Linus Torvalds | 1f1e895 | 2006-06-19 17:42:35 -0700 | [diff] [blame] | 302 | } |
Johannes Schindelin | bd321bc | 2005-10-26 15:10:20 +0200 | [diff] [blame] | 303 | |
| 304 | return 0; |
| 305 | } |