diff options
Diffstat (limited to 'trailer.c')
| -rw-r--r-- | trailer.c | 854 |
1 files changed, 497 insertions, 357 deletions
@@ -4,6 +4,7 @@ #include "commit.h" #include "tempfile.h" #include "trailer.h" +#include "list.h" /* * Copyright (c) 2013, 2014 Christian Couder <chriscool@tuxfamily.org> */ @@ -25,19 +26,42 @@ struct conf_info { static struct conf_info default_conf_info; struct trailer_item { - struct trailer_item *previous; - struct trailer_item *next; - const char *token; - const char *value; + struct list_head list; + /* + * If this is not a trailer line, the line is stored in value + * (excluding the terminating newline) and token is NULL. + */ + char *token; + char *value; +}; + +struct arg_item { + struct list_head list; + char *token; + char *value; struct conf_info conf; }; -static struct trailer_item *first_conf_item; +static LIST_HEAD(conf_head); static char *separators = ":"; +static int configured; + #define TRAILER_ARG_STRING "$ARG" +static const char *git_generated_prefixes[] = { + "Signed-off-by: ", + "(cherry picked from commit ", + NULL +}; + +/* Iterate over the elements of the list. */ +#define list_for_each_dir(pos, head, is_reverse) \ + for (pos = is_reverse ? (head)->prev : (head)->next; \ + pos != (head); \ + pos = is_reverse ? pos->prev : pos->next) + static int after_or_end(enum action_where where) { return (where == WHERE_AFTER) || (where == WHERE_END); @@ -56,31 +80,36 @@ static size_t token_len_without_separator(const char *token, size_t len) return len; } -static int same_token(struct trailer_item *a, struct trailer_item *b) +static int same_token(struct trailer_item *a, struct arg_item *b) { - size_t a_len = token_len_without_separator(a->token, strlen(a->token)); - size_t b_len = token_len_without_separator(b->token, strlen(b->token)); - size_t min_len = (a_len > b_len) ? b_len : a_len; + size_t a_len, b_len, min_len; + + if (!a->token) + return 0; + + a_len = token_len_without_separator(a->token, strlen(a->token)); + b_len = token_len_without_separator(b->token, strlen(b->token)); + min_len = (a_len > b_len) ? b_len : a_len; return !strncasecmp(a->token, b->token, min_len); } -static int same_value(struct trailer_item *a, struct trailer_item *b) +static int same_value(struct trailer_item *a, struct arg_item *b) { return !strcasecmp(a->value, b->value); } -static int same_trailer(struct trailer_item *a, struct trailer_item *b) +static int same_trailer(struct trailer_item *a, struct arg_item *b) { return same_token(a, b) && same_value(a, b); } -static inline int contains_only_spaces(const char *str) +static inline int is_blank_line(const char *str) { const char *s = str; - while (*s && isspace(*s)) + while (*s && *s != '\n' && isspace(*s)) s++; - return !*s; + return !*s || *s == '\n'; } static inline void strbuf_replace(struct strbuf *sb, const char *a, const char *b) @@ -92,11 +121,18 @@ static inline void strbuf_replace(struct strbuf *sb, const char *a, const char * static void free_trailer_item(struct trailer_item *item) { + free(item->token); + free(item->value); + free(item); +} + +static void free_arg_item(struct arg_item *item) +{ free(item->conf.name); free(item->conf.key); free(item->conf.command); - free((char *)item->token); - free((char *)item->value); + free(item->token); + free(item->value); free(item); } @@ -111,7 +147,14 @@ static char last_non_space_char(const char *s) static void print_tok_val(FILE *outfile, const char *tok, const char *val) { - char c = last_non_space_char(tok); + char c; + + if (!tok) { + fprintf(outfile, "%s\n", val); + return; + } + + c = last_non_space_char(tok); if (!c) return; if (strchr(separators, c)) @@ -120,108 +163,68 @@ static void print_tok_val(FILE *outfile, const char *tok, const char *val) fprintf(outfile, "%s%c %s\n", tok, separators[0], val); } -static void print_all(FILE *outfile, struct trailer_item *first, int trim_empty) +static void print_all(FILE *outfile, struct list_head *head, int trim_empty) { + struct list_head *pos; struct trailer_item *item; - for (item = first; item; item = item->next) { + list_for_each(pos, head) { + item = list_entry(pos, struct trailer_item, list); if (!trim_empty || strlen(item->value) > 0) print_tok_val(outfile, item->token, item->value); } } -static void update_last(struct trailer_item **last) -{ - if (*last) - while ((*last)->next != NULL) - *last = (*last)->next; -} - -static void update_first(struct trailer_item **first) +static struct trailer_item *trailer_from_arg(struct arg_item *arg_tok) { - if (*first) - while ((*first)->previous != NULL) - *first = (*first)->previous; + struct trailer_item *new = xcalloc(sizeof(*new), 1); + new->token = arg_tok->token; + new->value = arg_tok->value; + arg_tok->token = arg_tok->value = NULL; + free_arg_item(arg_tok); + return new; } static void add_arg_to_input_list(struct trailer_item *on_tok, - struct trailer_item *arg_tok, - struct trailer_item **first, - struct trailer_item **last) -{ - if (after_or_end(arg_tok->conf.where)) { - arg_tok->next = on_tok->next; - on_tok->next = arg_tok; - arg_tok->previous = on_tok; - if (arg_tok->next) - arg_tok->next->previous = arg_tok; - update_last(last); - } else { - arg_tok->previous = on_tok->previous; - on_tok->previous = arg_tok; - arg_tok->next = on_tok; - if (arg_tok->previous) - arg_tok->previous->next = arg_tok; - update_first(first); - } + struct arg_item *arg_tok) +{ + int aoe = after_or_end(arg_tok->conf.where); + struct trailer_item *to_add = trailer_from_arg(arg_tok); + if (aoe) + list_add(&to_add->list, &on_tok->list); + else + list_add_tail(&to_add->list, &on_tok->list); } static int check_if_different(struct trailer_item *in_tok, - struct trailer_item *arg_tok, - int check_all) + struct arg_item *arg_tok, + int check_all, + struct list_head *head) { enum action_where where = arg_tok->conf.where; + struct list_head *next_head; do { - if (!in_tok) - return 1; if (same_trailer(in_tok, arg_tok)) return 0; /* * if we want to add a trailer after another one, * we have to check those before this one */ - in_tok = after_or_end(where) ? in_tok->previous : in_tok->next; + next_head = after_or_end(where) ? in_tok->list.prev + : in_tok->list.next; + if (next_head == head) + break; + in_tok = list_entry(next_head, struct trailer_item, list); } while (check_all); return 1; } -static void remove_from_list(struct trailer_item *item, - struct trailer_item **first, - struct trailer_item **last) -{ - struct trailer_item *next = item->next; - struct trailer_item *previous = item->previous; - - if (next) { - item->next->previous = previous; - item->next = NULL; - } else if (last) - *last = previous; - - if (previous) { - item->previous->next = next; - item->previous = NULL; - } else if (first) - *first = next; -} - -static struct trailer_item *remove_first(struct trailer_item **first) -{ - struct trailer_item *item = *first; - *first = item->next; - if (item->next) { - item->next->previous = NULL; - item->next = NULL; - } - return item; -} - -static const char *apply_command(const char *command, const char *arg) +static char *apply_command(const char *command, const char *arg) { struct strbuf cmd = STRBUF_INIT; struct strbuf buf = STRBUF_INIT; struct child_process cp = CHILD_PROCESS_INIT; const char *argv[] = {NULL, NULL}; - const char *result; + char *result; strbuf_addstr(&cmd, command); if (arg) @@ -246,7 +249,7 @@ static const char *apply_command(const char *command, const char *arg) return result; } -static void apply_item_command(struct trailer_item *in_tok, struct trailer_item *arg_tok) +static void apply_item_command(struct trailer_item *in_tok, struct arg_item *arg_tok) { if (arg_tok->conf.command) { const char *arg; @@ -264,121 +267,108 @@ static void apply_item_command(struct trailer_item *in_tok, struct trailer_item } static void apply_arg_if_exists(struct trailer_item *in_tok, - struct trailer_item *arg_tok, + struct arg_item *arg_tok, struct trailer_item *on_tok, - struct trailer_item **in_tok_first, - struct trailer_item **in_tok_last) + struct list_head *head) { switch (arg_tok->conf.if_exists) { case EXISTS_DO_NOTHING: - free_trailer_item(arg_tok); + free_arg_item(arg_tok); break; case EXISTS_REPLACE: apply_item_command(in_tok, arg_tok); - add_arg_to_input_list(on_tok, arg_tok, - in_tok_first, in_tok_last); - remove_from_list(in_tok, in_tok_first, in_tok_last); + add_arg_to_input_list(on_tok, arg_tok); + list_del(&in_tok->list); free_trailer_item(in_tok); break; case EXISTS_ADD: apply_item_command(in_tok, arg_tok); - add_arg_to_input_list(on_tok, arg_tok, - in_tok_first, in_tok_last); + add_arg_to_input_list(on_tok, arg_tok); break; case EXISTS_ADD_IF_DIFFERENT: apply_item_command(in_tok, arg_tok); - if (check_if_different(in_tok, arg_tok, 1)) - add_arg_to_input_list(on_tok, arg_tok, - in_tok_first, in_tok_last); + if (check_if_different(in_tok, arg_tok, 1, head)) + add_arg_to_input_list(on_tok, arg_tok); else - free_trailer_item(arg_tok); + free_arg_item(arg_tok); break; case EXISTS_ADD_IF_DIFFERENT_NEIGHBOR: apply_item_command(in_tok, arg_tok); - if (check_if_different(on_tok, arg_tok, 0)) - add_arg_to_input_list(on_tok, arg_tok, - in_tok_first, in_tok_last); + if (check_if_different(on_tok, arg_tok, 0, head)) + add_arg_to_input_list(on_tok, arg_tok); else - free_trailer_item(arg_tok); + free_arg_item(arg_tok); break; } } -static void apply_arg_if_missing(struct trailer_item **in_tok_first, - struct trailer_item **in_tok_last, - struct trailer_item *arg_tok) +static void apply_arg_if_missing(struct list_head *head, + struct arg_item *arg_tok) { - struct trailer_item **in_tok; enum action_where where; + struct trailer_item *to_add; switch (arg_tok->conf.if_missing) { case MISSING_DO_NOTHING: - free_trailer_item(arg_tok); + free_arg_item(arg_tok); break; case MISSING_ADD: where = arg_tok->conf.where; - in_tok = after_or_end(where) ? in_tok_last : in_tok_first; apply_item_command(NULL, arg_tok); - if (*in_tok) { - add_arg_to_input_list(*in_tok, arg_tok, - in_tok_first, in_tok_last); - } else { - *in_tok_first = arg_tok; - *in_tok_last = arg_tok; - } - break; + to_add = trailer_from_arg(arg_tok); + if (after_or_end(where)) + list_add_tail(&to_add->list, head); + else + list_add(&to_add->list, head); } } -static int find_same_and_apply_arg(struct trailer_item **in_tok_first, - struct trailer_item **in_tok_last, - struct trailer_item *arg_tok) +static int find_same_and_apply_arg(struct list_head *head, + struct arg_item *arg_tok) { + struct list_head *pos; struct trailer_item *in_tok; struct trailer_item *on_tok; - struct trailer_item *following_tok; enum action_where where = arg_tok->conf.where; int middle = (where == WHERE_AFTER) || (where == WHERE_BEFORE); int backwards = after_or_end(where); - struct trailer_item *start_tok = backwards ? *in_tok_last : *in_tok_first; + struct trailer_item *start_tok; - for (in_tok = start_tok; in_tok; in_tok = following_tok) { - following_tok = backwards ? in_tok->previous : in_tok->next; + if (list_empty(head)) + return 0; + + start_tok = list_entry(backwards ? head->prev : head->next, + struct trailer_item, + list); + + list_for_each_dir(pos, head, backwards) { + in_tok = list_entry(pos, struct trailer_item, list); if (!same_token(in_tok, arg_tok)) continue; on_tok = middle ? in_tok : start_tok; - apply_arg_if_exists(in_tok, arg_tok, on_tok, - in_tok_first, in_tok_last); + apply_arg_if_exists(in_tok, arg_tok, on_tok, head); return 1; } return 0; } -static void process_trailers_lists(struct trailer_item **in_tok_first, - struct trailer_item **in_tok_last, - struct trailer_item **arg_tok_first) +static void process_trailers_lists(struct list_head *head, + struct list_head *arg_head) { - struct trailer_item *arg_tok; - struct trailer_item *next_arg; + struct list_head *pos, *p; + struct arg_item *arg_tok; - if (!*arg_tok_first) - return; - - for (arg_tok = *arg_tok_first; arg_tok; arg_tok = next_arg) { + list_for_each_safe(pos, p, arg_head) { int applied = 0; + arg_tok = list_entry(pos, struct arg_item, list); - next_arg = arg_tok->next; - remove_from_list(arg_tok, arg_tok_first, NULL); + list_del(pos); - applied = find_same_and_apply_arg(in_tok_first, - in_tok_last, - arg_tok); + applied = find_same_and_apply_arg(head, arg_tok); if (!applied) - apply_arg_if_missing(in_tok_first, - in_tok_last, - arg_tok); + apply_arg_if_missing(head, arg_tok); } } @@ -425,41 +415,32 @@ static int set_if_missing(struct conf_info *item, const char *value) return 0; } -static void duplicate_conf(struct conf_info *dst, struct conf_info *src) +static void duplicate_conf(struct conf_info *dst, const struct conf_info *src) { *dst = *src; - if (src->name) - dst->name = xstrdup(src->name); - if (src->key) - dst->key = xstrdup(src->key); - if (src->command) - dst->command = xstrdup(src->command); + dst->name = xstrdup_or_null(src->name); + dst->key = xstrdup_or_null(src->key); + dst->command = xstrdup_or_null(src->command); } -static struct trailer_item *get_conf_item(const char *name) +static struct arg_item *get_conf_item(const char *name) { - struct trailer_item *item; - struct trailer_item *previous; + struct list_head *pos; + struct arg_item *item; /* Look up item with same name */ - for (previous = NULL, item = first_conf_item; - item; - previous = item, item = item->next) { + list_for_each(pos, &conf_head) { + item = list_entry(pos, struct arg_item, list); if (!strcasecmp(item->conf.name, name)) return item; } /* Item does not already exists, create it */ - item = xcalloc(sizeof(struct trailer_item), 1); + item = xcalloc(sizeof(*item), 1); duplicate_conf(&item->conf, &default_conf_info); item->conf.name = xstrdup(name); - if (!previous) - first_conf_item = item; - else { - previous->next = item; - item->previous = previous; - } + list_add_tail(&item->list, &conf_head); return item; } @@ -509,7 +490,7 @@ static int git_trailer_default_config(const char *conf_key, const char *value, v static int git_trailer_config(const char *conf_key, const char *value, void *cb) { const char *trailer_item, *variable_name; - struct trailer_item *item; + struct arg_item *item; struct conf_info *conf; char *name = NULL; enum trailer_info_type type; @@ -562,38 +543,23 @@ static int git_trailer_config(const char *conf_key, const char *value, void *cb) warning(_("unknown value '%s' for key '%s'"), value, conf_key); break; default: - die("internal bug in trailer.c"); + die("BUG: trailer.c: unhandled type %d", type); } return 0; } -static int parse_trailer(struct strbuf *tok, struct strbuf *val, const char *trailer) +static void ensure_configured(void) { - size_t len; - struct strbuf seps = STRBUF_INIT; - strbuf_addstr(&seps, separators); - strbuf_addch(&seps, '='); - len = strcspn(trailer, seps.buf); - strbuf_release(&seps); - if (len == 0) { - int l = strlen(trailer); - while (l > 0 && isspace(trailer[l - 1])) - l--; - return error(_("empty trailer token in trailer '%.*s'"), l, trailer); - } - if (len < strlen(trailer)) { - strbuf_add(tok, trailer, len); - strbuf_trim(tok); - strbuf_addstr(val, trailer + len + 1); - strbuf_trim(val); - } else { - strbuf_addstr(tok, trailer); - strbuf_trim(tok); - } - return 0; + if (configured) + return; + + /* Default config must be setup first */ + git_config(git_trailer_default_config, NULL); + git_config(git_trailer_config, NULL); + configured = 1; } -static const char *token_from_item(struct trailer_item *item, char *tok) +static const char *token_from_item(struct arg_item *item, char *tok) { if (item->conf.key) return item->conf.key; @@ -602,245 +568,371 @@ static const char *token_from_item(struct trailer_item *item, char *tok) return item->conf.name; } -static struct trailer_item *new_trailer_item(struct trailer_item *conf_item, - char *tok, char *val) -{ - struct trailer_item *new = xcalloc(sizeof(*new), 1); - new->value = val ? val : xstrdup(""); - - if (conf_item) { - duplicate_conf(&new->conf, &conf_item->conf); - new->token = xstrdup(token_from_item(conf_item, tok)); - free(tok); - } else { - duplicate_conf(&new->conf, &default_conf_info); - new->token = tok; - } - - return new; -} - -static int token_matches_item(const char *tok, struct trailer_item *item, int tok_len) +static int token_matches_item(const char *tok, struct arg_item *item, int tok_len) { if (!strncasecmp(tok, item->conf.name, tok_len)) return 1; return item->conf.key ? !strncasecmp(tok, item->conf.key, tok_len) : 0; } -static struct trailer_item *create_trailer_item(const char *string) +/* + * If the given line is of the form + * "<token><optional whitespace><separator>..." or "<separator>...", return the + * location of the separator. Otherwise, return -1. The optional whitespace + * is allowed there primarily to allow things like "Bug #43" where <token> is + * "Bug" and <separator> is "#". + * + * The separator-starts-line case (in which this function returns 0) is + * distinguished from the non-well-formed-line case (in which this function + * returns -1) because some callers of this function need such a distinction. + */ +static int find_separator(const char *line, const char *separators) { - struct strbuf tok = STRBUF_INIT; - struct strbuf val = STRBUF_INIT; - struct trailer_item *item; - int tok_len; + int whitespace_found = 0; + const char *c; + for (c = line; *c; c++) { + if (strchr(separators, *c)) + return c - line; + if (!whitespace_found && (isalnum(*c) || *c == '-')) + continue; + if (c != line && (*c == ' ' || *c == '\t')) { + whitespace_found = 1; + continue; + } + break; + } + return -1; +} - if (parse_trailer(&tok, &val, string)) - return NULL; +/* + * Obtain the token, value, and conf from the given trailer. + * + * separator_pos must not be 0, since the token cannot be an empty string. + * + * If separator_pos is -1, interpret the whole trailer as a token. + */ +static void parse_trailer(struct strbuf *tok, struct strbuf *val, + const struct conf_info **conf, const char *trailer, + int separator_pos) +{ + struct arg_item *item; + int tok_len; + struct list_head *pos; - tok_len = token_len_without_separator(tok.buf, tok.len); + if (separator_pos != -1) { + strbuf_add(tok, trailer, separator_pos); + strbuf_trim(tok); + strbuf_addstr(val, trailer + separator_pos + 1); + strbuf_trim(val); + } else { + strbuf_addstr(tok, trailer); + strbuf_trim(tok); + } /* Lookup if the token matches something in the config */ - for (item = first_conf_item; item; item = item->next) { - if (token_matches_item(tok.buf, item, tok_len)) - return new_trailer_item(item, - strbuf_detach(&tok, NULL), - strbuf_detach(&val, NULL)); + tok_len = token_len_without_separator(tok->buf, tok->len); + if (conf) + *conf = &default_conf_info; + list_for_each(pos, &conf_head) { + item = list_entry(pos, struct arg_item, list); + if (token_matches_item(tok->buf, item, tok_len)) { + char *tok_buf = strbuf_detach(tok, NULL); + if (conf) + *conf = &item->conf; + strbuf_addstr(tok, token_from_item(item, tok_buf)); + free(tok_buf); + break; + } } +} - return new_trailer_item(NULL, - strbuf_detach(&tok, NULL), - strbuf_detach(&val, NULL)); +static struct trailer_item *add_trailer_item(struct list_head *head, char *tok, + char *val) +{ + struct trailer_item *new = xcalloc(sizeof(*new), 1); + new->token = tok; + new->value = val; + list_add_tail(&new->list, head); + return new; } -static void add_trailer_item(struct trailer_item **first, - struct trailer_item **last, - struct trailer_item *new) +static void add_arg_item(struct list_head *arg_head, char *tok, char *val, + const struct conf_info *conf) { - if (!new) - return; - if (!*last) { - *first = new; - *last = new; - } else { - (*last)->next = new; - new->previous = *last; - *last = new; - } + struct arg_item *new = xcalloc(sizeof(*new), 1); + new->token = tok; + new->value = val; + duplicate_conf(&new->conf, conf); + list_add_tail(&new->list, arg_head); } -static struct trailer_item *process_command_line_args(struct string_list *trailers) +static void process_command_line_args(struct list_head *arg_head, + struct string_list *trailers) { - struct trailer_item *arg_tok_first = NULL; - struct trailer_item *arg_tok_last = NULL; struct string_list_item *tr; - struct trailer_item *item; + struct arg_item *item; + struct strbuf tok = STRBUF_INIT; + struct strbuf val = STRBUF_INIT; + const struct conf_info *conf; + struct list_head *pos; - /* Add a trailer item for each configured trailer with a command */ - for (item = first_conf_item; item; item = item->next) { - if (item->conf.command) { - struct trailer_item *new = new_trailer_item(item, NULL, NULL); - add_trailer_item(&arg_tok_first, &arg_tok_last, new); - } + /* + * In command-line arguments, '=' is accepted (in addition to the + * separators that are defined). + */ + char *cl_separators = xstrfmt("=%s", separators); + + /* Add an arg item for each configured trailer with a command */ + list_for_each(pos, &conf_head) { + item = list_entry(pos, struct arg_item, list); + if (item->conf.command) + add_arg_item(arg_head, + xstrdup(token_from_item(item, NULL)), + xstrdup(""), + &item->conf); } - /* Add a trailer item for each trailer on the command line */ + /* Add an arg item for each trailer on the command line */ for_each_string_list_item(tr, trailers) { - struct trailer_item *new = create_trailer_item(tr->string); - add_trailer_item(&arg_tok_first, &arg_tok_last, new); + int separator_pos = find_separator(tr->string, cl_separators); + if (separator_pos == 0) { + struct strbuf sb = STRBUF_INIT; + strbuf_addstr(&sb, tr->string); + strbuf_trim(&sb); + error(_("empty trailer token in trailer '%.*s'"), + (int) sb.len, sb.buf); + strbuf_release(&sb); + } else { + parse_trailer(&tok, &val, &conf, tr->string, + separator_pos); + add_arg_item(arg_head, + strbuf_detach(&tok, NULL), + strbuf_detach(&val, NULL), + conf); + } } - return arg_tok_first; + free(cl_separators); } -static struct strbuf **read_input_file(const char *file) +static void read_input_file(struct strbuf *sb, const char *file) { - struct strbuf **lines; - struct strbuf sb = STRBUF_INIT; - if (file) { - if (strbuf_read_file(&sb, file, 0) < 0) + if (strbuf_read_file(sb, file, 0) < 0) die_errno(_("could not read input file '%s'"), file); } else { - if (strbuf_read(&sb, fileno(stdin), 0) < 0) + if (strbuf_read(sb, fileno(stdin), 0) < 0) die_errno(_("could not read from stdin")); } +} - lines = strbuf_split(&sb, '\n'); +static const char *next_line(const char *str) +{ + const char *nl = strchrnul(str, '\n'); + return nl + !!*nl; +} - strbuf_release(&sb); +/* + * Return the position of the start of the last line. If len is 0, return -1. + */ +static int last_line(const char *buf, size_t len) +{ + int i; + if (len == 0) + return -1; + if (len == 1) + return 0; + /* + * Skip the last character (in addition to the null terminator), + * because if the last character is a newline, it is considered as part + * of the last line anyway. + */ + i = len - 2; - return lines; + for (; i >= 0; i--) { + if (buf[i] == '\n') + return i + 1; + } + return 0; } /* - * Return the (0 based) index of the start of the patch or the line - * count if there is no patch in the message. + * Return the position of the start of the patch or the length of str if there + * is no patch in the message. */ -static int find_patch_start(struct strbuf **lines, int count) +static int find_patch_start(const char *str) { - int i; + const char *s; - /* Get the start of the patch part if any */ - for (i = 0; i < count; i++) { - if (starts_with(lines[i]->buf, "---")) - return i; + for (s = str; *s; s = next_line(s)) { + if (starts_with(s, "---")) + return s - str; } - return count; + return s - str; } /* - * Return the (0 based) index of the first trailer line or count if - * there are no trailers. Trailers are searched only in the lines from - * index (count - 1) down to index 0. + * Return the position of the first trailer line or len if there are no + * trailers. */ -static int find_trailer_start(struct strbuf **lines, int count) +static int find_trailer_start(const char *buf, size_t len) { - int start, end_of_title, only_spaces = 1; + const char *s; + int end_of_title, l, only_spaces = 1; + int recognized_prefix = 0, trailer_lines = 0, non_trailer_lines = 0; + /* + * Number of possible continuation lines encountered. This will be + * reset to 0 if we encounter a trailer (since those lines are to be + * considered continuations of that trailer), and added to + * non_trailer_lines if we encounter a non-trailer (since those lines + * are to be considered non-trailers). + */ + int possible_continuation_lines = 0; /* The first paragraph is the title and cannot be trailers */ - for (start = 0; start < count; start++) { - if (lines[start]->buf[0] == comment_line_char) + for (s = buf; s < buf + len; s = next_line(s)) { + if (s[0] == comment_line_char) continue; - if (contains_only_spaces(lines[start]->buf)) + if (is_blank_line(s)) break; } - end_of_title = start; + end_of_title = s - buf; /* - * Get the start of the trailers by looking starting from the end - * for a line with only spaces before lines with one separator. + * Get the start of the trailers by looking starting from the end for a + * blank line before a set of non-blank lines that (i) are all + * trailers, or (ii) contains at least one Git-generated trailer and + * consists of at least 25% trailers. */ - for (start = count - 1; start >= end_of_title; start--) { - if (lines[start]->buf[0] == comment_line_char) + for (l = last_line(buf, len); + l >= end_of_title; + l = last_line(buf, l)) { + const char *bol = buf + l; + const char **p; + int separator_pos; + + if (bol[0] == comment_line_char) { + non_trailer_lines += possible_continuation_lines; + possible_continuation_lines = 0; continue; - if (contains_only_spaces(lines[start]->buf)) { + } + if (is_blank_line(bol)) { if (only_spaces) continue; - return start + 1; + non_trailer_lines += possible_continuation_lines; + if (recognized_prefix && + trailer_lines * 3 >= non_trailer_lines) + return next_line(bol) - buf; + else if (trailer_lines && !non_trailer_lines) + return next_line(bol) - buf; + return len; } - if (strcspn(lines[start]->buf, separators) < lines[start]->len) { - if (only_spaces) - only_spaces = 0; - continue; + only_spaces = 0; + + for (p = git_generated_prefixes; *p; p++) { + if (starts_with(bol, *p)) { + trailer_lines++; + possible_continuation_lines = 0; + recognized_prefix = 1; + goto continue_outer_loop; + } } - return count; - } - return only_spaces ? count : 0; -} + separator_pos = find_separator(bol, separators); + if (separator_pos >= 1 && !isspace(bol[0])) { + struct list_head *pos; -/* Get the index of the end of the trailers */ -static int find_trailer_end(struct strbuf **lines, int patch_start) -{ - struct strbuf sb = STRBUF_INIT; - int i, ignore_bytes; - - for (i = 0; i < patch_start; i++) - strbuf_addbuf(&sb, lines[i]); - ignore_bytes = ignore_non_trailer(&sb); - strbuf_release(&sb); - for (i = patch_start - 1; i >= 0 && ignore_bytes > 0; i--) - ignore_bytes -= lines[i]->len; + trailer_lines++; + possible_continuation_lines = 0; + if (recognized_prefix) + continue; + list_for_each(pos, &conf_head) { + struct arg_item *item; + item = list_entry(pos, struct arg_item, list); + if (token_matches_item(bol, item, + separator_pos)) { + recognized_prefix = 1; + break; + } + } + } else if (isspace(bol[0])) + possible_continuation_lines++; + else { + non_trailer_lines++; + non_trailer_lines += possible_continuation_lines; + possible_continuation_lines = 0; + } +continue_outer_loop: + ; + } - return i + 1; + return len; } -static int has_blank_line_before(struct strbuf **lines, int start) +/* Return the position of the end of the trailers. */ +static int find_trailer_end(const char *buf, size_t len) { - for (;start >= 0; start--) { - if (lines[start]->buf[0] == comment_line_char) - continue; - return contains_only_spaces(lines[start]->buf); - } - return 0; + return len - ignore_non_trailer(buf, len); } -static void print_lines(FILE *outfile, struct strbuf **lines, int start, int end) +static int ends_with_blank_line(const char *buf, size_t len) { - int i; - for (i = start; lines[i] && i < end; i++) - fprintf(outfile, "%s", lines[i]->buf); + int ll = last_line(buf, len); + if (ll < 0) + return 0; + return is_blank_line(buf + ll); } static int process_input_file(FILE *outfile, - struct strbuf **lines, - struct trailer_item **in_tok_first, - struct trailer_item **in_tok_last) + const char *str, + struct list_head *head) { - int count = 0; - int patch_start, trailer_start, trailer_end, i; - - /* Get the line count */ - while (lines[count]) - count++; + struct trailer_info info; + struct strbuf tok = STRBUF_INIT; + struct strbuf val = STRBUF_INIT; + int i; - patch_start = find_patch_start(lines, count); - trailer_end = find_trailer_end(lines, patch_start); - trailer_start = find_trailer_start(lines, trailer_end); + trailer_info_get(&info, str); /* Print lines before the trailers as is */ - print_lines(outfile, lines, 0, trailer_start); + fwrite(str, 1, info.trailer_start - str, outfile); - if (!has_blank_line_before(lines, trailer_start - 1)) + if (!info.blank_line_before_trailer) fprintf(outfile, "\n"); - /* Parse trailer lines */ - for (i = trailer_start; i < trailer_end; i++) { - if (lines[i]->buf[0] != comment_line_char) { - struct trailer_item *new = create_trailer_item(lines[i]->buf); - add_trailer_item(in_tok_first, in_tok_last, new); + for (i = 0; i < info.trailer_nr; i++) { + int separator_pos; + char *trailer = info.trailers[i]; + if (trailer[0] == comment_line_char) + continue; + separator_pos = find_separator(trailer, separators); + if (separator_pos >= 1) { + parse_trailer(&tok, &val, NULL, trailer, + separator_pos); + add_trailer_item(head, + strbuf_detach(&tok, NULL), + strbuf_detach(&val, NULL)); + } else { + strbuf_addstr(&val, trailer); + strbuf_strip_suffix(&val, "\n"); + add_trailer_item(head, + NULL, + strbuf_detach(&val, NULL)); } } - return trailer_end; + trailer_info_release(&info); + + return info.trailer_end - str; } -static void free_all(struct trailer_item **first) +static void free_all(struct list_head *head) { - while (*first) { - struct trailer_item *item = remove_first(first); - free_trailer_item(item); + struct list_head *pos, *p; + list_for_each_safe(pos, p, head) { + list_del(pos); + free_trailer_item(list_entry(pos, struct trailer_item, list)); } } @@ -877,39 +969,87 @@ static FILE *create_in_place_tempfile(const char *file) void process_trailers(const char *file, int in_place, int trim_empty, struct string_list *trailers) { - struct trailer_item *in_tok_first = NULL; - struct trailer_item *in_tok_last = NULL; - struct trailer_item *arg_tok_first; - struct strbuf **lines; + LIST_HEAD(head); + LIST_HEAD(arg_head); + struct strbuf sb = STRBUF_INIT; int trailer_end; FILE *outfile = stdout; - /* Default config must be setup first */ - git_config(git_trailer_default_config, NULL); - git_config(git_trailer_config, NULL); + ensure_configured(); - lines = read_input_file(file); + read_input_file(&sb, file); if (in_place) outfile = create_in_place_tempfile(file); /* Print the lines before the trailers */ - trailer_end = process_input_file(outfile, lines, &in_tok_first, &in_tok_last); + trailer_end = process_input_file(outfile, sb.buf, &head); - arg_tok_first = process_command_line_args(trailers); + process_command_line_args(&arg_head, trailers); - process_trailers_lists(&in_tok_first, &in_tok_last, &arg_tok_first); + process_trailers_lists(&head, &arg_head); - print_all(outfile, in_tok_first, trim_empty); + print_all(outfile, &head, trim_empty); - free_all(&in_tok_first); + free_all(&head); /* Print the lines after the trailers as is */ - print_lines(outfile, lines, trailer_end, INT_MAX); + fwrite(sb.buf + trailer_end, 1, sb.len - trailer_end, outfile); if (in_place) if (rename_tempfile(&trailers_tempfile, file)) die_errno(_("could not rename temporary file to %s"), file); - strbuf_list_free(lines); + strbuf_release(&sb); +} + +void trailer_info_get(struct trailer_info *info, const char *str) +{ + int patch_start, trailer_end, trailer_start; + struct strbuf **trailer_lines, **ptr; + char **trailer_strings = NULL; + size_t nr = 0, alloc = 0; + char **last = NULL; + + ensure_configured(); + + patch_start = find_patch_start(str); + trailer_end = find_trailer_end(str, patch_start); + trailer_start = find_trailer_start(str, trailer_end); + + trailer_lines = strbuf_split_buf(str + trailer_start, + trailer_end - trailer_start, + '\n', + 0); + for (ptr = trailer_lines; *ptr; ptr++) { + if (last && isspace((*ptr)->buf[0])) { + struct strbuf sb = STRBUF_INIT; + strbuf_attach(&sb, *last, strlen(*last), strlen(*last)); + strbuf_addbuf(&sb, *ptr); + *last = strbuf_detach(&sb, NULL); + continue; + } + ALLOC_GROW(trailer_strings, nr + 1, alloc); + trailer_strings[nr] = strbuf_detach(*ptr, NULL); + last = find_separator(trailer_strings[nr], separators) >= 1 + ? &trailer_strings[nr] + : NULL; + nr++; + } + strbuf_list_free(trailer_lines); + + info->blank_line_before_trailer = ends_with_blank_line(str, + trailer_start); + info->trailer_start = str + trailer_start; + info->trailer_end = str + trailer_end; + info->trailers = trailer_strings; + info->trailer_nr = nr; +} + +void trailer_info_release(struct trailer_info *info) +{ + int i; + for (i = 0; i < info->trailer_nr; i++) + free(info->trailers[i]); + free(info->trailers); } |