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.5 by cebix, 2000-04-24T13:10:17Z vs.
Revision 1.19 by cebix, 2007-01-21T17:32:05Z

# Line 1 | Line 1
1   /*
2 < *  mon_cmd.cpp - mon standard commands
2 > *  mon_cmd.cpp - cxmon standard commands
3   *
4 < *  mon (C) 1997-1999 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 24 | Line 24
24  
25   #include "mon.h"
26   #include "mon_cmd.h"
27 < #include "mon_ppc.h"
28 < #include "mon_68k.h"
29 < #include "mon_x86.h"
30 < #include "mon_6502.h"
31 < #include "mon_8080.h"
27 > #include "mon_disass.h"
28 >
29 > #ifndef VERSION
30 > #define VERSION "3"
31 > #endif
32  
33  
34   /*
# Line 40 | Line 40
40   *  true: OK, false: Error
41   */
42  
43 < static bool range_args(uint32 *adr, uint32 *end_adr, uint32 def_range)
43 > static bool range_args(uintptr *adr, uintptr *end_adr, uint32 def_range)
44   {
45          *adr = mon_dot_address;
46          *end_adr = mon_dot_address + def_range;
# Line 67 | Line 67 | static bool range_args(uint32 *adr, uint
67   *  byte_string = (expression | STRING) {COMMA (expression | STRING)} END
68   */
69  
70 < static bool byte_string(uint8 *s, uint32 &len)
70 > static bool byte_string(uint8 *&str, uintptr &len)
71   {
72 <        uint32 value;
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, uint32
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 161 | Line 169 | void redir_output(void)
169  
170   void print_expr(void)
171   {
172 <        uint32 val;
172 >        uintptr val;
173  
174          if (!mon_expression(&val))
175                  return;
# Line 213 | Line 221 | void shell_command(void)
221  
222   void memory_dump(void)
223   {
224 <        uint32 adr, end_adr;
224 >        uintptr adr, end_adr;
225          uint8 mem[MEMDUMP_BPL + 1];
226  
227          mem[MEMDUMP_BPL] = 0;
# Line 222 | Line 230 | void memory_dump(void)
230                  return;
231  
232          while (adr <= end_adr && !mon_aborted()) {
233 <                fprintf(monout, "%08x:", 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 244 | Line 252 | void memory_dump(void)
252  
253   void ascii_dump(void)
254   {
255 <        uint32 adr, end_adr;
255 >        uintptr adr, end_adr;
256          uint8 str[ASCIIDUMP_BPL + 1];
257  
258          str[ASCIIDUMP_BPL] = 0;
# 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 270 | Line 278 | void ascii_dump(void)
278  
279   void binary_dump(void)
280   {
281 <        uint32 adr, end_adr;
281 >        uintptr adr, end_adr;
282          uint8 str[9];
283  
284          str[8] = 0;
# 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 298 | Line 306 | void binary_dump(void)
306   *  d68 [start [end]]
307   *  d80 [start [end]]
308   *  d86 [start [end]]
309 + *  d8086 [start [end]]
310   */
311  
312   enum CPUType {
313          CPU_PPC,
314          CPU_6502,
315          CPU_680x0,
316 <        CPU_8080,
317 <        CPU_80x86
316 >        CPU_Z80,
317 >        CPU_80x86_32,
318 >        CPU_80x86_16,
319 >        CPU_x86_64
320   };
321  
322   static void disassemble(CPUType type)
323   {
324 <        uint32 adr, end_adr;
324 >        uintptr adr, end_adr;
325  
326          if (!range_args(&adr, &end_adr, 16 * 4 - 1))  // 16 lines unless end address specified
327                  return;
# Line 319 | 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 330 | 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 <                                uint16 buf[8];
352 <                                buf[0] = mon_read_half(adr);
342 <                                buf[1] = mon_read_half(adr + 2);
343 <                                buf[2] = mon_read_half(adr + 4);
344 <                                buf[3] = mon_read_half(adr + 6);
345 <                                buf[4] = mon_read_half(adr + 8);
346 <                                buf[5] = mon_read_half(adr + 10);
347 <                                buf[6] = mon_read_half(adr + 12);
348 <                                buf[7] = mon_read_half(adr + 14);
349 <                                fprintf(monout, "%08x: ", mon_use_real_mem ? adr : adr % mon_mem_size);
350 <                                adr += disass_68k(monout, mon_use_real_mem ? adr : adr % mon_mem_size, buf);
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_8080:
356 >                case CPU_Z80:
357                          while (adr <= end_adr && !mon_aborted()) {
358 <                                uint8 op = mon_read_byte(adr);
359 <                                uint8 lo = mon_read_byte(adr + 1);
358 <                                uint8 hi = mon_read_byte(adr + 2);
359 <                                fprintf(monout, "%08x: ", mon_use_real_mem ? adr : adr % mon_mem_size);
360 <                                adr += disass_8080(monout, mon_use_real_mem ? adr : adr % mon_mem_size, op, lo, hi);
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_80x86:
363 >                case CPU_x86_64:
364                          while (adr <= end_adr && !mon_aborted()) {
365 <                                uint8 buf[16];
366 <                                for (int i=0; i<16; i++)
368 <                                        buf[i] = mon_read_byte(adr + i);
369 <                                fprintf(monout, "%08x: ", mon_use_real_mem ? adr : adr % mon_mem_size);
370 <                                adr += disass_x86(monout, mon_use_real_mem ? adr : adr % mon_mem_size, buf);
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, "%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, "%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 +                        }
382          }
383  
384          mon_dot_address = adr;
# Line 390 | Line 399 | void disassemble_680x0(void)
399          disassemble(CPU_680x0);
400   }
401  
402 < void disassemble_8080(void)
402 > void disassemble_z80(void)
403 > {
404 >        disassemble(CPU_Z80);
405 > }
406 >
407 > void disassemble_80x86_32(void)
408   {
409 <        disassemble(CPU_8080);
409 >        disassemble(CPU_80x86_32);
410   }
411  
412 < void disassemble_80x86(void)
412 > void disassemble_80x86_16(void)
413   {
414 <        disassemble(CPU_80x86);
414 >        disassemble(CPU_80x86_16);
415 > }
416 >
417 > void disassemble_x86_64(void)
418 > {
419 >        disassemble(CPU_x86_64);
420   }
421  
422  
# Line 408 | Line 427 | void disassemble_80x86(void)
427  
428   void modify(void)
429   {
430 <        uint32 adr, len, src_adr = 0;
431 <        uint8 str[256];
430 >        uintptr adr, len, src_adr = 0;
431 >        uint8 *str;
432  
433          if (!mon_expression(&adr))
434                  return;
# Line 418 | Line 437 | void modify(void)
437  
438          while (src_adr < len)
439                  mon_write_byte(adr++, str[src_adr++]);
421
440          mon_dot_address = adr;
441 +
442 +        free(str);
443   }
444  
445  
# Line 430 | Line 450 | void modify(void)
450  
451   void fill(void)
452   {
453 <        uint32 adr, end_adr, len, src_adr = 0;
454 <        uint8 str[256];
453 >        uintptr adr, end_adr, len, src_adr = 0;
454 >        uint8 *str;
455  
456          if (!mon_expression(&adr))
457                  return;
# Line 442 | 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 452 | Line 474 | void fill(void)
474  
475   void transfer(void)
476   {
477 <        uint32 adr, end_adr, dest;
477 >        uintptr adr, end_adr, dest;
478          int num;
479  
480          if (!mon_expression(&adr))
# Line 486 | Line 508 | void transfer(void)
508  
509   void compare(void)
510   {
511 <        uint32 adr, end_adr, dest;
511 >        uintptr adr, end_adr, dest;
512          int num = 0;
513  
514          if (!mon_expression(&adr))
# Line 502 | 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 545 | void compare(void)
545  
546   void hunt(void)
547   {
548 <        uint32 adr, end_adr, len;
549 <        uint8 str[256];
548 >        uintptr adr, end_adr, len;
549 >        uint8 *str;
550          int num = 0;
551  
552          if (!mon_expression(&adr))
# Line 542 | 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 552 | 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 565 | Line 589 | void hunt(void)
589  
590   void load_data(void)
591   {
592 <        uint32 start_adr;
592 >        uintptr start_adr;
593          FILE *file;
594          int fc;
595  
# Line 588 | Line 612 | void load_data(void)
612          if (!(file = fopen(mon_string, "rb")))
613                  mon_error("Unable to open file");
614          else {
615 <                uint32 adr = start_adr;
615 >                uintptr adr = start_adr;
616  
617                  while ((fc = fgetc(file)) != EOF)
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 607 | Line 631 | void load_data(void)
631  
632   void save_data(void)
633   {
634 <        uint32 start_adr, size;
634 >        uintptr start_adr, size;
635          FILE *file;
636  
637          if (!mon_expression(&start_adr))
# Line 631 | Line 655 | void save_data(void)
655          if (!(file = fopen(mon_string, "wb")))
656                  mon_error("Unable to create file");
657          else {
658 <                uint32 adr = start_adr, end_adr = start_adr + size - 1;
658 >                uintptr adr = start_adr, end_adr = start_adr + size - 1;
659  
660                  while (adr <= end_adr)
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