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 #define TRAILER_ARG_STRING "$ARG"
51 static const char *git_generated_prefixes
[] = {
53 "(cherry picked from commit ",
57 /* Iterate over the elements of the list. */
58 #define list_for_each_dir(pos, head, is_reverse) \
59 for (pos = is_reverse ? (head)->prev : (head)->next; \
61 pos = is_reverse ? pos->prev : pos->next)
63 static int after_or_end(enum action_where where
)
65 return (where
== WHERE_AFTER
) || (where
== WHERE_END
);
69 * Return the length of the string not including any final
70 * punctuation. E.g., the input "Signed-off-by:" would return
71 * 13, stripping the trailing punctuation but retaining
72 * internal punctuation.
74 static size_t token_len_without_separator(const char *token
, size_t len
)
76 while (len
> 0 && !isalnum(token
[len
- 1]))
81 static int same_token(struct trailer_item
*a
, struct arg_item
*b
)
83 size_t a_len
, b_len
, min_len
;
88 a_len
= token_len_without_separator(a
->token
, strlen(a
->token
));
89 b_len
= token_len_without_separator(b
->token
, strlen(b
->token
));
90 min_len
= (a_len
> b_len
) ? b_len
: a_len
;
92 return !strncasecmp(a
->token
, b
->token
, min_len
);
95 static int same_value(struct trailer_item
*a
, struct arg_item
*b
)
97 return !strcasecmp(a
->value
, b
->value
);
100 static int same_trailer(struct trailer_item
*a
, struct arg_item
*b
)
102 return same_token(a
, b
) && same_value(a
, b
);
105 static inline int contains_only_spaces(const char *str
)
108 while (*s
&& isspace(*s
))
113 static inline void strbuf_replace(struct strbuf
*sb
, const char *a
, const char *b
)
115 const char *ptr
= strstr(sb
->buf
, a
);
117 strbuf_splice(sb
, ptr
- sb
->buf
, strlen(a
), b
, strlen(b
));
120 static void free_trailer_item(struct trailer_item
*item
)
127 static void free_arg_item(struct arg_item
*item
)
129 free(item
->conf
.name
);
130 free(item
->conf
.key
);
131 free(item
->conf
.command
);
137 static char last_non_space_char(const char *s
)
140 for (i
= strlen(s
) - 1; i
>= 0; i
--)
146 static void print_tok_val(FILE *outfile
, const char *tok
, const char *val
)
151 fprintf(outfile
, "%s\n", val
);
155 c
= last_non_space_char(tok
);
158 if (strchr(separators
, c
))
159 fprintf(outfile
, "%s%s\n", tok
, val
);
161 fprintf(outfile
, "%s%c %s\n", tok
, separators
[0], val
);
164 static void print_all(FILE *outfile
, struct list_head
*head
, int trim_empty
)
166 struct list_head
*pos
;
167 struct trailer_item
*item
;
168 list_for_each(pos
, head
) {
169 item
= list_entry(pos
, struct trailer_item
, list
);
170 if (!trim_empty
|| strlen(item
->value
) > 0)
171 print_tok_val(outfile
, item
->token
, item
->value
);
175 static struct trailer_item
*trailer_from_arg(struct arg_item
*arg_tok
)
177 struct trailer_item
*new = xcalloc(sizeof(*new), 1);
178 new->token
= arg_tok
->token
;
179 new->value
= arg_tok
->value
;
180 arg_tok
->token
= arg_tok
->value
= NULL
;
181 free_arg_item(arg_tok
);
185 static void add_arg_to_input_list(struct trailer_item
*on_tok
,
186 struct arg_item
*arg_tok
)
188 int aoe
= after_or_end(arg_tok
->conf
.where
);
189 struct trailer_item
*to_add
= trailer_from_arg(arg_tok
);
191 list_add(&to_add
->list
, &on_tok
->list
);
193 list_add_tail(&to_add
->list
, &on_tok
->list
);
196 static int check_if_different(struct trailer_item
*in_tok
,
197 struct arg_item
*arg_tok
,
199 struct list_head
*head
)
201 enum action_where where
= arg_tok
->conf
.where
;
202 struct list_head
*next_head
;
204 if (same_trailer(in_tok
, arg_tok
))
207 * if we want to add a trailer after another one,
208 * we have to check those before this one
210 next_head
= after_or_end(where
) ? in_tok
->list
.prev
212 if (next_head
== head
)
214 in_tok
= list_entry(next_head
, struct trailer_item
, list
);
219 static char *apply_command(const char *command
, const char *arg
)
221 struct strbuf cmd
= STRBUF_INIT
;
222 struct strbuf buf
= STRBUF_INIT
;
223 struct child_process cp
= CHILD_PROCESS_INIT
;
224 const char *argv
[] = {NULL
, NULL
};
227 strbuf_addstr(&cmd
, command
);
229 strbuf_replace(&cmd
, TRAILER_ARG_STRING
, arg
);
233 cp
.env
= local_repo_env
;
237 if (capture_command(&cp
, &buf
, 1024)) {
238 error(_("running trailer command '%s' failed"), cmd
.buf
);
239 strbuf_release(&buf
);
240 result
= xstrdup("");
243 result
= strbuf_detach(&buf
, NULL
);
246 strbuf_release(&cmd
);
250 static void apply_item_command(struct trailer_item
*in_tok
, struct arg_item
*arg_tok
)
252 if (arg_tok
->conf
.command
) {
254 if (arg_tok
->value
&& arg_tok
->value
[0]) {
255 arg
= arg_tok
->value
;
257 if (in_tok
&& in_tok
->value
)
258 arg
= xstrdup(in_tok
->value
);
262 arg_tok
->value
= apply_command(arg_tok
->conf
.command
, arg
);
267 static void apply_arg_if_exists(struct trailer_item
*in_tok
,
268 struct arg_item
*arg_tok
,
269 struct trailer_item
*on_tok
,
270 struct list_head
*head
)
272 switch (arg_tok
->conf
.if_exists
) {
273 case EXISTS_DO_NOTHING
:
274 free_arg_item(arg_tok
);
277 apply_item_command(in_tok
, arg_tok
);
278 add_arg_to_input_list(on_tok
, arg_tok
);
279 list_del(&in_tok
->list
);
280 free_trailer_item(in_tok
);
283 apply_item_command(in_tok
, arg_tok
);
284 add_arg_to_input_list(on_tok
, arg_tok
);
286 case EXISTS_ADD_IF_DIFFERENT
:
287 apply_item_command(in_tok
, arg_tok
);
288 if (check_if_different(in_tok
, arg_tok
, 1, head
))
289 add_arg_to_input_list(on_tok
, arg_tok
);
291 free_arg_item(arg_tok
);
293 case EXISTS_ADD_IF_DIFFERENT_NEIGHBOR
:
294 apply_item_command(in_tok
, arg_tok
);
295 if (check_if_different(on_tok
, arg_tok
, 0, head
))
296 add_arg_to_input_list(on_tok
, arg_tok
);
298 free_arg_item(arg_tok
);
303 static void apply_arg_if_missing(struct list_head
*head
,
304 struct arg_item
*arg_tok
)
306 enum action_where where
;
307 struct trailer_item
*to_add
;
309 switch (arg_tok
->conf
.if_missing
) {
310 case MISSING_DO_NOTHING
:
311 free_arg_item(arg_tok
);
314 where
= arg_tok
->conf
.where
;
315 apply_item_command(NULL
, arg_tok
);
316 to_add
= trailer_from_arg(arg_tok
);
317 if (after_or_end(where
))
318 list_add_tail(&to_add
->list
, head
);
320 list_add(&to_add
->list
, head
);
324 static int find_same_and_apply_arg(struct list_head
*head
,
325 struct arg_item
*arg_tok
)
327 struct list_head
*pos
;
328 struct trailer_item
*in_tok
;
329 struct trailer_item
*on_tok
;
331 enum action_where where
= arg_tok
->conf
.where
;
332 int middle
= (where
== WHERE_AFTER
) || (where
== WHERE_BEFORE
);
333 int backwards
= after_or_end(where
);
334 struct trailer_item
*start_tok
;
336 if (list_empty(head
))
339 start_tok
= list_entry(backwards
? head
->prev
: head
->next
,
343 list_for_each_dir(pos
, head
, backwards
) {
344 in_tok
= list_entry(pos
, struct trailer_item
, list
);
345 if (!same_token(in_tok
, arg_tok
))
347 on_tok
= middle
? in_tok
: start_tok
;
348 apply_arg_if_exists(in_tok
, arg_tok
, on_tok
, head
);
354 static void process_trailers_lists(struct list_head
*head
,
355 struct list_head
*arg_head
)
357 struct list_head
*pos
, *p
;
358 struct arg_item
*arg_tok
;
360 list_for_each_safe(pos
, p
, arg_head
) {
362 arg_tok
= list_entry(pos
, struct arg_item
, list
);
366 applied
= find_same_and_apply_arg(head
, arg_tok
);
369 apply_arg_if_missing(head
, arg_tok
);
373 static int set_where(struct conf_info
*item
, const char *value
)
375 if (!strcasecmp("after", value
))
376 item
->where
= WHERE_AFTER
;
377 else if (!strcasecmp("before", value
))
378 item
->where
= WHERE_BEFORE
;
379 else if (!strcasecmp("end", value
))
380 item
->where
= WHERE_END
;
381 else if (!strcasecmp("start", value
))
382 item
->where
= WHERE_START
;
388 static int set_if_exists(struct conf_info
*item
, const char *value
)
390 if (!strcasecmp("addIfDifferent", value
))
391 item
->if_exists
= EXISTS_ADD_IF_DIFFERENT
;
392 else if (!strcasecmp("addIfDifferentNeighbor", value
))
393 item
->if_exists
= EXISTS_ADD_IF_DIFFERENT_NEIGHBOR
;
394 else if (!strcasecmp("add", value
))
395 item
->if_exists
= EXISTS_ADD
;
396 else if (!strcasecmp("replace", value
))
397 item
->if_exists
= EXISTS_REPLACE
;
398 else if (!strcasecmp("doNothing", value
))
399 item
->if_exists
= EXISTS_DO_NOTHING
;
405 static int set_if_missing(struct conf_info
*item
, const char *value
)
407 if (!strcasecmp("doNothing", value
))
408 item
->if_missing
= MISSING_DO_NOTHING
;
409 else if (!strcasecmp("add", value
))
410 item
->if_missing
= MISSING_ADD
;
416 static void duplicate_conf(struct conf_info
*dst
, const struct conf_info
*src
)
420 dst
->name
= xstrdup(src
->name
);
422 dst
->key
= xstrdup(src
->key
);
424 dst
->command
= xstrdup(src
->command
);
427 static struct arg_item
*get_conf_item(const char *name
)
429 struct list_head
*pos
;
430 struct arg_item
*item
;
432 /* Look up item with same name */
433 list_for_each(pos
, &conf_head
) {
434 item
= list_entry(pos
, struct arg_item
, list
);
435 if (!strcasecmp(item
->conf
.name
, name
))
439 /* Item does not already exists, create it */
440 item
= xcalloc(sizeof(*item
), 1);
441 duplicate_conf(&item
->conf
, &default_conf_info
);
442 item
->conf
.name
= xstrdup(name
);
444 list_add_tail(&item
->list
, &conf_head
);
449 enum trailer_info_type
{ TRAILER_KEY
, TRAILER_COMMAND
, TRAILER_WHERE
,
450 TRAILER_IF_EXISTS
, TRAILER_IF_MISSING
};
454 enum trailer_info_type type
;
455 } trailer_config_items
[] = {
456 { "key", TRAILER_KEY
},
457 { "command", TRAILER_COMMAND
},
458 { "where", TRAILER_WHERE
},
459 { "ifexists", TRAILER_IF_EXISTS
},
460 { "ifmissing", TRAILER_IF_MISSING
}
463 static int git_trailer_default_config(const char *conf_key
, const char *value
, void *cb
)
465 const char *trailer_item
, *variable_name
;
467 if (!skip_prefix(conf_key
, "trailer.", &trailer_item
))
470 variable_name
= strrchr(trailer_item
, '.');
471 if (!variable_name
) {
472 if (!strcmp(trailer_item
, "where")) {
473 if (set_where(&default_conf_info
, value
) < 0)
474 warning(_("unknown value '%s' for key '%s'"),
476 } else if (!strcmp(trailer_item
, "ifexists")) {
477 if (set_if_exists(&default_conf_info
, value
) < 0)
478 warning(_("unknown value '%s' for key '%s'"),
480 } else if (!strcmp(trailer_item
, "ifmissing")) {
481 if (set_if_missing(&default_conf_info
, value
) < 0)
482 warning(_("unknown value '%s' for key '%s'"),
484 } else if (!strcmp(trailer_item
, "separators")) {
485 separators
= xstrdup(value
);
491 static int git_trailer_config(const char *conf_key
, const char *value
, void *cb
)
493 const char *trailer_item
, *variable_name
;
494 struct arg_item
*item
;
495 struct conf_info
*conf
;
497 enum trailer_info_type type
;
500 if (!skip_prefix(conf_key
, "trailer.", &trailer_item
))
503 variable_name
= strrchr(trailer_item
, '.');
508 for (i
= 0; i
< ARRAY_SIZE(trailer_config_items
); i
++) {
509 if (strcmp(trailer_config_items
[i
].name
, variable_name
))
511 name
= xstrndup(trailer_item
, variable_name
- trailer_item
- 1);
512 type
= trailer_config_items
[i
].type
;
519 item
= get_conf_item(name
);
526 warning(_("more than one %s"), conf_key
);
527 conf
->key
= xstrdup(value
);
529 case TRAILER_COMMAND
:
531 warning(_("more than one %s"), conf_key
);
532 conf
->command
= xstrdup(value
);
535 if (set_where(conf
, value
))
536 warning(_("unknown value '%s' for key '%s'"), value
, conf_key
);
538 case TRAILER_IF_EXISTS
:
539 if (set_if_exists(conf
, value
))
540 warning(_("unknown value '%s' for key '%s'"), value
, conf_key
);
542 case TRAILER_IF_MISSING
:
543 if (set_if_missing(conf
, value
))
544 warning(_("unknown value '%s' for key '%s'"), value
, conf_key
);
547 die("BUG: trailer.c: unhandled type %d", type
);
552 static const char *token_from_item(struct arg_item
*item
, char *tok
)
555 return item
->conf
.key
;
558 return item
->conf
.name
;
561 static int token_matches_item(const char *tok
, struct arg_item
*item
, int tok_len
)
563 if (!strncasecmp(tok
, item
->conf
.name
, tok_len
))
565 return item
->conf
.key
? !strncasecmp(tok
, item
->conf
.key
, tok_len
) : 0;
569 * Return the location of the first separator in line, or -1 if there is no
572 static int find_separator(const char *line
, const char *separators
)
574 int loc
= strcspn(line
, separators
);
581 * Obtain the token, value, and conf from the given trailer.
583 * separator_pos must not be 0, since the token cannot be an empty string.
585 * If separator_pos is -1, interpret the whole trailer as a token.
587 static void parse_trailer(struct strbuf
*tok
, struct strbuf
*val
,
588 const struct conf_info
**conf
, const char *trailer
,
591 struct arg_item
*item
;
593 struct list_head
*pos
;
595 if (separator_pos
!= -1) {
596 strbuf_add(tok
, trailer
, separator_pos
);
598 strbuf_addstr(val
, trailer
+ separator_pos
+ 1);
601 strbuf_addstr(tok
, trailer
);
605 /* Lookup if the token matches something in the config */
606 tok_len
= token_len_without_separator(tok
->buf
, tok
->len
);
608 *conf
= &default_conf_info
;
609 list_for_each(pos
, &conf_head
) {
610 item
= list_entry(pos
, struct arg_item
, list
);
611 if (token_matches_item(tok
->buf
, item
, tok_len
)) {
612 char *tok_buf
= strbuf_detach(tok
, NULL
);
615 strbuf_addstr(tok
, token_from_item(item
, tok_buf
));
622 static void add_trailer_item(struct list_head
*head
, char *tok
, char *val
)
624 struct trailer_item
*new = xcalloc(sizeof(*new), 1);
627 list_add_tail(&new->list
, head
);
630 static void add_arg_item(struct list_head
*arg_head
, char *tok
, char *val
,
631 const struct conf_info
*conf
)
633 struct arg_item
*new = xcalloc(sizeof(*new), 1);
636 duplicate_conf(&new->conf
, conf
);
637 list_add_tail(&new->list
, arg_head
);
640 static void process_command_line_args(struct list_head
*arg_head
,
641 struct string_list
*trailers
)
643 struct string_list_item
*tr
;
644 struct arg_item
*item
;
645 struct strbuf tok
= STRBUF_INIT
;
646 struct strbuf val
= STRBUF_INIT
;
647 const struct conf_info
*conf
;
648 struct list_head
*pos
;
651 * In command-line arguments, '=' is accepted (in addition to the
652 * separators that are defined).
654 char *cl_separators
= xstrfmt("=%s", separators
);
656 /* Add an arg item for each configured trailer with a command */
657 list_for_each(pos
, &conf_head
) {
658 item
= list_entry(pos
, struct arg_item
, list
);
659 if (item
->conf
.command
)
660 add_arg_item(arg_head
,
661 xstrdup(token_from_item(item
, NULL
)),
666 /* Add an arg item for each trailer on the command line */
667 for_each_string_list_item(tr
, trailers
) {
668 int separator_pos
= find_separator(tr
->string
, cl_separators
);
669 if (separator_pos
== 0) {
670 struct strbuf sb
= STRBUF_INIT
;
671 strbuf_addstr(&sb
, tr
->string
);
673 error(_("empty trailer token in trailer '%.*s'"),
674 (int) sb
.len
, sb
.buf
);
677 parse_trailer(&tok
, &val
, &conf
, tr
->string
,
679 add_arg_item(arg_head
,
680 strbuf_detach(&tok
, NULL
),
681 strbuf_detach(&val
, NULL
),
689 static struct strbuf
**read_input_file(const char *file
)
691 struct strbuf
**lines
;
692 struct strbuf sb
= STRBUF_INIT
;
695 if (strbuf_read_file(&sb
, file
, 0) < 0)
696 die_errno(_("could not read input file '%s'"), file
);
698 if (strbuf_read(&sb
, fileno(stdin
), 0) < 0)
699 die_errno(_("could not read from stdin"));
702 lines
= strbuf_split(&sb
, '\n');
710 * Return the (0 based) index of the start of the patch or the line
711 * count if there is no patch in the message.
713 static int find_patch_start(struct strbuf
**lines
, int count
)
717 /* Get the start of the patch part if any */
718 for (i
= 0; i
< count
; i
++) {
719 if (starts_with(lines
[i
]->buf
, "---"))
727 * Return the (0 based) index of the first trailer line or count if
728 * there are no trailers. Trailers are searched only in the lines from
729 * index (count - 1) down to index 0.
731 static int find_trailer_start(struct strbuf
**lines
, int count
)
733 int start
, end_of_title
, only_spaces
= 1;
734 int recognized_prefix
= 0, trailer_lines
= 0, non_trailer_lines
= 0;
736 /* The first paragraph is the title and cannot be trailers */
737 for (start
= 0; start
< count
; start
++) {
738 if (lines
[start
]->buf
[0] == comment_line_char
)
740 if (contains_only_spaces(lines
[start
]->buf
))
743 end_of_title
= start
;
746 * Get the start of the trailers by looking starting from the end for a
747 * blank line before a set of non-blank lines that (i) are all
748 * trailers, or (ii) contains at least one Git-generated trailer and
749 * consists of at least 25% trailers.
751 for (start
= count
- 1; start
>= end_of_title
; start
--) {
755 if (lines
[start
]->buf
[0] == comment_line_char
)
757 if (contains_only_spaces(lines
[start
]->buf
)) {
760 if (recognized_prefix
&&
761 trailer_lines
* 3 >= non_trailer_lines
)
763 if (trailer_lines
&& !non_trailer_lines
)
769 for (p
= git_generated_prefixes
; *p
; p
++) {
770 if (starts_with(lines
[start
]->buf
, *p
)) {
772 recognized_prefix
= 1;
773 goto continue_outer_loop
;
777 separator_pos
= find_separator(lines
[start
]->buf
);
778 if (separator_pos
>= 1 && !isspace(lines
[start
]->buf
[0])) {
779 struct list_head
*pos
;
782 if (recognized_prefix
)
784 list_for_each(pos
, &conf_head
) {
785 struct arg_item
*item
;
786 item
= list_entry(pos
, struct arg_item
, list
);
787 if (token_matches_item(lines
[start
]->buf
, item
,
789 recognized_prefix
= 1;
802 /* Get the index of the end of the trailers */
803 static int find_trailer_end(struct strbuf
**lines
, int patch_start
)
805 struct strbuf sb
= STRBUF_INIT
;
808 for (i
= 0; i
< patch_start
; i
++)
809 strbuf_addbuf(&sb
, lines
[i
]);
810 ignore_bytes
= ignore_non_trailer(&sb
);
812 for (i
= patch_start
- 1; i
>= 0 && ignore_bytes
> 0; i
--)
813 ignore_bytes
-= lines
[i
]->len
;
818 static int has_blank_line_before(struct strbuf
**lines
, int start
)
820 for (;start
>= 0; start
--) {
821 if (lines
[start
]->buf
[0] == comment_line_char
)
823 return contains_only_spaces(lines
[start
]->buf
);
828 static void print_lines(FILE *outfile
, struct strbuf
**lines
, int start
, int end
)
831 for (i
= start
; lines
[i
] && i
< end
; i
++)
832 fprintf(outfile
, "%s", lines
[i
]->buf
);
835 static int process_input_file(FILE *outfile
,
836 struct strbuf
**lines
,
837 struct list_head
*head
)
840 int patch_start
, trailer_start
, trailer_end
, i
;
841 struct strbuf tok
= STRBUF_INIT
;
842 struct strbuf val
= STRBUF_INIT
;
844 /* Get the line count */
848 patch_start
= find_patch_start(lines
, count
);
849 trailer_end
= find_trailer_end(lines
, patch_start
);
850 trailer_start
= find_trailer_start(lines
, trailer_end
);
852 /* Print lines before the trailers as is */
853 print_lines(outfile
, lines
, 0, trailer_start
);
855 if (!has_blank_line_before(lines
, trailer_start
- 1))
856 fprintf(outfile
, "\n");
858 /* Parse trailer lines */
859 for (i
= trailer_start
; i
< trailer_end
; i
++) {
861 if (lines
[i
]->buf
[0] == comment_line_char
)
863 separator_pos
= find_separator(lines
[i
]->buf
, separators
);
864 if (separator_pos
>= 1) {
865 parse_trailer(&tok
, &val
, NULL
, lines
[i
]->buf
,
867 add_trailer_item(head
,
868 strbuf_detach(&tok
, NULL
),
869 strbuf_detach(&val
, NULL
));
871 strbuf_addbuf(&val
, lines
[i
]);
872 strbuf_strip_suffix(&val
, "\n");
873 add_trailer_item(head
,
875 strbuf_detach(&val
, NULL
));
882 static void free_all(struct list_head
*head
)
884 struct list_head
*pos
, *p
;
885 list_for_each_safe(pos
, p
, head
) {
887 free_trailer_item(list_entry(pos
, struct trailer_item
, list
));
891 static struct tempfile trailers_tempfile
;
893 static FILE *create_in_place_tempfile(const char *file
)
896 struct strbuf
template = STRBUF_INIT
;
901 die_errno(_("could not stat %s"), file
);
902 if (!S_ISREG(st
.st_mode
))
903 die(_("file %s is not a regular file"), file
);
904 if (!(st
.st_mode
& S_IWUSR
))
905 die(_("file %s is not writable by user"), file
);
907 /* Create temporary file in the same directory as the original */
908 tail
= strrchr(file
, '/');
910 strbuf_add(&template, file
, tail
- file
+ 1);
911 strbuf_addstr(&template, "git-interpret-trailers-XXXXXX");
913 xmks_tempfile_m(&trailers_tempfile
, template.buf
, st
.st_mode
);
914 strbuf_release(&template);
915 outfile
= fdopen_tempfile(&trailers_tempfile
, "w");
917 die_errno(_("could not open temporary file"));
922 void process_trailers(const char *file
, int in_place
, int trim_empty
, struct string_list
*trailers
)
926 struct strbuf
**lines
;
928 FILE *outfile
= stdout
;
930 /* Default config must be setup first */
931 git_config(git_trailer_default_config
, NULL
);
932 git_config(git_trailer_config
, NULL
);
934 lines
= read_input_file(file
);
937 outfile
= create_in_place_tempfile(file
);
939 /* Print the lines before the trailers */
940 trailer_end
= process_input_file(outfile
, lines
, &head
);
942 process_command_line_args(&arg_head
, trailers
);
944 process_trailers_lists(&head
, &arg_head
);
946 print_all(outfile
, &head
, trim_empty
);
950 /* Print the lines after the trailers as is */
951 print_lines(outfile
, lines
, trailer_end
, INT_MAX
);
954 if (rename_tempfile(&trailers_tempfile
, file
))
955 die_errno(_("could not rename temporary file to %s"), file
);
957 strbuf_list_free(lines
);