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.1.1.1 by cebix, 1999-10-04T19:31:09Z vs.
Revision 1.6 by hellwig, 2000-06-10T19:07:37Z

# Line 1 | Line 1
1   /*
2   *  mon_cmd.cpp - mon standard commands
3   *
4 < *  (C) 1997-1999 Christian Bauer
4 > *  mon (C) 1997-1999 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
8 > *  the Free Software Foundation; either version 2 of the License, or
9 > *  (at your option) any later version.
10 > *
11 > *  This program is distributed in the hope that it will be useful,
12 > *  but WITHOUT ANY WARRANTY; without even the implied warranty of
13 > *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14 > *  GNU General Public License for more details.
15 > *
16 > *  You should have received a copy of the GNU General Public License
17 > *  along with this program; if not, write to the Free Software
18 > *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
19   */
20  
21 < #include <stdio.h>
22 < #include <string.h>
23 < #include <unistd.h>
21 > #include "sysdeps.h"
22 >
23 > #include <stdlib.h>
24  
25   #include "mon.h"
26   #include "mon_cmd.h"
# Line 16 | Line 30
30   #include "mon_6502.h"
31   #include "mon_8080.h"
32  
33 + #ifndef VERSION
34 + #define VERSION "2"
35 + #endif
36 +
37  
38   /*
39   *  range_args = [expression] [[COMMA] expression] END
# Line 104 | Line 122 | static inline uint8 char2print(uint8 c)
122  
123   void version(void)
124   {
125 <        fprintf(monout, "mon V%d.%d\n", MON_VERSION, MON_REVISION);
125 >        fprintf(monout, "mon V" VERSION "\n");
126   }
127  
128  
# Line 157 | Line 175 | void print_expr(void)
175          }
176  
177          if (val > 0x7fffffff) {
178 <                fprintf(monout, "Hex unsigned:  $%08lx\n"
179 <                                          "Hex signed  : -$%08lx\n"
180 <                                          "Dec unsigned:  %lu\n"
181 <                                          "Dec signed  : %ld\n", val, -val, val, val);
178 >                fprintf(monout, "Hex unsigned:  $%08x\n"
179 >                                          "Hex signed  : -$%08x\n"
180 >                                          "Dec unsigned:  %u\n"
181 >                                          "Dec signed  : %d\n", val, -val, val, val);
182                  fprintf(monout, "Char        : '%c%c%c%c'\n", char2print(val >> 24), char2print(val >> 16), char2print(val >> 8), char2print(val));
183          } else {
184 <                fprintf(monout, "Hex : $%08lx\n"
185 <                                          "Dec : %ld\n", val, val);
184 >                fprintf(monout, "Hex : $%08x\n"
185 >                                          "Dec : %d\n", val, val);
186                  fprintf(monout, "Char: '%c%c%c%c'\n", char2print(val >> 24), char2print(val >> 16), char2print(val >> 8), char2print(val));
187          }
188   }
# Line 208 | Line 226 | void memory_dump(void)
226                  return;
227  
228          while (adr <= end_adr && !mon_aborted()) {
229 <                fprintf(monout, "%08lx:", mon_use_real_mem ? adr: adr % mon_mem_size);
229 >                fprintf(monout, "%08x:", mon_use_real_mem ? adr: adr % mon_mem_size);
230                  for (int i=0; i<MEMDUMP_BPL; i++, adr++) {
231                          if (i % 4 == 0)
232 <                                fprintf(monout, " %08lx", mon_read_word(adr));
232 >                                fprintf(monout, " %08x", mon_read_word(adr));
233                          mem[i] = char2print(mon_read_byte(adr));
234                  }
235                  fprintf(monout, "  '%s'\n", mem);
# Line 239 | Line 257 | void ascii_dump(void)
257                  return;
258  
259          while (adr <= end_adr && !mon_aborted()) {
260 <                fprintf(monout, "%08lx:", mon_use_real_mem ? adr : adr % mon_mem_size);
260 >                fprintf(monout, "%08x:", mon_use_real_mem ? adr : adr % mon_mem_size);
261                  for (int i=0; i<ASCIIDUMP_BPL; i++, adr++)
262                          str[i] = char2print(mon_read_byte(adr));
263                  fprintf(monout, " '%s'\n", str);
# Line 250 | Line 268 | void ascii_dump(void)
268  
269  
270   /*
271 + *  Binary dump
272 + *  b [start [end]]
273 + */
274 +
275 + void binary_dump(void)
276 + {
277 +        uint32 adr, end_adr;
278 +        uint8 str[9];
279 +
280 +        str[8] = 0;
281 +
282 +        if (!range_args(&adr, &end_adr, 7))  // 8 lines unless end address specified
283 +                return;
284 +
285 +        while (adr <= end_adr && !mon_aborted()) {
286 +                fprintf(monout, "%08x:", mon_use_real_mem ? adr : adr % mon_mem_size);
287 +                uint8 b = mon_read_byte(adr);
288 +                for (int m=0x80, i=0; i<8; m>>=1, i++)
289 +                        str[i] = (b & m) ? '*' : '.';
290 +                fprintf(monout, " '%s'\n", str);
291 +                adr++;
292 +        }
293 +
294 +        mon_dot_address = adr;
295 + }
296 +
297 +
298 + /*
299   *  Disassemble
300   *  d [start [end]]
301   *  d65 [start [end]]
# Line 277 | Line 323 | static void disassemble(CPUType type)
323                  case CPU_PPC:
324                          while (adr <= end_adr && !mon_aborted()) {
325                                  uint32 w = mon_read_word(adr);
326 <                                fprintf(monout, "%08lx: %08lx\t", mon_use_real_mem ? adr : adr % mon_mem_size, w);
326 >                                fprintf(monout, "%08x: %08x\t", mon_use_real_mem ? adr : adr % mon_mem_size, w);
327                                  disass_ppc(monout, mon_use_real_mem ? adr : adr % mon_mem_size, w);
328                                  adr += 4;
329                          }
# Line 288 | Line 334 | static void disassemble(CPUType type)
334                                  uint8 op = mon_read_byte(adr);
335                                  uint8 lo = mon_read_byte(adr + 1);
336                                  uint8 hi = mon_read_byte(adr + 2);
337 <                                fprintf(monout, "%08lx: ", mon_use_real_mem ? adr : adr % mon_mem_size);
337 >                                fprintf(monout, "%08x: ", mon_use_real_mem ? adr : adr % mon_mem_size);
338                                  adr += disass_6502(monout, mon_use_real_mem ? adr : adr % mon_mem_size, op, lo, hi);
339                          }
340                          break;
# Line 304 | Line 350 | static void disassemble(CPUType type)
350                                  buf[5] = mon_read_half(adr + 10);
351                                  buf[6] = mon_read_half(adr + 12);
352                                  buf[7] = mon_read_half(adr + 14);
353 <                                fprintf(monout, "%08lx: ", mon_use_real_mem ? adr : adr % mon_mem_size);
353 >                                fprintf(monout, "%08x: ", mon_use_real_mem ? adr : adr % mon_mem_size);
354                                  adr += disass_68k(monout, mon_use_real_mem ? adr : adr % mon_mem_size, buf);
355                          }
356                          break;
# Line 314 | Line 360 | static void disassemble(CPUType type)
360                                  uint8 op = mon_read_byte(adr);
361                                  uint8 lo = mon_read_byte(adr + 1);
362                                  uint8 hi = mon_read_byte(adr + 2);
363 <                                fprintf(monout, "%08lx: ", mon_use_real_mem ? adr : adr % mon_mem_size);
363 >                                fprintf(monout, "%08x: ", mon_use_real_mem ? adr : adr % mon_mem_size);
364                                  adr += disass_8080(monout, mon_use_real_mem ? adr : adr % mon_mem_size, op, lo, hi);
365                          }
366                          break;
# Line 324 | Line 370 | static void disassemble(CPUType type)
370                                  uint8 buf[16];
371                                  for (int i=0; i<16; i++)
372                                          buf[i] = mon_read_byte(adr + i);
373 <                                fprintf(monout, "%08lx: ", mon_use_real_mem ? adr : adr % mon_mem_size);
373 >                                fprintf(monout, "%08x: ", mon_use_real_mem ? adr : adr % mon_mem_size);
374                                  adr += disass_x86(monout, mon_use_real_mem ? adr : adr % mon_mem_size, buf);
375                          }
376                          break;
# Line 460 | Line 506 | void compare(void)
506  
507          while (adr <= end_adr && !mon_aborted()) {
508                  if (mon_read_byte(adr) != mon_read_byte(dest)) {
509 <                        fprintf(monout, "%08lx ", mon_use_real_mem ? adr : adr % mon_mem_size);
509 >                        fprintf(monout, "%08x ", mon_use_real_mem ? adr : adr % mon_mem_size);
510                          num++;
511                          if (!(num & 7))
512                                  fputc('\n', monout);
# Line 500 | Line 546 | void hunt(void)
546                                  break;
547  
548                  if (i == len) {
549 <                        fprintf(monout, "%08lx ", mon_use_real_mem ? adr : adr % mon_mem_size);
549 >                        fprintf(monout, "%08x ", mon_use_real_mem ? adr : adr % mon_mem_size);
550                          num++;
551                          if (num == 1)
552                                  mon_dot_address = adr;
# Line 552 | Line 598 | void load_data(void)
598                          mon_write_byte(adr++, fc);
599                  fclose(file);
600  
601 <                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);
601 >                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);
602                  mon_dot_address = adr;
603          }
604   }
# Line 595 | Line 641 | void save_data(void)
641                          fputc(mon_read_byte(adr++), file);
642                  fclose(file);
643  
644 <                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);
644 >                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);
645          }
646   }

Diff Legend

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