]>
git.ipfire.org Git - thirdparty/git.git/blob - attr.c
5 * The basic design decision here is that we are not going to have
6 * insanely large number of attributes.
8 * This is a randomly chosen prime.
17 struct git_attr
*next
;
20 char name
[FLEX_ARRAY
];
24 static struct git_attr_check
*check_all_attr
;
25 static struct git_attr
*(git_attr_hash
[HASHSIZE
]);
27 static unsigned hash_name(const char *name
, int namelen
)
34 val
= ((val
<< 7) | (val
>> 22)) ^ c
;
39 struct git_attr
*git_attr(const char *name
, int len
)
41 unsigned hval
= hash_name(name
, len
);
42 unsigned pos
= hval
% HASHSIZE
;
45 for (a
= git_attr_hash
[pos
]; a
; a
= a
->next
) {
47 !memcmp(a
->name
, name
, len
) && !a
->name
[len
])
51 a
= xmalloc(sizeof(*a
) + len
+ 1);
52 memcpy(a
->name
, name
, len
);
55 a
->next
= git_attr_hash
[pos
];
56 a
->attr_nr
= attr_nr
++;
57 git_attr_hash
[pos
] = a
;
59 check_all_attr
= xrealloc(check_all_attr
,
60 sizeof(*check_all_attr
) * attr_nr
);
61 check_all_attr
[a
->attr_nr
].attr
= a
;
66 * .gitattributes file is one line per record, each of which is
70 * (3) whitespace separated list of attribute names, each of which
71 * could be prefixed with '!' to mean "not set".
76 struct git_attr
*attr
;
82 struct git_attr
*attr
;
86 struct attr_state state
[FLEX_ARRAY
];
89 static const char blank
[] = " \t\r\n";
91 static struct match_attr
*parse_attr_line(const char *line
, const char *src
,
92 int lineno
, int macro_ok
)
96 const char *cp
, *name
;
97 struct match_attr
*res
= res
;
101 cp
= line
+ strspn(line
, blank
);
102 if (!*cp
|| *cp
== '#')
105 namelen
= strcspn(name
, blank
);
106 if (strlen(ATTRIBUTE_MACRO_PREFIX
) < namelen
&&
107 !prefixcmp(name
, ATTRIBUTE_MACRO_PREFIX
)) {
109 fprintf(stderr
, "%s not allowed: %s:%d\n",
114 name
+= strlen(ATTRIBUTE_MACRO_PREFIX
);
115 name
+= strspn(name
, blank
);
116 namelen
= strcspn(name
, blank
);
121 for (pass
= 0; pass
< 2; pass
++) {
122 /* pass 0 counts and allocates, pass 1 fills */
125 cp
= cp
+ strspn(cp
, blank
);
128 ep
= cp
+ strcspn(cp
, blank
);
130 struct attr_state
*e
;
132 e
= &(res
->state
[num_attr
]);
137 e
->attr
= git_attr(cp
, ep
- cp
);
140 cp
= ep
+ strspn(ep
, blank
);
147 sizeof(struct attr_state
) * num_attr
+
148 (is_macro
? 0 : namelen
+ 1));
150 res
->u
.attr
= git_attr(name
, namelen
);
152 res
->u
.pattern
= (char*)&(res
->state
[num_attr
]);
153 memcpy(res
->u
.pattern
, name
, namelen
);
154 res
->u
.pattern
[namelen
] = 0;
156 res
->is_macro
= is_macro
;
157 res
->num_attr
= num_attr
;
163 * Like info/exclude and .gitignore, the attribute information can
164 * come from many places.
166 * (1) .gitattribute file of the same directory;
167 * (2) .gitattribute file of the parent directory if (1) does not have any match;
168 * this goes recursively upwards, just like .gitignore
169 * (3) perhaps $GIT_DIR/info/attributes, as the final fallback.
171 * In the same file, later entries override the earlier match, so in the
172 * global list, we would have entries from info/attributes the earliest
173 * (reading the file from top to bottom), .gitattribute of the root
174 * directory (again, reading the file from top to bottom) down to the
175 * current directory, and then scan the list backwards to find the first match.
176 * This is exactly the same as what excluded() does in dir.c to deal with
180 static struct attr_stack
{
181 struct attr_stack
*prev
;
183 unsigned num_matches
;
184 struct match_attr
**attrs
;
187 static void free_attr_elem(struct attr_stack
*e
)
191 for (i
= 0; i
< e
->num_matches
; i
++)
196 static const char *builtin_attr
[] = {
197 "[attr]binary !diff !crlf",
201 static struct attr_stack
*read_attr_from_array(const char **list
)
203 struct attr_stack
*res
;
207 res
= xcalloc(1, sizeof(*res
));
208 while ((line
= *(list
++)) != NULL
) {
209 struct match_attr
*a
;
211 a
= parse_attr_line(line
, "[builtin]", ++lineno
, 1);
214 res
->attrs
= xrealloc(res
->attrs
, res
->num_matches
+ 1);
215 res
->attrs
[res
->num_matches
++] = a
;
220 static struct attr_stack
*read_attr_from_file(const char *path
, int macro_ok
)
223 struct attr_stack
*res
;
227 res
= xcalloc(1, sizeof(*res
));
228 fp
= fopen(path
, "r");
232 while (fgets(buf
, sizeof(buf
), fp
)) {
233 struct match_attr
*a
;
235 a
= parse_attr_line(buf
, path
, ++lineno
, macro_ok
);
238 res
->attrs
= xrealloc(res
->attrs
, res
->num_matches
+ 1);
239 res
->attrs
[res
->num_matches
++] = a
;
246 static void debug_info(const char *what
, struct attr_stack
*elem
)
248 fprintf(stderr
, "%s: %s\n", what
, elem
->origin
? elem
->origin
: "()");
250 static void debug_set(const char *what
, const char *match
, struct git_attr
*attr
, int set
)
252 fprintf(stderr
, "%s: %s => %d (%s)\n",
253 what
, attr
->name
, set
, match
);
255 #define debug_push(a) debug_info("push", (a))
256 #define debug_pop(a) debug_info("pop", (a))
258 #define debug_push(a) do { ; } while (0)
259 #define debug_pop(a) do { ; } while (0)
260 #define debug_set(a,b,c,d) do { ; } while (0)
263 static void bootstrap_attr_stack(void)
266 struct attr_stack
*elem
;
268 elem
= read_attr_from_array(builtin_attr
);
270 elem
->prev
= attr_stack
;
273 elem
= read_attr_from_file(GITATTRIBUTES_FILE
, 1);
274 elem
->origin
= strdup("");
275 elem
->prev
= attr_stack
;
279 elem
= read_attr_from_file(git_path(INFOATTRIBUTES_FILE
), 1);
281 elem
->prev
= attr_stack
;
286 static void prepare_attr_stack(const char *path
, int dirlen
)
288 struct attr_stack
*elem
, *info
;
290 char pathbuf
[PATH_MAX
];
293 * At the bottom of the attribute stack is the built-in
294 * set of attribute definitions. Then, contents from
295 * .gitattribute files from directories closer to the
296 * root to the ones in deeper directories are pushed
297 * to the stack. Finally, at the very top of the stack
298 * we always keep the contents of $GIT_DIR/info/attributes.
300 * When checking, we use entries from near the top of the
301 * stack, preferring $GIT_DIR/info/attributes, then
302 * .gitattributes in deeper directories to shallower ones,
303 * and finally use the built-in set as the default.
306 bootstrap_attr_stack();
309 * Pop the "info" one that is always at the top of the stack.
312 attr_stack
= info
->prev
;
315 * Pop the ones from directories that are not the prefix of
316 * the path we are checking.
318 while (attr_stack
&& attr_stack
->origin
) {
319 int namelen
= strlen(attr_stack
->origin
);
322 if (namelen
<= dirlen
&&
323 !strncmp(elem
->origin
, path
, namelen
))
327 attr_stack
= elem
->prev
;
328 free_attr_elem(elem
);
332 * Read from parent directories and push them down
337 len
= strlen(attr_stack
->origin
);
340 memcpy(pathbuf
, path
, dirlen
);
341 memcpy(pathbuf
+ dirlen
, "/", 2);
342 cp
= strchr(pathbuf
+ len
+ 1, '/');
343 strcpy(cp
+ 1, GITATTRIBUTES_FILE
);
344 elem
= read_attr_from_file(pathbuf
, 0);
346 elem
->origin
= strdup(pathbuf
);
347 elem
->prev
= attr_stack
;
353 * Finally push the "info" one at the top of the stack.
355 info
->prev
= attr_stack
;
359 static int path_matches(const char *pathname
, int pathlen
,
361 const char *base
, int baselen
)
363 if (!strchr(pattern
, '/')) {
365 const char *basename
= strrchr(pathname
, '/');
366 basename
= basename
? basename
+ 1 : pathname
;
367 return (fnmatch(pattern
, basename
, 0) == 0);
370 * match with FNM_PATHNAME; the pattern has base implicitly
375 if (pathlen
< baselen
||
376 (baselen
&& pathname
[baselen
- 1] != '/') ||
377 strncmp(pathname
, base
, baselen
))
379 return fnmatch(pattern
, pathname
+ baselen
, FNM_PATHNAME
) == 0;
382 static int fill(const char *path
, int pathlen
, struct attr_stack
*stk
, int rem
)
384 const char *base
= stk
->origin
? stk
->origin
: "";
386 struct git_attr_check
*check
= check_all_attr
;
388 for (i
= stk
->num_matches
- 1; 0 < rem
&& 0 <= i
; i
--) {
389 struct match_attr
*a
= stk
->attrs
[i
];
392 if (path_matches(path
, pathlen
,
393 a
->u
.pattern
, base
, strlen(base
))) {
394 for (j
= 0; 0 < rem
&& j
< a
->num_attr
; j
++) {
395 struct git_attr
*attr
= a
->state
[j
].attr
;
396 int set
= !a
->state
[j
].unset
;
397 int *n
= &(check
[attr
->attr_nr
].isset
);
400 debug_set("fill", a
->u
.pattern
, attr
, set
);
410 static int macroexpand(struct attr_stack
*stk
, int rem
)
413 struct git_attr_check
*check
= check_all_attr
;
415 for (i
= stk
->num_matches
- 1; 0 < rem
&& 0 <= i
; i
--) {
416 struct match_attr
*a
= stk
->attrs
[i
];
419 if (check
[a
->u
.attr
->attr_nr
].isset
< 0)
421 for (j
= 0; 0 < rem
&& j
< a
->num_attr
; j
++) {
422 struct git_attr
*attr
= a
->state
[j
].attr
;
423 int set
= !a
->state
[j
].unset
;
424 int *n
= &(check
[attr
->attr_nr
].isset
);
427 debug_set("expand", a
->u
.attr
->name
, attr
, set
);
436 int git_checkattr(const char *path
, int num
, struct git_attr_check
*check
)
438 struct attr_stack
*stk
;
440 int dirlen
, pathlen
, i
, rem
;
442 bootstrap_attr_stack();
443 for (i
= 0; i
< attr_nr
; i
++)
444 check_all_attr
[i
].isset
= -1;
446 pathlen
= strlen(path
);
447 cp
= strrchr(path
, '/');
452 prepare_attr_stack(path
, dirlen
);
454 for (stk
= attr_stack
; 0 < rem
&& stk
; stk
= stk
->prev
)
455 rem
= fill(path
, pathlen
, stk
, rem
);
457 for (stk
= attr_stack
; 0 < rem
&& stk
; stk
= stk
->prev
)
458 rem
= macroexpand(stk
, rem
);
460 for (i
= 0; i
< num
; i
++)
461 check
[i
].isset
= check_all_attr
[check
[i
].attr
->attr_nr
].isset
;