mirror of
https://github.com/git/git.git
synced 2024-05-30 13:46:08 +02:00
Merge branch 'ot/libify-get-ref-atom-value'
Code restructuring, in preparation for further work. * ot/libify-get-ref-atom-value: ref-filter: libify get_ref_atom_value() ref-filter: add return value to parsers ref-filter: change parsing function error handling ref-filter: add return value && strbuf to handlers ref-filter: start adding strbufs with errors ref-filter: add shortcut to work with strbufs
This commit is contained in:
commit
b7da73ac8b
|
@ -391,7 +391,6 @@ static void print_ref_list(struct ref_filter *filter, struct ref_sorting *sortin
|
||||||
struct ref_array array;
|
struct ref_array array;
|
||||||
int maxwidth = 0;
|
int maxwidth = 0;
|
||||||
const char *remote_prefix = "";
|
const char *remote_prefix = "";
|
||||||
struct strbuf out = STRBUF_INIT;
|
|
||||||
char *to_free = NULL;
|
char *to_free = NULL;
|
||||||
|
|
||||||
/*
|
/*
|
||||||
|
@ -419,7 +418,10 @@ static void print_ref_list(struct ref_filter *filter, struct ref_sorting *sortin
|
||||||
ref_array_sort(sorting, &array);
|
ref_array_sort(sorting, &array);
|
||||||
|
|
||||||
for (i = 0; i < array.nr; i++) {
|
for (i = 0; i < array.nr; i++) {
|
||||||
format_ref_array_item(array.items[i], format, &out);
|
struct strbuf out = STRBUF_INIT;
|
||||||
|
struct strbuf err = STRBUF_INIT;
|
||||||
|
if (format_ref_array_item(array.items[i], format, &out, &err))
|
||||||
|
die("%s", err.buf);
|
||||||
if (column_active(colopts)) {
|
if (column_active(colopts)) {
|
||||||
assert(!filter->verbose && "--column and --verbose are incompatible");
|
assert(!filter->verbose && "--column and --verbose are incompatible");
|
||||||
/* format to a string_list to let print_columns() do its job */
|
/* format to a string_list to let print_columns() do its job */
|
||||||
|
@ -428,6 +430,7 @@ static void print_ref_list(struct ref_filter *filter, struct ref_sorting *sortin
|
||||||
fwrite(out.buf, 1, out.len, stdout);
|
fwrite(out.buf, 1, out.len, stdout);
|
||||||
putchar('\n');
|
putchar('\n');
|
||||||
}
|
}
|
||||||
|
strbuf_release(&err);
|
||||||
strbuf_release(&out);
|
strbuf_release(&out);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
293
ref-filter.c
293
ref-filter.c
|
@ -101,22 +101,38 @@ static struct used_atom {
|
||||||
} *used_atom;
|
} *used_atom;
|
||||||
static int used_atom_cnt, need_tagged, need_symref;
|
static int used_atom_cnt, need_tagged, need_symref;
|
||||||
|
|
||||||
static void color_atom_parser(const struct ref_format *format, struct used_atom *atom, const char *color_value)
|
/*
|
||||||
|
* Expand string, append it to strbuf *sb, then return error code ret.
|
||||||
|
* Allow to save few lines of code.
|
||||||
|
*/
|
||||||
|
static int strbuf_addf_ret(struct strbuf *sb, int ret, const char *fmt, ...)
|
||||||
|
{
|
||||||
|
va_list ap;
|
||||||
|
va_start(ap, fmt);
|
||||||
|
strbuf_vaddf(sb, fmt, ap);
|
||||||
|
va_end(ap);
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
|
||||||
|
static int color_atom_parser(const struct ref_format *format, struct used_atom *atom,
|
||||||
|
const char *color_value, struct strbuf *err)
|
||||||
{
|
{
|
||||||
if (!color_value)
|
if (!color_value)
|
||||||
die(_("expected format: %%(color:<color>)"));
|
return strbuf_addf_ret(err, -1, _("expected format: %%(color:<color>)"));
|
||||||
if (color_parse(color_value, atom->u.color) < 0)
|
if (color_parse(color_value, atom->u.color) < 0)
|
||||||
die(_("unrecognized color: %%(color:%s)"), color_value);
|
return strbuf_addf_ret(err, -1, _("unrecognized color: %%(color:%s)"),
|
||||||
|
color_value);
|
||||||
/*
|
/*
|
||||||
* We check this after we've parsed the color, which lets us complain
|
* We check this after we've parsed the color, which lets us complain
|
||||||
* about syntactically bogus color names even if they won't be used.
|
* about syntactically bogus color names even if they won't be used.
|
||||||
*/
|
*/
|
||||||
if (!want_color(format->use_color))
|
if (!want_color(format->use_color))
|
||||||
color_parse("", atom->u.color);
|
color_parse("", atom->u.color);
|
||||||
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
static void refname_atom_parser_internal(struct refname_atom *atom,
|
static int refname_atom_parser_internal(struct refname_atom *atom, const char *arg,
|
||||||
const char *arg, const char *name)
|
const char *name, struct strbuf *err)
|
||||||
{
|
{
|
||||||
if (!arg)
|
if (!arg)
|
||||||
atom->option = R_NORMAL;
|
atom->option = R_NORMAL;
|
||||||
|
@ -126,16 +142,18 @@ static void refname_atom_parser_internal(struct refname_atom *atom,
|
||||||
skip_prefix(arg, "strip=", &arg)) {
|
skip_prefix(arg, "strip=", &arg)) {
|
||||||
atom->option = R_LSTRIP;
|
atom->option = R_LSTRIP;
|
||||||
if (strtol_i(arg, 10, &atom->lstrip))
|
if (strtol_i(arg, 10, &atom->lstrip))
|
||||||
die(_("Integer value expected refname:lstrip=%s"), arg);
|
return strbuf_addf_ret(err, -1, _("Integer value expected refname:lstrip=%s"), arg);
|
||||||
} else if (skip_prefix(arg, "rstrip=", &arg)) {
|
} else if (skip_prefix(arg, "rstrip=", &arg)) {
|
||||||
atom->option = R_RSTRIP;
|
atom->option = R_RSTRIP;
|
||||||
if (strtol_i(arg, 10, &atom->rstrip))
|
if (strtol_i(arg, 10, &atom->rstrip))
|
||||||
die(_("Integer value expected refname:rstrip=%s"), arg);
|
return strbuf_addf_ret(err, -1, _("Integer value expected refname:rstrip=%s"), arg);
|
||||||
} else
|
} else
|
||||||
die(_("unrecognized %%(%s) argument: %s"), name, arg);
|
return strbuf_addf_ret(err, -1, _("unrecognized %%(%s) argument: %s"), name, arg);
|
||||||
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
static void remote_ref_atom_parser(const struct ref_format *format, struct used_atom *atom, const char *arg)
|
static int remote_ref_atom_parser(const struct ref_format *format, struct used_atom *atom,
|
||||||
|
const char *arg, struct strbuf *err)
|
||||||
{
|
{
|
||||||
struct string_list params = STRING_LIST_INIT_DUP;
|
struct string_list params = STRING_LIST_INIT_DUP;
|
||||||
int i;
|
int i;
|
||||||
|
@ -145,9 +163,8 @@ static void remote_ref_atom_parser(const struct ref_format *format, struct used_
|
||||||
|
|
||||||
if (!arg) {
|
if (!arg) {
|
||||||
atom->u.remote_ref.option = RR_REF;
|
atom->u.remote_ref.option = RR_REF;
|
||||||
refname_atom_parser_internal(&atom->u.remote_ref.refname,
|
return refname_atom_parser_internal(&atom->u.remote_ref.refname,
|
||||||
arg, atom->name);
|
arg, atom->name, err);
|
||||||
return;
|
|
||||||
}
|
}
|
||||||
|
|
||||||
atom->u.remote_ref.nobracket = 0;
|
atom->u.remote_ref.nobracket = 0;
|
||||||
|
@ -170,29 +187,38 @@ static void remote_ref_atom_parser(const struct ref_format *format, struct used_
|
||||||
atom->u.remote_ref.push_remote = 1;
|
atom->u.remote_ref.push_remote = 1;
|
||||||
} else {
|
} else {
|
||||||
atom->u.remote_ref.option = RR_REF;
|
atom->u.remote_ref.option = RR_REF;
|
||||||
refname_atom_parser_internal(&atom->u.remote_ref.refname,
|
if (refname_atom_parser_internal(&atom->u.remote_ref.refname,
|
||||||
arg, atom->name);
|
arg, atom->name, err)) {
|
||||||
|
string_list_clear(¶ms, 0);
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
string_list_clear(¶ms, 0);
|
string_list_clear(¶ms, 0);
|
||||||
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
static void body_atom_parser(const struct ref_format *format, struct used_atom *atom, const char *arg)
|
static int body_atom_parser(const struct ref_format *format, struct used_atom *atom,
|
||||||
|
const char *arg, struct strbuf *err)
|
||||||
{
|
{
|
||||||
if (arg)
|
if (arg)
|
||||||
die(_("%%(body) does not take arguments"));
|
return strbuf_addf_ret(err, -1, _("%%(body) does not take arguments"));
|
||||||
atom->u.contents.option = C_BODY_DEP;
|
atom->u.contents.option = C_BODY_DEP;
|
||||||
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
static void subject_atom_parser(const struct ref_format *format, struct used_atom *atom, const char *arg)
|
static int subject_atom_parser(const struct ref_format *format, struct used_atom *atom,
|
||||||
|
const char *arg, struct strbuf *err)
|
||||||
{
|
{
|
||||||
if (arg)
|
if (arg)
|
||||||
die(_("%%(subject) does not take arguments"));
|
return strbuf_addf_ret(err, -1, _("%%(subject) does not take arguments"));
|
||||||
atom->u.contents.option = C_SUB;
|
atom->u.contents.option = C_SUB;
|
||||||
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
static void trailers_atom_parser(const struct ref_format *format, struct used_atom *atom, const char *arg)
|
static int trailers_atom_parser(const struct ref_format *format, struct used_atom *atom,
|
||||||
|
const char *arg, struct strbuf *err)
|
||||||
{
|
{
|
||||||
struct string_list params = STRING_LIST_INIT_DUP;
|
struct string_list params = STRING_LIST_INIT_DUP;
|
||||||
int i;
|
int i;
|
||||||
|
@ -205,15 +231,20 @@ static void trailers_atom_parser(const struct ref_format *format, struct used_at
|
||||||
atom->u.contents.trailer_opts.unfold = 1;
|
atom->u.contents.trailer_opts.unfold = 1;
|
||||||
else if (!strcmp(s, "only"))
|
else if (!strcmp(s, "only"))
|
||||||
atom->u.contents.trailer_opts.only_trailers = 1;
|
atom->u.contents.trailer_opts.only_trailers = 1;
|
||||||
else
|
else {
|
||||||
die(_("unknown %%(trailers) argument: %s"), s);
|
strbuf_addf(err, _("unknown %%(trailers) argument: %s"), s);
|
||||||
|
string_list_clear(¶ms, 0);
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
atom->u.contents.option = C_TRAILERS;
|
atom->u.contents.option = C_TRAILERS;
|
||||||
string_list_clear(¶ms, 0);
|
string_list_clear(¶ms, 0);
|
||||||
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
static void contents_atom_parser(const struct ref_format *format, struct used_atom *atom, const char *arg)
|
static int contents_atom_parser(const struct ref_format *format, struct used_atom *atom,
|
||||||
|
const char *arg, struct strbuf *err)
|
||||||
{
|
{
|
||||||
if (!arg)
|
if (!arg)
|
||||||
atom->u.contents.option = C_BARE;
|
atom->u.contents.option = C_BARE;
|
||||||
|
@ -225,16 +256,19 @@ static void contents_atom_parser(const struct ref_format *format, struct used_at
|
||||||
atom->u.contents.option = C_SUB;
|
atom->u.contents.option = C_SUB;
|
||||||
else if (skip_prefix(arg, "trailers", &arg)) {
|
else if (skip_prefix(arg, "trailers", &arg)) {
|
||||||
skip_prefix(arg, ":", &arg);
|
skip_prefix(arg, ":", &arg);
|
||||||
trailers_atom_parser(format, atom, *arg ? arg : NULL);
|
if (trailers_atom_parser(format, atom, *arg ? arg : NULL, err))
|
||||||
|
return -1;
|
||||||
} else if (skip_prefix(arg, "lines=", &arg)) {
|
} else if (skip_prefix(arg, "lines=", &arg)) {
|
||||||
atom->u.contents.option = C_LINES;
|
atom->u.contents.option = C_LINES;
|
||||||
if (strtoul_ui(arg, 10, &atom->u.contents.nlines))
|
if (strtoul_ui(arg, 10, &atom->u.contents.nlines))
|
||||||
die(_("positive value expected contents:lines=%s"), arg);
|
return strbuf_addf_ret(err, -1, _("positive value expected contents:lines=%s"), arg);
|
||||||
} else
|
} else
|
||||||
die(_("unrecognized %%(contents) argument: %s"), arg);
|
return strbuf_addf_ret(err, -1, _("unrecognized %%(contents) argument: %s"), arg);
|
||||||
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
static void objectname_atom_parser(const struct ref_format *format, struct used_atom *atom, const char *arg)
|
static int objectname_atom_parser(const struct ref_format *format, struct used_atom *atom,
|
||||||
|
const char *arg, struct strbuf *err)
|
||||||
{
|
{
|
||||||
if (!arg)
|
if (!arg)
|
||||||
atom->u.objectname.option = O_FULL;
|
atom->u.objectname.option = O_FULL;
|
||||||
|
@ -244,16 +278,18 @@ static void objectname_atom_parser(const struct ref_format *format, struct used_
|
||||||
atom->u.objectname.option = O_LENGTH;
|
atom->u.objectname.option = O_LENGTH;
|
||||||
if (strtoul_ui(arg, 10, &atom->u.objectname.length) ||
|
if (strtoul_ui(arg, 10, &atom->u.objectname.length) ||
|
||||||
atom->u.objectname.length == 0)
|
atom->u.objectname.length == 0)
|
||||||
die(_("positive value expected objectname:short=%s"), arg);
|
return strbuf_addf_ret(err, -1, _("positive value expected objectname:short=%s"), arg);
|
||||||
if (atom->u.objectname.length < MINIMUM_ABBREV)
|
if (atom->u.objectname.length < MINIMUM_ABBREV)
|
||||||
atom->u.objectname.length = MINIMUM_ABBREV;
|
atom->u.objectname.length = MINIMUM_ABBREV;
|
||||||
} else
|
} else
|
||||||
die(_("unrecognized %%(objectname) argument: %s"), arg);
|
return strbuf_addf_ret(err, -1, _("unrecognized %%(objectname) argument: %s"), arg);
|
||||||
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
static void refname_atom_parser(const struct ref_format *format, struct used_atom *atom, const char *arg)
|
static int refname_atom_parser(const struct ref_format *format, struct used_atom *atom,
|
||||||
|
const char *arg, struct strbuf *err)
|
||||||
{
|
{
|
||||||
refname_atom_parser_internal(&atom->u.refname, arg, atom->name);
|
return refname_atom_parser_internal(&atom->u.refname, arg, atom->name, err);
|
||||||
}
|
}
|
||||||
|
|
||||||
static align_type parse_align_position(const char *s)
|
static align_type parse_align_position(const char *s)
|
||||||
|
@ -267,7 +303,8 @@ static align_type parse_align_position(const char *s)
|
||||||
return -1;
|
return -1;
|
||||||
}
|
}
|
||||||
|
|
||||||
static void align_atom_parser(const struct ref_format *format, struct used_atom *atom, const char *arg)
|
static int align_atom_parser(const struct ref_format *format, struct used_atom *atom,
|
||||||
|
const char *arg, struct strbuf *err)
|
||||||
{
|
{
|
||||||
struct align *align = &atom->u.align;
|
struct align *align = &atom->u.align;
|
||||||
struct string_list params = STRING_LIST_INIT_DUP;
|
struct string_list params = STRING_LIST_INIT_DUP;
|
||||||
|
@ -275,7 +312,7 @@ static void align_atom_parser(const struct ref_format *format, struct used_atom
|
||||||
unsigned int width = ~0U;
|
unsigned int width = ~0U;
|
||||||
|
|
||||||
if (!arg)
|
if (!arg)
|
||||||
die(_("expected format: %%(align:<width>,<position>)"));
|
return strbuf_addf_ret(err, -1, _("expected format: %%(align:<width>,<position>)"));
|
||||||
|
|
||||||
align->position = ALIGN_LEFT;
|
align->position = ALIGN_LEFT;
|
||||||
|
|
||||||
|
@ -286,49 +323,65 @@ static void align_atom_parser(const struct ref_format *format, struct used_atom
|
||||||
|
|
||||||
if (skip_prefix(s, "position=", &s)) {
|
if (skip_prefix(s, "position=", &s)) {
|
||||||
position = parse_align_position(s);
|
position = parse_align_position(s);
|
||||||
if (position < 0)
|
if (position < 0) {
|
||||||
die(_("unrecognized position:%s"), s);
|
strbuf_addf(err, _("unrecognized position:%s"), s);
|
||||||
|
string_list_clear(¶ms, 0);
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
align->position = position;
|
align->position = position;
|
||||||
} else if (skip_prefix(s, "width=", &s)) {
|
} else if (skip_prefix(s, "width=", &s)) {
|
||||||
if (strtoul_ui(s, 10, &width))
|
if (strtoul_ui(s, 10, &width)) {
|
||||||
die(_("unrecognized width:%s"), s);
|
strbuf_addf(err, _("unrecognized width:%s"), s);
|
||||||
|
string_list_clear(¶ms, 0);
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
} else if (!strtoul_ui(s, 10, &width))
|
} else if (!strtoul_ui(s, 10, &width))
|
||||||
;
|
;
|
||||||
else if ((position = parse_align_position(s)) >= 0)
|
else if ((position = parse_align_position(s)) >= 0)
|
||||||
align->position = position;
|
align->position = position;
|
||||||
else
|
else {
|
||||||
die(_("unrecognized %%(align) argument: %s"), s);
|
strbuf_addf(err, _("unrecognized %%(align) argument: %s"), s);
|
||||||
|
string_list_clear(¶ms, 0);
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
if (width == ~0U)
|
if (width == ~0U) {
|
||||||
die(_("positive width expected with the %%(align) atom"));
|
string_list_clear(¶ms, 0);
|
||||||
|
return strbuf_addf_ret(err, -1, _("positive width expected with the %%(align) atom"));
|
||||||
|
}
|
||||||
align->width = width;
|
align->width = width;
|
||||||
string_list_clear(¶ms, 0);
|
string_list_clear(¶ms, 0);
|
||||||
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
static void if_atom_parser(const struct ref_format *format, struct used_atom *atom, const char *arg)
|
static int if_atom_parser(const struct ref_format *format, struct used_atom *atom,
|
||||||
|
const char *arg, struct strbuf *err)
|
||||||
{
|
{
|
||||||
if (!arg) {
|
if (!arg) {
|
||||||
atom->u.if_then_else.cmp_status = COMPARE_NONE;
|
atom->u.if_then_else.cmp_status = COMPARE_NONE;
|
||||||
return;
|
return 0;
|
||||||
} else if (skip_prefix(arg, "equals=", &atom->u.if_then_else.str)) {
|
} else if (skip_prefix(arg, "equals=", &atom->u.if_then_else.str)) {
|
||||||
atom->u.if_then_else.cmp_status = COMPARE_EQUAL;
|
atom->u.if_then_else.cmp_status = COMPARE_EQUAL;
|
||||||
} else if (skip_prefix(arg, "notequals=", &atom->u.if_then_else.str)) {
|
} else if (skip_prefix(arg, "notequals=", &atom->u.if_then_else.str)) {
|
||||||
atom->u.if_then_else.cmp_status = COMPARE_UNEQUAL;
|
atom->u.if_then_else.cmp_status = COMPARE_UNEQUAL;
|
||||||
} else {
|
} else
|
||||||
die(_("unrecognized %%(if) argument: %s"), arg);
|
return strbuf_addf_ret(err, -1, _("unrecognized %%(if) argument: %s"), arg);
|
||||||
}
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
static void head_atom_parser(const struct ref_format *format, struct used_atom *atom, const char *arg)
|
static int head_atom_parser(const struct ref_format *format, struct used_atom *atom,
|
||||||
|
const char *arg, struct strbuf *unused_err)
|
||||||
{
|
{
|
||||||
atom->u.head = resolve_refdup("HEAD", RESOLVE_REF_READING, NULL, NULL);
|
atom->u.head = resolve_refdup("HEAD", RESOLVE_REF_READING, NULL, NULL);
|
||||||
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
static struct {
|
static struct {
|
||||||
const char *name;
|
const char *name;
|
||||||
cmp_type cmp_type;
|
cmp_type cmp_type;
|
||||||
void (*parser)(const struct ref_format *format, struct used_atom *atom, const char *arg);
|
int (*parser)(const struct ref_format *format, struct used_atom *atom,
|
||||||
|
const char *arg, struct strbuf *err);
|
||||||
} valid_atom[] = {
|
} valid_atom[] = {
|
||||||
{ "refname" , FIELD_STR, refname_atom_parser },
|
{ "refname" , FIELD_STR, refname_atom_parser },
|
||||||
{ "objecttype" },
|
{ "objecttype" },
|
||||||
|
@ -387,7 +440,8 @@ struct ref_formatting_state {
|
||||||
|
|
||||||
struct atom_value {
|
struct atom_value {
|
||||||
const char *s;
|
const char *s;
|
||||||
void (*handler)(struct atom_value *atomv, struct ref_formatting_state *state);
|
int (*handler)(struct atom_value *atomv, struct ref_formatting_state *state,
|
||||||
|
struct strbuf *err);
|
||||||
uintmax_t value; /* used for sorting when not FIELD_STR */
|
uintmax_t value; /* used for sorting when not FIELD_STR */
|
||||||
struct used_atom *atom;
|
struct used_atom *atom;
|
||||||
};
|
};
|
||||||
|
@ -396,7 +450,8 @@ struct atom_value {
|
||||||
* Used to parse format string and sort specifiers
|
* Used to parse format string and sort specifiers
|
||||||
*/
|
*/
|
||||||
static int parse_ref_filter_atom(const struct ref_format *format,
|
static int parse_ref_filter_atom(const struct ref_format *format,
|
||||||
const char *atom, const char *ep)
|
const char *atom, const char *ep,
|
||||||
|
struct strbuf *err)
|
||||||
{
|
{
|
||||||
const char *sp;
|
const char *sp;
|
||||||
const char *arg;
|
const char *arg;
|
||||||
|
@ -406,7 +461,8 @@ static int parse_ref_filter_atom(const struct ref_format *format,
|
||||||
if (*sp == '*' && sp < ep)
|
if (*sp == '*' && sp < ep)
|
||||||
sp++; /* deref */
|
sp++; /* deref */
|
||||||
if (ep <= sp)
|
if (ep <= sp)
|
||||||
die(_("malformed field name: %.*s"), (int)(ep-atom), atom);
|
return strbuf_addf_ret(err, -1, _("malformed field name: %.*s"),
|
||||||
|
(int)(ep-atom), atom);
|
||||||
|
|
||||||
/* Do we have the atom already used elsewhere? */
|
/* Do we have the atom already used elsewhere? */
|
||||||
for (i = 0; i < used_atom_cnt; i++) {
|
for (i = 0; i < used_atom_cnt; i++) {
|
||||||
|
@ -432,7 +488,8 @@ static int parse_ref_filter_atom(const struct ref_format *format,
|
||||||
}
|
}
|
||||||
|
|
||||||
if (ARRAY_SIZE(valid_atom) <= i)
|
if (ARRAY_SIZE(valid_atom) <= i)
|
||||||
die(_("unknown field name: %.*s"), (int)(ep-atom), atom);
|
return strbuf_addf_ret(err, -1, _("unknown field name: %.*s"),
|
||||||
|
(int)(ep-atom), atom);
|
||||||
|
|
||||||
/* Add it in, including the deref prefix */
|
/* Add it in, including the deref prefix */
|
||||||
at = used_atom_cnt;
|
at = used_atom_cnt;
|
||||||
|
@ -451,8 +508,8 @@ static int parse_ref_filter_atom(const struct ref_format *format,
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
memset(&used_atom[at].u, 0, sizeof(used_atom[at].u));
|
memset(&used_atom[at].u, 0, sizeof(used_atom[at].u));
|
||||||
if (valid_atom[i].parser)
|
if (valid_atom[i].parser && valid_atom[i].parser(format, &used_atom[at], arg, err))
|
||||||
valid_atom[i].parser(format, &used_atom[at], arg);
|
return -1;
|
||||||
if (*atom == '*')
|
if (*atom == '*')
|
||||||
need_tagged = 1;
|
need_tagged = 1;
|
||||||
if (!strcmp(valid_atom[i].name, "symref"))
|
if (!strcmp(valid_atom[i].name, "symref"))
|
||||||
|
@ -481,7 +538,8 @@ static void quote_formatting(struct strbuf *s, const char *str, int quote_style)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
static void append_atom(struct atom_value *v, struct ref_formatting_state *state)
|
static int append_atom(struct atom_value *v, struct ref_formatting_state *state,
|
||||||
|
struct strbuf *unused_err)
|
||||||
{
|
{
|
||||||
/*
|
/*
|
||||||
* Quote formatting is only done when the stack has a single
|
* Quote formatting is only done when the stack has a single
|
||||||
|
@ -493,6 +551,7 @@ static void append_atom(struct atom_value *v, struct ref_formatting_state *state
|
||||||
quote_formatting(&state->stack->output, v->s, state->quote_style);
|
quote_formatting(&state->stack->output, v->s, state->quote_style);
|
||||||
else
|
else
|
||||||
strbuf_addstr(&state->stack->output, v->s);
|
strbuf_addstr(&state->stack->output, v->s);
|
||||||
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
static void push_stack_element(struct ref_formatting_stack **stack)
|
static void push_stack_element(struct ref_formatting_stack **stack)
|
||||||
|
@ -527,7 +586,8 @@ static void end_align_handler(struct ref_formatting_stack **stack)
|
||||||
strbuf_release(&s);
|
strbuf_release(&s);
|
||||||
}
|
}
|
||||||
|
|
||||||
static void align_atom_handler(struct atom_value *atomv, struct ref_formatting_state *state)
|
static int align_atom_handler(struct atom_value *atomv, struct ref_formatting_state *state,
|
||||||
|
struct strbuf *unused_err)
|
||||||
{
|
{
|
||||||
struct ref_formatting_stack *new_stack;
|
struct ref_formatting_stack *new_stack;
|
||||||
|
|
||||||
|
@ -535,6 +595,7 @@ static void align_atom_handler(struct atom_value *atomv, struct ref_formatting_s
|
||||||
new_stack = state->stack;
|
new_stack = state->stack;
|
||||||
new_stack->at_end = end_align_handler;
|
new_stack->at_end = end_align_handler;
|
||||||
new_stack->at_end_data = &atomv->atom->u.align;
|
new_stack->at_end_data = &atomv->atom->u.align;
|
||||||
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
static void if_then_else_handler(struct ref_formatting_stack **stack)
|
static void if_then_else_handler(struct ref_formatting_stack **stack)
|
||||||
|
@ -572,7 +633,8 @@ static void if_then_else_handler(struct ref_formatting_stack **stack)
|
||||||
free(if_then_else);
|
free(if_then_else);
|
||||||
}
|
}
|
||||||
|
|
||||||
static void if_atom_handler(struct atom_value *atomv, struct ref_formatting_state *state)
|
static int if_atom_handler(struct atom_value *atomv, struct ref_formatting_state *state,
|
||||||
|
struct strbuf *unused_err)
|
||||||
{
|
{
|
||||||
struct ref_formatting_stack *new_stack;
|
struct ref_formatting_stack *new_stack;
|
||||||
struct if_then_else *if_then_else = xcalloc(sizeof(struct if_then_else), 1);
|
struct if_then_else *if_then_else = xcalloc(sizeof(struct if_then_else), 1);
|
||||||
|
@ -584,6 +646,7 @@ static void if_atom_handler(struct atom_value *atomv, struct ref_formatting_stat
|
||||||
new_stack = state->stack;
|
new_stack = state->stack;
|
||||||
new_stack->at_end = if_then_else_handler;
|
new_stack->at_end = if_then_else_handler;
|
||||||
new_stack->at_end_data = if_then_else;
|
new_stack->at_end_data = if_then_else;
|
||||||
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
static int is_empty(const char *s)
|
static int is_empty(const char *s)
|
||||||
|
@ -596,7 +659,8 @@ static int is_empty(const char *s)
|
||||||
return 1;
|
return 1;
|
||||||
}
|
}
|
||||||
|
|
||||||
static void then_atom_handler(struct atom_value *atomv, struct ref_formatting_state *state)
|
static int then_atom_handler(struct atom_value *atomv, struct ref_formatting_state *state,
|
||||||
|
struct strbuf *err)
|
||||||
{
|
{
|
||||||
struct ref_formatting_stack *cur = state->stack;
|
struct ref_formatting_stack *cur = state->stack;
|
||||||
struct if_then_else *if_then_else = NULL;
|
struct if_then_else *if_then_else = NULL;
|
||||||
|
@ -604,11 +668,11 @@ static void then_atom_handler(struct atom_value *atomv, struct ref_formatting_st
|
||||||
if (cur->at_end == if_then_else_handler)
|
if (cur->at_end == if_then_else_handler)
|
||||||
if_then_else = (struct if_then_else *)cur->at_end_data;
|
if_then_else = (struct if_then_else *)cur->at_end_data;
|
||||||
if (!if_then_else)
|
if (!if_then_else)
|
||||||
die(_("format: %%(then) atom used without an %%(if) atom"));
|
return strbuf_addf_ret(err, -1, _("format: %%(then) atom used without an %%(if) atom"));
|
||||||
if (if_then_else->then_atom_seen)
|
if (if_then_else->then_atom_seen)
|
||||||
die(_("format: %%(then) atom used more than once"));
|
return strbuf_addf_ret(err, -1, _("format: %%(then) atom used more than once"));
|
||||||
if (if_then_else->else_atom_seen)
|
if (if_then_else->else_atom_seen)
|
||||||
die(_("format: %%(then) atom used after %%(else)"));
|
return strbuf_addf_ret(err, -1, _("format: %%(then) atom used after %%(else)"));
|
||||||
if_then_else->then_atom_seen = 1;
|
if_then_else->then_atom_seen = 1;
|
||||||
/*
|
/*
|
||||||
* If the 'equals' or 'notequals' attribute is used then
|
* If the 'equals' or 'notequals' attribute is used then
|
||||||
|
@ -624,9 +688,11 @@ static void then_atom_handler(struct atom_value *atomv, struct ref_formatting_st
|
||||||
} else if (cur->output.len && !is_empty(cur->output.buf))
|
} else if (cur->output.len && !is_empty(cur->output.buf))
|
||||||
if_then_else->condition_satisfied = 1;
|
if_then_else->condition_satisfied = 1;
|
||||||
strbuf_reset(&cur->output);
|
strbuf_reset(&cur->output);
|
||||||
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
static void else_atom_handler(struct atom_value *atomv, struct ref_formatting_state *state)
|
static int else_atom_handler(struct atom_value *atomv, struct ref_formatting_state *state,
|
||||||
|
struct strbuf *err)
|
||||||
{
|
{
|
||||||
struct ref_formatting_stack *prev = state->stack;
|
struct ref_formatting_stack *prev = state->stack;
|
||||||
struct if_then_else *if_then_else = NULL;
|
struct if_then_else *if_then_else = NULL;
|
||||||
|
@ -634,24 +700,26 @@ static void else_atom_handler(struct atom_value *atomv, struct ref_formatting_st
|
||||||
if (prev->at_end == if_then_else_handler)
|
if (prev->at_end == if_then_else_handler)
|
||||||
if_then_else = (struct if_then_else *)prev->at_end_data;
|
if_then_else = (struct if_then_else *)prev->at_end_data;
|
||||||
if (!if_then_else)
|
if (!if_then_else)
|
||||||
die(_("format: %%(else) atom used without an %%(if) atom"));
|
return strbuf_addf_ret(err, -1, _("format: %%(else) atom used without an %%(if) atom"));
|
||||||
if (!if_then_else->then_atom_seen)
|
if (!if_then_else->then_atom_seen)
|
||||||
die(_("format: %%(else) atom used without a %%(then) atom"));
|
return strbuf_addf_ret(err, -1, _("format: %%(else) atom used without a %%(then) atom"));
|
||||||
if (if_then_else->else_atom_seen)
|
if (if_then_else->else_atom_seen)
|
||||||
die(_("format: %%(else) atom used more than once"));
|
return strbuf_addf_ret(err, -1, _("format: %%(else) atom used more than once"));
|
||||||
if_then_else->else_atom_seen = 1;
|
if_then_else->else_atom_seen = 1;
|
||||||
push_stack_element(&state->stack);
|
push_stack_element(&state->stack);
|
||||||
state->stack->at_end_data = prev->at_end_data;
|
state->stack->at_end_data = prev->at_end_data;
|
||||||
state->stack->at_end = prev->at_end;
|
state->stack->at_end = prev->at_end;
|
||||||
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
static void end_atom_handler(struct atom_value *atomv, struct ref_formatting_state *state)
|
static int end_atom_handler(struct atom_value *atomv, struct ref_formatting_state *state,
|
||||||
|
struct strbuf *err)
|
||||||
{
|
{
|
||||||
struct ref_formatting_stack *current = state->stack;
|
struct ref_formatting_stack *current = state->stack;
|
||||||
struct strbuf s = STRBUF_INIT;
|
struct strbuf s = STRBUF_INIT;
|
||||||
|
|
||||||
if (!current->at_end)
|
if (!current->at_end)
|
||||||
die(_("format: %%(end) atom used without corresponding atom"));
|
return strbuf_addf_ret(err, -1, _("format: %%(end) atom used without corresponding atom"));
|
||||||
current->at_end(&state->stack);
|
current->at_end(&state->stack);
|
||||||
|
|
||||||
/* Stack may have been popped within at_end(), hence reset the current pointer */
|
/* Stack may have been popped within at_end(), hence reset the current pointer */
|
||||||
|
@ -668,6 +736,7 @@ static void end_atom_handler(struct atom_value *atomv, struct ref_formatting_sta
|
||||||
}
|
}
|
||||||
strbuf_release(&s);
|
strbuf_release(&s);
|
||||||
pop_stack_element(&state->stack);
|
pop_stack_element(&state->stack);
|
||||||
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
/*
|
/*
|
||||||
|
@ -702,17 +771,21 @@ int verify_ref_format(struct ref_format *format)
|
||||||
|
|
||||||
format->need_color_reset_at_eol = 0;
|
format->need_color_reset_at_eol = 0;
|
||||||
for (cp = format->format; *cp && (sp = find_next(cp)); ) {
|
for (cp = format->format; *cp && (sp = find_next(cp)); ) {
|
||||||
|
struct strbuf err = STRBUF_INIT;
|
||||||
const char *color, *ep = strchr(sp, ')');
|
const char *color, *ep = strchr(sp, ')');
|
||||||
int at;
|
int at;
|
||||||
|
|
||||||
if (!ep)
|
if (!ep)
|
||||||
return error(_("malformed format string %s"), sp);
|
return error(_("malformed format string %s"), sp);
|
||||||
/* sp points at "%(" and ep points at the closing ")" */
|
/* sp points at "%(" and ep points at the closing ")" */
|
||||||
at = parse_ref_filter_atom(format, sp + 2, ep);
|
at = parse_ref_filter_atom(format, sp + 2, ep, &err);
|
||||||
|
if (at < 0)
|
||||||
|
die("%s", err.buf);
|
||||||
cp = ep + 1;
|
cp = ep + 1;
|
||||||
|
|
||||||
if (skip_prefix(used_atom[at].name, "color:", &color))
|
if (skip_prefix(used_atom[at].name, "color:", &color))
|
||||||
format->need_color_reset_at_eol = !!strcmp(color, "reset");
|
format->need_color_reset_at_eol = !!strcmp(color, "reset");
|
||||||
|
strbuf_release(&err);
|
||||||
}
|
}
|
||||||
if (format->need_color_reset_at_eol && !want_color(format->use_color))
|
if (format->need_color_reset_at_eol && !want_color(format->use_color))
|
||||||
format->need_color_reset_at_eol = 0;
|
format->need_color_reset_at_eol = 0;
|
||||||
|
@ -1358,28 +1431,30 @@ static const char *get_refname(struct used_atom *atom, struct ref_array_item *re
|
||||||
return show_ref(&atom->u.refname, ref->refname);
|
return show_ref(&atom->u.refname, ref->refname);
|
||||||
}
|
}
|
||||||
|
|
||||||
static void get_object(struct ref_array_item *ref, const struct object_id *oid,
|
static int get_object(struct ref_array_item *ref, const struct object_id *oid,
|
||||||
int deref, struct object **obj)
|
int deref, struct object **obj, struct strbuf *err)
|
||||||
{
|
{
|
||||||
int eaten;
|
int eaten;
|
||||||
|
int ret = 0;
|
||||||
unsigned long size;
|
unsigned long size;
|
||||||
void *buf = get_obj(oid, obj, &size, &eaten);
|
void *buf = get_obj(oid, obj, &size, &eaten);
|
||||||
if (!buf)
|
if (!buf)
|
||||||
die(_("missing object %s for %s"),
|
ret = strbuf_addf_ret(err, -1, _("missing object %s for %s"),
|
||||||
oid_to_hex(oid), ref->refname);
|
oid_to_hex(oid), ref->refname);
|
||||||
if (!*obj)
|
else if (!*obj)
|
||||||
die(_("parse_object_buffer failed on %s for %s"),
|
ret = strbuf_addf_ret(err, -1, _("parse_object_buffer failed on %s for %s"),
|
||||||
oid_to_hex(oid), ref->refname);
|
oid_to_hex(oid), ref->refname);
|
||||||
|
else
|
||||||
grab_values(ref->value, deref, *obj, buf, size);
|
grab_values(ref->value, deref, *obj, buf, size);
|
||||||
if (!eaten)
|
if (!eaten)
|
||||||
free(buf);
|
free(buf);
|
||||||
|
return ret;
|
||||||
}
|
}
|
||||||
|
|
||||||
/*
|
/*
|
||||||
* Parse the object referred by ref, and grab needed value.
|
* Parse the object referred by ref, and grab needed value.
|
||||||
*/
|
*/
|
||||||
static void populate_value(struct ref_array_item *ref)
|
static int populate_value(struct ref_array_item *ref, struct strbuf *err)
|
||||||
{
|
{
|
||||||
struct object *obj;
|
struct object *obj;
|
||||||
int i;
|
int i;
|
||||||
|
@ -1501,16 +1576,17 @@ static void populate_value(struct ref_array_item *ref)
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
if (used_atom_cnt <= i)
|
if (used_atom_cnt <= i)
|
||||||
return;
|
return 0;
|
||||||
|
|
||||||
get_object(ref, &ref->objectname, 0, &obj);
|
if (get_object(ref, &ref->objectname, 0, &obj, err))
|
||||||
|
return -1;
|
||||||
|
|
||||||
/*
|
/*
|
||||||
* If there is no atom that wants to know about tagged
|
* If there is no atom that wants to know about tagged
|
||||||
* object, we are done.
|
* object, we are done.
|
||||||
*/
|
*/
|
||||||
if (!need_tagged || (obj->type != OBJ_TAG))
|
if (!need_tagged || (obj->type != OBJ_TAG))
|
||||||
return;
|
return 0;
|
||||||
|
|
||||||
/*
|
/*
|
||||||
* If it is a tag object, see if we use a value that derefs
|
* If it is a tag object, see if we use a value that derefs
|
||||||
|
@ -1524,20 +1600,23 @@ static void populate_value(struct ref_array_item *ref)
|
||||||
* is not consistent with what deref_tag() does
|
* is not consistent with what deref_tag() does
|
||||||
* which peels the onion to the core.
|
* which peels the onion to the core.
|
||||||
*/
|
*/
|
||||||
get_object(ref, tagged, 1, &obj);
|
return get_object(ref, tagged, 1, &obj, err);
|
||||||
}
|
}
|
||||||
|
|
||||||
/*
|
/*
|
||||||
* Given a ref, return the value for the atom. This lazily gets value
|
* Given a ref, return the value for the atom. This lazily gets value
|
||||||
* out of the object by calling populate value.
|
* out of the object by calling populate value.
|
||||||
*/
|
*/
|
||||||
static void get_ref_atom_value(struct ref_array_item *ref, int atom, struct atom_value **v)
|
static int get_ref_atom_value(struct ref_array_item *ref, int atom,
|
||||||
|
struct atom_value **v, struct strbuf *err)
|
||||||
{
|
{
|
||||||
if (!ref->value) {
|
if (!ref->value) {
|
||||||
populate_value(ref);
|
if (populate_value(ref, err))
|
||||||
|
return -1;
|
||||||
fill_missing_values(ref->value);
|
fill_missing_values(ref->value);
|
||||||
}
|
}
|
||||||
*v = &ref->value[atom];
|
*v = &ref->value[atom];
|
||||||
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
/*
|
/*
|
||||||
|
@ -2075,9 +2154,13 @@ static int cmp_ref_sorting(struct ref_sorting *s, struct ref_array_item *a, stru
|
||||||
int cmp;
|
int cmp;
|
||||||
cmp_type cmp_type = used_atom[s->atom].type;
|
cmp_type cmp_type = used_atom[s->atom].type;
|
||||||
int (*cmp_fn)(const char *, const char *);
|
int (*cmp_fn)(const char *, const char *);
|
||||||
|
struct strbuf err = STRBUF_INIT;
|
||||||
|
|
||||||
get_ref_atom_value(a, s->atom, &va);
|
if (get_ref_atom_value(a, s->atom, &va, &err))
|
||||||
get_ref_atom_value(b, s->atom, &vb);
|
die("%s", err.buf);
|
||||||
|
if (get_ref_atom_value(b, s->atom, &vb, &err))
|
||||||
|
die("%s", err.buf);
|
||||||
|
strbuf_release(&err);
|
||||||
cmp_fn = s->ignore_case ? strcasecmp : strcmp;
|
cmp_fn = s->ignore_case ? strcasecmp : strcmp;
|
||||||
if (s->version)
|
if (s->version)
|
||||||
cmp = versioncmp(va->s, vb->s);
|
cmp = versioncmp(va->s, vb->s);
|
||||||
|
@ -2136,9 +2219,10 @@ static void append_literal(const char *cp, const char *ep, struct ref_formatting
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
void format_ref_array_item(struct ref_array_item *info,
|
int format_ref_array_item(struct ref_array_item *info,
|
||||||
const struct ref_format *format,
|
const struct ref_format *format,
|
||||||
struct strbuf *final_buf)
|
struct strbuf *final_buf,
|
||||||
|
struct strbuf *error_buf)
|
||||||
{
|
{
|
||||||
const char *cp, *sp, *ep;
|
const char *cp, *sp, *ep;
|
||||||
struct ref_formatting_state state = REF_FORMATTING_STATE_INIT;
|
struct ref_formatting_state state = REF_FORMATTING_STATE_INIT;
|
||||||
|
@ -2148,14 +2232,17 @@ void format_ref_array_item(struct ref_array_item *info,
|
||||||
|
|
||||||
for (cp = format->format; *cp && (sp = find_next(cp)); cp = ep + 1) {
|
for (cp = format->format; *cp && (sp = find_next(cp)); cp = ep + 1) {
|
||||||
struct atom_value *atomv;
|
struct atom_value *atomv;
|
||||||
|
int pos;
|
||||||
|
|
||||||
ep = strchr(sp, ')');
|
ep = strchr(sp, ')');
|
||||||
if (cp < sp)
|
if (cp < sp)
|
||||||
append_literal(cp, sp, &state);
|
append_literal(cp, sp, &state);
|
||||||
get_ref_atom_value(info,
|
pos = parse_ref_filter_atom(format, sp + 2, ep, error_buf);
|
||||||
parse_ref_filter_atom(format, sp + 2, ep),
|
if (pos < 0 || get_ref_atom_value(info, pos, &atomv, error_buf) ||
|
||||||
&atomv);
|
atomv->handler(atomv, &state, error_buf)) {
|
||||||
atomv->handler(atomv, &state);
|
pop_stack_element(&state.stack);
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
}
|
}
|
||||||
if (*cp) {
|
if (*cp) {
|
||||||
sp = cp + strlen(cp);
|
sp = cp + strlen(cp);
|
||||||
|
@ -2164,21 +2251,30 @@ void format_ref_array_item(struct ref_array_item *info,
|
||||||
if (format->need_color_reset_at_eol) {
|
if (format->need_color_reset_at_eol) {
|
||||||
struct atom_value resetv;
|
struct atom_value resetv;
|
||||||
resetv.s = GIT_COLOR_RESET;
|
resetv.s = GIT_COLOR_RESET;
|
||||||
append_atom(&resetv, &state);
|
if (append_atom(&resetv, &state, error_buf)) {
|
||||||
|
pop_stack_element(&state.stack);
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if (state.stack->prev) {
|
||||||
|
pop_stack_element(&state.stack);
|
||||||
|
return strbuf_addf_ret(error_buf, -1, _("format: %%(end) atom missing"));
|
||||||
}
|
}
|
||||||
if (state.stack->prev)
|
|
||||||
die(_("format: %%(end) atom missing"));
|
|
||||||
strbuf_addbuf(final_buf, &state.stack->output);
|
strbuf_addbuf(final_buf, &state.stack->output);
|
||||||
pop_stack_element(&state.stack);
|
pop_stack_element(&state.stack);
|
||||||
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
void show_ref_array_item(struct ref_array_item *info,
|
void show_ref_array_item(struct ref_array_item *info,
|
||||||
const struct ref_format *format)
|
const struct ref_format *format)
|
||||||
{
|
{
|
||||||
struct strbuf final_buf = STRBUF_INIT;
|
struct strbuf final_buf = STRBUF_INIT;
|
||||||
|
struct strbuf error_buf = STRBUF_INIT;
|
||||||
|
|
||||||
format_ref_array_item(info, format, &final_buf);
|
if (format_ref_array_item(info, format, &final_buf, &error_buf))
|
||||||
|
die("%s", error_buf.buf);
|
||||||
fwrite(final_buf.buf, 1, final_buf.len, stdout);
|
fwrite(final_buf.buf, 1, final_buf.len, stdout);
|
||||||
|
strbuf_release(&error_buf);
|
||||||
strbuf_release(&final_buf);
|
strbuf_release(&final_buf);
|
||||||
putchar('\n');
|
putchar('\n');
|
||||||
}
|
}
|
||||||
|
@ -2201,7 +2297,12 @@ static int parse_sorting_atom(const char *atom)
|
||||||
*/
|
*/
|
||||||
struct ref_format dummy = REF_FORMAT_INIT;
|
struct ref_format dummy = REF_FORMAT_INIT;
|
||||||
const char *end = atom + strlen(atom);
|
const char *end = atom + strlen(atom);
|
||||||
return parse_ref_filter_atom(&dummy, atom, end);
|
struct strbuf err = STRBUF_INIT;
|
||||||
|
int res = parse_ref_filter_atom(&dummy, atom, end, &err);
|
||||||
|
if (res < 0)
|
||||||
|
die("%s", err.buf);
|
||||||
|
strbuf_release(&err);
|
||||||
|
return res;
|
||||||
}
|
}
|
||||||
|
|
||||||
/* If no sorting option is given, use refname to sort as default */
|
/* If no sorting option is given, use refname to sort as default */
|
||||||
|
|
|
@ -110,9 +110,10 @@ int verify_ref_format(struct ref_format *format);
|
||||||
/* Sort the given ref_array as per the ref_sorting provided */
|
/* Sort the given ref_array as per the ref_sorting provided */
|
||||||
void ref_array_sort(struct ref_sorting *sort, struct ref_array *array);
|
void ref_array_sort(struct ref_sorting *sort, struct ref_array *array);
|
||||||
/* Based on the given format and quote_style, fill the strbuf */
|
/* Based on the given format and quote_style, fill the strbuf */
|
||||||
void format_ref_array_item(struct ref_array_item *info,
|
int format_ref_array_item(struct ref_array_item *info,
|
||||||
const struct ref_format *format,
|
const struct ref_format *format,
|
||||||
struct strbuf *final_buf);
|
struct strbuf *final_buf,
|
||||||
|
struct strbuf *error_buf);
|
||||||
/* Print the ref using the given format and quote_style */
|
/* Print the ref using the given format and quote_style */
|
||||||
void show_ref_array_item(struct ref_array_item *info, const struct ref_format *format);
|
void show_ref_array_item(struct ref_array_item *info, const struct ref_format *format);
|
||||||
/* Parse a single sort specifier and add it to the list */
|
/* Parse a single sort specifier and add it to the list */
|
||||||
|
|
Loading…
Reference in New Issue