Merge with master to pick up gitk updates.
[git] / ls-tree.c
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
10 static int line_termination = '\n';
11 #define LS_RECURSIVE 1
12 #define LS_TREE_ONLY 2
13 static int ls_options = 0;
14
15 static struct tree_entry_list root_entry;
16
17 static 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
42 static 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
57 static 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
111 static 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
124 static const char *entry_type(struct tree_entry_list *e)
125 {
126         return (e->directory ? "tree" : "blob");
127 }
128
129 static 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 */
137 static int show_entry(struct tree_entry_list *, int);
138
139 static 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
151 static 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
187 static 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
202 static 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
211 static const char ls_tree_usage[] =
212         "git-ls-tree [-d] [-r] [-z] <tree-ish> [path...]";
213
214 int 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 }