2 #include "string-list.h"
3 #include "run-command.h"
9 * Copyright (c) 2013, 2014 Christian Couder <chriscool@tuxfamily.org>
12 enum action_where
{ WHERE_END
, WHERE_AFTER
, WHERE_BEFORE
, WHERE_START
};
13 enum action_if_exists
{ EXISTS_ADD_IF_DIFFERENT_NEIGHBOR
, EXISTS_ADD_IF_DIFFERENT
,
14 EXISTS_ADD
, EXISTS_REPLACE
, EXISTS_DO_NOTHING
};
15 enum action_if_missing
{ MISSING_ADD
, MISSING_DO_NOTHING
};
21 enum action_where where
;
22 enum action_if_exists if_exists
;
23 enum action_if_missing if_missing
;
26 static struct conf_info default_conf_info
;
29 struct list_head list
;
31 * If this is not a trailer line, the line is stored in value
32 * (excluding the terminating newline) and token is NULL.
39 struct list_head list
;
42 struct conf_info conf
;
45 static LIST_HEAD(conf_head
);
47 static char *separators
= ":";
49 static int configured
;
51 #define TRAILER_ARG_STRING "$ARG"
53 static const char *git_generated_prefixes
[] = {
55 "(cherry picked from commit ",
59 /* Iterate over the elements of the list. */
60 #define list_for_each_dir(pos, head, is_reverse) \
61 for (pos = is_reverse ? (head)->prev : (head)->next; \
63 pos = is_reverse ? pos->prev : pos->next)
65 static int after_or_end(enum action_where where
)
67 return (where
== WHERE_AFTER
) || (where
== WHERE_END
);
71 * Return the length of the string not including any final
72 * punctuation. E.g., the input "Signed-off-by:" would return
73 * 13, stripping the trailing punctuation but retaining
74 * internal punctuation.
76 static size_t token_len_without_separator(const char *token
, size_t len
)
78 while (len
> 0 && !isalnum(token
[len
- 1]))
83 static int same_token(struct trailer_item
*a
, struct arg_item
*b
)
85 size_t a_len
, b_len
, min_len
;
90 a_len
= token_len_without_separator(a
->token
, strlen(a
->token
));
91 b_len
= token_len_without_separator(b
->token
, strlen(b
->token
));
92 min_len
= (a_len
> b_len
) ? b_len
: a_len
;
94 return !strncasecmp(a
->token
, b
->token
, min_len
);
97 static int same_value(struct trailer_item
*a
, struct arg_item
*b
)
99 return !strcasecmp(a
->value
, b
->value
);
102 static int same_trailer(struct trailer_item
*a
, struct arg_item
*b
)
104 return same_token(a
, b
) && same_value(a
, b
);
107 static inline int is_blank_line(const char *str
)
110 while (*s
&& *s
!= '\n' && isspace(*s
))
112 return !*s
|| *s
== '\n';
115 static inline void strbuf_replace(struct strbuf
*sb
, const char *a
, const char *b
)
117 const char *ptr
= strstr(sb
->buf
, a
);
119 strbuf_splice(sb
, ptr
- sb
->buf
, strlen(a
), b
, strlen(b
));
122 static void free_trailer_item(struct trailer_item
*item
)
129 static void free_arg_item(struct arg_item
*item
)
131 free(item
->conf
.name
);
132 free(item
->conf
.key
);
133 free(item
->conf
.command
);
139 static char last_non_space_char(const char *s
)
142 for (i
= strlen(s
) - 1; i
>= 0; i
--)
148 static void print_tok_val(FILE *outfile
, const char *tok
, const char *val
)
153 fprintf(outfile
, "%s\n", val
);
157 c
= last_non_space_char(tok
);
160 if (strchr(separators
, c
))
161 fprintf(outfile
, "%s%s\n", tok
, val
);
163 fprintf(outfile
, "%s%c %s\n", tok
, separators
[0], val
);
166 static void print_all(FILE *outfile
, struct list_head
*head
,
167 const struct process_trailer_options
*opts
)
169 struct list_head
*pos
;
170 struct trailer_item
*item
;
171 list_for_each(pos
, head
) {
172 item
= list_entry(pos
, struct trailer_item
, list
);
173 if ((!opts
->trim_empty
|| strlen(item
->value
) > 0) &&
174 (!opts
->only_trailers
|| item
->token
))
175 print_tok_val(outfile
, item
->token
, item
->value
);
179 static struct trailer_item
*trailer_from_arg(struct arg_item
*arg_tok
)
181 struct trailer_item
*new = xcalloc(sizeof(*new), 1);
182 new->token
= arg_tok
->token
;
183 new->value
= arg_tok
->value
;
184 arg_tok
->token
= arg_tok
->value
= NULL
;
185 free_arg_item(arg_tok
);
189 static void add_arg_to_input_list(struct trailer_item
*on_tok
,
190 struct arg_item
*arg_tok
)
192 int aoe
= after_or_end(arg_tok
->conf
.where
);
193 struct trailer_item
*to_add
= trailer_from_arg(arg_tok
);
195 list_add(&to_add
->list
, &on_tok
->list
);
197 list_add_tail(&to_add
->list
, &on_tok
->list
);
200 static int check_if_different(struct trailer_item
*in_tok
,
201 struct arg_item
*arg_tok
,
203 struct list_head
*head
)
205 enum action_where where
= arg_tok
->conf
.where
;
206 struct list_head
*next_head
;
208 if (same_trailer(in_tok
, arg_tok
))
211 * if we want to add a trailer after another one,
212 * we have to check those before this one
214 next_head
= after_or_end(where
) ? in_tok
->list
.prev
216 if (next_head
== head
)
218 in_tok
= list_entry(next_head
, struct trailer_item
, list
);
223 static char *apply_command(const char *command
, const char *arg
)
225 struct strbuf cmd
= STRBUF_INIT
;
226 struct strbuf buf
= STRBUF_INIT
;
227 struct child_process cp
= CHILD_PROCESS_INIT
;
228 const char *argv
[] = {NULL
, NULL
};
231 strbuf_addstr(&cmd
, command
);
233 strbuf_replace(&cmd
, TRAILER_ARG_STRING
, arg
);
237 cp
.env
= local_repo_env
;
241 if (capture_command(&cp
, &buf
, 1024)) {
242 error(_("running trailer command '%s' failed"), cmd
.buf
);
243 strbuf_release(&buf
);
244 result
= xstrdup("");
247 result
= strbuf_detach(&buf
, NULL
);
250 strbuf_release(&cmd
);
254 static void apply_item_command(struct trailer_item
*in_tok
, struct arg_item
*arg_tok
)
256 if (arg_tok
->conf
.command
) {
258 if (arg_tok
->value
&& arg_tok
->value
[0]) {
259 arg
= arg_tok
->value
;
261 if (in_tok
&& in_tok
->value
)
262 arg
= xstrdup(in_tok
->value
);
266 arg_tok
->value
= apply_command(arg_tok
->conf
.command
, arg
);
271 static void apply_arg_if_exists(struct trailer_item
*in_tok
,
272 struct arg_item
*arg_tok
,
273 struct trailer_item
*on_tok
,
274 struct list_head
*head
)
276 switch (arg_tok
->conf
.if_exists
) {
277 case EXISTS_DO_NOTHING
:
278 free_arg_item(arg_tok
);
281 apply_item_command(in_tok
, arg_tok
);
282 add_arg_to_input_list(on_tok
, arg_tok
);
283 list_del(&in_tok
->list
);
284 free_trailer_item(in_tok
);
287 apply_item_command(in_tok
, arg_tok
);
288 add_arg_to_input_list(on_tok
, arg_tok
);
290 case EXISTS_ADD_IF_DIFFERENT
:
291 apply_item_command(in_tok
, arg_tok
);
292 if (check_if_different(in_tok
, arg_tok
, 1, head
))
293 add_arg_to_input_list(on_tok
, arg_tok
);
295 free_arg_item(arg_tok
);
297 case EXISTS_ADD_IF_DIFFERENT_NEIGHBOR
:
298 apply_item_command(in_tok
, arg_tok
);
299 if (check_if_different(on_tok
, arg_tok
, 0, head
))
300 add_arg_to_input_list(on_tok
, arg_tok
);
302 free_arg_item(arg_tok
);
307 static void apply_arg_if_missing(struct list_head
*head
,
308 struct arg_item
*arg_tok
)
310 enum action_where where
;
311 struct trailer_item
*to_add
;
313 switch (arg_tok
->conf
.if_missing
) {
314 case MISSING_DO_NOTHING
:
315 free_arg_item(arg_tok
);
318 where
= arg_tok
->conf
.where
;
319 apply_item_command(NULL
, arg_tok
);
320 to_add
= trailer_from_arg(arg_tok
);
321 if (after_or_end(where
))
322 list_add_tail(&to_add
->list
, head
);
324 list_add(&to_add
->list
, head
);
328 static int find_same_and_apply_arg(struct list_head
*head
,
329 struct arg_item
*arg_tok
)
331 struct list_head
*pos
;
332 struct trailer_item
*in_tok
;
333 struct trailer_item
*on_tok
;
335 enum action_where where
= arg_tok
->conf
.where
;
336 int middle
= (where
== WHERE_AFTER
) || (where
== WHERE_BEFORE
);
337 int backwards
= after_or_end(where
);
338 struct trailer_item
*start_tok
;
340 if (list_empty(head
))
343 start_tok
= list_entry(backwards
? head
->prev
: head
->next
,
347 list_for_each_dir(pos
, head
, backwards
) {
348 in_tok
= list_entry(pos
, struct trailer_item
, list
);
349 if (!same_token(in_tok
, arg_tok
))
351 on_tok
= middle
? in_tok
: start_tok
;
352 apply_arg_if_exists(in_tok
, arg_tok
, on_tok
, head
);
358 static void process_trailers_lists(struct list_head
*head
,
359 struct list_head
*arg_head
)
361 struct list_head
*pos
, *p
;
362 struct arg_item
*arg_tok
;
364 list_for_each_safe(pos
, p
, arg_head
) {
366 arg_tok
= list_entry(pos
, struct arg_item
, list
);
370 applied
= find_same_and_apply_arg(head
, arg_tok
);
373 apply_arg_if_missing(head
, arg_tok
);
377 static int set_where(struct conf_info
*item
, const char *value
)
379 if (!strcasecmp("after", value
))
380 item
->where
= WHERE_AFTER
;
381 else if (!strcasecmp("before", value
))
382 item
->where
= WHERE_BEFORE
;
383 else if (!strcasecmp("end", value
))
384 item
->where
= WHERE_END
;
385 else if (!strcasecmp("start", value
))
386 item
->where
= WHERE_START
;
392 static int set_if_exists(struct conf_info
*item
, const char *value
)
394 if (!strcasecmp("addIfDifferent", value
))
395 item
->if_exists
= EXISTS_ADD_IF_DIFFERENT
;
396 else if (!strcasecmp("addIfDifferentNeighbor", value
))
397 item
->if_exists
= EXISTS_ADD_IF_DIFFERENT_NEIGHBOR
;
398 else if (!strcasecmp("add", value
))
399 item
->if_exists
= EXISTS_ADD
;
400 else if (!strcasecmp("replace", value
))
401 item
->if_exists
= EXISTS_REPLACE
;
402 else if (!strcasecmp("doNothing", value
))
403 item
->if_exists
= EXISTS_DO_NOTHING
;
409 static int set_if_missing(struct conf_info
*item
, const char *value
)
411 if (!strcasecmp("doNothing", value
))
412 item
->if_missing
= MISSING_DO_NOTHING
;
413 else if (!strcasecmp("add", value
))
414 item
->if_missing
= MISSING_ADD
;
420 static void duplicate_conf(struct conf_info
*dst
, const struct conf_info
*src
)
423 dst
->name
= xstrdup_or_null(src
->name
);
424 dst
->key
= xstrdup_or_null(src
->key
);
425 dst
->command
= xstrdup_or_null(src
->command
);
428 static struct arg_item
*get_conf_item(const char *name
)
430 struct list_head
*pos
;
431 struct arg_item
*item
;
433 /* Look up item with same name */
434 list_for_each(pos
, &conf_head
) {
435 item
= list_entry(pos
, struct arg_item
, list
);
436 if (!strcasecmp(item
->conf
.name
, name
))
440 /* Item does not already exists, create it */
441 item
= xcalloc(sizeof(*item
), 1);
442 duplicate_conf(&item
->conf
, &default_conf_info
);
443 item
->conf
.name
= xstrdup(name
);
445 list_add_tail(&item
->list
, &conf_head
);
450 enum trailer_info_type
{ TRAILER_KEY
, TRAILER_COMMAND
, TRAILER_WHERE
,
451 TRAILER_IF_EXISTS
, TRAILER_IF_MISSING
};
455 enum trailer_info_type type
;
456 } trailer_config_items
[] = {
457 { "key", TRAILER_KEY
},
458 { "command", TRAILER_COMMAND
},
459 { "where", TRAILER_WHERE
},
460 { "ifexists", TRAILER_IF_EXISTS
},
461 { "ifmissing", TRAILER_IF_MISSING
}
464 static int git_trailer_default_config(const char *conf_key
, const char *value
, void *cb
)
466 const char *trailer_item
, *variable_name
;
468 if (!skip_prefix(conf_key
, "trailer.", &trailer_item
))
471 variable_name
= strrchr(trailer_item
, '.');
472 if (!variable_name
) {
473 if (!strcmp(trailer_item
, "where")) {
474 if (set_where(&default_conf_info
, value
) < 0)
475 warning(_("unknown value '%s' for key '%s'"),
477 } else if (!strcmp(trailer_item
, "ifexists")) {
478 if (set_if_exists(&default_conf_info
, value
) < 0)
479 warning(_("unknown value '%s' for key '%s'"),
481 } else if (!strcmp(trailer_item
, "ifmissing")) {
482 if (set_if_missing(&default_conf_info
, value
) < 0)
483 warning(_("unknown value '%s' for key '%s'"),
485 } else if (!strcmp(trailer_item
, "separators")) {
486 separators
= xstrdup(value
);
492 static int git_trailer_config(const char *conf_key
, const char *value
, void *cb
)
494 const char *trailer_item
, *variable_name
;
495 struct arg_item
*item
;
496 struct conf_info
*conf
;
498 enum trailer_info_type type
;
501 if (!skip_prefix(conf_key
, "trailer.", &trailer_item
))
504 variable_name
= strrchr(trailer_item
, '.');
509 for (i
= 0; i
< ARRAY_SIZE(trailer_config_items
); i
++) {
510 if (strcmp(trailer_config_items
[i
].name
, variable_name
))
512 name
= xstrndup(trailer_item
, variable_name
- trailer_item
- 1);
513 type
= trailer_config_items
[i
].type
;
520 item
= get_conf_item(name
);
527 warning(_("more than one %s"), conf_key
);
528 conf
->key
= xstrdup(value
);
530 case TRAILER_COMMAND
:
532 warning(_("more than one %s"), conf_key
);
533 conf
->command
= xstrdup(value
);
536 if (set_where(conf
, value
))
537 warning(_("unknown value '%s' for key '%s'"), value
, conf_key
);
539 case TRAILER_IF_EXISTS
:
540 if (set_if_exists(conf
, value
))
541 warning(_("unknown value '%s' for key '%s'"), value
, conf_key
);
543 case TRAILER_IF_MISSING
:
544 if (set_if_missing(conf
, value
))
545 warning(_("unknown value '%s' for key '%s'"), value
, conf_key
);
548 die("BUG: trailer.c: unhandled type %d", type
);
553 static void ensure_configured(void)
558 /* Default config must be setup first */
559 git_config(git_trailer_default_config
, NULL
);
560 git_config(git_trailer_config
, NULL
);
564 static const char *token_from_item(struct arg_item
*item
, char *tok
)
567 return item
->conf
.key
;
570 return item
->conf
.name
;
573 static int token_matches_item(const char *tok
, struct arg_item
*item
, int tok_len
)
575 if (!strncasecmp(tok
, item
->conf
.name
, tok_len
))
577 return item
->conf
.key
? !strncasecmp(tok
, item
->conf
.key
, tok_len
) : 0;
581 * If the given line is of the form
582 * "<token><optional whitespace><separator>..." or "<separator>...", return the
583 * location of the separator. Otherwise, return -1. The optional whitespace
584 * is allowed there primarily to allow things like "Bug #43" where <token> is
585 * "Bug" and <separator> is "#".
587 * The separator-starts-line case (in which this function returns 0) is
588 * distinguished from the non-well-formed-line case (in which this function
589 * returns -1) because some callers of this function need such a distinction.
591 static int find_separator(const char *line
, const char *separators
)
593 int whitespace_found
= 0;
595 for (c
= line
; *c
; c
++) {
596 if (strchr(separators
, *c
))
598 if (!whitespace_found
&& (isalnum(*c
) || *c
== '-'))
600 if (c
!= line
&& (*c
== ' ' || *c
== '\t')) {
601 whitespace_found
= 1;
610 * Obtain the token, value, and conf from the given trailer.
612 * separator_pos must not be 0, since the token cannot be an empty string.
614 * If separator_pos is -1, interpret the whole trailer as a token.
616 static void parse_trailer(struct strbuf
*tok
, struct strbuf
*val
,
617 const struct conf_info
**conf
, const char *trailer
,
620 struct arg_item
*item
;
622 struct list_head
*pos
;
624 if (separator_pos
!= -1) {
625 strbuf_add(tok
, trailer
, separator_pos
);
627 strbuf_addstr(val
, trailer
+ separator_pos
+ 1);
630 strbuf_addstr(tok
, trailer
);
634 /* Lookup if the token matches something in the config */
635 tok_len
= token_len_without_separator(tok
->buf
, tok
->len
);
637 *conf
= &default_conf_info
;
638 list_for_each(pos
, &conf_head
) {
639 item
= list_entry(pos
, struct arg_item
, list
);
640 if (token_matches_item(tok
->buf
, item
, tok_len
)) {
641 char *tok_buf
= strbuf_detach(tok
, NULL
);
644 strbuf_addstr(tok
, token_from_item(item
, tok_buf
));
651 static struct trailer_item
*add_trailer_item(struct list_head
*head
, char *tok
,
654 struct trailer_item
*new = xcalloc(sizeof(*new), 1);
657 list_add_tail(&new->list
, head
);
661 static void add_arg_item(struct list_head
*arg_head
, char *tok
, char *val
,
662 const struct conf_info
*conf
)
664 struct arg_item
*new = xcalloc(sizeof(*new), 1);
667 duplicate_conf(&new->conf
, conf
);
668 list_add_tail(&new->list
, arg_head
);
671 static void process_command_line_args(struct list_head
*arg_head
,
672 struct string_list
*trailers
)
674 struct string_list_item
*tr
;
675 struct arg_item
*item
;
676 struct strbuf tok
= STRBUF_INIT
;
677 struct strbuf val
= STRBUF_INIT
;
678 const struct conf_info
*conf
;
679 struct list_head
*pos
;
682 * In command-line arguments, '=' is accepted (in addition to the
683 * separators that are defined).
685 char *cl_separators
= xstrfmt("=%s", separators
);
687 /* Add an arg item for each configured trailer with a command */
688 list_for_each(pos
, &conf_head
) {
689 item
= list_entry(pos
, struct arg_item
, list
);
690 if (item
->conf
.command
)
691 add_arg_item(arg_head
,
692 xstrdup(token_from_item(item
, NULL
)),
697 /* Add an arg item for each trailer on the command line */
698 for_each_string_list_item(tr
, trailers
) {
699 int separator_pos
= find_separator(tr
->string
, cl_separators
);
700 if (separator_pos
== 0) {
701 struct strbuf sb
= STRBUF_INIT
;
702 strbuf_addstr(&sb
, tr
->string
);
704 error(_("empty trailer token in trailer '%.*s'"),
705 (int) sb
.len
, sb
.buf
);
708 parse_trailer(&tok
, &val
, &conf
, tr
->string
,
710 add_arg_item(arg_head
,
711 strbuf_detach(&tok
, NULL
),
712 strbuf_detach(&val
, NULL
),
720 static void read_input_file(struct strbuf
*sb
, const char *file
)
723 if (strbuf_read_file(sb
, file
, 0) < 0)
724 die_errno(_("could not read input file '%s'"), file
);
726 if (strbuf_read(sb
, fileno(stdin
), 0) < 0)
727 die_errno(_("could not read from stdin"));
731 static const char *next_line(const char *str
)
733 const char *nl
= strchrnul(str
, '\n');
738 * Return the position of the start of the last line. If len is 0, return -1.
740 static int last_line(const char *buf
, size_t len
)
748 * Skip the last character (in addition to the null terminator),
749 * because if the last character is a newline, it is considered as part
750 * of the last line anyway.
754 for (; i
>= 0; i
--) {
762 * Return the position of the start of the patch or the length of str if there
763 * is no patch in the message.
765 static int find_patch_start(const char *str
)
769 for (s
= str
; *s
; s
= next_line(s
)) {
770 if (starts_with(s
, "---"))
778 * Return the position of the first trailer line or len if there are no
781 static int find_trailer_start(const char *buf
, size_t len
)
784 int end_of_title
, l
, only_spaces
= 1;
785 int recognized_prefix
= 0, trailer_lines
= 0, non_trailer_lines
= 0;
787 * Number of possible continuation lines encountered. This will be
788 * reset to 0 if we encounter a trailer (since those lines are to be
789 * considered continuations of that trailer), and added to
790 * non_trailer_lines if we encounter a non-trailer (since those lines
791 * are to be considered non-trailers).
793 int possible_continuation_lines
= 0;
795 /* The first paragraph is the title and cannot be trailers */
796 for (s
= buf
; s
< buf
+ len
; s
= next_line(s
)) {
797 if (s
[0] == comment_line_char
)
799 if (is_blank_line(s
))
802 end_of_title
= s
- buf
;
805 * Get the start of the trailers by looking starting from the end for a
806 * blank line before a set of non-blank lines that (i) are all
807 * trailers, or (ii) contains at least one Git-generated trailer and
808 * consists of at least 25% trailers.
810 for (l
= last_line(buf
, len
);
812 l
= last_line(buf
, l
)) {
813 const char *bol
= buf
+ l
;
817 if (bol
[0] == comment_line_char
) {
818 non_trailer_lines
+= possible_continuation_lines
;
819 possible_continuation_lines
= 0;
822 if (is_blank_line(bol
)) {
825 non_trailer_lines
+= possible_continuation_lines
;
826 if (recognized_prefix
&&
827 trailer_lines
* 3 >= non_trailer_lines
)
828 return next_line(bol
) - buf
;
829 else if (trailer_lines
&& !non_trailer_lines
)
830 return next_line(bol
) - buf
;
835 for (p
= git_generated_prefixes
; *p
; p
++) {
836 if (starts_with(bol
, *p
)) {
838 possible_continuation_lines
= 0;
839 recognized_prefix
= 1;
840 goto continue_outer_loop
;
844 separator_pos
= find_separator(bol
, separators
);
845 if (separator_pos
>= 1 && !isspace(bol
[0])) {
846 struct list_head
*pos
;
849 possible_continuation_lines
= 0;
850 if (recognized_prefix
)
852 list_for_each(pos
, &conf_head
) {
853 struct arg_item
*item
;
854 item
= list_entry(pos
, struct arg_item
, list
);
855 if (token_matches_item(bol
, item
,
857 recognized_prefix
= 1;
861 } else if (isspace(bol
[0]))
862 possible_continuation_lines
++;
865 non_trailer_lines
+= possible_continuation_lines
;
866 possible_continuation_lines
= 0;
875 /* Return the position of the end of the trailers. */
876 static int find_trailer_end(const char *buf
, size_t len
)
878 return len
- ignore_non_trailer(buf
, len
);
881 static int ends_with_blank_line(const char *buf
, size_t len
)
883 int ll
= last_line(buf
, len
);
886 return is_blank_line(buf
+ ll
);
889 static int process_input_file(FILE *outfile
,
891 struct list_head
*head
,
892 const struct process_trailer_options
*opts
)
894 struct trailer_info info
;
895 struct strbuf tok
= STRBUF_INIT
;
896 struct strbuf val
= STRBUF_INIT
;
899 trailer_info_get(&info
, str
);
901 /* Print lines before the trailers as is */
902 if (!opts
->only_trailers
)
903 fwrite(str
, 1, info
.trailer_start
- str
, outfile
);
905 if (!opts
->only_trailers
&& !info
.blank_line_before_trailer
)
906 fprintf(outfile
, "\n");
908 for (i
= 0; i
< info
.trailer_nr
; i
++) {
910 char *trailer
= info
.trailers
[i
];
911 if (trailer
[0] == comment_line_char
)
913 separator_pos
= find_separator(trailer
, separators
);
914 if (separator_pos
>= 1) {
915 parse_trailer(&tok
, &val
, NULL
, trailer
,
917 add_trailer_item(head
,
918 strbuf_detach(&tok
, NULL
),
919 strbuf_detach(&val
, NULL
));
920 } else if (!opts
->only_trailers
) {
921 strbuf_addstr(&val
, trailer
);
922 strbuf_strip_suffix(&val
, "\n");
923 add_trailer_item(head
,
925 strbuf_detach(&val
, NULL
));
929 trailer_info_release(&info
);
931 return info
.trailer_end
- str
;
934 static void free_all(struct list_head
*head
)
936 struct list_head
*pos
, *p
;
937 list_for_each_safe(pos
, p
, head
) {
939 free_trailer_item(list_entry(pos
, struct trailer_item
, list
));
943 static struct tempfile trailers_tempfile
;
945 static FILE *create_in_place_tempfile(const char *file
)
948 struct strbuf
template = STRBUF_INIT
;
953 die_errno(_("could not stat %s"), file
);
954 if (!S_ISREG(st
.st_mode
))
955 die(_("file %s is not a regular file"), file
);
956 if (!(st
.st_mode
& S_IWUSR
))
957 die(_("file %s is not writable by user"), file
);
959 /* Create temporary file in the same directory as the original */
960 tail
= strrchr(file
, '/');
962 strbuf_add(&template, file
, tail
- file
+ 1);
963 strbuf_addstr(&template, "git-interpret-trailers-XXXXXX");
965 xmks_tempfile_m(&trailers_tempfile
, template.buf
, st
.st_mode
);
966 strbuf_release(&template);
967 outfile
= fdopen_tempfile(&trailers_tempfile
, "w");
969 die_errno(_("could not open temporary file"));
974 void process_trailers(const char *file
,
975 const struct process_trailer_options
*opts
,
976 struct string_list
*trailers
)
979 struct strbuf sb
= STRBUF_INIT
;
981 FILE *outfile
= stdout
;
985 read_input_file(&sb
, file
);
988 outfile
= create_in_place_tempfile(file
);
990 /* Print the lines before the trailers */
991 trailer_end
= process_input_file(outfile
, sb
.buf
, &head
, opts
);
993 if (!opts
->only_input
) {
995 process_command_line_args(&arg_head
, trailers
);
996 process_trailers_lists(&head
, &arg_head
);
999 print_all(outfile
, &head
, opts
);
1003 /* Print the lines after the trailers as is */
1004 if (!opts
->only_trailers
)
1005 fwrite(sb
.buf
+ trailer_end
, 1, sb
.len
- trailer_end
, outfile
);
1008 if (rename_tempfile(&trailers_tempfile
, file
))
1009 die_errno(_("could not rename temporary file to %s"), file
);
1011 strbuf_release(&sb
);
1014 void trailer_info_get(struct trailer_info
*info
, const char *str
)
1016 int patch_start
, trailer_end
, trailer_start
;
1017 struct strbuf
**trailer_lines
, **ptr
;
1018 char **trailer_strings
= NULL
;
1019 size_t nr
= 0, alloc
= 0;
1022 ensure_configured();
1024 patch_start
= find_patch_start(str
);
1025 trailer_end
= find_trailer_end(str
, patch_start
);
1026 trailer_start
= find_trailer_start(str
, trailer_end
);
1028 trailer_lines
= strbuf_split_buf(str
+ trailer_start
,
1029 trailer_end
- trailer_start
,
1032 for (ptr
= trailer_lines
; *ptr
; ptr
++) {
1033 if (last
&& isspace((*ptr
)->buf
[0])) {
1034 struct strbuf sb
= STRBUF_INIT
;
1035 strbuf_attach(&sb
, *last
, strlen(*last
), strlen(*last
));
1036 strbuf_addbuf(&sb
, *ptr
);
1037 *last
= strbuf_detach(&sb
, NULL
);
1040 ALLOC_GROW(trailer_strings
, nr
+ 1, alloc
);
1041 trailer_strings
[nr
] = strbuf_detach(*ptr
, NULL
);
1042 last
= find_separator(trailer_strings
[nr
], separators
) >= 1
1043 ? &trailer_strings
[nr
]
1047 strbuf_list_free(trailer_lines
);
1049 info
->blank_line_before_trailer
= ends_with_blank_line(str
,
1051 info
->trailer_start
= str
+ trailer_start
;
1052 info
->trailer_end
= str
+ trailer_end
;
1053 info
->trailers
= trailer_strings
;
1054 info
->trailer_nr
= nr
;
1057 void trailer_info_release(struct trailer_info
*info
)
1060 for (i
= 0; i
< info
->trailer_nr
; i
++)
1061 free(info
->trailers
[i
]);
1062 free(info
->trailers
);