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.4 by cebix, 1999-10-25T08:04:47Z

# 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"
# Line 27 | Line 29
29   #include "mon_x86.h"
30   #include "mon_6502.h"
31   #include "mon_8080.h"
30 – #include "version.h"
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%d.%d\n", MON_VERSION_MAJOR, MON_VERSION_MINOR);
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 290 | Line 291 | static void disassemble(CPUType type)
291                  case CPU_PPC:
292                          while (adr <= end_adr && !mon_aborted()) {
293                                  uint32 w = mon_read_word(adr);
294 <                                fprintf(monout, "%08lx: %08lx\t", mon_use_real_mem ? adr : adr % mon_mem_size, w);
294 >                                fprintf(monout, "%08x: %08x\t", mon_use_real_mem ? adr : adr % mon_mem_size, w);
295                                  disass_ppc(monout, mon_use_real_mem ? adr : adr % mon_mem_size, w);
296                                  adr += 4;
297                          }
# Line 301 | Line 302 | static void disassemble(CPUType type)
302                                  uint8 op = mon_read_byte(adr);
303                                  uint8 lo = mon_read_byte(adr + 1);
304                                  uint8 hi = mon_read_byte(adr + 2);
305 <                                fprintf(monout, "%08lx: ", mon_use_real_mem ? adr : adr % mon_mem_size);
305 >                                fprintf(monout, "%08x: ", mon_use_real_mem ? adr : adr % mon_mem_size);
306                                  adr += disass_6502(monout, mon_use_real_mem ? adr : adr % mon_mem_size, op, lo, hi);
307                          }
308                          break;
# Line 317 | Line 318 | static void disassemble(CPUType type)
318                                  buf[5] = mon_read_half(adr + 10);
319                                  buf[6] = mon_read_half(adr + 12);
320                                  buf[7] = mon_read_half(adr + 14);
321 <                                fprintf(monout, "%08lx: ", mon_use_real_mem ? adr : adr % mon_mem_size);
321 >                                fprintf(monout, "%08x: ", mon_use_real_mem ? adr : adr % mon_mem_size);
322                                  adr += disass_68k(monout, mon_use_real_mem ? adr : adr % mon_mem_size, buf);
323                          }
324                          break;
# Line 327 | Line 328 | static void disassemble(CPUType type)
328                                  uint8 op = mon_read_byte(adr);
329                                  uint8 lo = mon_read_byte(adr + 1);
330                                  uint8 hi = mon_read_byte(adr + 2);
331 <                                fprintf(monout, "%08lx: ", mon_use_real_mem ? adr : adr % mon_mem_size);
331 >                                fprintf(monout, "%08x: ", mon_use_real_mem ? adr : adr % mon_mem_size);
332                                  adr += disass_8080(monout, mon_use_real_mem ? adr : adr % mon_mem_size, op, lo, hi);
333                          }
334                          break;
# Line 337 | Line 338 | static void disassemble(CPUType type)
338                                  uint8 buf[16];
339                                  for (int i=0; i<16; i++)
340                                          buf[i] = mon_read_byte(adr + i);
341 <                                fprintf(monout, "%08lx: ", mon_use_real_mem ? adr : adr % mon_mem_size);
341 >                                fprintf(monout, "%08x: ", mon_use_real_mem ? adr : adr % mon_mem_size);
342                                  adr += disass_x86(monout, mon_use_real_mem ? adr : adr % mon_mem_size, buf);
343                          }
344                          break;
# Line 473 | Line 474 | void compare(void)
474  
475          while (adr <= end_adr && !mon_aborted()) {
476                  if (mon_read_byte(adr) != mon_read_byte(dest)) {
477 <                        fprintf(monout, "%08lx ", mon_use_real_mem ? adr : adr % mon_mem_size);
477 >                        fprintf(monout, "%08x ", mon_use_real_mem ? adr : adr % mon_mem_size);
478                          num++;
479                          if (!(num & 7))
480                                  fputc('\n', monout);
# Line 513 | Line 514 | void hunt(void)
514                                  break;
515  
516                  if (i == len) {
517 <                        fprintf(monout, "%08lx ", mon_use_real_mem ? adr : adr % mon_mem_size);
517 >                        fprintf(monout, "%08x ", mon_use_real_mem ? adr : adr % mon_mem_size);
518                          num++;
519                          if (num == 1)
520                                  mon_dot_address = adr;
# Line 565 | Line 566 | void load_data(void)
566                          mon_write_byte(adr++, fc);
567                  fclose(file);
568  
569 <                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);
569 >                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);
570                  mon_dot_address = adr;
571          }
572   }
# Line 608 | Line 609 | void save_data(void)
609                          fputc(mon_read_byte(adr++), file);
610                  fclose(file);
611  
612 <                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);
612 >                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);
613          }
614   }

Diff Legend

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