Merge branch 'fixes'
[git/jnareb-git.git] / ls-tree.c
blobdd642e0bf059cdf969d370fc1155fb189a0c89ce
1 /*
2 * GIT - The information manager from hell
4 * Copyright (C) Linus Torvalds, 2005
5 */
6 #include "cache.h"
7 #include "blob.h"
8 #include "tree.h"
10 static int line_termination = '\n';
11 #define LS_RECURSIVE 1
12 #define LS_TREE_ONLY 2
13 static int ls_options = 0;
15 static struct tree_entry_list root_entry;
17 static void prepare_root(unsigned char *sha1)
19 unsigned char rsha[20];
20 unsigned long size;
21 void *buf;
22 struct tree *root_tree;
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));
29 root_tree = lookup_tree(rsha);
30 if (!root_tree)
31 die("Could not read %s", sha1_to_hex(sha1));
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;
42 static int prepare_children(struct tree_entry_list *elem)
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;
54 return 0;
57 static struct tree_entry_list *find_entry(const char *path, char *pathbuf)
59 const char *next, *slash;
60 int len;
61 struct tree_entry_list *elem = &root_entry, *oldelem = NULL;
63 *(pathbuf) = '\0';
65 /* Find tree element, descending from root, that
66 * corresponds to the named path, lazily expanding
67 * the tree if possible.
70 while (path) {
71 /* The fact we still have path means that the caller
72 * wants us to make sure that elem at this point is a
73 * directory, and possibly descend into it. Even what
74 * is left is just trailing slashes, we loop back to
75 * here, and this call to prepare_children() will
76 * catch elem not being a tree. Nice.
78 if (prepare_children(elem))
79 return NULL;
81 slash = strchr(path, '/');
82 if (!slash) {
83 len = strlen(path);
84 next = NULL;
86 else {
87 next = slash + 1;
88 len = slash - path;
90 if (len) {
91 if (oldelem) {
92 pathbuf += sprintf(pathbuf, "%s/", oldelem->name);
95 /* (len == 0) if the original path was "drivers/char/"
96 * and we have run already two rounds, having elem
97 * pointing at the drivers/char directory.
99 elem = elem->item.tree->entries;
100 while (elem) {
101 if ((strlen(elem->name) == len) &&
102 !strncmp(elem->name, path, len)) {
103 /* found */
104 break;
106 elem = elem->next;
108 if (!elem)
109 return NULL;
111 oldelem = elem;
113 path = next;
116 return elem;
119 static const char *entry_type(struct tree_entry_list *e)
121 return (e->directory ? "tree" : "blob");
124 static const char *entry_hex(struct tree_entry_list *e)
126 return sha1_to_hex(e->directory
127 ? e->item.tree->object.sha1
128 : e->item.blob->object.sha1);
131 /* forward declaration for mutually recursive routines */
132 static int show_entry(struct tree_entry_list *, int, char *pathbuf);
134 static int show_children(struct tree_entry_list *e, int level, char *pathbuf)
136 int oldlen = strlen(pathbuf);
138 if (e != &root_entry)
139 sprintf(pathbuf + oldlen, "%s/", e->name);
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, pathbuf);
146 e = e->next;
149 pathbuf[oldlen] = '\0';
151 return 0;
154 static int show_entry(struct tree_entry_list *e, int level, char *pathbuf)
156 int err = 0;
158 if (e != &root_entry) {
159 printf("%06o %s %s %s%s", e->mode, entry_type(e),
160 entry_hex(e), pathbuf, e->name);
161 putchar(line_termination);
164 if (e->directory) {
165 /* If this is a directory, we have the following cases:
166 * (1) This is the top-level request (explicit path from the
167 * command line, or "root" if there is no command line).
168 * a. Without any flag. We show direct children. We do not
169 * recurse into them.
170 * b. With -r. We do recurse into children.
171 * c. With -d. We do not recurse into children.
172 * (2) We came here because our caller is either (1-a) or
173 * (1-b).
174 * a. Without any flag. We do not show our children (which
175 * are grandchildren for the original request).
176 * b. With -r. We continue to recurse into our children.
177 * c. With -d. We should not have come here to begin with.
179 if (level == 0 && !(ls_options & LS_TREE_ONLY))
180 /* case (1)-a and (1)-b */
181 err = err | show_children(e, level+1, pathbuf);
182 else if (level && ls_options & LS_RECURSIVE)
183 /* case (2)-b */
184 err = err | show_children(e, level+1, pathbuf);
186 return err;
189 static int list_one(const char *path)
191 int err = 0;
192 char pathbuf[MAXPATHLEN + 1];
193 struct tree_entry_list *e = find_entry(path, pathbuf);
194 if (!e) {
195 /* traditionally ls-tree does not complain about
196 * missing path. We may change this later to match
197 * what "/bin/ls -a" does, which is to complain.
199 return err;
201 err = err | show_entry(e, 0, pathbuf);
202 return err;
205 static int list(char **path)
207 int i;
208 int err = 0;
209 for (i = 0; path[i]; i++)
210 err = err | list_one(path[i]);
211 return err;
214 static const char ls_tree_usage[] =
215 "git-ls-tree [-d] [-r] [-z] <tree-ish> [path...]";
217 int main(int argc, char **argv)
219 static char *path0[] = { "", NULL };
220 char **path;
221 unsigned char sha1[20];
223 while (1 < argc && argv[1][0] == '-') {
224 switch (argv[1][1]) {
225 case 'z':
226 line_termination = 0;
227 break;
228 case 'r':
229 ls_options |= LS_RECURSIVE;
230 break;
231 case 'd':
232 ls_options |= LS_TREE_ONLY;
233 break;
234 default:
235 usage(ls_tree_usage);
237 argc--; argv++;
240 if (argc < 2)
241 usage(ls_tree_usage);
242 if (get_sha1(argv[1], sha1) < 0)
243 usage(ls_tree_usage);
245 path = (argc == 2) ? path0 : (argv + 2);
246 prepare_root(sha1);
247 if (list(path) < 0)
248 die("list failed");
249 return 0;