1diff a/Documentation/git-ls-tree.txt b/Documentation/git-ls-tree.txt 2--- a/Documentation/git-ls-tree.txt 3+++ b/Documentation/git-ls-tree.txt 4@@ -4,23 +4,26 @@ v0.1, May 2005 5 6 NAME 7 ---- 8-git-ls-tree - Displays a tree object in human readable form 9+git-ls-tree - Lists the contents of a tree object. 10 11 12 SYNOPSIS 13 -------- 14-'git-ls-tree' [-r] [-z] <tree-ish> [paths...] 15+'git-ls-tree' [-d] [-r] [-z] <tree-ish> [paths...] 16 17 DESCRIPTION 18 ----------- 19-Converts the tree object to a human readable (and script processable) 20-form. 21+Lists the contents of a tree object, like what "/bin/ls -a" does 22+in the current working directory. 23 24 OPTIONS 25 ------- 26 <tree-ish>:: 27 Id of a tree. 28 29+-d:: 30+ show only the named tree entry itself, not its children 31+ 32 -r:: 33 recurse into sub-trees 34 35@@ -28,18 +31,19 @@ OPTIONS 36 \0 line termination on output 37 38 paths:: 39- Optionally, restrict the output of git-ls-tree to specific 40- paths. Directories will only list their tree blob ids. 41- Implies -r. 42+ When paths are given, shows them. Otherwise implicitly 43+ uses the root level of the tree as the sole path argument. 44+ 45 46 Output Format 47 ------------- 48- <mode>\t <type>\t <object>\t <file> 49+ <mode> SP <type> SP <object> TAB <file> 50 51 52 Author 53 ------ 54 Written by Linus Torvalds <torvalds@osdl.org> 55+Completely rewritten from scratch by Junio C Hamano <junkio@cox.net> 56 57 Documentation 58 -------------- 59diff a/ls-tree.c b/ls-tree.c 60--- a/ls-tree.c 61+++ b/ls-tree.c 62@@ -4,188 +4,217 @@ 63 * Copyright (C) Linus Torvalds, 2005 64 */ 65 #include "cache.h" 66+#include "blob.h" 67+#include "tree.h" 68 69 static int line_termination = '\n'; 70-static int recursive = 0; 71+#define LS_RECURSIVE 1 72+#define LS_TREE_ONLY 2 73+static int ls_options = 0; 74 75-struct path_prefix { 76- struct path_prefix *prev; 77- const char *name; 78-}; 79- 80-#define DEBUG(fmt, ...) 81- 82-static int string_path_prefix(char *buff, size_t blen, struct path_prefix *prefix) 83-{ 84- int len = 0; 85- if (prefix) { 86- if (prefix->prev) { 87- len = string_path_prefix(buff,blen,prefix->prev); 88- buff += len; 89- blen -= len; 90- if (blen > 0) { 91- *buff = '/'; 92- len++; 93- buff++; 94- blen--; 95- } 96- } 97- strncpy(buff,prefix->name,blen); 98- return len + strlen(prefix->name); 99- } 100+static struct tree_entry_list root_entry; 101 102- return 0; 103+static void prepare_root(unsigned char *sha1) 104+{ 105+ unsigned char rsha[20]; 106+ unsigned long size; 107+ void *buf; 108+ struct tree *root_tree; 109+ 110+ buf = read_object_with_reference(sha1, "tree", &size, rsha); 111+ free(buf); 112+ if (!buf) 113+ die("Could not read %s", sha1_to_hex(sha1)); 114+ 115+ root_tree = lookup_tree(rsha); 116+ if (!root_tree) 117+ die("Could not read %s", sha1_to_hex(sha1)); 118+ 119+ /* Prepare a fake entry */ 120+ root_entry.directory = 1; 121+ root_entry.executable = root_entry.symlink = 0; 122+ root_entry.mode = S_IFDIR; 123+ root_entry.name = ""; 124+ root_entry.item.tree = root_tree; 125+ root_entry.parent = NULL; 126 } 127 128-static void print_path_prefix(struct path_prefix *prefix) 129+static int prepare_children(struct tree_entry_list *elem) 130 { 131- if (prefix) { 132- if (prefix->prev) { 133- print_path_prefix(prefix->prev); 134- putchar('/'); 135- } 136- fputs(prefix->name, stdout); 137+ if (!elem->directory) 138+ return -1; 139+ if (!elem->item.tree->object.parsed) { 140+ struct tree_entry_list *e; 141+ if (parse_tree(elem->item.tree)) 142+ return -1; 143+ /* Set up the parent link */ 144+ for (e = elem->item.tree->entries; e; e = e->next) 145+ e->parent = elem; 146 } 147+ return 0; 148 } 149 150-/* 151- * return: 152- * -1 if prefix is *not* a subset of path 153- * 0 if prefix == path 154- * 1 if prefix is a subset of path 155- */ 156-static int pathcmp(const char *path, struct path_prefix *prefix) 157-{ 158- char buff[PATH_MAX]; 159- int len,slen; 160+static struct tree_entry_list *find_entry_0(struct tree_entry_list *elem, 161+ const char *path, 162+ const char *path_end) 163+{ 164+ const char *ep; 165+ int len; 166+ 167+ while (path < path_end) { 168+ if (prepare_children(elem)) 169+ return NULL; 170 171- if (prefix == NULL) 172- return 1; 173+ /* In elem->tree->entries, find the one that has name 174+ * that matches what is between path and ep. 175+ */ 176+ elem = elem->item.tree->entries; 177 178- len = string_path_prefix(buff, sizeof buff, prefix); 179- slen = strlen(path); 180+ ep = strchr(path, '/'); 181+ if (!ep || path_end <= ep) 182+ ep = path_end; 183+ len = ep - path; 184+ 185+ while (elem) { 186+ if ((strlen(elem->name) == len) && 187+ !strncmp(elem->name, path, len)) 188+ break; 189+ elem = elem->next; 190+ } 191+ if (path_end <= ep || !elem) 192+ return elem; 193+ while (*ep == '/' && ep < path_end) 194+ ep++; 195+ path = ep; 196+ } 197+ return NULL; 198+} 199 200- if (slen < len) 201- return -1; 202+static struct tree_entry_list *find_entry(const char *path, 203+ const char *path_end) 204+{ 205+ /* Find tree element, descending from root, that 206+ * corresponds to the named path, lazily expanding 207+ * the tree if possible. 208+ */ 209+ if (path == path_end) { 210+ /* Special. This is the root level */ 211+ return &root_entry; 212+ } 213+ return find_entry_0(&root_entry, path, path_end); 214+} 215 216- if (strncmp(path,buff,len) == 0) { 217- if (slen == len) 218- return 0; 219- else 220- return 1; 221+static void show_entry_name(struct tree_entry_list *e) 222+{ 223+ /* This is yucky. The root level is there for 224+ * our convenience but we really want to do a 225+ * forest. 226+ */ 227+ if (e->parent && e->parent != &root_entry) { 228+ show_entry_name(e->parent); 229+ putchar('/'); 230 } 231+ printf("%s", e->name); 232+} 233 234- return -1; 235-} 236+static const char *entry_type(struct tree_entry_list *e) 237+{ 238+ return (e->directory ? "tree" : "blob"); 239+} 240 241-/* 242- * match may be NULL, or a *sorted* list of paths 243- */ 244-static void list_recursive(void *buffer, 245- const char *type, 246- unsigned long size, 247- struct path_prefix *prefix, 248- char **match, int matches) 249-{ 250- struct path_prefix this_prefix; 251- this_prefix.prev = prefix; 252- 253- if (strcmp(type, "tree")) 254- die("expected a 'tree' node"); 255- 256- if (matches) 257- recursive = 1; 258- 259- while (size) { 260- int namelen = strlen(buffer)+1; 261- void *eltbuf = NULL; 262- char elttype[20]; 263- unsigned long eltsize; 264- unsigned char *sha1 = buffer + namelen; 265- char *path = strchr(buffer, ' ') + 1; 266- unsigned int mode; 267- const char *matched = NULL; 268- int mtype = -1; 269- int mindex; 270- 271- if (size < namelen + 20 || sscanf(buffer, "%o", &mode) != 1) 272- die("corrupt 'tree' file"); 273- buffer = sha1 + 20; 274- size -= namelen + 20; 275- 276- this_prefix.name = path; 277- for ( mindex = 0; mindex < matches; mindex++) { 278- mtype = pathcmp(match[mindex],&this_prefix); 279- if (mtype >= 0) { 280- matched = match[mindex]; 281- break; 282- } 283- } 284+static const char *entry_hex(struct tree_entry_list *e) 285+{ 286+ return sha1_to_hex(e->directory 287+ ? e->item.tree->object.sha1 288+ : e->item.blob->object.sha1); 289+} 290 291- /* 292- * If we're not matching, or if this is an exact match, 293- * print out the info 294- */ 295- if (!matches || (matched != NULL && mtype == 0)) { 296- printf("%06o %s %s\t", mode, 297- S_ISDIR(mode) ? "tree" : "blob", 298- sha1_to_hex(sha1)); 299- print_path_prefix(&this_prefix); 300- putchar(line_termination); 301- } 302+/* forward declaration for mutually recursive routines */ 303+static int show_entry(struct tree_entry_list *, int); 304 305- if (! recursive || ! S_ISDIR(mode)) 306- continue; 307+static int show_children(struct tree_entry_list *e, int level) 308+{ 309+ if (prepare_children(e)) 310+ die("internal error: ls-tree show_children called with non tree"); 311+ e = e->item.tree->entries; 312+ while (e) { 313+ show_entry(e, level); 314+ e = e->next; 315+ } 316+ return 0; 317+} 318 319- if (matches && ! matched) 320- continue; 321+static int show_entry(struct tree_entry_list *e, int level) 322+{ 323+ int err = 0; 324 325- if (! (eltbuf = read_sha1_file(sha1, elttype, &eltsize)) ) { 326- error("cannot read %s", sha1_to_hex(sha1)); 327- continue; 328- } 329+ if (e != &root_entry) { 330+ printf("%06o %s %s ", e->mode, entry_type(e), 331+ entry_hex(e)); 332+ show_entry_name(e); 333+ putchar(line_termination); 334+ } 335 336- /* If this is an exact directory match, we may have 337- * directory files following this path. Match on them. 338- * Otherwise, we're at a patch subcomponent, and we need 339- * to try to match again. 340+ if (e->directory) { 341+ /* If this is a directory, we have the following cases: 342+ * (1) This is the top-level request (explicit path from the 343+ * command line, or "root" if there is no command line). 344+ * a. Without any flag. We show direct children. We do not 345+ * recurse into them. 346+ * b. With -r. We do recurse into children. 347+ * c. With -d. We do not recurse into children. 348+ * (2) We came here because our caller is either (1-a) or 349+ * (1-b). 350+ * a. Without any flag. We do not show our children (which 351+ * are grandchildren for the original request). 352+ * b. With -r. We continue to recurse into our children. 353+ * c. With -d. We should not have come here to begin with. 354 */ 355- if (mtype == 0) 356- mindex++; 357- 358- list_recursive(eltbuf, elttype, eltsize, &this_prefix, &match[mindex], matches-mindex); 359- free(eltbuf); 360+ if (level == 0 && !(ls_options & LS_TREE_ONLY)) 361+ /* case (1)-a and (1)-b */ 362+ err = err | show_children(e, level+1); 363+ else if (level && ls_options & LS_RECURSIVE) 364+ /* case (2)-b */ 365+ err = err | show_children(e, level+1); 366 } 367+ return err; 368 } 369 370-static int qcmp(const void *a, const void *b) 371+static int list_one(const char *path, const char *path_end) 372 { 373- return strcmp(*(char **)a, *(char **)b); 374+ int err = 0; 375+ struct tree_entry_list *e = find_entry(path, path_end); 376+ if (!e) { 377+ /* traditionally ls-tree does not complain about 378+ * missing path. We may change this later to match 379+ * what "/bin/ls -a" does, which is to complain. 380+ */ 381+ return err; 382+ } 383+ err = err | show_entry(e, 0); 384+ return err; 385 } 386 387-static int list(unsigned char *sha1,char **path) 388+static int list(char **path) 389 { 390- void *buffer; 391- unsigned long size; 392- int npaths; 393- 394- for (npaths = 0; path[npaths] != NULL; npaths++) 395- ; 396- 397- qsort(path,npaths,sizeof(char *),qcmp); 398- 399- buffer = read_object_with_reference(sha1, "tree", &size, NULL); 400- if (!buffer) 401- die("unable to read sha1 file"); 402- list_recursive(buffer, "tree", size, NULL, path, npaths); 403- free(buffer); 404- return 0; 405+ int i; 406+ int err = 0; 407+ for (i = 0; path[i]; i++) { 408+ int len = strlen(path[i]); 409+ while (0 <= len && path[i][len] == '/') 410+ len--; 411+ err = err | list_one(path[i], path[i] + len); 412+ } 413+ return err; 414 } 415 416-static const char *ls_tree_usage = "git-ls-tree [-r] [-z] <key> [paths...]"; 417+static const char *ls_tree_usage = 418+ "git-ls-tree [-d] [-r] [-z] <tree-ish> [path...]"; 419 420 int main(int argc, char **argv) 421 { 422+ static char *path0[] = { "", NULL }; 423+ char **path; 424 unsigned char sha1[20]; 425 426 while (1 < argc && argv[1][0] == '-') { 427@@ -194,7 +223,10 @@ int main(int argc, char **argv) 428 line_termination = 0; 429 break; 430 case 'r': 431- recursive = 1; 432+ ls_options |= LS_RECURSIVE; 433+ break; 434+ case 'd': 435+ ls_options |= LS_TREE_ONLY; 436 break; 437 default: 438 usage(ls_tree_usage); 439@@ -206,7 +238,10 @@ int main(int argc, char **argv) 440 usage(ls_tree_usage); 441 if (get_sha1(argv[1], sha1) < 0) 442 usage(ls_tree_usage); 443- if (list(sha1, &argv[2]) < 0) 444+ 445+ path = (argc == 2) ? path0 : (argv + 2); 446+ prepare_root(sha1); 447+ if (list(path) < 0) 448 die("list failed"); 449 return 0; 450 } 451diff a/t/t3100-ls-tree-restrict.sh b/t/t3100-ls-tree-restrict.sh 452--- a/t/t3100-ls-tree-restrict.sh 453+++ b/t/t3100-ls-tree-restrict.sh 454@@ -74,8 +74,8 @@ test_expect_success \ 455 'ls-tree filtered' \ 456 'git-ls-tree $tree path1 path0 >current && 457 cat >expected <<\EOF && 458-100644 blob X path0 459 120000 blob X path1 460+100644 blob X path0 461 EOF 462 test_output' 463 464@@ -85,7 +85,6 @@ test_expect_success \ 465 cat >expected <<\EOF && 466 040000 tree X path2 467 040000 tree X path2/baz 468-100644 blob X path2/baz/b 469 120000 blob X path2/bazbo 470 100644 blob X path2/foo 471 EOF 472diff a/tree.c b/tree.c 473--- a/tree.c 474+++ b/tree.c 475@@ -133,7 +133,7 @@ int parse_tree_buffer(struct tree *item, 476 } 477 if (obj) 478 add_ref(&item->object, obj); 479- 480+ entry->parent = NULL; /* needs to be filled by the user */ 481 *list_p = entry; 482 list_p = &entry->next; 483 } 484diff a/tree.h b/tree.h 485--- a/tree.h 486+++ b/tree.h 487@@ -16,6 +16,7 @@ struct tree_entry_list { 488 struct tree *tree; 489 struct blob *blob; 490 } item; 491+ struct tree_entry_list *parent; 492 }; 493 494 struct tree { 495