+static int show_entry(struct tree_entry_list *e, int level)
+{
+ int err = 0;
+
+ if (e != &root_entry) {
+ printf("%06o %s %s ", e->mode, entry_type(e),
+ entry_hex(e));
+ show_entry_name(e);
+ putchar(line_termination);
+ }
+
+ if (e->directory) {
+ /* If this is a directory, we have the following cases:
+ * (1) This is the top-level request (explicit path from the
+ * command line, or "root" if there is no command line).
+ * a. Without any flag. We show direct children. We do not
+ * recurse into them.
+ * b. With -r. We do recurse into children.
+ * c. With -d. We do not recurse into children.
+ * (2) We came here because our caller is either (1-a) or
+ * (1-b).
+ * a. Without any flag. We do not show our children (which
+ * are grandchildren for the original request).
+ * b. With -r. We continue to recurse into our children.
+ * c. With -d. We should not have come here to begin with.
+ */
+ if (level == 0 && !(ls_options & LS_TREE_ONLY))
+ /* case (1)-a and (1)-b */
+ err = err | show_children(e, level+1);
+ else if (level && ls_options & LS_RECURSIVE)
+ /* case (2)-b */
+ err = err | show_children(e, level+1);
+ }
+ return err;
+}
+
+static int list_one(const char *path)
+{
+ int err = 0;
+ struct tree_entry_list *e = find_entry(path);
+ if (!e) {
+ /* traditionally ls-tree does not complain about
+ * missing path. We may change this later to match
+ * what "/bin/ls -a" does, which is to complain.
+ */
+ return err;
+ }
+ err = err | show_entry(e, 0);
+ return err;
+}
+
+static int list(char **path)
+{
+ int i;
+ int err = 0;
+ for (i = 0; path[i]; i++)
+ err = err | list_one(path[i]);
+ return err;
+}
+
+static const char ls_tree_usage[] =
+ "git-ls-tree [-d] [-r] [-z] <tree-ish> [path...]";