]> git.ipfire.org Git - thirdparty/git.git/blob - dir-iterator.c
git-submodule.sh: shorten submodule SHA-1s using rev-parse
[thirdparty/git.git] / dir-iterator.c
1 #include "cache.h"
2 #include "dir.h"
3 #include "iterator.h"
4 #include "dir-iterator.h"
5
6 struct dir_iterator_level {
7 int initialized;
8
9 DIR *dir;
10
11 /*
12 * The length of the directory part of path at this level
13 * (including a trailing '/'):
14 */
15 size_t prefix_len;
16
17 /*
18 * The last action that has been taken with the current entry
19 * (needed for directories, which have to be included in the
20 * iteration and also iterated into):
21 */
22 enum {
23 DIR_STATE_ITER,
24 DIR_STATE_RECURSE
25 } dir_state;
26 };
27
28 /*
29 * The full data structure used to manage the internal directory
30 * iteration state. It includes members that are not part of the
31 * public interface.
32 */
33 struct dir_iterator_int {
34 struct dir_iterator base;
35
36 /*
37 * The number of levels currently on the stack. This is always
38 * at least 1, because when it becomes zero the iteration is
39 * ended and this struct is freed.
40 */
41 size_t levels_nr;
42
43 /* The number of levels that have been allocated on the stack */
44 size_t levels_alloc;
45
46 /*
47 * A stack of levels. levels[0] is the uppermost directory
48 * that will be included in this iteration.
49 */
50 struct dir_iterator_level *levels;
51 };
52
53 int dir_iterator_advance(struct dir_iterator *dir_iterator)
54 {
55 struct dir_iterator_int *iter =
56 (struct dir_iterator_int *)dir_iterator;
57
58 while (1) {
59 struct dir_iterator_level *level =
60 &iter->levels[iter->levels_nr - 1];
61 struct dirent *de;
62
63 if (!level->initialized) {
64 /*
65 * Note: dir_iterator_begin() ensures that
66 * path is not the empty string.
67 */
68 if (!is_dir_sep(iter->base.path.buf[iter->base.path.len - 1]))
69 strbuf_addch(&iter->base.path, '/');
70 level->prefix_len = iter->base.path.len;
71
72 level->dir = opendir(iter->base.path.buf);
73 if (!level->dir && errno != ENOENT) {
74 warning("error opening directory %s: %s",
75 iter->base.path.buf, strerror(errno));
76 /* Popping the level is handled below */
77 }
78
79 level->initialized = 1;
80 } else if (S_ISDIR(iter->base.st.st_mode)) {
81 if (level->dir_state == DIR_STATE_ITER) {
82 /*
83 * The directory was just iterated
84 * over; now prepare to iterate into
85 * it.
86 */
87 level->dir_state = DIR_STATE_RECURSE;
88 ALLOC_GROW(iter->levels, iter->levels_nr + 1,
89 iter->levels_alloc);
90 level = &iter->levels[iter->levels_nr++];
91 level->initialized = 0;
92 continue;
93 } else {
94 /*
95 * The directory has already been
96 * iterated over and iterated into;
97 * we're done with it.
98 */
99 }
100 }
101
102 if (!level->dir) {
103 /*
104 * This level is exhausted (or wasn't opened
105 * successfully); pop up a level.
106 */
107 if (--iter->levels_nr == 0)
108 return dir_iterator_abort(dir_iterator);
109
110 continue;
111 }
112
113 /*
114 * Loop until we find an entry that we can give back
115 * to the caller:
116 */
117 while (1) {
118 strbuf_setlen(&iter->base.path, level->prefix_len);
119 errno = 0;
120 de = readdir(level->dir);
121
122 if (!de) {
123 /* This level is exhausted; pop up a level. */
124 if (errno) {
125 warning("error reading directory %s: %s",
126 iter->base.path.buf, strerror(errno));
127 } else if (closedir(level->dir))
128 warning("error closing directory %s: %s",
129 iter->base.path.buf, strerror(errno));
130
131 level->dir = NULL;
132 if (--iter->levels_nr == 0)
133 return dir_iterator_abort(dir_iterator);
134 break;
135 }
136
137 if (is_dot_or_dotdot(de->d_name))
138 continue;
139
140 strbuf_addstr(&iter->base.path, de->d_name);
141 if (lstat(iter->base.path.buf, &iter->base.st) < 0) {
142 if (errno != ENOENT)
143 warning("error reading path '%s': %s",
144 iter->base.path.buf,
145 strerror(errno));
146 continue;
147 }
148
149 /*
150 * We have to set these each time because
151 * the path strbuf might have been realloc()ed.
152 */
153 iter->base.relative_path =
154 iter->base.path.buf + iter->levels[0].prefix_len;
155 iter->base.basename =
156 iter->base.path.buf + level->prefix_len;
157 level->dir_state = DIR_STATE_ITER;
158
159 return ITER_OK;
160 }
161 }
162 }
163
164 int dir_iterator_abort(struct dir_iterator *dir_iterator)
165 {
166 struct dir_iterator_int *iter = (struct dir_iterator_int *)dir_iterator;
167
168 for (; iter->levels_nr; iter->levels_nr--) {
169 struct dir_iterator_level *level =
170 &iter->levels[iter->levels_nr - 1];
171
172 if (level->dir && closedir(level->dir)) {
173 strbuf_setlen(&iter->base.path, level->prefix_len);
174 warning("error closing directory %s: %s",
175 iter->base.path.buf, strerror(errno));
176 }
177 }
178
179 free(iter->levels);
180 strbuf_release(&iter->base.path);
181 free(iter);
182 return ITER_DONE;
183 }
184
185 struct dir_iterator *dir_iterator_begin(const char *path)
186 {
187 struct dir_iterator_int *iter = xcalloc(1, sizeof(*iter));
188 struct dir_iterator *dir_iterator = &iter->base;
189
190 if (!path || !*path)
191 BUG("empty path passed to dir_iterator_begin()");
192
193 strbuf_init(&iter->base.path, PATH_MAX);
194 strbuf_addstr(&iter->base.path, path);
195
196 ALLOC_GROW(iter->levels, 10, iter->levels_alloc);
197
198 iter->levels_nr = 1;
199 iter->levels[0].initialized = 0;
200
201 return dir_iterator;
202 }