2 #include "cache-tree.h"
9 const char *tree_type
= "tree";
11 static int read_one_entry_opt(const unsigned char *sha1
, const char *base
, int baselen
, const char *pathname
, unsigned mode
, int stage
, int opt
)
15 struct cache_entry
*ce
;
18 return READ_TREE_RECURSIVE
;
20 len
= strlen(pathname
);
21 size
= cache_entry_size(baselen
+ len
);
22 ce
= xcalloc(1, size
);
24 ce
->ce_mode
= create_ce_mode(mode
);
25 ce
->ce_flags
= create_ce_flags(baselen
+ len
, stage
);
26 memcpy(ce
->name
, base
, baselen
);
27 memcpy(ce
->name
+ baselen
, pathname
, len
+1);
28 hashcpy(ce
->sha1
, sha1
);
29 return add_cache_entry(ce
, opt
);
32 static int read_one_entry(const unsigned char *sha1
, const char *base
, int baselen
, const char *pathname
, unsigned mode
, int stage
, void *context
)
34 return read_one_entry_opt(sha1
, base
, baselen
, pathname
, mode
, stage
,
35 ADD_CACHE_OK_TO_ADD
|ADD_CACHE_SKIP_DFCHECK
);
39 * This is used when the caller knows there is no existing entries at
40 * the stage that will conflict with the entry being added.
42 static int read_one_entry_quick(const unsigned char *sha1
, const char *base
, int baselen
, const char *pathname
, unsigned mode
, int stage
, void *context
)
44 return read_one_entry_opt(sha1
, base
, baselen
, pathname
, mode
, stage
,
45 ADD_CACHE_JUST_APPEND
);
48 static int read_tree_1(struct tree
*tree
, struct strbuf
*base
,
49 int stage
, struct pathspec
*pathspec
,
50 read_tree_fn_t fn
, void *context
)
52 struct tree_desc desc
;
53 struct name_entry entry
;
54 unsigned char sha1
[20];
55 int len
, retval
= 0, oldlen
= base
->len
;
60 init_tree_desc(&desc
, tree
->buffer
, tree
->size
);
62 while (tree_entry(&desc
, &entry
)) {
64 retval
= tree_entry_interesting(&entry
, base
, 0, pathspec
);
71 switch (fn(entry
.sha1
, base
->buf
, base
->len
,
72 entry
.path
, entry
.mode
, stage
, context
)) {
75 case READ_TREE_RECURSIVE
:
81 if (S_ISDIR(entry
.mode
))
82 hashcpy(sha1
, entry
.sha1
);
83 else if (S_ISGITLINK(entry
.mode
)) {
84 struct commit
*commit
;
86 commit
= lookup_commit(entry
.sha1
);
88 die("Commit %s in submodule path %s%s not found",
89 sha1_to_hex(entry
.sha1
),
90 base
->buf
, entry
.path
);
92 if (parse_commit(commit
))
93 die("Invalid commit %s in submodule path %s%s",
94 sha1_to_hex(entry
.sha1
),
95 base
->buf
, entry
.path
);
97 hashcpy(sha1
, commit
->tree
->object
.sha1
);
102 len
= tree_entry_len(entry
.path
, entry
.sha1
);
103 strbuf_add(base
, entry
.path
, len
);
104 strbuf_addch(base
, '/');
105 retval
= read_tree_1(lookup_tree(sha1
),
106 base
, stage
, pathspec
,
108 strbuf_setlen(base
, oldlen
);
115 int read_tree_recursive(struct tree
*tree
,
116 const char *base
, int baselen
,
117 int stage
, const char **match
,
118 read_tree_fn_t fn
, void *context
)
120 struct strbuf sb
= STRBUF_INIT
;
121 struct pathspec pathspec
;
124 init_pathspec(&pathspec
, match
);
125 for (i
= 0; i
< pathspec
.nr
; i
++)
126 pathspec
.items
[i
].has_wildcard
= 0;
127 strbuf_add(&sb
, base
, baselen
);
128 ret
= read_tree_1(tree
, &sb
, stage
, &pathspec
, fn
, context
);
130 free_pathspec(&pathspec
);
134 static int cmp_cache_name_compare(const void *a_
, const void *b_
)
136 const struct cache_entry
*ce1
, *ce2
;
138 ce1
= *((const struct cache_entry
**)a_
);
139 ce2
= *((const struct cache_entry
**)b_
);
140 return cache_name_compare(ce1
->name
, ce1
->ce_flags
,
141 ce2
->name
, ce2
->ce_flags
);
144 int read_tree(struct tree
*tree
, int stage
, const char **match
)
146 read_tree_fn_t fn
= NULL
;
150 * Currently the only existing callers of this function all
151 * call it with stage=1 and after making sure there is nothing
152 * at that stage; we could always use read_one_entry_quick().
154 * But when we decide to straighten out git-read-tree not to
155 * use unpack_trees() in some cases, this will probably start
160 * See if we have cache entry at the stage. If so,
161 * do it the original slow way, otherwise, append and then
164 for (i
= 0; !fn
&& i
< active_nr
; i
++) {
165 struct cache_entry
*ce
= active_cache
[i
];
166 if (ce_stage(ce
) == stage
)
171 fn
= read_one_entry_quick
;
172 err
= read_tree_recursive(tree
, "", 0, stage
, match
, fn
, NULL
);
173 if (fn
== read_one_entry
|| err
)
177 * Sort the cache entry -- we need to nuke the cache tree, though.
179 cache_tree_free(&active_cache_tree
);
180 qsort(active_cache
, active_nr
, sizeof(active_cache
[0]),
181 cmp_cache_name_compare
);
185 struct tree
*lookup_tree(const unsigned char *sha1
)
187 struct object
*obj
= lookup_object(sha1
);
189 return create_object(sha1
, OBJ_TREE
, alloc_tree_node());
191 obj
->type
= OBJ_TREE
;
192 if (obj
->type
!= OBJ_TREE
) {
193 error("Object %s is a %s, not a tree",
194 sha1_to_hex(sha1
), typename(obj
->type
));
197 return (struct tree
*) obj
;
200 int parse_tree_buffer(struct tree
*item
, void *buffer
, unsigned long size
)
202 if (item
->object
.parsed
)
204 item
->object
.parsed
= 1;
205 item
->buffer
= buffer
;
211 int parse_tree(struct tree
*item
)
213 enum object_type type
;
217 if (item
->object
.parsed
)
219 buffer
= read_sha1_file(item
->object
.sha1
, &type
, &size
);
221 return error("Could not read %s",
222 sha1_to_hex(item
->object
.sha1
));
223 if (type
!= OBJ_TREE
) {
225 return error("Object %s not a tree",
226 sha1_to_hex(item
->object
.sha1
));
228 return parse_tree_buffer(item
, buffer
, size
);
231 struct tree
*parse_tree_indirect(const unsigned char *sha1
)
233 struct object
*obj
= parse_object(sha1
);
237 if (obj
->type
== OBJ_TREE
)
238 return (struct tree
*) obj
;
239 else if (obj
->type
== OBJ_COMMIT
)
240 obj
= &(((struct commit
*) obj
)->tree
->object
);
241 else if (obj
->type
== OBJ_TAG
)
242 obj
= ((struct tag
*) obj
)->tagged
;
246 parse_object(obj
->sha1
);