Skip to content

Commit

Permalink
update-ref --stdin: read the whole input at once
Browse files Browse the repository at this point in the history 
Read the whole input into a strbuf at once, and then parse it from
there.  This might also be a tad faster, but that is not the point.
The point is to decouple the parsing code from the input source (the
old parsing code had to read new data even in the middle of commands).
Add docstrings for the parsing functions.

Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
  • Loading branch information
Michael Haggerty authored and Junio C Hamano committed Apr 7, 2014
1 parent 595deb8 commit e23d843
Showing 1 changed file with 108 additions and 62 deletions.
170 changes: 108 additions & 62 deletions builtin/update-ref.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -85,44 +85,70 @@ static const char *parse_arg(const char *next, struct strbuf *arg)
return next;
}

static const char *parse_first_arg(const char *next, struct strbuf *arg)
/*
* Parse the argument immediately after "command SP". If not -z, then
* handle C-quoting. Write the argument to arg. Set *next to point
* at the character that terminates the argument. Die if C-quoting is
* malformed.
*/
static void parse_first_arg(struct strbuf *input, const char **next,
struct strbuf *arg)
{
/* Parse argument immediately after "command SP" */
strbuf_reset(arg);
if (line_termination) {
/* Without -z, use the next argument */
next = parse_arg(next, arg);
*next = parse_arg(*next, arg);
} else {
/* With -z, use rest of first NUL-terminated line */
strbuf_addstr(arg, next);
next = next + arg->len;
/* With -z, use everything up to the next NUL */
strbuf_addstr(arg, *next);
*next += arg->len;
}
return next;
}

static const char *parse_next_arg(const char *next, struct strbuf *arg)
/*
* Parse a SP/NUL separator followed by the next SP- or NUL-terminated
* argument, if any. If there is an argument, write it to arg, set
* *next to point at the character terminating the argument, and
* return 0. If there is no argument at all (not even the empty
* string), return a non-zero result and leave *next unchanged.
*/
static int parse_next_arg(struct strbuf *input, const char **next,
struct strbuf *arg)
{
/* Parse next SP-terminated or NUL-terminated argument, if any */
strbuf_reset(arg);
if (line_termination) {
/* Without -z, consume SP and use next argument */
if (!*next)
return NULL;
if (*next != ' ')
die("expected SP but got: %s", next);
next = parse_arg(next + 1, arg);
if (!**next || **next == line_termination)
return -1;
if (**next != ' ')
die("expected SP but got: %s", *next);
(*next)++;
*next = parse_arg(*next, arg);
} else {
/* With -z, read the next NUL-terminated line */
if (*next)
die("expected NUL but got: %s", next);
if (strbuf_getline(arg, stdin, '\0') == EOF)
return NULL;
next = arg->buf + arg->len;
if (**next)
die("expected NUL but got: %s", *next);
(*next)++;
if (*next == input->buf + input->len)
return -1;
strbuf_addstr(arg, *next);
*next += arg->len;
}
return next;
return 0;
}

static void parse_cmd_update(const char *next)

/*
* The following five parse_cmd_*() functions parse the corresponding
* command. In each case, next points at the character following the
* command name and the following space. They each return a pointer
* to the character terminating the command, and die with an
* explanatory message if there are any parsing problems. All of
* these functions handle either text or binary format input,
* depending on how line_termination is set.
*/

static const char *parse_cmd_update(struct strbuf *input, const char *next)
{
struct strbuf ref = STRBUF_INIT;
struct strbuf newvalue = STRBUF_INIT;
Expand All @@ -131,128 +157,148 @@ static void parse_cmd_update(const char *next)

update = update_alloc();

if ((next = parse_first_arg(next, &ref)) != NULL && ref.buf[0])
parse_first_arg(input, &next, &ref);
if (ref.buf[0])
update_store_ref_name(update, ref.buf);
else
die("update line missing <ref>");

if ((next = parse_next_arg(next, &newvalue)) != NULL)
if (!parse_next_arg(input, &next, &newvalue))
update_store_new_sha1(update, newvalue.buf);
else
die("update %s missing <newvalue>", ref.buf);

if ((next = parse_next_arg(next, &oldvalue)) != NULL)
if (!parse_next_arg(input, &next, &oldvalue)) {
update_store_old_sha1(update, oldvalue.buf);
else if(!line_termination)
if (*next != line_termination)
die("update %s has extra input: %s", ref.buf, next);
} else if (!line_termination)
die("update %s missing [<oldvalue>] NUL", ref.buf);

if (next && *next)
die("update %s has extra input: %s", ref.buf, next);
return next;
}

static void parse_cmd_create(const char *next)
static const char *parse_cmd_create(struct strbuf *input, const char *next)
{
struct strbuf ref = STRBUF_INIT;
struct strbuf newvalue = STRBUF_INIT;
struct ref_update *update;

update = update_alloc();

if ((next = parse_first_arg(next, &ref)) != NULL && ref.buf[0])
parse_first_arg(input, &next, &ref);
if (ref.buf[0])
update_store_ref_name(update, ref.buf);
else
die("create line missing <ref>");

if ((next = parse_next_arg(next, &newvalue)) != NULL)
if (!parse_next_arg(input, &next, &newvalue))
update_store_new_sha1(update, newvalue.buf);
else
die("create %s missing <newvalue>", ref.buf);

if (is_null_sha1(update->new_sha1))
die("create %s given zero new value", ref.buf);

if (next && *next)
if (*next != line_termination)
die("create %s has extra input: %s", ref.buf, next);

return next;
}

static void parse_cmd_delete(const char *next)
static const char *parse_cmd_delete(struct strbuf *input, const char *next)
{
struct strbuf ref = STRBUF_INIT;
struct strbuf oldvalue = STRBUF_INIT;
struct ref_update *update;

update = update_alloc();

if ((next = parse_first_arg(next, &ref)) != NULL && ref.buf[0])
parse_first_arg(input, &next, &ref);
if (ref.buf[0])
update_store_ref_name(update, ref.buf);
else
die("delete line missing <ref>");

if ((next = parse_next_arg(next, &oldvalue)) != NULL)
if (!parse_next_arg(input, &next, &oldvalue)) {
update_store_old_sha1(update, oldvalue.buf);
else if(!line_termination)
if (update->have_old && is_null_sha1(update->old_sha1))
die("delete %s given zero old value", ref.buf);
} else if (!line_termination)
die("delete %s missing [<oldvalue>] NUL", ref.buf);
if (update->have_old && is_null_sha1(update->old_sha1))
die("delete %s given zero old value", ref.buf);

if (next && *next)
if (*next != line_termination)
die("delete %s has extra input: %s", ref.buf, next);

return next;
}

static void parse_cmd_verify(const char *next)
static const char *parse_cmd_verify(struct strbuf *input, const char *next)
{
struct strbuf ref = STRBUF_INIT;
struct strbuf value = STRBUF_INIT;
struct ref_update *update;

update = update_alloc();

if ((next = parse_first_arg(next, &ref)) != NULL && ref.buf[0])
parse_first_arg(input, &next, &ref);
if (ref.buf[0])
update_store_ref_name(update, ref.buf);
else
die("verify line missing <ref>");

if ((next = parse_next_arg(next, &value)) != NULL) {
if (!parse_next_arg(input, &next, &value)) {
update_store_old_sha1(update, value.buf);
update_store_new_sha1(update, value.buf);
} else if(!line_termination)
} else if (!line_termination)
die("verify %s missing [<oldvalue>] NUL", ref.buf);

if (next && *next)
if (*next != line_termination)
die("verify %s has extra input: %s", ref.buf, next);

return next;
}

static void parse_cmd_option(const char *next)
static const char *parse_cmd_option(struct strbuf *input, const char *next)
{
if (!strcmp(next, "no-deref"))
if (!strncmp(next, "no-deref", 8) && next[8] == line_termination)
update_flags |= REF_NODEREF;
else
die("option unknown: %s", next);
return next + 8;
}

static void update_refs_stdin(void)
{
struct strbuf cmd = STRBUF_INIT;
struct strbuf input = STRBUF_INIT;
const char *next;

if (strbuf_read(&input, 0, 1000) < 0)
die_errno("could not read from stdin");
next = input.buf;
/* Read each line dispatch its command */
while (strbuf_getline(&cmd, stdin, line_termination) != EOF)
if (!cmd.buf[0])
while (next < input.buf + input.len) {
if (*next == line_termination)
die("empty command in input");
else if (isspace(*cmd.buf))
die("whitespace before command: %s", cmd.buf);
else if (starts_with(cmd.buf, "update "))
parse_cmd_update(cmd.buf + 7);
else if (starts_with(cmd.buf, "create "))
parse_cmd_create(cmd.buf + 7);
else if (starts_with(cmd.buf, "delete "))
parse_cmd_delete(cmd.buf + 7);
else if (starts_with(cmd.buf, "verify "))
parse_cmd_verify(cmd.buf + 7);
else if (starts_with(cmd.buf, "option "))
parse_cmd_option(cmd.buf + 7);
else if (isspace(*next))
die("whitespace before command: %s", next);
else if (starts_with(next, "update "))
next = parse_cmd_update(&input, next + 7);
else if (starts_with(next, "create "))
next = parse_cmd_create(&input, next + 7);
else if (starts_with(next, "delete "))
next = parse_cmd_delete(&input, next + 7);
else if (starts_with(next, "verify "))
next = parse_cmd_verify(&input, next + 7);
else if (starts_with(next, "option "))
next = parse_cmd_option(&input, next + 7);
else
die("unknown command: %s", cmd.buf);
die("unknown command: %s", next);

next++;
}

strbuf_release(&cmd);
strbuf_release(&input);
}

int cmd_update_ref(int argc, const char **argv, const char *prefix)
Expand Down

0 comments on commit e23d843

Please sign in to comment.