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.2 by cebix, 1999-10-04T21:16:02Z vs.
Revision 1.11 by gbeauche, 2002-07-17T10:00:54Z

#	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 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 39 | 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 66 | 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 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 160 | 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 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 212 | 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 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, "%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, " %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 243 | 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 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	+	uintptr 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]]
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		};
312
313		static void disassemble(CPUType type)
314		{
315	<	uint32 adr, end_adr;
315	>	uintptr adr, end_adr;
316
317		if (!range_args(&adr, &end_adr, 16 * 4 - 1))  // 16 lines unless end address specified
318		return;
#	Line 290 | Line 321 | static void disassemble(CPUType type)
321		case CPU_PPC:
322		while (adr <= end_adr && !mon_aborted()) {
323		uint32 w = mon_read_word(adr);
324	<	fprintf(monout, "%08lx: %08lx\t", mon_use_real_mem ? adr : adr % mon_mem_size, w);
324	>	fprintf(monout, "%08x: %08x\t", mon_use_real_mem ? adr : adr % mon_mem_size, w);
325		disass_ppc(monout, mon_use_real_mem ? adr : adr % mon_mem_size, w);
326		adr += 4;
327		}
#	Line 301 | Line 332 | static void disassemble(CPUType type)
332		uint8 op = mon_read_byte(adr);
333		uint8 lo = mon_read_byte(adr + 1);
334		uint8 hi = mon_read_byte(adr + 2);
335	<	fprintf(monout, "%08lx: ", mon_use_real_mem ? adr : adr % mon_mem_size);
335	>	fprintf(monout, "%08x: ", mon_use_real_mem ? adr : adr % mon_mem_size);
336		adr += disass_6502(monout, mon_use_real_mem ? adr : adr % mon_mem_size, op, lo, hi);
337		}
338		break;
339
340		case CPU_680x0:
341		while (adr <= end_adr && !mon_aborted()) {
342	<	uint16 buf[8];
343	<	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);
342	>	fprintf(monout, "%08x: ", mon_use_real_mem ? adr : adr % mon_mem_size);
343	>	adr += disass_68k(monout, mon_use_real_mem ? adr : adr % mon_mem_size);
344		}
345		break;
346
347	<	case CPU_8080:
347	>	case CPU_Z80:
348		while (adr <= end_adr && !mon_aborted()) {
349	<	uint8 op = mon_read_byte(adr);
350	<	uint8 lo = mon_read_byte(adr + 1);
329	<	uint8 hi = mon_read_byte(adr + 2);
330	<	fprintf(monout, "%08lx: ", mon_use_real_mem ? adr : adr % mon_mem_size);
331	<	adr += disass_8080(monout, mon_use_real_mem ? adr : adr % mon_mem_size, op, lo, hi);
349	>	fprintf(monout, "%08x: ", mon_use_real_mem ? adr : adr % mon_mem_size);
350	>	adr += disass_z80(monout, mon_use_real_mem ? adr : adr % mon_mem_size);
351		}
352		break;
353
354	<	case CPU_80x86:
354	>	case CPU_80x86_32:
355		while (adr <= end_adr && !mon_aborted()) {
356	<	uint8 buf[16];
357	<	for (int i=0; i<16; i++)
358	<	buf[i] = mon_read_byte(adr + i);
359	<	fprintf(monout, "%08lx: ", mon_use_real_mem ? adr : adr % mon_mem_size);
360	<	adr += disass_x86(monout, mon_use_real_mem ? adr : adr % mon_mem_size, buf);
356	>	fprintf(monout, "%08x: ", mon_use_real_mem ? adr : adr % mon_mem_size);
357	>	adr += disass_x86(monout, mon_use_real_mem ? adr : adr % mon_mem_size, false);
358	>	}
359	>	break;
360	>
361	>	case CPU_80x86_16:
362	>	while (adr <= end_adr && !mon_aborted()) {
363	>	fprintf(monout, "%08x: ", mon_use_real_mem ? adr : adr % mon_mem_size);
364	>	adr += disass_x86(monout, mon_use_real_mem ? adr : adr % mon_mem_size, true);
365		}
366		break;
367		}
#	Line 361 | Line 384 | void disassemble_680x0(void)
384		disassemble(CPU_680x0);
385		}
386
387	<	void disassemble_8080(void)
387	>	void disassemble_z80(void)
388	>	{
389	>	disassemble(CPU_Z80);
390	>	}
391	>
392	>	void disassemble_80x86_32(void)
393		{
394	<	disassemble(CPU_8080);
394	>	disassemble(CPU_80x86_32);
395		}
396
397	<	void disassemble_80x86(void)
397	>	void disassemble_80x86_16(void)
398		{
399	<	disassemble(CPU_80x86);
399	>	disassemble(CPU_80x86_16);
400		}
401
402
#	Line 379 | Line 407 | void disassemble_80x86(void)
407
408		void modify(void)
409		{
410	<	uint32 adr, len, src_adr = 0;
410	>	uintptr adr, len, src_adr = 0;
411		uint8 str[256];
412
413		if (!mon_expression(&adr))
#	Line 401 | Line 429 | void modify(void)
429
430		void fill(void)
431		{
432	<	uint32 adr, end_adr, len, src_adr = 0;
432	>	uintptr adr, end_adr, len, src_adr = 0;
433		uint8 str[256];
434
435		if (!mon_expression(&adr))
#	Line 423 | Line 451 | void fill(void)
451
452		void transfer(void)
453		{
454	<	uint32 adr, end_adr, dest;
454	>	uintptr adr, end_adr, dest;
455		int num;
456
457		if (!mon_expression(&adr))
#	Line 457 | Line 485 | void transfer(void)
485
486		void compare(void)
487		{
488	<	uint32 adr, end_adr, dest;
488	>	uintptr adr, end_adr, dest;
489		int num = 0;
490
491		if (!mon_expression(&adr))
#	Line 473 | Line 501 | void compare(void)
501
502		while (adr <= end_adr && !mon_aborted()) {
503		if (mon_read_byte(adr) != mon_read_byte(dest)) {
504	<	fprintf(monout, "%08lx ", mon_use_real_mem ? adr : adr % mon_mem_size);
504	>	fprintf(monout, "%08x ", mon_use_real_mem ? adr : adr % mon_mem_size);
505		num++;
506		if (!(num & 7))
507		fputc('\n', monout);
#	Line 494 | Line 522 | void compare(void)
522
523		void hunt(void)
524		{
525	<	uint32 adr, end_adr, len;
525	>	uintptr adr, end_adr, len;
526		uint8 str[256];
527		int num = 0;
528
#	Line 513 | Line 541 | void hunt(void)
541		break;
542
543		if (i == len) {
544	<	fprintf(monout, "%08lx ", mon_use_real_mem ? adr : adr % mon_mem_size);
544	>	fprintf(monout, "%08x ", mon_use_real_mem ? adr : adr % mon_mem_size);
545		num++;
546		if (num == 1)
547		mon_dot_address = adr;
#	Line 536 | Line 564 | void hunt(void)
564
565		void load_data(void)
566		{
567	<	uint32 start_adr;
567	>	uintptr start_adr;
568		FILE *file;
569		int fc;
570
#	Line 559 | Line 587 | void load_data(void)
587		if (!(file = fopen(mon_string, "rb")))
588		mon_error("Unable to open file");
589		else {
590	<	uint32 adr = start_adr;
590	>	uintptr adr = start_adr;
591
592		while ((fc = fgetc(file)) != EOF)
593		mon_write_byte(adr++, fc);
594		fclose(file);
595
596	<	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);
596	>	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);
597		mon_dot_address = adr;
598		}
599		}
#	Line 578 | Line 606 | void load_data(void)
606
607		void save_data(void)
608		{
609	<	uint32 start_adr, size;
609	>	uintptr start_adr, size;
610		FILE *file;
611
612		if (!mon_expression(&start_adr))
#	Line 602 | Line 630 | void save_data(void)
630		if (!(file = fopen(mon_string, "wb")))
631		mon_error("Unable to create file");
632		else {
633	<	uint32 adr = start_adr, end_adr = start_adr + size - 1;
633	>	uintptr adr = start_adr, end_adr = start_adr + size - 1;
634
635		while (adr <= end_adr)
636		fputc(mon_read_byte(adr++), file);
637		fclose(file);
638
639	<	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);
639	>	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);
640		}
641		}

Diff Legend

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