1 #define NO_THE_INDEX_COMPATIBILITY_MACROS
3 #include "cache-tree.h"
5 #include "object-store.h"
10 #include "tree-walk.h"
11 #include "repository.h"
13 const char *tree_type
= "tree";
15 static int read_one_entry_opt(struct index_state
*istate
,
16 const struct object_id
*oid
,
17 const char *base
, int baselen
,
19 unsigned mode
, int stage
, int opt
)
22 struct cache_entry
*ce
;
25 return READ_TREE_RECURSIVE
;
27 len
= strlen(pathname
);
28 ce
= make_empty_cache_entry(istate
, baselen
+ len
);
30 ce
->ce_mode
= create_ce_mode(mode
);
31 ce
->ce_flags
= create_ce_flags(stage
);
32 ce
->ce_namelen
= baselen
+ len
;
33 memcpy(ce
->name
, base
, baselen
);
34 memcpy(ce
->name
+ baselen
, pathname
, len
+1);
35 oidcpy(&ce
->oid
, oid
);
36 return add_index_entry(istate
, ce
, opt
);
39 static int read_one_entry(const struct object_id
*oid
, struct strbuf
*base
,
40 const char *pathname
, unsigned mode
, int stage
,
43 struct index_state
*istate
= context
;
44 return read_one_entry_opt(istate
, oid
, base
->buf
, base
->len
, pathname
,
46 ADD_CACHE_OK_TO_ADD
|ADD_CACHE_SKIP_DFCHECK
);
50 * This is used when the caller knows there is no existing entries at
51 * the stage that will conflict with the entry being added.
53 static int read_one_entry_quick(const struct object_id
*oid
, struct strbuf
*base
,
54 const char *pathname
, unsigned mode
, int stage
,
57 struct index_state
*istate
= context
;
58 return read_one_entry_opt(istate
, oid
, base
->buf
, base
->len
, pathname
,
60 ADD_CACHE_JUST_APPEND
);
63 static int read_tree_1(struct tree
*tree
, struct strbuf
*base
,
64 int stage
, const struct pathspec
*pathspec
,
65 read_tree_fn_t fn
, void *context
)
67 struct tree_desc desc
;
68 struct name_entry entry
;
70 int len
, oldlen
= base
->len
;
71 enum interesting retval
= entry_not_interesting
;
76 init_tree_desc(&desc
, tree
->buffer
, tree
->size
);
78 while (tree_entry(&desc
, &entry
)) {
79 if (retval
!= all_entries_interesting
) {
80 retval
= tree_entry_interesting(&entry
, base
, 0, pathspec
);
81 if (retval
== all_entries_not_interesting
)
83 if (retval
== entry_not_interesting
)
87 switch (fn(entry
.oid
, base
,
88 entry
.path
, entry
.mode
, stage
, context
)) {
91 case READ_TREE_RECURSIVE
:
97 if (S_ISDIR(entry
.mode
))
98 oidcpy(&oid
, entry
.oid
);
99 else if (S_ISGITLINK(entry
.mode
)) {
100 struct commit
*commit
;
102 commit
= lookup_commit(the_repository
, entry
.oid
);
104 die("Commit %s in submodule path %s%s not found",
105 oid_to_hex(entry
.oid
),
106 base
->buf
, entry
.path
);
108 if (parse_commit(commit
))
109 die("Invalid commit %s in submodule path %s%s",
110 oid_to_hex(entry
.oid
),
111 base
->buf
, entry
.path
);
113 oidcpy(&oid
, get_commit_tree_oid(commit
));
118 len
= tree_entry_len(&entry
);
119 strbuf_add(base
, entry
.path
, len
);
120 strbuf_addch(base
, '/');
121 retval
= read_tree_1(lookup_tree(the_repository
, &oid
),
122 base
, stage
, pathspec
,
124 strbuf_setlen(base
, oldlen
);
131 int read_tree_recursive(struct tree
*tree
,
132 const char *base
, int baselen
,
133 int stage
, const struct pathspec
*pathspec
,
134 read_tree_fn_t fn
, void *context
)
136 struct strbuf sb
= STRBUF_INIT
;
139 strbuf_add(&sb
, base
, baselen
);
140 ret
= read_tree_1(tree
, &sb
, stage
, pathspec
, fn
, context
);
145 static int cmp_cache_name_compare(const void *a_
, const void *b_
)
147 const struct cache_entry
*ce1
, *ce2
;
149 ce1
= *((const struct cache_entry
**)a_
);
150 ce2
= *((const struct cache_entry
**)b_
);
151 return cache_name_stage_compare(ce1
->name
, ce1
->ce_namelen
, ce_stage(ce1
),
152 ce2
->name
, ce2
->ce_namelen
, ce_stage(ce2
));
155 int read_tree(struct tree
*tree
, int stage
, struct pathspec
*match
,
156 struct index_state
*istate
)
158 read_tree_fn_t fn
= NULL
;
162 * Currently the only existing callers of this function all
163 * call it with stage=1 and after making sure there is nothing
164 * at that stage; we could always use read_one_entry_quick().
166 * But when we decide to straighten out git-read-tree not to
167 * use unpack_trees() in some cases, this will probably start
172 * See if we have cache entry at the stage. If so,
173 * do it the original slow way, otherwise, append and then
176 for (i
= 0; !fn
&& i
< istate
->cache_nr
; i
++) {
177 const struct cache_entry
*ce
= istate
->cache
[i
];
178 if (ce_stage(ce
) == stage
)
183 fn
= read_one_entry_quick
;
184 err
= read_tree_recursive(tree
, "", 0, stage
, match
, fn
, istate
);
185 if (fn
== read_one_entry
|| err
)
189 * Sort the cache entry -- we need to nuke the cache tree, though.
191 cache_tree_free(&istate
->cache_tree
);
192 QSORT(istate
->cache
, istate
->cache_nr
, cmp_cache_name_compare
);
196 struct tree
*lookup_tree(struct repository
*r
, const struct object_id
*oid
)
198 struct object
*obj
= lookup_object(r
, oid
->hash
);
200 return create_object(r
, oid
->hash
,
202 return object_as_type(r
, obj
, OBJ_TREE
, 0);
205 int parse_tree_buffer(struct tree
*item
, void *buffer
, unsigned long size
)
207 if (item
->object
.parsed
)
209 item
->object
.parsed
= 1;
210 item
->buffer
= buffer
;
216 int parse_tree_gently(struct tree
*item
, int quiet_on_missing
)
218 enum object_type type
;
222 if (item
->object
.parsed
)
224 buffer
= read_object_file(&item
->object
.oid
, &type
, &size
);
226 return quiet_on_missing
? -1 :
227 error("Could not read %s",
228 oid_to_hex(&item
->object
.oid
));
229 if (type
!= OBJ_TREE
) {
231 return error("Object %s not a tree",
232 oid_to_hex(&item
->object
.oid
));
234 return parse_tree_buffer(item
, buffer
, size
);
237 void free_tree_buffer(struct tree
*tree
)
239 FREE_AND_NULL(tree
->buffer
);
241 tree
->object
.parsed
= 0;
244 struct tree
*parse_tree_indirect(const struct object_id
*oid
)
246 struct object
*obj
= parse_object(the_repository
, oid
);
250 if (obj
->type
== OBJ_TREE
)
251 return (struct tree
*) obj
;
252 else if (obj
->type
== OBJ_COMMIT
)
253 obj
= &(get_commit_tree(((struct commit
*)obj
))->object
);
254 else if (obj
->type
== OBJ_TAG
)
255 obj
= ((struct tag
*) obj
)->tagged
;
259 parse_object(the_repository
, &obj
->oid
);