1/* 2 * GIT - The information manager from hell 3 * 4 * Copyright (C) Linus Torvalds, 2005 5 */ 6#include "cache.h" 7#include "blob.h" 8#include "tree.h" 9 10static int line_termination = '\n'; 11#define LS_RECURSIVE 1 12#define LS_TREE_ONLY 2 13static int ls_options = 0; 14 15static struct tree_entry_list root_entry; 16 17static void prepare_root(unsigned char *sha1) 18{ 19 unsigned char rsha[20]; 20 unsigned long size; 21 void *buf; 22 struct tree *root_tree; 23 24 buf = read_object_with_reference(sha1, "tree", &size, rsha); 25 free(buf); 26 if (!buf) 27 die("Could not read %s", sha1_to_hex(sha1)); 28 29 root_tree = lookup_tree(rsha); 30 if (!root_tree) 31 die("Could not read %s", sha1_to_hex(sha1)); 32 33 /* Prepare a fake entry */ 34 root_entry.directory = 1; 35 root_entry.executable = root_entry.symlink = 0; 36 root_entry.mode = S_IFDIR; 37 root_entry.name = ""; 38 root_entry.item.tree = root_tree; 39 root_entry.parent = NULL; 40} 41 42static int prepare_children(struct tree_entry_list *elem) 43{ 44 if (!elem->directory) 45 return -1; 46 if (!elem->item.tree->object.parsed) { 47 struct tree_entry_list *e; 48 if (parse_tree(elem->item.tree)) 49 return -1; 50 /* Set up the parent link */ 51 for (e = elem->item.tree->entries; e; e = e->next) 52 e->parent = elem; 53 } 54 return 0; 55} 56 57static struct tree_entry_list *find_entry(const char *path) 58{ 59 const char *next, *slash; 60 int len; 61 struct tree_entry_list *elem = &root_entry; 62 63 /* Find tree element, descending from root, that 64 * corresponds to the named path, lazily expanding 65 * the tree if possible. 66 */ 67 68 while (path) { 69 /* The fact we still have path means that the caller 70 * wants us to make sure that elem at this point is a 71 * directory, and possibly descend into it. Even what 72 * is left is just trailing slashes, we loop back to 73 * here, and this call to prepare_children() will 74 * catch elem not being a tree. Nice. 75 */ 76 if (prepare_children(elem)) 77 return NULL; 78 79 slash = strchr(path, '/'); 80 if (!slash) { 81 len = strlen(path); 82 next = NULL; 83 } 84 else { 85 next = slash + 1; 86 len = slash - path; 87 } 88 if (len) { 89 /* (len == 0) if the original path was "drivers/char/" 90 * and we have run already two rounds, having elem 91 * pointing at the drivers/char directory. 92 */ 93 elem = elem->item.tree->entries; 94 while (elem) { 95 if ((strlen(elem->name) == len) && 96 !strncmp(elem->name, path, len)) { 97 /* found */ 98 break; 99 } 100 elem = elem->next; 101 } 102 if (!elem) 103 return NULL; 104 } 105 path = next; 106 } 107 108 return elem; 109} 110 111static void show_entry_name(struct tree_entry_list *e) 112{ 113 /* This is yucky. The root level is there for 114 * our convenience but we really want to do a 115 * forest. 116 */ 117 if (e->parent && e->parent != &root_entry) { 118 show_entry_name(e->parent); 119 putchar('/'); 120 } 121 printf("%s", e->name); 122} 123 124static const char *entry_type(struct tree_entry_list *e) 125{ 126 return (e->directory ? "tree" : "blob"); 127} 128 129static const char *entry_hex(struct tree_entry_list *e) 130{ 131 return sha1_to_hex(e->directory 132 ? e->item.tree->object.sha1 133 : e->item.blob->object.sha1); 134} 135 136/* forward declaration for mutually recursive routines */ 137static int show_entry(struct tree_entry_list *, int); 138 139static int show_children(struct tree_entry_list *e, int level) 140{ 141 if (prepare_children(e)) 142 die("internal error: ls-tree show_children called with non tree"); 143 e = e->item.tree->entries; 144 while (e) { 145 show_entry(e, level); 146 e = e->next; 147 } 148 return 0; 149} 150 151static int show_entry(struct tree_entry_list *e, int level) 152{ 153 int err = 0; 154 155 if (e != &root_entry) { 156 printf("%06o %s %s ", e->mode, entry_type(e), 157 entry_hex(e)); 158 show_entry_name(e); 159 putchar(line_termination); 160 } 161 162 if (e->directory) { 163 /* If this is a directory, we have the following cases: 164 * (1) This is the top-level request (explicit path from the 165 * command line, or "root" if there is no command line). 166 * a. Without any flag. We show direct children. We do not 167 * recurse into them. 168 * b. With -r. We do recurse into children. 169 * c. With -d. We do not recurse into children. 170 * (2) We came here because our caller is either (1-a) or 171 * (1-b). 172 * a. Without any flag. We do not show our children (which 173 * are grandchildren for the original request). 174 * b. With -r. We continue to recurse into our children. 175 * c. With -d. We should not have come here to begin with. 176 */ 177 if (level == 0 && !(ls_options & LS_TREE_ONLY)) 178 /* case (1)-a and (1)-b */ 179 err = err | show_children(e, level+1); 180 else if (level && ls_options & LS_RECURSIVE) 181 /* case (2)-b */ 182 err = err | show_children(e, level+1); 183 } 184 return err; 185} 186 187static int list_one(const char *path) 188{ 189 int err = 0; 190 struct tree_entry_list *e = find_entry(path); 191 if (!e) { 192 /* traditionally ls-tree does not complain about 193 * missing path. We may change this later to match 194 * what "/bin/ls -a" does, which is to complain. 195 */ 196 return err; 197 } 198 err = err | show_entry(e, 0); 199 return err; 200} 201 202static int list(char **path) 203{ 204 int i; 205 int err = 0; 206 for (i = 0; path[i]; i++) 207 err = err | list_one(path[i]); 208 return err; 209} 210 211static const char ls_tree_usage[] = 212 "git-ls-tree [-d] [-r] [-z] <tree-ish> [path...]"; 213 214int main(int argc, char **argv) 215{ 216 static char *path0[] = { "", NULL }; 217 char **path; 218 unsigned char sha1[20]; 219 220 while (1 < argc && argv[1][0] == '-') { 221 switch (argv[1][1]) { 222 case 'z': 223 line_termination = 0; 224 break; 225 case 'r': 226 ls_options |= LS_RECURSIVE; 227 break; 228 case 'd': 229 ls_options |= LS_TREE_ONLY; 230 break; 231 default: 232 usage(ls_tree_usage); 233 } 234 argc--; argv++; 235 } 236 237 if (argc < 2) 238 usage(ls_tree_usage); 239 if (get_sha1(argv[1], sha1) < 0) 240 usage(ls_tree_usage); 241 242 path = (argc == 2) ? path0 : (argv + 2); 243 prepare_root(sha1); 244 if (list(path) < 0) 245 die("list failed"); 246 return 0; 247}