monitor: refactor whitespace and optional argument parsing

Takes out the optional ('?') message parsing from the main switch loop
in monitor_parse_command. Adds optional argument option for boolean parameters.

Signed-off-by: Alon Levy <alevy@redhat.com>
---
Previous patch used qemu_free (that's how old it is), fixed.

 monitor.c |   79 +++++++++++++++++++++++-------------------------------------
 1 files changed, 30 insertions(+), 49 deletions(-)

Alon Levy <alevy@redhat.com> writes:

> Takes out the optional ('?') message parsing from the main switch loop
> in monitor_parse_command. Adds optional argument option for boolean parameters.
>
> Signed-off-by: Alon Levy <alevy@redhat.com>
> ---
> Previous patch used qemu_free (that's how old it is), fixed.
>
>  monitor.c |   79 +++++++++++++++++++++++-------------------------------------
>  1 files changed, 30 insertions(+), 49 deletions(-)
>
> diff --git a/monitor.c b/monitor.c
> index ffda0fe..a482705 100644
> --- a/monitor.c
> +++ b/monitor.c
> @@ -3976,6 +3976,29 @@ static const mon_cmd_t *monitor_parse_command(Monitor *mon,
>              break;
>          c = *typestr;
>          typestr++;
> +        while (qemu_isspace(*p)) {
> +            p++;
> +        }
> +        /* take care of optional arguments */
> +        switch (c) {
> +        case 's':
> +        case 'i':
> +        case 'l':
> +        case 'M':
> +        case 'o':
> +        case 'T':
> +        case 'b':
> +            if (*typestr == '?') {
> +                typestr++;
> +                if (*p == '\0') {
> +                    /* missing optional argument: NULL argument */
> +                    g_free(key);
> +                    key = NULL;
> +                    continue;
> +                }
> +            }
> +            break;
> +        }
>          switch(c) {
>          case 'F':
>          case 'B':
> @@ -3983,15 +4006,6 @@ static const mon_cmd_t *monitor_parse_command(Monitor *mon,
>              {
>                  int ret;
>  
> -                while (qemu_isspace(*p))
> -                    p++;
> -                if (*typestr == '?') {
> -                    typestr++;
> -                    if (*p == '\0') {
> -                        /* no optional string: NULL argument */
> -                        break;
> -                    }
> -                }
>                  ret = get_str(buf, sizeof(buf), &p);
>                  if (ret < 0) {
>                      switch(c) {

This is cases 'F', 'B' and 's'.  I'm afraid your new code covers only
's'.

> @@ -4021,9 +4035,6 @@ static const mon_cmd_t *monitor_parse_command(Monitor *mon,
>                  if (!opts_list || opts_list->desc->name) {
>                      goto bad_type;
>                  }
> -                while (qemu_isspace(*p)) {
> -                    p++;
> -                }
>                  if (!*p)
>                      break;
>                  if (get_str(buf, sizeof(buf), &p) < 0) {
> @@ -4041,8 +4052,6 @@ static const mon_cmd_t *monitor_parse_command(Monitor *mon,
>              {
>                  int count, format, size;
>  
> -                while (qemu_isspace(*p))
> -                    p++;
>                  if (*p == '/') {
>                      /* format found */
>                      p++;
> @@ -4122,23 +4131,15 @@ static const mon_cmd_t *monitor_parse_command(Monitor *mon,
>              {
>                  int64_t val;
>  
> -                while (qemu_isspace(*p))
> -                    p++;
> -                if (*typestr == '?' || *typestr == '.') {
> -                    if (*typestr == '?') {
> -                        if (*p == '\0') {
> -                            typestr++;
> -                            break;
> -                        }
> -                    } else {
> -                        if (*p == '.') {
> +                if (*typestr == '.') {
> +                    if (*p == '.') {
> +                        p++;
> +                        while (qemu_isspace(*p)) {
>                              p++;
> -                            while (qemu_isspace(*p))
> -                                p++;
> -                        } else {
> -                            typestr++;
> -                            break;
>                          }
> +                    } else {
> +                        typestr++;
> +                        break;
>                      }
>                      typestr++;
>                  }
> @@ -4160,15 +4161,6 @@ static const mon_cmd_t *monitor_parse_command(Monitor *mon,
>                  int64_t val;
>                  char *end;
>  
> -                while (qemu_isspace(*p)) {
> -                    p++;
> -                }
> -                if (*typestr == '?') {
> -                    typestr++;
> -                    if (*p == '\0') {
> -                        break;
> -                    }
> -                }
>                  val = strtosz(p, &end);
>                  if (val < 0) {
>                      monitor_printf(mon, "invalid size\n");
> @@ -4182,14 +4174,6 @@ static const mon_cmd_t *monitor_parse_command(Monitor *mon,
>              {
>                  double val;
>  
> -                while (qemu_isspace(*p))
> -                    p++;
> -                if (*typestr == '?') {
> -                    typestr++;
> -                    if (*p == '\0') {
> -                        break;
> -                    }
> -                }
>                  if (get_double(mon, &val, &p) < 0) {
>                      goto fail;
>                  }
> @@ -4215,9 +4199,6 @@ static const mon_cmd_t *monitor_parse_command(Monitor *mon,
>                  const char *beg;
>                  int val;
>  
> -                while (qemu_isspace(*p)) {
> -                    p++;
> -                }
>                  beg = p;
>                  while (qemu_isgraph(*p)) {
>                      p++;

Could be split into parts:

1. Hoist the space skip out of the switch

2. Hoist handling of '?' out of the switch

3. Permit optional boolean parameters

I'd delay the third part until there's a user.