Diff for /qemu/cmd.c between versions 1.1 and 1.1.1.6

version 1.1, 2018/04/24 17:21:29 version 1.1.1.6, 2018/04/24 19:35:24
Line 21 Line 21
 #include <ctype.h>  #include <ctype.h>
 #include <errno.h>  #include <errno.h>
 #include <sys/time.h>  #include <sys/time.h>
   #include <getopt.h>
   
 #include "cmd.h"  #include "cmd.h"
   #include "qemu-aio.h"
   #include "main-loop.h"
   
 #define _(x)    x       /* not gettext support yet */  #define _(x)    x       /* not gettext support yet */
   
 extern int optind;  
   
 /* from libxcmd/command.c */  /* from libxcmd/command.c */
   
 cmdinfo_t       *cmdtab;  cmdinfo_t       *cmdtab;
Line 45  compare(const void *a, const void *b) Line 46  compare(const void *a, const void *b)
                       ((const cmdinfo_t *)b)->name);                        ((const cmdinfo_t *)b)->name);
 }  }
   
 void  void add_command(const cmdinfo_t *ci)
 add_command(  
         const cmdinfo_t *ci)  
 {  {
         cmdtab = realloc((void *)cmdtab, ++ncmds * sizeof(*cmdtab));      cmdtab = g_realloc((void *)cmdtab, ++ncmds * sizeof(*cmdtab));
         cmdtab[ncmds - 1] = *ci;      cmdtab[ncmds - 1] = *ci;
         qsort(cmdtab, ncmds, sizeof(*cmdtab), compare);      qsort(cmdtab, ncmds, sizeof(*cmdtab), compare);
 }  }
   
 static int  static int
Line 122  find_command( Line 121  find_command(
         return NULL;          return NULL;
 }  }
   
 void  void add_user_command(char *optarg)
 add_user_command(char *optarg)  
 {  {
         ncmdline++;      cmdline = g_realloc(cmdline, ++ncmdline * sizeof(char *));
         cmdline = realloc(cmdline, sizeof(char*) * (ncmdline));      cmdline[ncmdline-1] = optarg;
         if (!cmdline) {  
                 perror("realloc");  
                 exit(1);  
         }  
         cmdline[ncmdline-1] = optarg;  
 }  }
   
 static int  static int
Line 150  add_args_command( Line 143  add_args_command(
         args_func = af;          args_func = af;
 }  }
   
 void  static void prep_fetchline(void *opaque)
 command_loop(void)  
 {  {
         int             c, i, j = 0, done = 0;      int *fetchable = opaque;
         char            *input;  
         char            **v;  
         const cmdinfo_t *ct;  
   
         for (i = 0; !done && i < ncmdline; i++) {      qemu_set_fd_handler(STDIN_FILENO, NULL, NULL, NULL);
                 input = strdup(cmdline[i]);      *fetchable= 1;
                 if (!input) {  }
                         fprintf(stderr,  
                                 _("cannot strdup command '%s': %s\n"),  static char *get_prompt(void);
                                 cmdline[i], strerror(errno));  
                         exit(1);  void command_loop(void)
                 }  {
                 v = breakline(input, &c);      int c, i, j = 0, done = 0, fetchable = 0, prompted = 0;
                 if (c) {      char *input;
                         ct = find_command(v[0]);      char **v;
                         if (ct) {      const cmdinfo_t *ct;
                                 if (ct->flags & CMD_FLAG_GLOBAL)  
                                         done = command(ct, c, v);      for (i = 0; !done && i < ncmdline; i++) {
                                 else {          input = strdup(cmdline[i]);
                                         j = 0;          if (!input) {
                                         while (!done && (j = args_command(j)))              fprintf(stderr, _("cannot strdup command '%s': %s\n"),
                                                 done = command(ct, c, v);                      cmdline[i], strerror(errno));
                                 }              exit(1);
                         } else          }
                                 fprintf(stderr, _("command \"%s\" not found\n"),          v = breakline(input, &c);
                                         v[0]);          if (c) {
                 }              ct = find_command(v[0]);
                 doneline(input, v);              if (ct) {
         }                  if (ct->flags & CMD_FLAG_GLOBAL) {
         if (cmdline) {                      done = command(ct, c, v);
                 free(cmdline);                  } else {
                 return;                      j = 0;
         }                      while (!done && (j = args_command(j))) {
         while (!done) {                          done = command(ct, c, v);
                 if ((input = fetchline()) == NULL)                      }
                         break;                  }
                 v = breakline(input, &c);              } else {
                 if (c) {                  fprintf(stderr, _("command \"%s\" not found\n"), v[0]);
                         ct = find_command(v[0]);              }
                         if (ct)  
                                 done = command(ct, c, v);  
                         else  
                                 fprintf(stderr, _("command \"%s\" not found\n"),  
                                         v[0]);  
                 }  
                 doneline(input, v);  
         }          }
           doneline(input, v);
       }
       if (cmdline) {
           g_free(cmdline);
           return;
       }
   
       while (!done) {
           if (!prompted) {
               printf("%s", get_prompt());
               fflush(stdout);
               qemu_set_fd_handler(STDIN_FILENO, prep_fetchline, NULL, &fetchable);
               prompted = 1;
           }
   
           main_loop_wait(false);
   
           if (!fetchable) {
               continue;
           }
           input = fetchline();
           if (input == NULL) {
               break;
           }
           v = breakline(input, &c);
           if (c) {
               ct = find_command(v[0]);
               if (ct) {
                   done = command(ct, c, v);
               } else {
                   fprintf(stderr, _("command \"%s\" not found\n"), v[0]);
               }
           }
           doneline(input, v);
   
           prompted = 0;
           fetchable = 0;
       }
       qemu_set_fd_handler(STDIN_FILENO, NULL, NULL, NULL);
 }  }
   
 /* from libxcmd/input.c */  /* from libxcmd/input.c */
Line 271  fetchline(void) Line 292  fetchline(void)
   
         if (!line)          if (!line)
                 return NULL;                  return NULL;
         printf("%s", get_prompt());  
         fflush(stdout);  
         if (!fgets(line, MAXREADLINESZ, stdin)) {          if (!fgets(line, MAXREADLINESZ, stdin)) {
                 free(line);                  free(line);
                 return NULL;                  return NULL;
Line 288  static char *qemu_strsep(char **input, c Line 307  static char *qemu_strsep(char **input, c
 {  {
     char *result = *input;      char *result = *input;
     if (result != NULL) {      if (result != NULL) {
     char *p = result;          char *p;
     for (p = result; *p != '\0'; p++) {  
         if (strchr(delim, *p)) {          for (p = result; *p != '\0'; p++) {
               if (strchr(delim, *p)) {
                 break;                  break;
             }              }
         }          }
Line 304  static char *qemu_strsep(char **input, c Line 324  static char *qemu_strsep(char **input, c
     return result;      return result;
 }  }
   
 char **  char **breakline(char *input, int *count)
 breakline(  
         char    *input,  
         int     *count)  
 {  {
         int     c = 0;      int c = 0;
         char    *p;      char *p;
         char    **rval = calloc(sizeof(char *), 1);      char **rval = calloc(sizeof(char *), 1);
       char **tmp;
         while (rval && (p = qemu_strsep(&input, " ")) != NULL) {  
                 if (!*p)      while (rval && (p = qemu_strsep(&input, " ")) != NULL) {
                         continue;          if (!*p) {
                 c++;              continue;
                 rval = realloc(rval, sizeof(*rval) * (c + 1));          }
                 if (!rval) {          c++;
                         c = 0;          tmp = realloc(rval, sizeof(*rval) * (c + 1));
                         break;          if (!tmp) {
                 }              free(rval);
                 rval[c - 1] = p;              rval = NULL;
                 rval[c] = NULL;              c = 0;
         }              break;
         *count = c;          } else {
         return rval;              rval = tmp;
           }
           rval[c - 1] = p;
           rval[c] = NULL;
       }
       *count = c;
       return rval;
 }  }
   
 void  void
Line 362  cvtnum( Line 385  cvtnum(
         if (sp[1] != '\0')          if (sp[1] != '\0')
                 return -1LL;                  return -1LL;
   
         c = tolower(*sp);          c = qemu_tolower(*sp);
         switch (c) {          switch (c) {
         default:          default:
                 return i;                  return i;
Line 395  cvtstr( Line 418  cvtstr(
         char            *str,          char            *str,
         size_t          size)          size_t          size)
 {  {
         const char      *fmt;          char            *trim;
         int             precise;          const char      *suffix;
   
         precise = ((double)value * 1000 == (double)(int)value * 1000);  
   
         if (value >= EXABYTES(1)) {          if (value >= EXABYTES(1)) {
                 fmt = precise ? "%.f EiB" : "%.3f EiB";                  suffix = " EiB";
                 snprintf(str, size, fmt, TO_EXABYTES(value));                  snprintf(str, size - 4, "%.3f", TO_EXABYTES(value));
         } else if (value >= PETABYTES(1)) {          } else if (value >= PETABYTES(1)) {
                 fmt = precise ? "%.f PiB" : "%.3f PiB";                  suffix = " PiB";
                 snprintf(str, size, fmt, TO_PETABYTES(value));                  snprintf(str, size - 4, "%.3f", TO_PETABYTES(value));
         } else if (value >= TERABYTES(1)) {          } else if (value >= TERABYTES(1)) {
                 fmt = precise ? "%.f TiB" : "%.3f TiB";                  suffix = " TiB";
                 snprintf(str, size, fmt, TO_TERABYTES(value));                  snprintf(str, size - 4, "%.3f", TO_TERABYTES(value));
         } else if (value >= GIGABYTES(1)) {          } else if (value >= GIGABYTES(1)) {
                 fmt = precise ? "%.f GiB" : "%.3f GiB";                  suffix = " GiB";
                 snprintf(str, size, fmt, TO_GIGABYTES(value));                  snprintf(str, size - 4, "%.3f", TO_GIGABYTES(value));
         } else if (value >= MEGABYTES(1)) {          } else if (value >= MEGABYTES(1)) {
                 fmt = precise ? "%.f MiB" : "%.3f MiB";                  suffix = " MiB";
                 snprintf(str, size, fmt, TO_MEGABYTES(value));                  snprintf(str, size - 4, "%.3f", TO_MEGABYTES(value));
         } else if (value >= KILOBYTES(1)) {          } else if (value >= KILOBYTES(1)) {
                 fmt = precise ? "%.f KiB" : "%.3f KiB";                  suffix = " KiB";
                 snprintf(str, size, fmt, TO_KILOBYTES(value));                  snprintf(str, size - 4, "%.3f", TO_KILOBYTES(value));
           } else {
                   suffix = " bytes";
                   snprintf(str, size - 6, "%f", value);
           }
   
           trim = strstr(str, ".000");
           if (trim) {
                   strcpy(trim, suffix);
         } else {          } else {
                 snprintf(str, size, "%f bytes", value);                  strcat(str, suffix);
         }          }
 }  }
   
Line 459  timestr( Line 488  timestr(
                         snprintf(ts, size, "%u:%02u.%02u",                          snprintf(ts, size, "%u:%02u.%02u",
                                 (unsigned int) MINUTES(tv->tv_sec),                                  (unsigned int) MINUTES(tv->tv_sec),
                                 (unsigned int) SECONDS(tv->tv_sec),                                  (unsigned int) SECONDS(tv->tv_sec),
                                 (unsigned int) usec * 100);                                  (unsigned int) (usec * 100));
                         return;                          return;
                 }                  }
                 format |= VERBOSE_FIXED_TIME;   /* fallback if hours needed */                  format |= VERBOSE_FIXED_TIME;   /* fallback if hours needed */
Line 470  timestr( Line 499  timestr(
                         (unsigned int) HOURS(tv->tv_sec),                          (unsigned int) HOURS(tv->tv_sec),
                         (unsigned int) MINUTES(tv->tv_sec),                          (unsigned int) MINUTES(tv->tv_sec),
                         (unsigned int) SECONDS(tv->tv_sec),                          (unsigned int) SECONDS(tv->tv_sec),
                         (unsigned int) usec * 100);                          (unsigned int) (usec * 100));
         } else {          } else {
                 snprintf(ts, size, "0.%04u sec", (unsigned int) usec * 10000);                  snprintf(ts, size, "0.%04u sec", (unsigned int) (usec * 10000));
         }          }
 }  }
   

Removed from v.1.1  
changed lines
  Added in v.1.1.1.6


unix.superglobalmegacorp.com