ViewVC Help
View File | Revision Log | Show Annotations | Revision Graph | Root Listing
root/cebix/mon/src/mon_cmd.cpp
(Generate patch)

Comparing mon/src/mon_cmd.cpp (file contents):
Revision 1.12 by cebix, 2002-08-03T14:54:28Z vs.
Revision 1.17 by cebix, 2004-02-12T17:18:03Z

# Line 1 | Line 1
1   /*
2   *  mon_cmd.cpp - cxmon standard commands
3   *
4 < *  cxmon (C) 1997-2002 Christian Bauer, Marc Hellwig
4 > *  cxmon (C) 1997-2004 Christian Bauer, Marc Hellwig
5   *
6   *  This program is free software; you can redistribute it and/or modify
7   *  it under the terms of the GNU General Public License as published by
# Line 67 | Line 67 | static bool range_args(uintptr *adr, uin
67   *  byte_string = (expression | STRING) {COMMA (expression | STRING)} END
68   */
69  
70 < static bool byte_string(uint8 *s, uintptr &len)
70 > static bool byte_string(uint8 *&str, uintptr &len)
71   {
72          uintptr value;
73  
74 +        static const int GRANULARITY = 16; // must be a power of 2
75 +        str = NULL;
76          len = 0;
77          goto start;
78  
# Line 81 | Line 83 | static bool byte_string(uint8 *s, uintpt
83   start:
84                          if (mon_token == T_STRING) {
85                                  uint8 *p = (uint8 *)mon_string;
86 <                                while ((*s++ = *p++) != 0) ;
87 <                                s--;
88 <                                len += strlen(mon_string);
86 >                                unsigned n = strlen(mon_string);
87 >                                str = (uint8 *)realloc(str, (len + n - 1 + GRANULARITY) & ~(GRANULARITY - 1));
88 >                                memcpy(str + len, mon_string, n);
89 >                                len += n;
90                                  mon_get_token();
91                          } else if (mon_expression(&value)) {
92 <                                *s++ = value;
92 >                                str = (uint8 *)realloc(str, (len + GRANULARITY) & ~(GRANULARITY - 1));
93 >                                str[len] = value;
94                                  len++;
95 <                        } else
95 >                        } else {
96 >                                if (str)
97 >                                        free(str);
98                                  return false;
99 +                        }
100  
101 <                } else if (mon_token == T_END)
101 >                } else if (mon_token == T_END) {
102                          return true;
103 <                else {
103 >                } else {
104                          mon_error("',' expected");
105 +                        if (str)
106 +                                free(str);
107                          return false;
108                  }
109          }
# Line 253 | Line 262 | void ascii_dump(void)
262                  return;
263  
264          while (adr <= end_adr && !mon_aborted()) {
265 <                fprintf(monout, "%08x:", mon_use_real_mem ? adr : adr % mon_mem_size);
265 >                fprintf(monout, "%0*lx:", 2 * sizeof(adr), mon_use_real_mem ? adr : adr % mon_mem_size);
266                  for (int i=0; i<ASCIIDUMP_BPL; i++, adr++)
267                          str[i] = char2print(mon_read_byte(adr));
268                  fprintf(monout, " '%s'\n", str);
# Line 279 | Line 288 | void binary_dump(void)
288                  return;
289  
290          while (adr <= end_adr && !mon_aborted()) {
291 <                fprintf(monout, "%08x:", mon_use_real_mem ? adr : adr % mon_mem_size);
291 >                fprintf(monout, "%0*lx:", 2 * sizeof(adr), mon_use_real_mem ? adr : adr % mon_mem_size);
292                  uint8 b = mon_read_byte(adr);
293                  for (int m=0x80, i=0; i<8; m>>=1, i++)
294                          str[i] = (b & m) ? '*' : '.';
# Line 307 | Line 316 | enum CPUType {
316          CPU_680x0,
317          CPU_Z80,
318          CPU_80x86_32,
319 <        CPU_80x86_16
319 >        CPU_80x86_16,
320 >        CPU_x86_64
321   };
322  
323   static void disassemble(CPUType type)
# Line 321 | Line 331 | static void disassemble(CPUType type)
331                  case CPU_PPC:
332                          while (adr <= end_adr && !mon_aborted()) {
333                                  uint32 w = mon_read_word(adr);
334 <                                fprintf(monout, "%08x: %08x\t", mon_use_real_mem ? adr : adr % mon_mem_size, w);
334 >                                fprintf(monout, "%0*lx: %08x\t", 2 * sizeof(adr), mon_use_real_mem ? adr : adr % mon_mem_size, w);
335                                  disass_ppc(monout, mon_use_real_mem ? adr : adr % mon_mem_size, w);
336                                  adr += 4;
337                          }
# Line 332 | Line 342 | static void disassemble(CPUType type)
342                                  uint8 op = mon_read_byte(adr);
343                                  uint8 lo = mon_read_byte(adr + 1);
344                                  uint8 hi = mon_read_byte(adr + 2);
345 <                                fprintf(monout, "%08x: ", mon_use_real_mem ? adr : adr % mon_mem_size);
345 >                                fprintf(monout, "%0*lx: ", 2 * sizeof(adr), mon_use_real_mem ? adr : adr % mon_mem_size);
346                                  adr += disass_6502(monout, mon_use_real_mem ? adr : adr % mon_mem_size, op, lo, hi);
347                          }
348                          break;
349  
350                  case CPU_680x0:
351                          while (adr <= end_adr && !mon_aborted()) {
352 <                                fprintf(monout, "%08x: ", mon_use_real_mem ? adr : adr % mon_mem_size);
352 >                                fprintf(monout, "%0*lx: ", 2 * sizeof(adr), mon_use_real_mem ? adr : adr % mon_mem_size);
353                                  adr += disass_68k(monout, mon_use_real_mem ? adr : adr % mon_mem_size);
354                          }
355                          break;
356  
357                  case CPU_Z80:
358                          while (adr <= end_adr && !mon_aborted()) {
359 <                                fprintf(monout, "%08x: ", mon_use_real_mem ? adr : adr % mon_mem_size);
359 >                                fprintf(monout, "%0*lx: ", 2 * sizeof(adr), mon_use_real_mem ? adr : adr % mon_mem_size);
360                                  adr += disass_z80(monout, mon_use_real_mem ? adr : adr % mon_mem_size);
361                          }
362                          break;
363  
364 +                case CPU_x86_64:
365 +                        while (adr <= end_adr && !mon_aborted()) {
366 +                                fprintf(monout, "%0*lx: ", 2 * sizeof(adr), mon_use_real_mem ? adr : adr % mon_mem_size);
367 +                                adr += disass_x86(monout, mon_use_real_mem ? adr : adr % mon_mem_size, 64);
368 +                        }
369 +                        break;
370 +
371                  case CPU_80x86_32:
372                          while (adr <= end_adr && !mon_aborted()) {
373 <                                fprintf(monout, "%08x: ", mon_use_real_mem ? adr : adr % mon_mem_size);
374 <                                adr += disass_x86(monout, mon_use_real_mem ? adr : adr % mon_mem_size, false);
373 >                                fprintf(monout, "%0*lx: ", 2 * sizeof(adr), mon_use_real_mem ? adr : adr % mon_mem_size);
374 >                                adr += disass_x86(monout, mon_use_real_mem ? adr : adr % mon_mem_size, 32);
375                          }
376                          break;
377  
378                  case CPU_80x86_16:
379                          while (adr <= end_adr && !mon_aborted()) {
380 <                                fprintf(monout, "%08x: ", mon_use_real_mem ? adr : adr % mon_mem_size);
381 <                                adr += disass_x86(monout, mon_use_real_mem ? adr : adr % mon_mem_size, true);
380 >                                fprintf(monout, "%0*lx: ", 2 * sizeof(adr), mon_use_real_mem ? adr : adr % mon_mem_size);
381 >                                adr += disass_x86(monout, mon_use_real_mem ? adr : adr % mon_mem_size, 16);
382                          }
366 –                        break;
383          }
384  
385          mon_dot_address = adr;
# Line 399 | Line 415 | void disassemble_80x86_16(void)
415          disassemble(CPU_80x86_16);
416   }
417  
418 + void disassemble_x86_64(void)
419 + {
420 +        disassemble(CPU_x86_64);
421 + }
422 +
423  
424   /*
425   *  Modify memory
# Line 408 | Line 429 | void disassemble_80x86_16(void)
429   void modify(void)
430   {
431          uintptr adr, len, src_adr = 0;
432 <        uint8 str[256];
432 >        uint8 *str;
433  
434          if (!mon_expression(&adr))
435                  return;
# Line 417 | Line 438 | void modify(void)
438  
439          while (src_adr < len)
440                  mon_write_byte(adr++, str[src_adr++]);
420 –
441          mon_dot_address = adr;
442 +
443 +        free(str);
444   }
445  
446  
# Line 430 | Line 452 | void modify(void)
452   void fill(void)
453   {
454          uintptr adr, end_adr, len, src_adr = 0;
455 <        uint8 str[256];
455 >        uint8 *str;
456  
457          if (!mon_expression(&adr))
458                  return;
# Line 441 | Line 463 | void fill(void)
463  
464          while (adr <= end_adr)
465                  mon_write_byte(adr++, str[src_adr++ % len]);
466 +
467 +        free(str);
468   }
469  
470  
# Line 501 | Line 525 | void compare(void)
525  
526          while (adr <= end_adr && !mon_aborted()) {
527                  if (mon_read_byte(adr) != mon_read_byte(dest)) {
528 <                        fprintf(monout, "%08x ", mon_use_real_mem ? adr : adr % mon_mem_size);
528 >                        fprintf(monout, "%0*lx ", 2 * sizeof(adr), mon_use_real_mem ? adr : adr % mon_mem_size);
529                          num++;
530                          if (!(num & 7))
531                                  fputc('\n', monout);
# Line 523 | Line 547 | void compare(void)
547   void hunt(void)
548   {
549          uintptr adr, end_adr, len;
550 <        uint8 str[256];
550 >        uint8 *str;
551          int num = 0;
552  
553          if (!mon_expression(&adr))
# Line 541 | Line 565 | void hunt(void)
565                                  break;
566  
567                  if (i == len) {
568 <                        fprintf(monout, "%08x ", mon_use_real_mem ? adr : adr % mon_mem_size);
568 >                        fprintf(monout, "%0*lx ", 2 * sizeof(adr), mon_use_real_mem ? adr : adr % mon_mem_size);
569                          num++;
570                          if (num == 1)
571                                  mon_dot_address = adr;
# Line 551 | Line 575 | void hunt(void)
575                  adr++;
576          }
577  
578 +        free(str);
579 +
580          if (num & 7)
581                  fputc('\n', monout);
582          fprintf(monout, "Found %d occurrences\n", num);
# Line 593 | Line 619 | void load_data(void)
619                          mon_write_byte(adr++, fc);
620                  fclose(file);
621  
622 <                fprintf(monerr, "%08x bytes read from %08x to %08x\n", adr - start_adr, mon_use_real_mem ? start_adr : start_adr % mon_mem_size, mon_use_real_mem ? adr-1 : (adr-1) % mon_mem_size);
622 >                fprintf(monerr, "%08x bytes read from %0*lx to %0*lx\n", adr - start_adr, 2 * sizeof(adr), mon_use_real_mem ? start_adr : start_adr % mon_mem_size, 2 * sizeof(adr), mon_use_real_mem ? adr-1 : (adr-1) % mon_mem_size);
623                  mon_dot_address = adr;
624          }
625   }
# Line 636 | Line 662 | void save_data(void)
662                          fputc(mon_read_byte(adr++), file);
663                  fclose(file);
664  
665 <                fprintf(monerr, "%08x bytes written from %08x to %08x\n", size, mon_use_real_mem ? start_adr : start_adr % mon_mem_size, mon_use_real_mem ? end_adr : end_adr % mon_mem_size);
665 >                fprintf(monerr, "%08x bytes written from %0*lx to %0*lx\n", size, 2 * sizeof(adr), mon_use_real_mem ? start_adr : start_adr % mon_mem_size, 2 * sizeof(adr), mon_use_real_mem ? end_adr : end_adr % mon_mem_size);
666          }
667   }

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines