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.19 by cebix, 2007-01-21T17:32:05Z

# 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 80 | Line 82 | static bool byte_string(uint8 *s, uintpt
82  
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);
85 >                                unsigned n = strlen(mon_string);
86 >                                str = (uint8 *)realloc(str, (len + n - 1 + GRANULARITY) & ~(GRANULARITY - 1));
87 >                                memcpy(str + len, mon_string, n);
88 >                                len += n;
89                                  mon_get_token();
90                          } else if (mon_expression(&value)) {
91 <                                *s++ = value;
91 >                                str = (uint8 *)realloc(str, (len + GRANULARITY) & ~(GRANULARITY - 1));
92 >                                str[len] = value;
93                                  len++;
94 <                        } else
94 >                        } else {
95 >                                if (str)
96 >                                        free(str);
97                                  return false;
98 +                        }
99  
100 <                } else if (mon_token == T_END)
100 >                } else if (mon_token == T_END) {
101                          return true;
102 <                else {
102 >                } else {
103                          mon_error("',' expected");
104 +                        if (str)
105 +                                free(str);
106                          return false;
107                  }
108          }
# Line 118 | Line 126 | static inline uint8 char2print(uint8 c)
126  
127   void version(void)
128   {
129 <        fprintf(monout, "mon V" VERSION "\n");
129 >        fprintf(monout, "cxmon V" VERSION "\n");
130   }
131  
132  
# Line 222 | Line 230 | void memory_dump(void)
230                  return;
231  
232          while (adr <= end_adr && !mon_aborted()) {
233 <                fprintf(monout, "%0*lx:", 2 * sizeof(adr), mon_use_real_mem ? adr: adr % mon_mem_size);
233 >                fprintf(monout, "%0*lx:", int(2 * sizeof(adr)), mon_use_real_mem ? adr: adr % mon_mem_size);
234                  for (int i=0; i<MEMDUMP_BPL; i++, adr++) {
235                          if (i % 4 == 0)
236                                  fprintf(monout, " %08x", mon_read_word(adr));
# Line 253 | Line 261 | void ascii_dump(void)
261                  return;
262  
263          while (adr <= end_adr && !mon_aborted()) {
264 <                fprintf(monout, "%08x:", mon_use_real_mem ? adr : adr % mon_mem_size);
264 >                fprintf(monout, "%0*lx:", int(2 * sizeof(adr)), mon_use_real_mem ? adr : adr % mon_mem_size);
265                  for (int i=0; i<ASCIIDUMP_BPL; i++, adr++)
266                          str[i] = char2print(mon_read_byte(adr));
267                  fprintf(monout, " '%s'\n", str);
# Line 279 | Line 287 | void binary_dump(void)
287                  return;
288  
289          while (adr <= end_adr && !mon_aborted()) {
290 <                fprintf(monout, "%08x:", mon_use_real_mem ? adr : adr % mon_mem_size);
290 >                fprintf(monout, "%0*lx:", int(2 * sizeof(adr)), mon_use_real_mem ? adr : adr % mon_mem_size);
291                  uint8 b = mon_read_byte(adr);
292                  for (int m=0x80, i=0; i<8; m>>=1, i++)
293                          str[i] = (b & m) ? '*' : '.';
# Line 307 | Line 315 | enum CPUType {
315          CPU_680x0,
316          CPU_Z80,
317          CPU_80x86_32,
318 <        CPU_80x86_16
318 >        CPU_80x86_16,
319 >        CPU_x86_64
320   };
321  
322   static void disassemble(CPUType type)
# Line 321 | Line 330 | static void disassemble(CPUType type)
330                  case CPU_PPC:
331                          while (adr <= end_adr && !mon_aborted()) {
332                                  uint32 w = mon_read_word(adr);
333 <                                fprintf(monout, "%08x: %08x\t", mon_use_real_mem ? adr : adr % mon_mem_size, w);
333 >                                fprintf(monout, "%0*lx: %08x\t", int(2 * sizeof(adr)), mon_use_real_mem ? adr : adr % mon_mem_size, w);
334                                  disass_ppc(monout, mon_use_real_mem ? adr : adr % mon_mem_size, w);
335                                  adr += 4;
336                          }
# Line 332 | Line 341 | static void disassemble(CPUType type)
341                                  uint8 op = mon_read_byte(adr);
342                                  uint8 lo = mon_read_byte(adr + 1);
343                                  uint8 hi = mon_read_byte(adr + 2);
344 <                                fprintf(monout, "%08x: ", mon_use_real_mem ? adr : adr % mon_mem_size);
344 >                                fprintf(monout, "%0*lx: ", int(2 * sizeof(adr)), mon_use_real_mem ? adr : adr % mon_mem_size);
345                                  adr += disass_6502(monout, mon_use_real_mem ? adr : adr % mon_mem_size, op, lo, hi);
346                          }
347                          break;
348  
349                  case CPU_680x0:
350                          while (adr <= end_adr && !mon_aborted()) {
351 <                                fprintf(monout, "%08x: ", mon_use_real_mem ? adr : adr % mon_mem_size);
351 >                                fprintf(monout, "%0*lx: ", int(2 * sizeof(adr)), mon_use_real_mem ? adr : adr % mon_mem_size);
352                                  adr += disass_68k(monout, mon_use_real_mem ? adr : adr % mon_mem_size);
353                          }
354                          break;
355  
356                  case CPU_Z80:
357                          while (adr <= end_adr && !mon_aborted()) {
358 <                                fprintf(monout, "%08x: ", mon_use_real_mem ? adr : adr % mon_mem_size);
358 >                                fprintf(monout, "%0*lx: ", int(2 * sizeof(adr)), mon_use_real_mem ? adr : adr % mon_mem_size);
359                                  adr += disass_z80(monout, mon_use_real_mem ? adr : adr % mon_mem_size);
360                          }
361                          break;
362  
363 +                case CPU_x86_64:
364 +                        while (adr <= end_adr && !mon_aborted()) {
365 +                                fprintf(monout, "%0*lx: ", int(2 * sizeof(adr)), mon_use_real_mem ? adr : adr % mon_mem_size);
366 +                                adr += disass_x86(monout, mon_use_real_mem ? adr : adr % mon_mem_size, 64);
367 +                        }
368 +                        break;
369 +
370                  case CPU_80x86_32:
371                          while (adr <= end_adr && !mon_aborted()) {
372 <                                fprintf(monout, "%08x: ", mon_use_real_mem ? adr : adr % mon_mem_size);
373 <                                adr += disass_x86(monout, mon_use_real_mem ? adr : adr % mon_mem_size, false);
372 >                                fprintf(monout, "%0*lx: ", int(2 * sizeof(adr)), mon_use_real_mem ? adr : adr % mon_mem_size);
373 >                                adr += disass_x86(monout, mon_use_real_mem ? adr : adr % mon_mem_size, 32);
374                          }
375                          break;
376  
377                  case CPU_80x86_16:
378                          while (adr <= end_adr && !mon_aborted()) {
379 <                                fprintf(monout, "%08x: ", mon_use_real_mem ? adr : adr % mon_mem_size);
380 <                                adr += disass_x86(monout, mon_use_real_mem ? adr : adr % mon_mem_size, true);
379 >                                fprintf(monout, "%0*lx: ", int(2 * sizeof(adr)), mon_use_real_mem ? adr : adr % mon_mem_size);
380 >                                adr += disass_x86(monout, mon_use_real_mem ? adr : adr % mon_mem_size, 16);
381                          }
366 –                        break;
382          }
383  
384          mon_dot_address = adr;
# Line 399 | Line 414 | void disassemble_80x86_16(void)
414          disassemble(CPU_80x86_16);
415   }
416  
417 + void disassemble_x86_64(void)
418 + {
419 +        disassemble(CPU_x86_64);
420 + }
421 +
422  
423   /*
424   *  Modify memory
# Line 408 | Line 428 | void disassemble_80x86_16(void)
428   void modify(void)
429   {
430          uintptr adr, len, src_adr = 0;
431 <        uint8 str[256];
431 >        uint8 *str;
432  
433          if (!mon_expression(&adr))
434                  return;
# Line 417 | Line 437 | void modify(void)
437  
438          while (src_adr < len)
439                  mon_write_byte(adr++, str[src_adr++]);
420 –
440          mon_dot_address = adr;
441 +
442 +        free(str);
443   }
444  
445  
# Line 430 | Line 451 | void modify(void)
451   void fill(void)
452   {
453          uintptr adr, end_adr, len, src_adr = 0;
454 <        uint8 str[256];
454 >        uint8 *str;
455  
456          if (!mon_expression(&adr))
457                  return;
# Line 441 | Line 462 | void fill(void)
462  
463          while (adr <= end_adr)
464                  mon_write_byte(adr++, str[src_adr++ % len]);
465 +
466 +        free(str);
467   }
468  
469  
# Line 501 | Line 524 | void compare(void)
524  
525          while (adr <= end_adr && !mon_aborted()) {
526                  if (mon_read_byte(adr) != mon_read_byte(dest)) {
527 <                        fprintf(monout, "%08x ", mon_use_real_mem ? adr : adr % mon_mem_size);
527 >                        fprintf(monout, "%0*lx ", int(2 * sizeof(adr)), mon_use_real_mem ? adr : adr % mon_mem_size);
528                          num++;
529                          if (!(num & 7))
530                                  fputc('\n', monout);
# Line 523 | Line 546 | void compare(void)
546   void hunt(void)
547   {
548          uintptr adr, end_adr, len;
549 <        uint8 str[256];
549 >        uint8 *str;
550          int num = 0;
551  
552          if (!mon_expression(&adr))
# Line 541 | Line 564 | void hunt(void)
564                                  break;
565  
566                  if (i == len) {
567 <                        fprintf(monout, "%08x ", mon_use_real_mem ? adr : adr % mon_mem_size);
567 >                        fprintf(monout, "%0*lx ", int(2 * sizeof(adr)), mon_use_real_mem ? adr : adr % mon_mem_size);
568                          num++;
569                          if (num == 1)
570                                  mon_dot_address = adr;
# Line 551 | Line 574 | void hunt(void)
574                  adr++;
575          }
576  
577 +        free(str);
578 +
579          if (num & 7)
580                  fputc('\n', monout);
581          fprintf(monout, "Found %d occurrences\n", num);
# Line 593 | Line 618 | void load_data(void)
618                          mon_write_byte(adr++, fc);
619                  fclose(file);
620  
621 <                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);
621 >                fprintf(monerr, "%08x bytes read from %0*lx to %0*lx\n", adr - start_adr, int(2 * sizeof(adr)), mon_use_real_mem ? start_adr : start_adr % mon_mem_size, int(2 * sizeof(adr)), mon_use_real_mem ? adr-1 : (adr-1) % mon_mem_size);
622                  mon_dot_address = adr;
623          }
624   }
# Line 636 | Line 661 | void save_data(void)
661                          fputc(mon_read_byte(adr++), file);
662                  fclose(file);
663  
664 <                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);
664 >                fprintf(monerr, "%08x bytes written from %0*lx to %0*lx\n", size, int(2 * sizeof(adr)), mon_use_real_mem ? start_adr : start_adr % mon_mem_size, int(2 * sizeof(adr)), mon_use_real_mem ? end_adr : end_adr % mon_mem_size);
665          }
666   }

Diff Legend

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