2014-10-13 20:16:29 +02:00
|
|
|
/*
|
|
|
|
|
* Builtin "git interpret-trailers"
|
|
|
|
|
*
|
|
|
|
|
* Copyright (c) 2013, 2014 Christian Couder <chriscool@tuxfamily.org>
|
|
|
|
|
*
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#include "builtin.h"
|
2023-03-21 07:25:54 +01:00
|
|
|
#include "gettext.h"
|
2014-10-13 20:16:29 +02:00
|
|
|
#include "parse-options.h"
|
|
|
|
|
#include "string-list.h"
|
2024-03-01 01:14:41 +01:00
|
|
|
#include "tempfile.h"
|
2014-10-13 20:16:29 +02:00
|
|
|
#include "trailer.h"
|
2019-06-19 05:37:28 +02:00
|
|
|
#include "config.h"
|
2014-10-13 20:16:29 +02:00
|
|
|
|
|
|
|
|
static const char * const git_interpret_trailers_usage[] = {
|
2022-10-13 17:39:02 +02:00
|
|
|
N_("git interpret-trailers [--in-place] [--trim-empty]\n"
|
2024-03-16 16:21:41 +01:00
|
|
|
" [(--trailer (<key>|<key-alias>)[(=|:)<value>])...]\n"
|
2022-10-13 17:39:18 +02:00
|
|
|
" [--parse] [<file>...]"),
|
2014-10-13 20:16:29 +02:00
|
|
|
NULL
|
|
|
|
|
};
|
|
|
|
|
|
2017-08-01 11:03:32 +02:00
|
|
|
static enum trailer_where where;
|
|
|
|
|
static enum trailer_if_exists if_exists;
|
|
|
|
|
static enum trailer_if_missing if_missing;
|
|
|
|
|
|
|
|
|
|
static int option_parse_where(const struct option *opt,
|
2023-08-31 23:22:15 +02:00
|
|
|
const char *arg, int unset UNUSED)
|
2017-08-01 11:03:32 +02:00
|
|
|
{
|
2023-08-31 23:22:15 +02:00
|
|
|
/* unset implies NULL arg, which is handled in our helper */
|
parse-options: prefer opt->value to globals in callbacks
We have several parse-options callbacks that ignore their "opt"
parameters entirely. This is a little unusual, as we'd normally put the
result of the parsing into opt->value. In the case of these callbacks,
though, they directly manipulate global variables instead (and in
most cases the caller sets opt->value to NULL in the OPT_CALLBACK
declaration).
The immediate symptom we'd like to deal with is that the unused "opt"
variables trigger -Wunused-parameter. But how to fix that is debatable.
One option is to annotate them with UNUSED. But another is to have the
caller pass in the appropriate variable via opt->value, and use it. That
has the benefit of making the callbacks reusable (in theory at least),
and makes it clear from the OPT_CALLBACK declaration which variables
will be affected (doubly so for the cases in builtin/fast-export.c,
where we do set opt->value, but it is completely ignored!).
The slight downside is that we lose type safety, since they're now
passing through void pointers.
I went with the "just use them" approach here. The loss of type safety
is unfortunate, but that is already an issue with most of the other
callbacks. If we want to try to address that, we should do so more
consistently (and this patch would prepare these callbacks for whatever
we choose to do there).
Note that in the cases in builtin/fast-export.c, we are passing
anonymous enums. We'll have to give them names so that we can declare
the appropriate pointer type within the callbacks.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2023-08-31 23:21:07 +02:00
|
|
|
return trailer_set_where(opt->value, arg);
|
2017-08-01 11:03:32 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int option_parse_if_exists(const struct option *opt,
|
2023-08-31 23:22:15 +02:00
|
|
|
const char *arg, int unset UNUSED)
|
2017-08-01 11:03:32 +02:00
|
|
|
{
|
2023-08-31 23:22:15 +02:00
|
|
|
/* unset implies NULL arg, which is handled in our helper */
|
parse-options: prefer opt->value to globals in callbacks
We have several parse-options callbacks that ignore their "opt"
parameters entirely. This is a little unusual, as we'd normally put the
result of the parsing into opt->value. In the case of these callbacks,
though, they directly manipulate global variables instead (and in
most cases the caller sets opt->value to NULL in the OPT_CALLBACK
declaration).
The immediate symptom we'd like to deal with is that the unused "opt"
variables trigger -Wunused-parameter. But how to fix that is debatable.
One option is to annotate them with UNUSED. But another is to have the
caller pass in the appropriate variable via opt->value, and use it. That
has the benefit of making the callbacks reusable (in theory at least),
and makes it clear from the OPT_CALLBACK declaration which variables
will be affected (doubly so for the cases in builtin/fast-export.c,
where we do set opt->value, but it is completely ignored!).
The slight downside is that we lose type safety, since they're now
passing through void pointers.
I went with the "just use them" approach here. The loss of type safety
is unfortunate, but that is already an issue with most of the other
callbacks. If we want to try to address that, we should do so more
consistently (and this patch would prepare these callbacks for whatever
we choose to do there).
Note that in the cases in builtin/fast-export.c, we are passing
anonymous enums. We'll have to give them names so that we can declare
the appropriate pointer type within the callbacks.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2023-08-31 23:21:07 +02:00
|
|
|
return trailer_set_if_exists(opt->value, arg);
|
2017-08-01 11:03:32 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int option_parse_if_missing(const struct option *opt,
|
2023-08-31 23:22:15 +02:00
|
|
|
const char *arg, int unset UNUSED)
|
2017-08-01 11:03:32 +02:00
|
|
|
{
|
2023-08-31 23:22:15 +02:00
|
|
|
/* unset implies NULL arg, which is handled in our helper */
|
parse-options: prefer opt->value to globals in callbacks
We have several parse-options callbacks that ignore their "opt"
parameters entirely. This is a little unusual, as we'd normally put the
result of the parsing into opt->value. In the case of these callbacks,
though, they directly manipulate global variables instead (and in
most cases the caller sets opt->value to NULL in the OPT_CALLBACK
declaration).
The immediate symptom we'd like to deal with is that the unused "opt"
variables trigger -Wunused-parameter. But how to fix that is debatable.
One option is to annotate them with UNUSED. But another is to have the
caller pass in the appropriate variable via opt->value, and use it. That
has the benefit of making the callbacks reusable (in theory at least),
and makes it clear from the OPT_CALLBACK declaration which variables
will be affected (doubly so for the cases in builtin/fast-export.c,
where we do set opt->value, but it is completely ignored!).
The slight downside is that we lose type safety, since they're now
passing through void pointers.
I went with the "just use them" approach here. The loss of type safety
is unfortunate, but that is already an issue with most of the other
callbacks. If we want to try to address that, we should do so more
consistently (and this patch would prepare these callbacks for whatever
we choose to do there).
Note that in the cases in builtin/fast-export.c, we are passing
anonymous enums. We'll have to give them names so that we can declare
the appropriate pointer type within the callbacks.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2023-08-31 23:21:07 +02:00
|
|
|
return trailer_set_if_missing(opt->value, arg);
|
2017-08-01 11:03:32 +02:00
|
|
|
}
|
|
|
|
|
|
2017-08-01 11:03:31 +02:00
|
|
|
static void new_trailers_clear(struct list_head *trailers)
|
|
|
|
|
{
|
|
|
|
|
struct list_head *pos, *tmp;
|
|
|
|
|
struct new_trailer_item *item;
|
|
|
|
|
|
|
|
|
|
list_for_each_safe(pos, tmp, trailers) {
|
|
|
|
|
item = list_entry(pos, struct new_trailer_item, list);
|
|
|
|
|
list_del(pos);
|
|
|
|
|
free(item);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int option_parse_trailer(const struct option *opt,
|
|
|
|
|
const char *arg, int unset)
|
|
|
|
|
{
|
|
|
|
|
struct list_head *trailers = opt->value;
|
|
|
|
|
struct new_trailer_item *item;
|
|
|
|
|
|
|
|
|
|
if (unset) {
|
|
|
|
|
new_trailers_clear(trailers);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (!arg)
|
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
|
|
item = xmalloc(sizeof(*item));
|
|
|
|
|
item->text = arg;
|
2017-08-01 11:03:32 +02:00
|
|
|
item->where = where;
|
|
|
|
|
item->if_exists = if_exists;
|
|
|
|
|
item->if_missing = if_missing;
|
2017-08-01 11:03:31 +02:00
|
|
|
list_add_tail(&item->list, trailers);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2017-08-15 12:23:34 +02:00
|
|
|
static int parse_opt_parse(const struct option *opt, const char *arg,
|
|
|
|
|
int unset)
|
|
|
|
|
{
|
|
|
|
|
struct process_trailer_options *v = opt->value;
|
|
|
|
|
v->only_trailers = 1;
|
|
|
|
|
v->only_input = 1;
|
|
|
|
|
v->unfold = 1;
|
assert NOARG/NONEG behavior of parse-options callbacks
When we define a parse-options callback, the flags we put in the option
struct must match what the callback expects. For example, a callback
which does not handle the "unset" parameter should only be used with
PARSE_OPT_NONEG. But since the callback and the option struct are not
defined next to each other, it's easy to get this wrong (as earlier
patches in this series show).
Fortunately, the compiler can help us here: compiling with
-Wunused-parameters can show us which callbacks ignore their "unset"
parameters (and likewise, ones that ignore "arg" expect to be triggered
with PARSE_OPT_NOARG).
But after we've inspected a callback and determined that all of its
callers use the right flags, what do we do next? We'd like to silence
the compiler warning, but do so in a way that will catch any wrong calls
in the future.
We can do that by actually checking those variables and asserting that
they match our expectations. Because this is such a common pattern,
we'll introduce some helper macros. The resulting messages aren't
as descriptive as we could make them, but the file/line information from
BUG() is enough to identify the problem (and anyway, the point is that
these should never be seen).
Each of the annotated callbacks in this patch triggers
-Wunused-parameters, and was manually inspected to make sure all callers
use the correct options (so none of these BUGs should be triggerable).
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-11-05 07:45:42 +01:00
|
|
|
BUG_ON_OPT_NEG(unset);
|
|
|
|
|
BUG_ON_OPT_ARG(arg);
|
2017-08-15 12:23:34 +02:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2024-03-01 01:14:41 +01:00
|
|
|
static struct tempfile *trailers_tempfile;
|
|
|
|
|
|
|
|
|
|
static FILE *create_in_place_tempfile(const char *file)
|
|
|
|
|
{
|
|
|
|
|
struct stat st;
|
|
|
|
|
struct strbuf filename_template = STRBUF_INIT;
|
|
|
|
|
const char *tail;
|
|
|
|
|
FILE *outfile;
|
|
|
|
|
|
|
|
|
|
if (stat(file, &st))
|
|
|
|
|
die_errno(_("could not stat %s"), file);
|
|
|
|
|
if (!S_ISREG(st.st_mode))
|
|
|
|
|
die(_("file %s is not a regular file"), file);
|
|
|
|
|
if (!(st.st_mode & S_IWUSR))
|
|
|
|
|
die(_("file %s is not writable by user"), file);
|
|
|
|
|
|
|
|
|
|
/* Create temporary file in the same directory as the original */
|
|
|
|
|
tail = strrchr(file, '/');
|
|
|
|
|
if (tail)
|
|
|
|
|
strbuf_add(&filename_template, file, tail - file + 1);
|
|
|
|
|
strbuf_addstr(&filename_template, "git-interpret-trailers-XXXXXX");
|
|
|
|
|
|
|
|
|
|
trailers_tempfile = xmks_tempfile_m(filename_template.buf, st.st_mode);
|
|
|
|
|
strbuf_release(&filename_template);
|
|
|
|
|
outfile = fdopen_tempfile(trailers_tempfile, "w");
|
|
|
|
|
if (!outfile)
|
|
|
|
|
die_errno(_("could not open temporary file"));
|
|
|
|
|
|
|
|
|
|
return outfile;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void read_input_file(struct strbuf *sb, const char *file)
|
|
|
|
|
{
|
|
|
|
|
if (file) {
|
|
|
|
|
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)
|
|
|
|
|
die_errno(_("could not read from stdin"));
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void interpret_trailers(const struct process_trailer_options *opts,
|
|
|
|
|
struct list_head *new_trailer_head,
|
|
|
|
|
const char *file)
|
|
|
|
|
{
|
|
|
|
|
LIST_HEAD(head);
|
|
|
|
|
struct strbuf sb = STRBUF_INIT;
|
2024-03-01 01:14:44 +01:00
|
|
|
struct strbuf trailer_block = STRBUF_INIT;
|
2024-05-02 06:54:23 +02:00
|
|
|
struct trailer_info *info;
|
2024-03-01 01:14:41 +01:00
|
|
|
FILE *outfile = stdout;
|
|
|
|
|
|
|
|
|
|
trailer_config_init();
|
|
|
|
|
|
|
|
|
|
read_input_file(&sb, file);
|
|
|
|
|
|
|
|
|
|
if (opts->in_place)
|
|
|
|
|
outfile = create_in_place_tempfile(file);
|
|
|
|
|
|
2024-05-02 06:54:23 +02:00
|
|
|
info = parse_trailers(opts, sb.buf, &head);
|
2024-03-01 01:14:41 +01:00
|
|
|
|
|
|
|
|
/* Print the lines before the trailers */
|
|
|
|
|
if (!opts->only_trailers)
|
2024-05-02 06:54:22 +02:00
|
|
|
fwrite(sb.buf, 1, trailer_block_start(info), outfile);
|
2024-03-01 01:14:41 +01:00
|
|
|
|
2024-05-02 06:54:22 +02:00
|
|
|
if (!opts->only_trailers && !blank_line_before_trailer_block(info))
|
2024-03-01 01:14:41 +01:00
|
|
|
fprintf(outfile, "\n");
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
if (!opts->only_input) {
|
|
|
|
|
LIST_HEAD(config_head);
|
|
|
|
|
LIST_HEAD(arg_head);
|
|
|
|
|
parse_trailers_from_config(&config_head);
|
|
|
|
|
parse_trailers_from_command_line_args(&arg_head, new_trailer_head);
|
|
|
|
|
list_splice(&config_head, &arg_head);
|
|
|
|
|
process_trailers_lists(&head, &arg_head);
|
|
|
|
|
}
|
|
|
|
|
|
2024-03-01 01:14:44 +01:00
|
|
|
/* Print trailer block. */
|
|
|
|
|
format_trailers(opts, &head, &trailer_block);
|
2024-03-01 01:14:41 +01:00
|
|
|
free_trailers(&head);
|
2024-03-01 01:14:44 +01:00
|
|
|
fwrite(trailer_block.buf, 1, trailer_block.len, outfile);
|
|
|
|
|
strbuf_release(&trailer_block);
|
2024-03-01 01:14:41 +01:00
|
|
|
|
|
|
|
|
/* Print the lines after the trailers as is */
|
|
|
|
|
if (!opts->only_trailers)
|
2024-05-02 06:54:22 +02:00
|
|
|
fwrite(sb.buf + trailer_block_end(info), 1, sb.len - trailer_block_end(info), outfile);
|
|
|
|
|
trailer_info_release(info);
|
2024-03-01 01:14:41 +01:00
|
|
|
|
|
|
|
|
if (opts->in_place)
|
|
|
|
|
if (rename_tempfile(&trailers_tempfile, file))
|
|
|
|
|
die_errno(_("could not rename temporary file to %s"), file);
|
|
|
|
|
|
|
|
|
|
strbuf_release(&sb);
|
|
|
|
|
}
|
|
|
|
|
|
2014-10-13 20:16:29 +02:00
|
|
|
int cmd_interpret_trailers(int argc, const char **argv, const char *prefix)
|
|
|
|
|
{
|
2017-08-10 20:03:58 +02:00
|
|
|
struct process_trailer_options opts = PROCESS_TRAILER_OPTIONS_INIT;
|
2017-08-01 11:03:31 +02:00
|
|
|
LIST_HEAD(trailers);
|
2014-10-13 20:16:29 +02:00
|
|
|
|
|
|
|
|
struct option options[] = {
|
2017-08-10 20:03:58 +02:00
|
|
|
OPT_BOOL(0, "in-place", &opts.in_place, N_("edit files in place")),
|
|
|
|
|
OPT_BOOL(0, "trim-empty", &opts.trim_empty, N_("trim empty trailers")),
|
2017-08-01 11:03:31 +02:00
|
|
|
|
2023-10-13 23:18:27 +02:00
|
|
|
OPT_CALLBACK(0, "where", &where, N_("placement"),
|
2017-08-01 11:03:32 +02:00
|
|
|
N_("where to place the new trailer"), option_parse_where),
|
parse-options: prefer opt->value to globals in callbacks
We have several parse-options callbacks that ignore their "opt"
parameters entirely. This is a little unusual, as we'd normally put the
result of the parsing into opt->value. In the case of these callbacks,
though, they directly manipulate global variables instead (and in
most cases the caller sets opt->value to NULL in the OPT_CALLBACK
declaration).
The immediate symptom we'd like to deal with is that the unused "opt"
variables trigger -Wunused-parameter. But how to fix that is debatable.
One option is to annotate them with UNUSED. But another is to have the
caller pass in the appropriate variable via opt->value, and use it. That
has the benefit of making the callbacks reusable (in theory at least),
and makes it clear from the OPT_CALLBACK declaration which variables
will be affected (doubly so for the cases in builtin/fast-export.c,
where we do set opt->value, but it is completely ignored!).
The slight downside is that we lose type safety, since they're now
passing through void pointers.
I went with the "just use them" approach here. The loss of type safety
is unfortunate, but that is already an issue with most of the other
callbacks. If we want to try to address that, we should do so more
consistently (and this patch would prepare these callbacks for whatever
we choose to do there).
Note that in the cases in builtin/fast-export.c, we are passing
anonymous enums. We'll have to give them names so that we can declare
the appropriate pointer type within the callbacks.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2023-08-31 23:21:07 +02:00
|
|
|
OPT_CALLBACK(0, "if-exists", &if_exists, N_("action"),
|
2017-08-01 11:03:32 +02:00
|
|
|
N_("action if trailer already exists"), option_parse_if_exists),
|
parse-options: prefer opt->value to globals in callbacks
We have several parse-options callbacks that ignore their "opt"
parameters entirely. This is a little unusual, as we'd normally put the
result of the parsing into opt->value. In the case of these callbacks,
though, they directly manipulate global variables instead (and in
most cases the caller sets opt->value to NULL in the OPT_CALLBACK
declaration).
The immediate symptom we'd like to deal with is that the unused "opt"
variables trigger -Wunused-parameter. But how to fix that is debatable.
One option is to annotate them with UNUSED. But another is to have the
caller pass in the appropriate variable via opt->value, and use it. That
has the benefit of making the callbacks reusable (in theory at least),
and makes it clear from the OPT_CALLBACK declaration which variables
will be affected (doubly so for the cases in builtin/fast-export.c,
where we do set opt->value, but it is completely ignored!).
The slight downside is that we lose type safety, since they're now
passing through void pointers.
I went with the "just use them" approach here. The loss of type safety
is unfortunate, but that is already an issue with most of the other
callbacks. If we want to try to address that, we should do so more
consistently (and this patch would prepare these callbacks for whatever
we choose to do there).
Note that in the cases in builtin/fast-export.c, we are passing
anonymous enums. We'll have to give them names so that we can declare
the appropriate pointer type within the callbacks.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2023-08-31 23:21:07 +02:00
|
|
|
OPT_CALLBACK(0, "if-missing", &if_missing, N_("action"),
|
2017-08-01 11:03:32 +02:00
|
|
|
N_("action if trailer is missing"), option_parse_if_missing),
|
|
|
|
|
|
2017-08-15 12:23:21 +02:00
|
|
|
OPT_BOOL(0, "only-trailers", &opts.only_trailers, N_("output only the trailers")),
|
2023-09-08 00:20:04 +02:00
|
|
|
OPT_BOOL(0, "only-input", &opts.only_input, N_("do not apply trailer.* configuration variables")),
|
2023-09-08 00:20:06 +02:00
|
|
|
OPT_BOOL(0, "unfold", &opts.unfold, N_("reformat multiline trailer values as single-line values")),
|
2023-09-08 00:20:03 +02:00
|
|
|
OPT_CALLBACK_F(0, "parse", &opts, NULL, N_("alias for --only-trailers --only-input --unfold"),
|
Use OPT_CALLBACK and OPT_CALLBACK_F
In the codebase, there are many options which use OPTION_CALLBACK in a
plain ol' struct definition. However, we have the OPT_CALLBACK and
OPT_CALLBACK_F macros which are meant to abstract these plain struct
definitions away. These macros are useful as they semantically signal to
developers that these are just normal callback option with nothing fancy
happening.
Replace plain struct definitions of OPTION_CALLBACK with OPT_CALLBACK or
OPT_CALLBACK_F where applicable. The heavy lifting was done using the
following (disgusting) shell script:
#!/bin/sh
do_replacement () {
tr '\n' '\r' |
sed -e 's/{\s*OPTION_CALLBACK,\s*\([^,]*\),\([^,]*\),\([^,]*\),\([^,]*\),\([^,]*\),\s*0,\(\s*[^[:space:]}]*\)\s*}/OPT_CALLBACK(\1,\2,\3,\4,\5,\6)/g' |
sed -e 's/{\s*OPTION_CALLBACK,\s*\([^,]*\),\([^,]*\),\([^,]*\),\([^,]*\),\([^,]*\),\([^,]*\),\(\s*[^[:space:]}]*\)\s*}/OPT_CALLBACK_F(\1,\2,\3,\4,\5,\6,\7)/g' |
tr '\r' '\n'
}
for f in $(git ls-files \*.c)
do
do_replacement <"$f" >"$f.tmp"
mv "$f.tmp" "$f"
done
The result was manually inspected and then reformatted to match the
style of the surrounding code. Finally, using
`git grep OPTION_CALLBACK \*.c`, leftover results which were not handled
by the script were manually transformed.
Signed-off-by: Denton Liu <liu.denton@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2020-04-28 10:36:28 +02:00
|
|
|
PARSE_OPT_NOARG | PARSE_OPT_NONEG, parse_opt_parse),
|
2023-09-08 00:20:02 +02:00
|
|
|
OPT_BOOL(0, "no-divider", &opts.no_divider, N_("do not treat \"---\" as the end of input")),
|
2017-08-01 11:03:31 +02:00
|
|
|
OPT_CALLBACK(0, "trailer", &trailers, N_("trailer"),
|
|
|
|
|
N_("trailer(s) to add"), option_parse_trailer),
|
2014-10-13 20:16:29 +02:00
|
|
|
OPT_END()
|
|
|
|
|
};
|
|
|
|
|
|
2019-06-19 05:37:28 +02:00
|
|
|
git_config(git_default_config, NULL);
|
|
|
|
|
|
2014-10-13 20:16:29 +02:00
|
|
|
argc = parse_options(argc, argv, prefix, options,
|
|
|
|
|
git_interpret_trailers_usage, 0);
|
|
|
|
|
|
2017-08-27 07:55:04 +02:00
|
|
|
if (opts.only_input && !list_empty(&trailers))
|
2017-08-15 12:23:25 +02:00
|
|
|
usage_msg_opt(
|
|
|
|
|
_("--trailer with --only-input does not make sense"),
|
|
|
|
|
git_interpret_trailers_usage,
|
|
|
|
|
options);
|
|
|
|
|
|
2014-10-13 20:16:29 +02:00
|
|
|
if (argc) {
|
|
|
|
|
int i;
|
|
|
|
|
for (i = 0; i < argc; i++)
|
2024-03-01 01:14:40 +01:00
|
|
|
interpret_trailers(&opts, &trailers, argv[i]);
|
2016-01-14 17:57:55 +01:00
|
|
|
} else {
|
2017-08-10 20:03:58 +02:00
|
|
|
if (opts.in_place)
|
2016-01-14 17:57:55 +01:00
|
|
|
die(_("no input file given for in-place editing"));
|
2024-03-01 01:14:40 +01:00
|
|
|
interpret_trailers(&opts, &trailers, NULL);
|
2016-01-14 17:57:55 +01:00
|
|
|
}
|
2014-10-13 20:16:29 +02:00
|
|
|
|
2017-08-01 11:03:31 +02:00
|
|
|
new_trailers_clear(&trailers);
|
2014-10-13 20:16:29 +02:00
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
