ViewVC Help

View File | Revision Log | Show Annotations | Revision Graph | Root Listing

root/cebix/mon/src/mon_cmd.cpp

Comparing mon/src/mon_cmd.cpp (file contents):
Revision 1.5 by cebix, 2000-04-24T13:10:17Z vs.
Revision 1.14 by cebix, 2003-06-19T15:07:46Z

#	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-2002 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 *s, uintptr &len)
71		{
72	<	uint32 value;
72	>	uintptr value;
73
74		len = 0;
75		goto start;
#	Line 161 | Line 161 | void redir_output(void)
161
162		void print_expr(void)
163		{
164	<	uint32 val;
164	>	uintptr val;
165
166		if (!mon_expression(&val))
167		return;
#	Line 213 | Line 213 | void shell_command(void)
213
214		void memory_dump(void)
215		{
216	<	uint32 adr, end_adr;
216	>	uintptr adr, end_adr;
217		uint8 mem[MEMDUMP_BPL + 1];
218
219		mem[MEMDUMP_BPL] = 0;
#	Line 222 | Line 222 | void memory_dump(void)
222		return;
223
224		while (adr <= end_adr && !mon_aborted()) {
225	<	fprintf(monout, "%08x:", mon_use_real_mem ? adr: adr % mon_mem_size);
225	>	fprintf(monout, "%0*lx:", 2 * sizeof(adr), 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, " %08x", mon_read_word(adr));
#	Line 244 | Line 244 | void memory_dump(void)
244
245		void ascii_dump(void)
246		{
247	<	uint32 adr, end_adr;
247	>	uintptr adr, end_adr;
248		uint8 str[ASCIIDUMP_BPL + 1];
249
250		str[ASCIIDUMP_BPL] = 0;
#	Line 253 | Line 253 | void ascii_dump(void)
253		return;
254
255		while (adr <= end_adr && !mon_aborted()) {
256	<	fprintf(monout, "%08x:", mon_use_real_mem ? adr : adr % mon_mem_size);
256	>	fprintf(monout, "%0*lx:", 2 * sizeof(adr), 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 270 | Line 270 | void ascii_dump(void)
270
271		void binary_dump(void)
272		{
273	<	uint32 adr, end_adr;
273	>	uintptr adr, end_adr;
274		uint8 str[9];
275
276		str[8] = 0;
#	Line 279 | Line 279 | void binary_dump(void)
279		return;
280
281		while (adr <= end_adr && !mon_aborted()) {
282	<	fprintf(monout, "%08x:", mon_use_real_mem ? adr : adr % mon_mem_size);
282	>	fprintf(monout, "%0*lx:", 2 * sizeof(adr), 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) ? '*' : '.';
#	Line 298 | Line 298 | void binary_dump(void)
298		*  d68 [start [end]]
299		*  d80 [start [end]]
300		*  d86 [start [end]]
301	+	*  d8086 [start [end]]
302		*/
303
304		enum CPUType {
305		CPU_PPC,
306		CPU_6502,
307		CPU_680x0,
308	<	CPU_8080,
309	<	CPU_80x86
308	>	CPU_Z80,
309	>	CPU_80x86_32,
310	>	CPU_80x86_16,
311	>	CPU_x86_64
312		};
313
314		static void disassemble(CPUType type)
315		{
316	<	uint32 adr, end_adr;
316	>	uintptr adr, end_adr;
317
318		if (!range_args(&adr, &end_adr, 16 * 4 - 1))  // 16 lines unless end address specified
319		return;
#	Line 319 | Line 322 | static void disassemble(CPUType type)
322		case CPU_PPC:
323		while (adr <= end_adr && !mon_aborted()) {
324		uint32 w = mon_read_word(adr);
325	<	fprintf(monout, "%08x: %08x\t", mon_use_real_mem ? adr : adr % mon_mem_size, w);
325	>	fprintf(monout, "%0*lx: %08x\t", 2 * sizeof(adr), mon_use_real_mem ? adr : adr % mon_mem_size, w);
326		disass_ppc(monout, mon_use_real_mem ? adr : adr % mon_mem_size, w);
327		adr += 4;
328		}
#	Line 330 | Line 333 | static void disassemble(CPUType type)
333		uint8 op = mon_read_byte(adr);
334		uint8 lo = mon_read_byte(adr + 1);
335		uint8 hi = mon_read_byte(adr + 2);
336	<	fprintf(monout, "%08x: ", mon_use_real_mem ? adr : adr % mon_mem_size);
336	>	fprintf(monout, "%0*lx: ", 2 * sizeof(adr), mon_use_real_mem ? adr : adr % mon_mem_size);
337		adr += disass_6502(monout, mon_use_real_mem ? adr : adr % mon_mem_size, op, lo, hi);
338		}
339		break;
340
341		case CPU_680x0:
342		while (adr <= end_adr && !mon_aborted()) {
343	<	uint16 buf[8];
344	<	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);
343	>	fprintf(monout, "%0*lx: ", 2 * sizeof(adr), mon_use_real_mem ? adr : adr % mon_mem_size);
344	>	adr += disass_68k(monout, mon_use_real_mem ? adr : adr % mon_mem_size);
345		}
346		break;
347
348	<	case CPU_8080:
348	>	case CPU_Z80:
349		while (adr <= end_adr && !mon_aborted()) {
350	<	uint8 op = mon_read_byte(adr);
351	<	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);
350	>	fprintf(monout, "%0*lx: ", 2 * sizeof(adr), mon_use_real_mem ? adr : adr % mon_mem_size);
351	>	adr += disass_z80(monout, mon_use_real_mem ? adr : adr % mon_mem_size);
352		}
353		break;
354
355	<	case CPU_80x86:
355	>	case CPU_x86_64:
356		while (adr <= end_adr && !mon_aborted()) {
357	<	uint8 buf[16];
358	<	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);
357	>	fprintf(monout, "%0*lx: ", 2 * sizeof(adr), mon_use_real_mem ? adr : adr % mon_mem_size);
358	>	adr += disass_x86(monout, mon_use_real_mem ? adr : adr % mon_mem_size, 64);
359		}
360		break;
361	+
362	+	case CPU_80x86_32:
363	+	while (adr <= end_adr && !mon_aborted()) {
364	+	fprintf(monout, "%0*lx: ", 2 * sizeof(adr), mon_use_real_mem ? adr : adr % mon_mem_size);
365	+	adr += disass_x86(monout, mon_use_real_mem ? adr : adr % mon_mem_size, 32);
366	+	}
367	+	break;
368	+
369	+	case CPU_80x86_16:
370	+	while (adr <= end_adr && !mon_aborted()) {
371	+	fprintf(monout, "%0*lx: ", 2 * sizeof(adr), mon_use_real_mem ? adr : adr % mon_mem_size);
372	+	adr += disass_x86(monout, mon_use_real_mem ? adr : adr % mon_mem_size, 16);
373	+	}
374		}
375
376		mon_dot_address = adr;
#	Line 390 | Line 391 | void disassemble_680x0(void)
391		disassemble(CPU_680x0);
392		}
393
394	<	void disassemble_8080(void)
394	>	void disassemble_z80(void)
395	>	{
396	>	disassemble(CPU_Z80);
397	>	}
398	>
399	>	void disassemble_80x86_32(void)
400	>	{
401	>	disassemble(CPU_80x86_32);
402	>	}
403	>
404	>	void disassemble_80x86_16(void)
405		{
406	<	disassemble(CPU_8080);
406	>	disassemble(CPU_80x86_16);
407		}
408
409	<	void disassemble_80x86(void)
409	>	void disassemble_x86_64(void)
410		{
411	<	disassemble(CPU_80x86);
411	>	disassemble(CPU_x86_64);
412		}
413
414
#	Line 408 | Line 419 | void disassemble_80x86(void)
419
420		void modify(void)
421		{
422	<	uint32 adr, len, src_adr = 0;
422	>	uintptr adr, len, src_adr = 0;
423		uint8 str[256];
424
425		if (!mon_expression(&adr))
#	Line 430 | Line 441 | void modify(void)
441
442		void fill(void)
443		{
444	<	uint32 adr, end_adr, len, src_adr = 0;
444	>	uintptr adr, end_adr, len, src_adr = 0;
445		uint8 str[256];
446
447		if (!mon_expression(&adr))
#	Line 452 | Line 463 | void fill(void)
463
464		void transfer(void)
465		{
466	<	uint32 adr, end_adr, dest;
466	>	uintptr adr, end_adr, dest;
467		int num;
468
469		if (!mon_expression(&adr))
#	Line 486 | Line 497 | void transfer(void)
497
498		void compare(void)
499		{
500	<	uint32 adr, end_adr, dest;
500	>	uintptr adr, end_adr, dest;
501		int num = 0;
502
503		if (!mon_expression(&adr))
#	Line 502 | Line 513 | void compare(void)
513
514		while (adr <= end_adr && !mon_aborted()) {
515		if (mon_read_byte(adr) != mon_read_byte(dest)) {
516	<	fprintf(monout, "%08x ", mon_use_real_mem ? adr : adr % mon_mem_size);
516	>	fprintf(monout, "%0*lx ", 2 * sizeof(adr), mon_use_real_mem ? adr : adr % mon_mem_size);
517		num++;
518		if (!(num & 7))
519		fputc('\n', monout);
#	Line 523 | Line 534 | void compare(void)
534
535		void hunt(void)
536		{
537	<	uint32 adr, end_adr, len;
537	>	uintptr adr, end_adr, len;
538		uint8 str[256];
539		int num = 0;
540
#	Line 542 | Line 553 | void hunt(void)
553		break;
554
555		if (i == len) {
556	<	fprintf(monout, "%08x ", mon_use_real_mem ? adr : adr % mon_mem_size);
556	>	fprintf(monout, "%0*lx ", 2 * sizeof(adr), mon_use_real_mem ? adr : adr % mon_mem_size);
557		num++;
558		if (num == 1)
559		mon_dot_address = adr;
#	Line 565 | Line 576 | void hunt(void)
576
577		void load_data(void)
578		{
579	<	uint32 start_adr;
579	>	uintptr start_adr;
580		FILE *file;
581		int fc;
582
#	Line 588 | Line 599 | void load_data(void)
599		if (!(file = fopen(mon_string, "rb")))
600		mon_error("Unable to open file");
601		else {
602	<	uint32 adr = start_adr;
602	>	uintptr adr = start_adr;
603
604		while ((fc = fgetc(file)) != EOF)
605		mon_write_byte(adr++, fc);
606		fclose(file);
607
608	<	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);
608	>	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);
609		mon_dot_address = adr;
610		}
611		}
#	Line 607 | Line 618 | void load_data(void)
618
619		void save_data(void)
620		{
621	<	uint32 start_adr, size;
621	>	uintptr start_adr, size;
622		FILE *file;
623
624		if (!mon_expression(&start_adr))
#	Line 631 | Line 642 | void save_data(void)
642		if (!(file = fopen(mon_string, "wb")))
643		mon_error("Unable to create file");
644		else {
645	<	uint32 adr = start_adr, end_adr = start_adr + size - 1;
645	>	uintptr adr = start_adr, end_adr = start_adr + size - 1;
646
647		while (adr <= end_adr)
648		fputc(mon_read_byte(adr++), file);
649		fclose(file);
650
651	<	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);
651	>	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);
652		}
653		}

Diff Legend

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