From aa1c48df8172f844455cc12f25aa49be8ffdd828 Mon Sep 17 00:00:00 2001 From: Junio C Hamano Date: Fri, 15 Apr 2005 08:37:05 -0700 Subject: [PATCH] [PATCH] ls-tree enhancements This adds '-r' (recursive) option and '-z' (NUL terminated) option to ls-tree. I need it so that the merge-trees (formerly known as git-merge.perl) script does not need to create any temporary dircache while merging. It used to use show-files on a temporary dircache to get the list of files in the ancestor tree, and also used the dircache to store the result of its automerge. I probably still need it for the latter reason, but with this patch not for the former reason anymore. It is relative to bb95843a5a0f397270819462812735ee29796fb4 Signed-off-by: Junio C Hamano Signed-off-by: Linus Torvalds --- ls-tree.c | 108 +++++++++++++++++++++++++++++++++++++++++++++--------- 1 file changed, 90 insertions(+), 18 deletions(-) diff --git a/ls-tree.c b/ls-tree.c index 102b12555..e25de0167 100644 --- a/ls-tree.c +++ b/ls-tree.c @@ -5,45 +5,117 @@ */ #include "cache.h" -static int list(unsigned char *sha1) +int line_termination = '\n'; +int recursive = 0; + +struct path_prefix { + struct path_prefix *prev; + const char *name; +}; + +static void print_path_prefix(struct path_prefix *prefix) { - void *buffer; - unsigned long size; - char type[20]; + if (prefix) { + if (prefix->prev) + print_path_prefix(prefix->prev); + fputs(prefix->name, stdout); + putchar('/'); + } +} + +static void list_recursive(void *buffer, + unsigned char *type, + unsigned long size, + struct path_prefix *prefix) +{ + struct path_prefix this_prefix; + this_prefix.prev = prefix; - buffer = read_sha1_file(sha1, type, &size); - if (!buffer) - die("unable to read sha1 file"); if (strcmp(type, "tree")) die("expected a 'tree' node"); + while (size) { - int len = strlen(buffer)+1; - unsigned char *sha1 = buffer + len; - char *path = strchr(buffer, ' ')+1; + int namelen = strlen(buffer)+1; + void *eltbuf; + char elttype[20]; + unsigned long eltsize; + unsigned char *sha1 = buffer + namelen; + char *path = strchr(buffer, ' ') + 1; unsigned int mode; - unsigned char *type; - if (size < len + 20 || sscanf(buffer, "%o", &mode) != 1) + if (size < namelen + 20 || sscanf(buffer, "%o", &mode) != 1) die("corrupt 'tree' file"); buffer = sha1 + 20; - size -= len + 20; + size -= namelen + 20; + /* XXX: We do some ugly mode heuristics here. * It seems not worth it to read each file just to get this - * and the file size. -- pasky@ucw.cz */ - type = S_ISDIR(mode) ? "tree" : "blob"; - printf("%03o\t%s\t%s\t%s\n", mode, type, sha1_to_hex(sha1), path); + * and the file size. -- pasky@ucw.cz + * ... that is, when we are not recursive -- junkio@cox.net + */ + eltbuf = (recursive ? read_sha1_file(sha1, elttype, &eltsize) : + NULL); + if (! eltbuf) { + if (recursive) + error("cannot read %s", sha1_to_hex(sha1)); + type = S_ISDIR(mode) ? "tree" : "blob"; + } + else + type = elttype; + + printf("%03o\t%s\t%s\t", mode, type, sha1_to_hex(sha1)); + print_path_prefix(prefix); + fputs(path, stdout); + putchar(line_termination); + + if (eltbuf && !strcmp(type, "tree")) { + this_prefix.name = path; + list_recursive(eltbuf, elttype, eltsize, &this_prefix); + } + free(eltbuf); } +} + +static int list(unsigned char *sha1) +{ + void *buffer; + unsigned long size; + char type[20]; + + buffer = read_sha1_file(sha1, type, &size); + if (!buffer) + die("unable to read sha1 file"); + list_recursive(buffer, type, size, NULL); return 0; } +static void _usage(void) +{ + usage("ls-tree [-r] [-z] "); +} + int main(int argc, char **argv) { unsigned char sha1[20]; + while (1 < argc && argv[1][0] == '-') { + switch (argv[1][1]) { + case 'z': + line_termination = 0; + break; + case 'r': + recursive = 1; + break; + default: + _usage(); + } + argc--; argv++; + } + if (argc != 2) - usage("ls-tree "); + _usage(); if (get_sha1_hex(argv[1], sha1) < 0) - usage("ls-tree "); + _usage(); sha1_file_directory = getenv(DB_ENVIRONMENT); if (!sha1_file_directory) sha1_file_directory = DEFAULT_DB_ENVIRONMENT; -- 2.30.2