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.16 by cebix, 2004-02-12T17:14:36Z 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-2003 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 82 | Line 82 | static bool byte_string(uint8 *&str, uin
82  
83   start:
84                          if (mon_token == T_STRING) {
85 –                                uint8 *p = (uint8 *)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);
# Line 127 | 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 231 | 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 262 | 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 288 | 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 317 | 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 331 | 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 342 | 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 420 | 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 461 | 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   }
# Line 525 | 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 565 | 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 619 | 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 662 | 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