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.14 by cebix, 2003-06-19T15:07:46Z vs.
Revision 1.21 by cebix, 2012-06-19T22:23:25Z

# 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, "%0*lx:", 2 * sizeof(adr), 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, "%0*lx:", 2 * sizeof(adr), 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 308 | Line 316 | enum CPUType {
316          CPU_Z80,
317          CPU_80x86_32,
318          CPU_80x86_16,
319 <        CPU_x86_64
319 >        CPU_x86_64,
320 >        CPU_MIPS,
321 >        CPU_MIPS_LITTLE,
322   };
323  
324   static void disassemble(CPUType type)
# Line 322 | Line 332 | static void disassemble(CPUType type)
332                  case CPU_PPC:
333                          while (adr <= end_adr && !mon_aborted()) {
334                                  uint32 w = mon_read_word(adr);
335 <                                fprintf(monout, "%0*lx: %08x\t", 2 * sizeof(adr), mon_use_real_mem ? adr : adr % mon_mem_size, w);
335 >                                fprintf(monout, "%0*lx: %08x\t", int(2 * sizeof(adr)), mon_use_real_mem ? adr : adr % mon_mem_size, w);
336                                  disass_ppc(monout, mon_use_real_mem ? adr : adr % mon_mem_size, w);
337                                  adr += 4;
338                          }
# Line 333 | Line 343 | static void disassemble(CPUType type)
343                                  uint8 op = mon_read_byte(adr);
344                                  uint8 lo = mon_read_byte(adr + 1);
345                                  uint8 hi = mon_read_byte(adr + 2);
346 <                                fprintf(monout, "%0*lx: ", 2 * sizeof(adr), mon_use_real_mem ? adr : adr % mon_mem_size);
346 >                                fprintf(monout, "%0*lx: ", int(2 * sizeof(adr)), mon_use_real_mem ? adr : adr % mon_mem_size);
347                                  adr += disass_6502(monout, mon_use_real_mem ? adr : adr % mon_mem_size, op, lo, hi);
348                          }
349                          break;
350  
351                  case CPU_680x0:
352                          while (adr <= end_adr && !mon_aborted()) {
353 <                                fprintf(monout, "%0*lx: ", 2 * sizeof(adr), mon_use_real_mem ? adr : adr % mon_mem_size);
353 >                                fprintf(monout, "%0*lx: ", int(2 * sizeof(adr)), mon_use_real_mem ? adr : adr % mon_mem_size);
354                                  adr += disass_68k(monout, mon_use_real_mem ? adr : adr % mon_mem_size);
355                          }
356                          break;
357  
358                  case CPU_Z80:
359                          while (adr <= end_adr && !mon_aborted()) {
360 <                                fprintf(monout, "%0*lx: ", 2 * sizeof(adr), mon_use_real_mem ? adr : adr % mon_mem_size);
360 >                                fprintf(monout, "%0*lx: ", int(2 * sizeof(adr)), mon_use_real_mem ? adr : adr % mon_mem_size);
361                                  adr += disass_z80(monout, mon_use_real_mem ? adr : adr % mon_mem_size);
362                          }
363                          break;
364  
365 +                case CPU_MIPS:
366 +                case CPU_MIPS_LITTLE:
367 +                        while (adr <= end_adr && !mon_aborted()) {
368 +                                fprintf(monout, "%0*lx: ", int(2 * sizeof(adr)), mon_use_real_mem ? adr : adr % mon_mem_size);
369 +                                adr += disass_mips(monout, mon_use_real_mem ? adr : adr % mon_mem_size, type == CPU_MIPS_LITTLE);
370 +                        }
371 +                        break;
372 +
373                  case CPU_x86_64:
374                          while (adr <= end_adr && !mon_aborted()) {
375 <                                fprintf(monout, "%0*lx: ", 2 * sizeof(adr), mon_use_real_mem ? adr : adr % mon_mem_size);
375 >                                fprintf(monout, "%0*lx: ", int(2 * sizeof(adr)), mon_use_real_mem ? adr : adr % mon_mem_size);
376                                  adr += disass_x86(monout, mon_use_real_mem ? adr : adr % mon_mem_size, 64);
377                          }
378                          break;
379  
380                  case CPU_80x86_32:
381                          while (adr <= end_adr && !mon_aborted()) {
382 <                                fprintf(monout, "%0*lx: ", 2 * sizeof(adr), mon_use_real_mem ? adr : adr % mon_mem_size);
382 >                                fprintf(monout, "%0*lx: ", int(2 * sizeof(adr)), mon_use_real_mem ? adr : adr % mon_mem_size);
383                                  adr += disass_x86(monout, mon_use_real_mem ? adr : adr % mon_mem_size, 32);
384                          }
385                          break;
386  
387                  case CPU_80x86_16:
388                          while (adr <= end_adr && !mon_aborted()) {
389 <                                fprintf(monout, "%0*lx: ", 2 * sizeof(adr), mon_use_real_mem ? adr : adr % mon_mem_size);
389 >                                fprintf(monout, "%0*lx: ", int(2 * sizeof(adr)), mon_use_real_mem ? adr : adr % mon_mem_size);
390                                  adr += disass_x86(monout, mon_use_real_mem ? adr : adr % mon_mem_size, 16);
391                          }
392          }
# Line 411 | Line 429 | void disassemble_x86_64(void)
429          disassemble(CPU_x86_64);
430   }
431  
432 + void disassemble_mips(void)
433 + {
434 +        disassemble(CPU_MIPS);
435 + }
436 +
437 + void disassemble_mipsel(void)
438 + {
439 +        disassemble(CPU_MIPS_LITTLE);
440 + }
441 +
442  
443   /*
444   *  Modify memory
# Line 420 | Line 448 | void disassemble_x86_64(void)
448   void modify(void)
449   {
450          uintptr adr, len, src_adr = 0;
451 <        uint8 str[256];
451 >        uint8 *str;
452  
453          if (!mon_expression(&adr))
454                  return;
# Line 429 | Line 457 | void modify(void)
457  
458          while (src_adr < len)
459                  mon_write_byte(adr++, str[src_adr++]);
432 –
460          mon_dot_address = adr;
461 +
462 +        free(str);
463   }
464  
465  
# Line 442 | Line 471 | void modify(void)
471   void fill(void)
472   {
473          uintptr adr, end_adr, len, src_adr = 0;
474 <        uint8 str[256];
474 >        uint8 *str;
475  
476          if (!mon_expression(&adr))
477                  return;
# Line 451 | Line 480 | void fill(void)
480          if (!byte_string(str, len))
481                  return;
482  
483 <        while (adr <= end_adr)
484 <                mon_write_byte(adr++, str[src_adr++ % len]);
483 >        if (len) {
484 >                while (adr <= end_adr)
485 >                        mon_write_byte(adr++, str[src_adr++ % len]);
486 >        }
487 >
488 >        free(str);
489   }
490  
491  
# Line 513 | Line 546 | void compare(void)
546  
547          while (adr <= end_adr && !mon_aborted()) {
548                  if (mon_read_byte(adr) != mon_read_byte(dest)) {
549 <                        fprintf(monout, "%0*lx ", 2 * sizeof(adr), mon_use_real_mem ? adr : adr % mon_mem_size);
549 >                        fprintf(monout, "%0*lx ", int(2 * sizeof(adr)), mon_use_real_mem ? adr : adr % mon_mem_size);
550                          num++;
551                          if (!(num & 7))
552                                  fputc('\n', monout);
# Line 535 | Line 568 | void compare(void)
568   void hunt(void)
569   {
570          uintptr adr, end_adr, len;
571 <        uint8 str[256];
571 >        uint8 *str;
572          int num = 0;
573  
574          if (!mon_expression(&adr))
# Line 553 | Line 586 | void hunt(void)
586                                  break;
587  
588                  if (i == len) {
589 <                        fprintf(monout, "%0*lx ", 2 * sizeof(adr), mon_use_real_mem ? adr : adr % mon_mem_size);
589 >                        fprintf(monout, "%0*lx ", int(2 * sizeof(adr)), mon_use_real_mem ? adr : adr % mon_mem_size);
590                          num++;
591                          if (num == 1)
592                                  mon_dot_address = adr;
# Line 563 | Line 596 | void hunt(void)
596                  adr++;
597          }
598  
599 +        free(str);
600 +
601          if (num & 7)
602                  fputc('\n', monout);
603          fprintf(monout, "Found %d occurrences\n", num);
# Line 605 | Line 640 | void load_data(void)
640                          mon_write_byte(adr++, fc);
641                  fclose(file);
642  
643 <                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);
643 >                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);
644                  mon_dot_address = adr;
645          }
646   }
# Line 648 | Line 683 | void save_data(void)
683                          fputc(mon_read_byte(adr++), file);
684                  fclose(file);
685  
686 <                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);
686 >                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);
687          }
688   }

Diff Legend

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