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.2 by cebix, 1999-10-04T21:16:02Z vs.
Revision 1.8 by cebix, 2000-10-06T00:04:22Z

# Line 20 | Line 20
20  
21   #include "sysdeps.h"
22  
23 + #include <stdlib.h>
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"
30 < #include "version.h"
27 > #include "mon_disass.h"
28 >
29 > #ifndef VERSION
30 > #define VERSION "2"
31 > #endif
32  
33  
34   /*
# Line 117 | Line 118 | static inline uint8 char2print(uint8 c)
118  
119   void version(void)
120   {
121 <        fprintf(monout, "mon V%d.%d\n", VERSION_MAJOR, VERSION_MINOR);
121 >        fprintf(monout, "mon V" VERSION "\n");
122   }
123  
124  
# Line 170 | Line 171 | void print_expr(void)
171          }
172  
173          if (val > 0x7fffffff) {
174 <                fprintf(monout, "Hex unsigned:  $%08lx\n"
175 <                                          "Hex signed  : -$%08lx\n"
176 <                                          "Dec unsigned:  %lu\n"
177 <                                          "Dec signed  : %ld\n", val, -val, val, val);
174 >                fprintf(monout, "Hex unsigned:  $%08x\n"
175 >                                          "Hex signed  : -$%08x\n"
176 >                                          "Dec unsigned:  %u\n"
177 >                                          "Dec signed  : %d\n", val, -val, val, val);
178                  fprintf(monout, "Char        : '%c%c%c%c'\n", char2print(val >> 24), char2print(val >> 16), char2print(val >> 8), char2print(val));
179          } else {
180 <                fprintf(monout, "Hex : $%08lx\n"
181 <                                          "Dec : %ld\n", val, val);
180 >                fprintf(monout, "Hex : $%08x\n"
181 >                                          "Dec : %d\n", val, val);
182                  fprintf(monout, "Char: '%c%c%c%c'\n", char2print(val >> 24), char2print(val >> 16), char2print(val >> 8), char2print(val));
183          }
184   }
# Line 221 | Line 222 | void memory_dump(void)
222                  return;
223  
224          while (adr <= end_adr && !mon_aborted()) {
225 <                fprintf(monout, "%08lx:", mon_use_real_mem ? adr: adr % mon_mem_size);
225 >                fprintf(monout, "%08x:", mon_use_real_mem ? adr: adr % mon_mem_size);
226                  for (int i=0; i<MEMDUMP_BPL; i++, adr++) {
227                          if (i % 4 == 0)
228 <                                fprintf(monout, " %08lx", mon_read_word(adr));
228 >                                fprintf(monout, " %08x", mon_read_word(adr));
229                          mem[i] = char2print(mon_read_byte(adr));
230                  }
231                  fprintf(monout, "  '%s'\n", mem);
# Line 252 | Line 253 | void ascii_dump(void)
253                  return;
254  
255          while (adr <= end_adr && !mon_aborted()) {
256 <                fprintf(monout, "%08lx:", mon_use_real_mem ? adr : adr % mon_mem_size);
256 >                fprintf(monout, "%08x:", mon_use_real_mem ? adr : adr % mon_mem_size);
257                  for (int i=0; i<ASCIIDUMP_BPL; i++, adr++)
258                          str[i] = char2print(mon_read_byte(adr));
259                  fprintf(monout, " '%s'\n", str);
# Line 263 | Line 264 | void ascii_dump(void)
264  
265  
266   /*
267 + *  Binary dump
268 + *  b [start [end]]
269 + */
270 +
271 + void binary_dump(void)
272 + {
273 +        uint32 adr, end_adr;
274 +        uint8 str[9];
275 +
276 +        str[8] = 0;
277 +
278 +        if (!range_args(&adr, &end_adr, 7))  // 8 lines unless end address specified
279 +                return;
280 +
281 +        while (adr <= end_adr && !mon_aborted()) {
282 +                fprintf(monout, "%08x:", mon_use_real_mem ? adr : adr % mon_mem_size);
283 +                uint8 b = mon_read_byte(adr);
284 +                for (int m=0x80, i=0; i<8; m>>=1, i++)
285 +                        str[i] = (b & m) ? '*' : '.';
286 +                fprintf(monout, " '%s'\n", str);
287 +                adr++;
288 +        }
289 +
290 +        mon_dot_address = adr;
291 + }
292 +
293 +
294 + /*
295   *  Disassemble
296   *  d [start [end]]
297   *  d65 [start [end]]
# Line 276 | Line 305 | enum CPUType {
305          CPU_6502,
306          CPU_680x0,
307          CPU_8080,
308 <        CPU_80x86
308 >        CPU_80x86_32,
309 >        CPU_80x86_16
310   };
311  
312   static void disassemble(CPUType type)
# Line 290 | Line 320 | static void disassemble(CPUType type)
320                  case CPU_PPC:
321                          while (adr <= end_adr && !mon_aborted()) {
322                                  uint32 w = mon_read_word(adr);
323 <                                fprintf(monout, "%08lx: %08lx\t", mon_use_real_mem ? adr : adr % mon_mem_size, w);
323 >                                fprintf(monout, "%08x: %08x\t", mon_use_real_mem ? adr : adr % mon_mem_size, w);
324                                  disass_ppc(monout, mon_use_real_mem ? adr : adr % mon_mem_size, w);
325                                  adr += 4;
326                          }
# Line 301 | Line 331 | static void disassemble(CPUType type)
331                                  uint8 op = mon_read_byte(adr);
332                                  uint8 lo = mon_read_byte(adr + 1);
333                                  uint8 hi = mon_read_byte(adr + 2);
334 <                                fprintf(monout, "%08lx: ", mon_use_real_mem ? adr : adr % mon_mem_size);
334 >                                fprintf(monout, "%08x: ", mon_use_real_mem ? adr : adr % mon_mem_size);
335                                  adr += disass_6502(monout, mon_use_real_mem ? adr : adr % mon_mem_size, op, lo, hi);
336                          }
337                          break;
338  
339                  case CPU_680x0:
340                          while (adr <= end_adr && !mon_aborted()) {
341 <                                uint16 buf[8];
342 <                                buf[0] = mon_read_half(adr);
313 <                                buf[1] = mon_read_half(adr + 2);
314 <                                buf[2] = mon_read_half(adr + 4);
315 <                                buf[3] = mon_read_half(adr + 6);
316 <                                buf[4] = mon_read_half(adr + 8);
317 <                                buf[5] = mon_read_half(adr + 10);
318 <                                buf[6] = mon_read_half(adr + 12);
319 <                                buf[7] = mon_read_half(adr + 14);
320 <                                fprintf(monout, "%08lx: ", mon_use_real_mem ? adr : adr % mon_mem_size);
321 <                                adr += disass_68k(monout, mon_use_real_mem ? adr : adr % mon_mem_size, buf);
341 >                                fprintf(monout, "%08x: ", mon_use_real_mem ? adr : adr % mon_mem_size);
342 >                                adr += disass_68k(monout, mon_use_real_mem ? adr : adr % mon_mem_size);
343                          }
344                          break;
345  
# Line 327 | Line 348 | static void disassemble(CPUType type)
348                                  uint8 op = mon_read_byte(adr);
349                                  uint8 lo = mon_read_byte(adr + 1);
350                                  uint8 hi = mon_read_byte(adr + 2);
351 <                                fprintf(monout, "%08lx: ", mon_use_real_mem ? adr : adr % mon_mem_size);
351 >                                fprintf(monout, "%08x: ", mon_use_real_mem ? adr : adr % mon_mem_size);
352                                  adr += disass_8080(monout, mon_use_real_mem ? adr : adr % mon_mem_size, op, lo, hi);
353                          }
354                          break;
355  
356 <                case CPU_80x86:
356 >                case CPU_80x86_32:
357                          while (adr <= end_adr && !mon_aborted()) {
358 <                                uint8 buf[16];
359 <                                for (int i=0; i<16; i++)
360 <                                        buf[i] = mon_read_byte(adr + i);
361 <                                fprintf(monout, "%08lx: ", mon_use_real_mem ? adr : adr % mon_mem_size);
362 <                                adr += disass_x86(monout, mon_use_real_mem ? adr : adr % mon_mem_size, buf);
358 >                                fprintf(monout, "%08x: ", mon_use_real_mem ? adr : adr % mon_mem_size);
359 >                                adr += disass_x86(monout, mon_use_real_mem ? adr : adr % mon_mem_size, false);
360 >                        }
361 >                        break;
362 >
363 >                case CPU_80x86_16:
364 >                        while (adr <= end_adr && !mon_aborted()) {
365 >                                fprintf(monout, "%08x: ", mon_use_real_mem ? adr : adr % mon_mem_size);
366 >                                adr += disass_x86(monout, mon_use_real_mem ? adr : adr % mon_mem_size, true);
367                          }
368                          break;
369          }
# Line 366 | Line 391 | void disassemble_8080(void)
391          disassemble(CPU_8080);
392   }
393  
394 < void disassemble_80x86(void)
394 > void disassemble_80x86_32(void)
395 > {
396 >        disassemble(CPU_80x86_32);
397 > }
398 >
399 > void disassemble_80x86_16(void)
400   {
401 <        disassemble(CPU_80x86);
401 >        disassemble(CPU_80x86_16);
402   }
403  
404  
# Line 473 | Line 503 | void compare(void)
503  
504          while (adr <= end_adr && !mon_aborted()) {
505                  if (mon_read_byte(adr) != mon_read_byte(dest)) {
506 <                        fprintf(monout, "%08lx ", mon_use_real_mem ? adr : adr % mon_mem_size);
506 >                        fprintf(monout, "%08x ", mon_use_real_mem ? adr : adr % mon_mem_size);
507                          num++;
508                          if (!(num & 7))
509                                  fputc('\n', monout);
# Line 513 | Line 543 | void hunt(void)
543                                  break;
544  
545                  if (i == len) {
546 <                        fprintf(monout, "%08lx ", mon_use_real_mem ? adr : adr % mon_mem_size);
546 >                        fprintf(monout, "%08x ", mon_use_real_mem ? adr : adr % mon_mem_size);
547                          num++;
548                          if (num == 1)
549                                  mon_dot_address = adr;
# Line 565 | Line 595 | void load_data(void)
595                          mon_write_byte(adr++, fc);
596                  fclose(file);
597  
598 <                fprintf(monerr, "%08lx bytes read from %08lx to %08lx\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);
598 >                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);
599                  mon_dot_address = adr;
600          }
601   }
# Line 608 | Line 638 | void save_data(void)
638                          fputc(mon_read_byte(adr++), file);
639                  fclose(file);
640  
641 <                fprintf(monerr, "%08lx bytes written from %08lx to %08lx\n", size, mon_use_real_mem ? start_adr : start_adr % mon_mem_size, mon_use_real_mem ? end_adr : end_adr % mon_mem_size);
641 >                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);
642          }
643   }

Diff Legend

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