Diff for /qemu/monitor.c between versions 1.1.1.3 and 1.1.1.4

version 1.1.1.3, 2018/04/24 16:40:46 version 1.1.1.4, 2018/04/24 16:42:48
Line 82  void term_puts(const char *str) Line 82  void term_puts(const char *str)
         c = *str++;          c = *str++;
         if (c == '\0')          if (c == '\0')
             break;              break;
           if (c == '\n')
               term_outbuf[term_outbuf_index++] = '\r';
         term_outbuf[term_outbuf_index++] = c;          term_outbuf[term_outbuf_index++] = c;
         if (term_outbuf_index >= sizeof(term_outbuf) ||          if (term_outbuf_index >= (sizeof(term_outbuf) - 1) ||
             c == '\n')              c == '\n')
             term_flush();              term_flush();
     }      }
Line 533  static void memory_dump(int count, int f Line 535  static void memory_dump(int count, int f
             term_printf(" ");              term_printf(" ");
             switch(format) {              switch(format) {
             case 'o':              case 'o':
                 term_printf("%#*llo", max_digits, v);                  term_printf("%#*" PRIo64, max_digits, v);
                 break;                  break;
             case 'x':              case 'x':
                 term_printf("0x%0*llx", max_digits, v);                  term_printf("0x%0*" PRIx64, max_digits, v);
                 break;                  break;
             case 'u':              case 'u':
                 term_printf("%*llu", max_digits, v);                  term_printf("%*" PRIu64, max_digits, v);
                 break;                  break;
             case 'd':              case 'd':
                 term_printf("%*lld", max_digits, v);                  term_printf("%*" PRId64, max_digits, v);
                 break;                  break;
             case 'c':              case 'c':
                 term_printc(v);                  term_printc(v);
Line 602  static void do_print(int count, int form Line 604  static void do_print(int count, int form
 #else  #else
     switch(format) {      switch(format) {
     case 'o':      case 'o':
         term_printf("%#llo", val);          term_printf("%#" PRIo64, val);
         break;          break;
     case 'x':      case 'x':
         term_printf("%#llx", val);          term_printf("%#" PRIx64, val);
         break;          break;
     case 'u':      case 'u':
         term_printf("%llu", val);          term_printf("%" PRIu64, val);
         break;          break;
     default:      default:
     case 'd':      case 'd':
         term_printf("%lld", val);          term_printf("%" PRId64, val);
         break;          break;
     case 'c':      case 'c':
         term_printc(val);          term_printc(val);
Line 666  static const KeyDef key_defs[] = { Line 668  static const KeyDef key_defs[] = {
     { 0x09, "8" },      { 0x09, "8" },
     { 0x0a, "9" },      { 0x0a, "9" },
     { 0x0b, "0" },      { 0x0b, "0" },
       { 0x0c, "minus" },
       { 0x0d, "equal" },
     { 0x0e, "backspace" },      { 0x0e, "backspace" },
   
     { 0x0f, "tab" },      { 0x0f, "tab" },
Line 715  static const KeyDef key_defs[] = { Line 719  static const KeyDef key_defs[] = {
     { 0x45, "num_lock" },      { 0x45, "num_lock" },
     { 0x46, "scroll_lock" },      { 0x46, "scroll_lock" },
   
       { 0xb5, "kp_divide" },
       { 0x37, "kp_multiply" },
       { 0x4a, "kp_substract" },
       { 0x4e, "kp_add" },
       { 0x9c, "kp_enter" },
       { 0x53, "kp_decimal" },
   
       { 0x52, "kp_0" },
       { 0x4f, "kp_1" },
       { 0x50, "kp_2" },
       { 0x51, "kp_3" },
       { 0x4b, "kp_4" },
       { 0x4c, "kp_5" },
       { 0x4d, "kp_6" },
       { 0x47, "kp_7" },
       { 0x48, "kp_8" },
       { 0x49, "kp_9" },
       
     { 0x56, "<" },      { 0x56, "<" },
   
     { 0x57, "f11" },      { 0x57, "f11" },
Line 740  static const KeyDef key_defs[] = { Line 762  static const KeyDef key_defs[] = {
 static int get_keycode(const char *key)  static int get_keycode(const char *key)
 {  {
     const KeyDef *p;      const KeyDef *p;
       char *endp;
       int ret;
   
     for(p = key_defs; p->name != NULL; p++) {      for(p = key_defs; p->name != NULL; p++) {
         if (!strcmp(key, p->name))          if (!strcmp(key, p->name))
             return p->keycode;              return p->keycode;
     }      }
       if (strstart(key, "0x", NULL)) {
           ret = strtoul(key, &endp, 0);
           if (*endp == '\0' && ret >= 0x01 && ret <= 0xff)
               return ret;
       }
     return -1;      return -1;
 }  }
   
Line 792  static void do_send_key(const char *stri Line 821  static void do_send_key(const char *stri
     }      }
 }  }
   
   static int mouse_button_state;
   
   static void do_mouse_move(const char *dx_str, const char *dy_str, 
                             const char *dz_str)
   {
       int dx, dy, dz;
       dx = strtol(dx_str, NULL, 0);
       dy = strtol(dy_str, NULL, 0);
       dz = 0;
       if (dz_str) 
           dz = strtol(dz_str, NULL, 0);
       kbd_mouse_event(dx, dy, dz, mouse_button_state);
   }
   
   static void do_mouse_button(int button_state)
   {
       mouse_button_state = button_state;
       kbd_mouse_event(0, 0, 0, mouse_button_state);
   }
   
 static void do_ioport_read(int count, int format, int size, int addr, int has_index, int index)  static void do_ioport_read(int count, int format, int size, int addr, int has_index, int index)
 {  {
     uint32_t val;      uint32_t val;
Line 999  static void do_info_profile(void) Line 1048  static void do_info_profile(void)
     total = qemu_time;      total = qemu_time;
     if (total == 0)      if (total == 0)
         total = 1;          total = 1;
     term_printf("async time  %lld (%0.3f)\n",      term_printf("async time  %" PRId64 " (%0.3f)\n",
                 dev_time, dev_time / (double)ticks_per_sec);                  dev_time, dev_time / (double)ticks_per_sec);
     term_printf("qemu time   %lld (%0.3f)\n",      term_printf("qemu time   %" PRId64 " (%0.3f)\n",
                 qemu_time, qemu_time / (double)ticks_per_sec);                  qemu_time, qemu_time / (double)ticks_per_sec);
     term_printf("kqemu time  %lld (%0.3f %0.1f%%) count=%lld int=%lld excp=%lld intr=%lld\n",      term_printf("kqemu time  %" PRId64 " (%0.3f %0.1f%%) count=%" PRId64 " int=%" PRId64 " excp=%" PRId64 " intr=%" PRId64 "\n",
                 kqemu_time, kqemu_time / (double)ticks_per_sec,                  kqemu_time, kqemu_time / (double)ticks_per_sec,
                 kqemu_time / (double)total * 100.0,                  kqemu_time / (double)total * 100.0,
                 kqemu_exec_count,                  kqemu_exec_count,
Line 1028  static void do_info_profile(void) Line 1077  static void do_info_profile(void)
 }  }
 #endif  #endif
   
   /* Capture support */
   static LIST_HEAD (capture_list_head, CaptureState) capture_head;
   
   static void do_info_capture (void)
   {
       int i;
       CaptureState *s;
   
       for (s = capture_head.lh_first, i = 0; s; s = s->entries.le_next, ++i) {
           term_printf ("[%d]: ", i);
           s->ops.info (s->opaque);
       }
   }
   
   static void do_stop_capture (int n)
   {
       int i;
       CaptureState *s;
   
       for (s = capture_head.lh_first, i = 0; s; s = s->entries.le_next, ++i) {
           if (i == n) {
               s->ops.destroy (s->opaque);
               LIST_REMOVE (s, entries);
               qemu_free (s);
               return;
           }
       }
   }
   
   #ifdef HAS_AUDIO
   int wav_start_capture (CaptureState *s, const char *path, int freq,
                          int bits, int nchannels);
   
   static void do_wav_capture (const char *path,
                               int has_freq, int freq,
                               int has_bits, int bits,
                               int has_channels, int nchannels)
   {
       CaptureState *s;
   
       s = qemu_mallocz (sizeof (*s));
       if (!s) {
           term_printf ("Not enough memory to add wave capture\n");
           return;
       }
   
       freq = has_freq ? freq : 44100;
       bits = has_bits ? bits : 16;
       nchannels = has_channels ? nchannels : 2;
   
       if (wav_start_capture (s, path, freq, bits, nchannels)) {
           term_printf ("Faied to add wave capture\n");
           qemu_free (s);
       }
       LIST_INSERT_HEAD (&capture_head, s, entries);
   }
   #endif
   
 static term_cmd_t term_cmds[] = {  static term_cmd_t term_cmds[] = {
     { "help|?", "s?", do_help,       { "help|?", "s?", do_help, 
       "[cmd]", "show the help" },        "[cmd]", "show the help" },
Line 1080  static term_cmd_t term_cmds[] = { Line 1187  static term_cmd_t term_cmds[] = {
       "device", "remove USB device 'bus.addr'" },        "device", "remove USB device 'bus.addr'" },
     { "cpu", "i", do_cpu_set,       { "cpu", "i", do_cpu_set, 
       "index", "set the default CPU" },        "index", "set the default CPU" },
       { "mouse_move", "sss?", do_mouse_move, 
         "dx dy [dz]", "send mouse move events" },
       { "mouse_button", "i", do_mouse_button, 
         "state", "change mouse button state (1=L, 2=M, 4=R)" },
   #ifdef HAS_AUDIO
       { "wavcapture", "si?i?i?", do_wav_capture,
         "path [frequency bits channels]",
         "capture audio to a wave file (default frequency=44100 bits=16 channels=2)" },
   #endif
        { "stopcapture", "i", do_stop_capture,
          "capture index", "stop capture" },
     { NULL, NULL, },       { NULL, NULL, }, 
 };  };
   
Line 1118  static term_cmd_t info_cmds[] = { Line 1236  static term_cmd_t info_cmds[] = {
       "", "show host USB devices", },        "", "show host USB devices", },
     { "profile", "", do_info_profile,      { "profile", "", do_info_profile,
       "", "show profiling information", },        "", "show profiling information", },
       { "capture", "", do_info_capture,
         "show capture information" },
     { NULL, NULL, },      { NULL, NULL, },
 };  };
   
Line 1557  static target_long expr_unary(void) Line 1677  static target_long expr_unary(void)
         n = 0;          n = 0;
         break;          break;
     default:      default:
         /* XXX: 64 bit version */  #if TARGET_LONG_BITS == 64
           n = strtoull(pch, &p, 0);
   #else
         n = strtoul(pch, &p, 0);          n = strtoul(pch, &p, 0);
   #endif
         if (pch == p) {          if (pch == p) {
             expr_error("invalid char in expression");              expr_error("invalid char in expression");
         }          }
Line 1917  static void monitor_handle_command(const Line 2040  static void monitor_handle_command(const
                 while (isspace(*p))                   while (isspace(*p)) 
                     p++;                      p++;
                 if (*typestr == '?' || *typestr == '.') {                  if (*typestr == '?' || *typestr == '.') {
                     typestr++;  
                     if (*typestr == '?') {                      if (*typestr == '?') {
                         if (*p == '\0')                          if (*p == '\0')
                             has_arg = 0;                              has_arg = 0;
Line 1933  static void monitor_handle_command(const Line 2055  static void monitor_handle_command(const
                             has_arg = 0;                              has_arg = 0;
                         }                          }
                     }                      }
                       typestr++;
                     if (nb_args >= MAX_ARGS)                      if (nb_args >= MAX_ARGS)
                         goto error_args;                          goto error_args;
                     args[nb_args++] = (void *)has_arg;                      args[nb_args++] = (void *)has_arg;
Line 2025  static void monitor_handle_command(const Line 2148  static void monitor_handle_command(const
     case 6:      case 6:
         cmd->handler(args[0], args[1], args[2], args[3], args[4], args[5]);          cmd->handler(args[0], args[1], args[2], args[3], args[4], args[5]);
         break;          break;
       case 7:
           cmd->handler(args[0], args[1], args[2], args[3], args[4], args[5], args[6]);
           break;
     default:      default:
         term_printf("unsupported number of arguments: %d\n", nb_args);          term_printf("unsupported number of arguments: %d\n", nb_args);
         goto fail;          goto fail;
Line 2152  void readline_find_completion(const char Line 2278  void readline_find_completion(const char
     int nb_args, i, len;      int nb_args, i, len;
     const char *ptype, *str;      const char *ptype, *str;
     term_cmd_t *cmd;      term_cmd_t *cmd;
       const KeyDef *key;
   
     parse_cmdline(cmdline, &nb_args, args);      parse_cmdline(cmdline, &nb_args, args);
 #ifdef DEBUG_COMPLETION  #ifdef DEBUG_COMPLETION
Line 2213  void readline_find_completion(const char Line 2340  void readline_find_completion(const char
                 for(cmd = info_cmds; cmd->name != NULL; cmd++) {                  for(cmd = info_cmds; cmd->name != NULL; cmd++) {
                     cmd_completion(str, cmd->name);                      cmd_completion(str, cmd->name);
                 }                  }
               } else if (!strcmp(cmd->name, "sendkey")) {
                   completion_index = strlen(str);
                   for(key = key_defs; key->name != NULL; key++) {
                       cmd_completion(str, key->name);
                   }
             }              }
             break;              break;
         default:          default:

Removed from v.1.1.1.3  
changed lines
  Added in v.1.1.1.4


unix.superglobalmegacorp.com